Function execute

packages/plugin/src/tools/ctx-reduce/tools.ts:30–114

(args: CtxReduceArgs, toolContext)

                .describe("Tag IDs to drop entirely. Ranges: '3-5', '1,2,9'"),
        },
        async execute(args: CtxReduceArgs, toolContext) {
            const sessionId = toolContext.sessionID;

            if (!args.drop) {
                return "Error: 'drop' must be provided.";
            }

            let dropIds: number[] = [];

            try {
                dropIds = parseRangeString(args.drop);
            } catch (e) {
                return `Error: Invalid range syntax. ${(e as Error).message}`;
            }

            const allIds = [...new Set(dropIds)];

            const allTags = getTagsBySession(deps.db, sessionId);
            const foundSet = new Set(allTags.map((tag) => tag.tagNumber));
            const unknownIds = allIds.filter((id) => !foundSet.has(id));
            if (unknownIds.length > 0) {
                return `Error: Unknown tag(s) ${formatIds(unknownIds)}. Check available tags in conversation.`;
            }

            const activeTags = allTags.filter((tag) => tag.status === "active");
            const protectedTagIds = activeTags
                .map((tag) => tag.tagNumber)
                .sort((left, right) => right - left)
                .slice(0, deps.protectedTags);
            const protectedSet = new Set(protectedTagIds);

            const tagStatusMap = new Map(allTags.map((tag) => [tag.tagNumber, tag.status]));

            const pendingOps = getPendingOps(deps.db, sessionId);
            const pendingMap = new Map(pendingOps.map((op) => [op.tagId, op.operation]));

            const conflicts: string[] = [];
            for (const id of dropIds) {
                if (tagStatusMap.get(id) === "compacted") {
                    conflicts.push(`§${id}§ is from before compaction`);
                }
            }
            if (conflicts.length > 0) {
                return `Error: Conflicting operations — ${conflicts.join("; ")}.`;
            }

            const preFilterDropCount = dropIds.length;
            dropIds = dropIds.filter(
                (id) => tagStatusMap.get(id) !== "dropped" && pendingMap.get(id) !== "drop",
            );
            const skippedCount = preFilterDropCount - dropIds.length;

            if (dropIds.length === 0) {
                return "All requested tags were already queued or processed. No new action is needed.";
            }

            try {
                deps.db.transaction(() => {