@tarquinen/opencode-dcp 0.3.16 → 0.3.18

package/dist/lib/janitor.js

@@ -2,7 +2,8 @@ import { z } from "zod";
 import { buildAnalysisPrompt } from "./prompt";
 import { selectModel, extractModelFromSession } from "./model-selector";
 import { estimateTokensBatch, formatTokenCount } from "./tokenizer";
-import { detectDuplicates, extractParameterKey } from "./deduplicator";
+import { detectDuplicates } from "./deduplicator";
+import { extractParameterKey } from "./display-utils";
 export class Janitor {
     client;
     prunedIdsState;
@@ -13,13 +14,10 @@ export class Janitor {
     modelCache;
     configModel;
     showModelErrorToasts;
+    strictModelSelection;
     pruningSummary;
     workingDirectory;
-    constructor(client, prunedIdsState, statsState, logger, toolParametersCache, protectedTools, modelCache, configModel, // Format: "provider/model"
-    showModelErrorToasts = true, // Whether to show toast for model errors
-    pruningSummary = "detailed", // UI summary display mode
-    workingDirectory // Current working directory for relative path display
-    ) {
+    constructor(client, prunedIdsState, statsState, logger, toolParametersCache, protectedTools, modelCache, configModel, showModelErrorToasts = true, strictModelSelection = false, pruningSummary = "detailed", workingDirectory) {
         this.client = client;
         this.prunedIdsState = prunedIdsState;
         this.statsState = statsState;
@@ -29,20 +27,16 @@ export class Janitor {
         this.modelCache = modelCache;
         this.configModel = configModel;
         this.showModelErrorToasts = showModelErrorToasts;
+        this.strictModelSelection = strictModelSelection;
         this.pruningSummary = pruningSummary;
         this.workingDirectory = workingDirectory;
     }
-    /**
-     * Sends an ignored message to the session UI (user sees it, AI doesn't)
-     */
     async sendIgnoredMessage(sessionID, text) {
         try {
             await this.client.session.prompt({
-                path: {
-                    id: sessionID
-                },
+                path: { id: sessionID },
                 body: {
-                    noReply: true, // Don't wait for AI response
+                    noReply: true,
                     parts: [{
                             type: 'text',
                             text: text,
@@ -52,82 +46,56 @@ export class Janitor {
             });
         }
         catch (error) {
-            this.logger.error("janitor", "Failed to send notification", {
-                error: error.message
-            });
+            this.logger.error("janitor", "Failed to send notification", { error: error.message });
         }
     }
-    /**
-     * Convenience method for idle-triggered pruning (sends notification automatically)
-     */
     async runOnIdle(sessionID, strategies) {
         await this.runWithStrategies(sessionID, strategies, { trigger: 'idle' });
-        // Notification is handled inside runWithStrategies
     }
-    /**
-     * Convenience method for tool-triggered pruning (returns result for tool output)
-     */
     async runForTool(sessionID, strategies, reason) {
         return await this.runWithStrategies(sessionID, strategies, { trigger: 'tool', reason });
     }
-    /**
-     * Core pruning method that accepts strategies and options
-     */
     async runWithStrategies(sessionID, strategies, options) {
         try {
-            // Skip if no strategies configured
             if (strategies.length === 0) {
                 return null;
             }
-            // Fetch session info and messages from OpenCode API
             const [sessionInfoResponse, messagesResponse] = await Promise.all([
                 this.client.session.get({ path: { id: sessionID } }),
                 this.client.session.messages({ path: { id: sessionID }, query: { limit: 100 } })
             ]);
             const sessionInfo = sessionInfoResponse.data;
-            // Handle the response format - it should be { data: Array<{info, parts}> } or just the array
             const messages = messagesResponse.data || messagesResponse;
-            // If there are no messages or very few, skip analysis
             if (!messages || messages.length < 3) {
                 return null;
             }
-            // Extract tool call IDs from the session and track their output sizes
-            // Also track batch tool relationships and tool metadata
             const toolCallIds = [];
             const toolOutputs = new Map();
-            const toolMetadata = new Map(); // callID -> {tool, parameters}
-            const batchToolChildren = new Map(); // batchID -> [childIDs]
+            const toolMetadata = new Map();
+            const batchToolChildren = new Map();
             let currentBatchId = null;
             for (const msg of messages) {
                 if (msg.parts) {
                     for (const part of msg.parts) {
                         if (part.type === "tool" && part.callID) {
-                            // Normalize tool call IDs to lowercase for consistent comparison
                             const normalizedId = part.callID.toLowerCase();
                             toolCallIds.push(normalizedId);
-                            // Try to get parameters from cache first, fall back to part.parameters
-                            // Cache might have either case, so check both
                             const cachedData = this.toolParametersCache.get(part.callID) || this.toolParametersCache.get(normalizedId);
-                            const parameters = cachedData?.parameters || part.parameters;
-                            // Track tool metadata (name and parameters)
+                            const parameters = cachedData?.parameters ?? part.state?.input ?? part.parameters;
                             toolMetadata.set(normalizedId, {
                                 tool: part.tool,
                                 parameters: parameters
                             });
-                            // Track the output content for size calculation
                             if (part.state?.status === "completed" && part.state.output) {
                                 toolOutputs.set(normalizedId, part.state.output);
                             }
-                            // Check if this is a batch tool by looking at the tool name
                             if (part.tool === "batch") {
                                 currentBatchId = normalizedId;
                                 batchToolChildren.set(normalizedId, []);
                             }
-                            // If we're inside a batch and this is a prt_ (parallel) tool call, it's a child
                             else if (currentBatchId && normalizedId.startsWith('prt_')) {
                                 batchToolChildren.get(currentBatchId).push(normalizedId);
                             }
-                            // If we hit a non-batch, non-prt_ tool, we're out of the batch
                             else if (currentBatchId && !normalizedId.startsWith('prt_')) {
                                 currentBatchId = null;
                             }
@@ -135,16 +103,12 @@ export class Janitor {
                     }
                 }
             }
-            // Get already pruned IDs to filter them out
             const alreadyPrunedIds = this.prunedIdsState.get(sessionID) ?? [];
             const unprunedToolCallIds = toolCallIds.filter(id => !alreadyPrunedIds.includes(id));
-            // If there are no unpruned tool calls, skip analysis
             if (unprunedToolCallIds.length === 0) {
                 return null;
             }
-            // ============================================================
-            // PHASE 1: DUPLICATE DETECTION (if enabled)
-            // ============================================================
+            // PHASE 1: DUPLICATE DETECTION
             let deduplicatedIds = [];
             let deduplicationDetails = new Map();
             if (strategies.includes('deduplication')) {
@@ -152,23 +116,17 @@ export class Janitor {
                 deduplicatedIds = dedupeResult.duplicateIds;
                 deduplicationDetails = dedupeResult.deduplicationDetails;
             }
-            // Calculate candidates available for pruning (excludes protected tools)
             const candidateCount = unprunedToolCallIds.filter(id => {
                 const metadata = toolMetadata.get(id);
                 return !metadata || !this.protectedTools.includes(metadata.tool);
             }).length;
-            // ============================================================
-            // PHASE 2: LLM ANALYSIS (if enabled)
-            // ============================================================
+            // PHASE 2: LLM ANALYSIS
             let llmPrunedIds = [];
             if (strategies.includes('ai-analysis')) {
-                // Filter out duplicates and protected tools
                 const protectedToolCallIds = [];
                 const prunableToolCallIds = unprunedToolCallIds.filter(id => {
-                    // Skip already deduplicated
                     if (deduplicatedIds.includes(id))
                         return false;
-                    // Skip protected tools
                     const metadata = toolMetadata.get(id);
                     if (metadata && this.protectedTools.includes(metadata.tool)) {
                         protectedToolCallIds.push(id);
@@ -176,9 +134,7 @@ export class Janitor {
                     }
                     return true;
                 });
-                // Run LLM analysis only if there are prunable tools
                 if (prunableToolCallIds.length > 0) {
-                    // Select appropriate model with intelligent fallback
                     const cachedModelInfo = this.modelCache.get(sessionID);
                     const sessionModelInfo = extractModelFromSession(sessionInfo, this.logger);
                     const currentModelInfo = cachedModelInfo || sessionModelInfo;
@@ -186,73 +142,68 @@ export class Janitor {
                     this.logger.info("janitor", `Model: ${modelSelection.modelInfo.providerID}/${modelSelection.modelInfo.modelID}`, {
                         source: modelSelection.source
                     });
-                    // Show toast if we had to fallback from a failed model
                     if (modelSelection.failedModel && this.showModelErrorToasts) {
+                        const skipAi = modelSelection.source === 'fallback' && this.strictModelSelection;
                         try {
                             await this.client.tui.showToast({
                                 body: {
-                                    title: "DCP: Model fallback",
-                                    message: `${modelSelection.failedModel.providerID}/${modelSelection.failedModel.modelID} failed\nUsing ${modelSelection.modelInfo.providerID}/${modelSelection.modelInfo.modelID}`,
+                                    title: skipAi ? "DCP: AI analysis skipped" : "DCP: Model fallback",
+                                    message: skipAi
+                                        ? `${modelSelection.failedModel.providerID}/${modelSelection.failedModel.modelID} failed\nAI analysis skipped (strictModelSelection enabled)`
+                                        : `${modelSelection.failedModel.providerID}/${modelSelection.failedModel.modelID} failed\nUsing ${modelSelection.modelInfo.providerID}/${modelSelection.modelInfo.modelID}`,
                                     variant: "info",
                                     duration: 5000
                                 }
                             });
                         }
                         catch (toastError) {
-                            // Don't fail the whole operation if toast fails
                         }
                     }
-                    // Lazy import - only load the 2.8MB ai package when actually needed
-                    const { generateObject } = await import('ai');
-                    // Replace already-pruned tool outputs to save tokens in janitor context
-                    const allPrunedSoFar = [...alreadyPrunedIds, ...deduplicatedIds];
-                    const sanitizedMessages = this.replacePrunedToolOutputs(messages, allPrunedSoFar);
-                    // Build the prompt for analysis (pass reason if provided)
-                    const analysisPrompt = buildAnalysisPrompt(prunableToolCallIds, sanitizedMessages, allPrunedSoFar, protectedToolCallIds, options.reason);
-                    // Save janitor shadow context directly (auth providers may bypass globalThis.fetch)
-                    await this.logger.saveWrappedContext("janitor-shadow", [{ role: "user", content: analysisPrompt }], {
-                        sessionID,
-                        modelProvider: modelSelection.modelInfo.providerID,
-                        modelID: modelSelection.modelInfo.modelID,
-                        candidateToolCount: prunableToolCallIds.length,
-                        alreadyPrunedCount: allPrunedSoFar.length,
-                        protectedToolCount: protectedToolCallIds.length,
-                        trigger: options.trigger,
-                        reason: options.reason
-                    });
-                    // Analyze which tool calls are obsolete
-                    const result = await generateObject({
-                        model: modelSelection.model,
-                        schema: z.object({
-                            pruned_tool_call_ids: z.array(z.string()),
-                            reasoning: z.string(),
-                        }),
-                        prompt: analysisPrompt
-                    });
-                    // Filter LLM results to only include IDs that were actually candidates
-                    // (LLM sometimes returns duplicate IDs that were already filtered out)
-                    const rawLlmPrunedIds = result.object.pruned_tool_call_ids;
-                    llmPrunedIds = rawLlmPrunedIds.filter(id => prunableToolCallIds.includes(id.toLowerCase()));
-                    if (llmPrunedIds.length > 0) {
-                        const reasoning = result.object.reasoning.replace(/\n+/g, ' ').replace(/\s+/g, ' ').trim();
-                        this.logger.info("janitor", `LLM reasoning: ${reasoning.substring(0, 200)}${reasoning.length > 200 ? '...' : ''}`);
+                    if (modelSelection.source === 'fallback' && this.strictModelSelection) {
+                        this.logger.info("janitor", "Skipping AI analysis (fallback model, strictModelSelection enabled)");
+                    }
+                    else {
+                        const { generateObject } = await import('ai');
+                        const allPrunedSoFar = [...alreadyPrunedIds, ...deduplicatedIds];
+                        const sanitizedMessages = this.replacePrunedToolOutputs(messages, allPrunedSoFar);
+                        const analysisPrompt = buildAnalysisPrompt(prunableToolCallIds, sanitizedMessages, allPrunedSoFar, protectedToolCallIds, options.reason);
+                        await this.logger.saveWrappedContext("janitor-shadow", [{ role: "user", content: analysisPrompt }], {
+                            sessionID,
+                            modelProvider: modelSelection.modelInfo.providerID,
+                            modelID: modelSelection.modelInfo.modelID,
+                            candidateToolCount: prunableToolCallIds.length,
+                            alreadyPrunedCount: allPrunedSoFar.length,
+                            protectedToolCount: protectedToolCallIds.length,
+                            trigger: options.trigger,
+                            reason: options.reason
+                        });
+                        const result = await generateObject({
+                            model: modelSelection.model,
+                            schema: z.object({
+                                pruned_tool_call_ids: z.array(z.string()),
+                                reasoning: z.string(),
+                            }),
+                            prompt: analysisPrompt
+                        });
+                        const rawLlmPrunedIds = result.object.pruned_tool_call_ids;
+                        llmPrunedIds = rawLlmPrunedIds.filter(id => prunableToolCallIds.includes(id.toLowerCase()));
+                        if (llmPrunedIds.length > 0) {
+                            const reasoning = result.object.reasoning.replace(/\n+/g, ' ').replace(/\s+/g, ' ').trim();
+                            this.logger.info("janitor", `LLM reasoning: ${reasoning.substring(0, 200)}${reasoning.length > 200 ? '...' : ''}`);
+                        }
                     }
                 }
             }
-            // ============================================================
             // PHASE 3: COMBINE & EXPAND
-            // ============================================================
             const newlyPrunedIds = [...deduplicatedIds, ...llmPrunedIds];
             if (newlyPrunedIds.length === 0) {
                 return null;
             }
-            // Helper to expand batch tool IDs to include their children
             const expandBatchIds = (ids) => {
                 const expanded = new Set();
                 for (const id of ids) {
                     const normalizedId = id.toLowerCase();
                     expanded.add(normalizedId);
-                    // If this is a batch tool, add all its children
                     const children = batchToolChildren.get(normalizedId);
                     if (children) {
                         children.forEach(childId => expanded.add(childId));
@@ -260,27 +211,18 @@ export class Janitor {
                 }
                 return Array.from(expanded);
             };
-            // Expand batch tool IDs to include their children
             const expandedPrunedIds = new Set(expandBatchIds(newlyPrunedIds));
-            // Expand llmPrunedIds for UI display (so batch children show instead of "unknown metadata")
             const expandedLlmPrunedIds = expandBatchIds(llmPrunedIds);
-            // Calculate which IDs are actually NEW (not already pruned)
             const finalNewlyPrunedIds = Array.from(expandedPrunedIds).filter(id => !alreadyPrunedIds.includes(id));
-            // finalPrunedIds includes everything (new + already pruned) for logging
             const finalPrunedIds = Array.from(expandedPrunedIds);
-            // ============================================================
             // PHASE 4: CALCULATE STATS & NOTIFICATION
-            // ============================================================
-            // Calculate token savings once (used by both notification and log)
             const tokensSaved = await this.calculateTokensSaved(finalNewlyPrunedIds, toolOutputs);
-            // Accumulate session stats (for showing cumulative totals in UI)
             const currentStats = this.statsState.get(sessionID) ?? { totalToolsPruned: 0, totalTokensSaved: 0 };
             const sessionStats = {
                 totalToolsPruned: currentStats.totalToolsPruned + finalNewlyPrunedIds.length,
                 totalTokensSaved: currentStats.totalTokensSaved + tokensSaved
             };
             this.statsState.set(sessionID, sessionStats);
-            // Determine notification mode based on which strategies ran
             const hasLlmAnalysis = strategies.includes('ai-analysis');
             if (hasLlmAnalysis) {
                 await this.sendSmartModeNotification(sessionID, deduplicatedIds, deduplicationDetails, expandedLlmPrunedIds, toolMetadata, tokensSaved, sessionStats);
@@ -288,19 +230,13 @@ export class Janitor {
             else {
                 await this.sendAutoModeNotification(sessionID, deduplicatedIds, deduplicationDetails, tokensSaved, sessionStats);
             }
-            // ============================================================
             // PHASE 5: STATE UPDATE
-            // ============================================================
-            // Merge newly pruned IDs with existing ones (using expanded IDs)
             const allPrunedIds = [...new Set([...alreadyPrunedIds, ...finalPrunedIds])];
             this.prunedIdsState.set(sessionID, allPrunedIds);
-            // Log final summary
-            // Format: "Pruned 5/5 tools (~4.2K tokens), 0 kept" or with breakdown if both duplicate and llm
             const prunedCount = finalNewlyPrunedIds.length;
             const keptCount = candidateCount - prunedCount;
             const hasBoth = deduplicatedIds.length > 0 && llmPrunedIds.length > 0;
             const breakdown = hasBoth ? ` (${deduplicatedIds.length} duplicate, ${llmPrunedIds.length} llm)` : "";
-            // Build log metadata
             const logMeta = { trigger: options.trigger };
             if (options.reason) {
                 logMeta.reason = options.reason;
@@ -321,17 +257,10 @@ export class Janitor {
                 error: error.message,
                 trigger: options.trigger
             });
-            // Don't throw - this is a fire-and-forget background process
-            // Silently fail and try again on next idle event
             return null;
         }
     }
-    /**
-     * Helper function to shorten paths for display
-     */
     shortenPath(input) {
-        // Handle compound strings like: "pattern" in /absolute/path
-        // Extract and shorten just the path portion
         const inPathMatch = input.match(/^(.+) in (.+)$/);
         if (inPathMatch) {
             const prefix = inPathMatch[1];
@@ -341,31 +270,23 @@ export class Janitor {
         }
         return this.shortenSinglePath(input);
     }
-    /**
-     * Shorten a single path string
-     */
     shortenSinglePath(path) {
         const homeDir = require('os').homedir();
-        // Strip working directory FIRST (before ~ replacement) for cleaner relative paths
         if (this.workingDirectory) {
             if (path.startsWith(this.workingDirectory + '/')) {
                 return path.slice(this.workingDirectory.length + 1);
             }
-            // Exact match (the directory itself)
             if (path === this.workingDirectory) {
                 return '.';
             }
         }
-        // Replace home directory with ~
         if (path.startsWith(homeDir)) {
             path = '~' + path.slice(homeDir.length);
         }
-        // Shorten node_modules paths: show package + file only
         const nodeModulesMatch = path.match(/node_modules\/(@[^\/]+\/[^\/]+|[^\/]+)\/(.*)/);
         if (nodeModulesMatch) {
             return `${nodeModulesMatch[1]}/${nodeModulesMatch[2]}`;
         }
-        // Try matching against ~ version of working directory (for paths already with ~)
         if (this.workingDirectory) {
             const workingDirWithTilde = this.workingDirectory.startsWith(homeDir)
                 ? '~' + this.workingDirectory.slice(homeDir.length)
@@ -379,11 +300,6 @@ export class Janitor {
         }
         return path;
     }
-    /**
-     * Replace pruned tool outputs with placeholder text to save tokens in janitor context
-     * This applies the same replacement logic as the global fetch wrapper, but for the
-     * janitor's shadow inference to avoid sending already-pruned content to the LLM
-     */
     replacePrunedToolOutputs(messages, prunedIds) {
         if (prunedIds.length === 0)
             return messages;
@@ -398,7 +314,6 @@ export class Janitor {
                         part.callID &&
                         prunedIdsSet.has(part.callID.toLowerCase()) &&
                         part.state?.output) {
-                        // Replace with the same placeholder used by the global fetch wrapper
                         return {
                             ...part,
                             state: {
@@ -412,9 +327,6 @@ export class Janitor {
             };
         });
     }
-    /**
-     * Helper function to calculate token savings from tool outputs
-     */
     async calculateTokensSaved(prunedIds, toolOutputs) {
         const outputsToTokenize = [];
         for (const prunedId of prunedIds) {
@@ -424,63 +336,44 @@ export class Janitor {
             }
         }
         if (outputsToTokenize.length > 0) {
-            // Use batch tokenization for efficiency (lazy loads gpt-tokenizer)
             const tokenCounts = await estimateTokensBatch(outputsToTokenize);
             return tokenCounts.reduce((sum, count) => sum + count, 0);
         }
         return 0;
     }
-    /**
-     * Build a summary of tools by grouping them
-     * Uses shared extractParameterKey logic for consistent parameter extraction
-     *
-     * Note: prunedIds may be in original case (from LLM) but toolMetadata uses lowercase keys
-     */
     buildToolsSummary(prunedIds, toolMetadata) {
         const toolsSummary = new Map();
-        // Helper function to truncate long strings
         const truncate = (str, maxLen = 60) => {
             if (str.length <= maxLen)
                 return str;
             return str.slice(0, maxLen - 3) + '...';
         };
         for (const prunedId of prunedIds) {
-            // Normalize ID to lowercase for lookup (toolMetadata uses lowercase keys)
             const normalizedId = prunedId.toLowerCase();
             const metadata = toolMetadata.get(normalizedId);
             if (metadata) {
                 const toolName = metadata.tool;
-                // Skip 'batch' tool in UI summary - it's a wrapper and its children are shown individually
                 if (toolName === 'batch')
                     continue;
                 if (!toolsSummary.has(toolName)) {
                     toolsSummary.set(toolName, []);
                 }
-                // Use shared parameter extraction logic
                 const paramKey = extractParameterKey(metadata);
                 if (paramKey) {
-                    // Apply path shortening and truncation for display
                     const displayKey = truncate(this.shortenPath(paramKey), 80);
                     toolsSummary.get(toolName).push(displayKey);
                 }
                 else {
-                    // For tools with no extractable parameter key, add a placeholder
-                    // This ensures the tool still shows up in the summary
                     toolsSummary.get(toolName).push('(default)');
                 }
             }
         }
         return toolsSummary;
     }
-    /**
-     * Group deduplication details by tool type
-     * Shared helper used by notifications and tool output formatting
-     */
     groupDeduplicationDetails(deduplicationDetails) {
         const grouped = new Map();
         for (const [_, details] of deduplicationDetails) {
             const { toolName, parameterKey, duplicateCount } = details;
-            // Skip 'batch' tool in UI summary - it's a wrapper and its children are shown individually
             if (toolName === 'batch')
                 continue;
             if (!grouped.has(toolName)) {
@@ -493,10 +386,6 @@ export class Janitor {
         }
         return grouped;
     }
-    /**
-     * Format grouped deduplication results as lines
-     * Shared helper for building deduplication summaries
-     */
     formatDeduplicationLines(grouped, indent = '  ') {
         const lines = [];
         for (const [toolName, items] of grouped.entries()) {
@@ -507,10 +396,6 @@ export class Janitor {
         }
         return lines;
     }
-    /**
-     * Format tool summary (from buildToolsSummary) as lines
-     * Shared helper for building LLM-pruned summaries
-     */
     formatToolSummaryLines(toolsSummary, indent = '  ') {
         const lines = [];
         for (const [toolName, params] of toolsSummary.entries()) {
@@ -526,47 +411,34 @@ export class Janitor {
         }
         return lines;
     }
-    /**
-     * Send minimal summary notification (just tokens saved and count)
-     */
     async sendMinimalNotification(sessionID, totalPruned, tokensSaved, sessionStats) {
         if (totalPruned === 0)
             return;
         const tokensFormatted = formatTokenCount(tokensSaved);
         const toolText = totalPruned === 1 ? 'tool' : 'tools';
         let message = `🧹 DCP: Saved ~${tokensFormatted} tokens (${totalPruned} ${toolText} pruned)`;
-        // Add session totals if there's been more than one pruning run
         if (sessionStats.totalToolsPruned > totalPruned) {
             message += ` │ Session: ~${formatTokenCount(sessionStats.totalTokensSaved)} tokens, ${sessionStats.totalToolsPruned} tools`;
         }
         await this.sendIgnoredMessage(sessionID, message);
     }
-    /**
-     * Auto mode notification - shows only deduplication results
-     */
     async sendAutoModeNotification(sessionID, deduplicatedIds, deduplicationDetails, tokensSaved, sessionStats) {
         if (deduplicatedIds.length === 0)
             return;
-        // Check if notifications are disabled
         if (this.pruningSummary === 'off')
             return;
-        // Send minimal notification if configured
         if (this.pruningSummary === 'minimal') {
             await this.sendMinimalNotification(sessionID, deduplicatedIds.length, tokensSaved, sessionStats);
             return;
         }
-        // Otherwise send detailed notification
         const tokensFormatted = formatTokenCount(tokensSaved);
         const toolText = deduplicatedIds.length === 1 ? 'tool' : 'tools';
         let message = `🧹 DCP: Saved ~${tokensFormatted} tokens (${deduplicatedIds.length} duplicate ${toolText} removed)`;
-        // Add session totals if there's been more than one pruning run
         if (sessionStats.totalToolsPruned > deduplicatedIds.length) {
             message += ` │ Session: ~${formatTokenCount(sessionStats.totalTokensSaved)} tokens, ${sessionStats.totalToolsPruned} tools`;
         }
         message += '\n';
-        // Group by tool type using shared helper
         const grouped = this.groupDeduplicationDetails(deduplicationDetails);
-        // Display grouped results (with UI-specific formatting: total dupes header, limit to 5)
         for (const [toolName, items] of grouped.entries()) {
             const totalDupes = items.reduce((sum, item) => sum + (item.count - 1), 0);
             message += `\n${toolName} (${totalDupes} duplicate${totalDupes > 1 ? 's' : ''}):\n`;
@@ -580,22 +452,16 @@ export class Janitor {
         }
         await this.sendIgnoredMessage(sessionID, message.trim());
     }
-    /**
-     * Format pruning result for tool output (returned to AI)
-     * Uses shared helpers for consistency with UI notifications
-     */
     formatPruningResultForTool(result) {
         const lines = [];
         lines.push(`Context pruning complete. Pruned ${result.prunedCount} tool outputs.`);
         lines.push('');
-        // Section 1: Deduplicated tools
         if (result.deduplicatedIds.length > 0 && result.deduplicationDetails.size > 0) {
             lines.push(`Duplicates removed (${result.deduplicatedIds.length}):`);
             const grouped = this.groupDeduplicationDetails(result.deduplicationDetails);
             lines.push(...this.formatDeduplicationLines(grouped));
             lines.push('');
         }
-        // Section 2: LLM-pruned tools
         if (result.llmPrunedIds.length > 0) {
             lines.push(`Semantically pruned (${result.llmPrunedIds.length}):`);
             const toolsSummary = this.buildToolsSummary(result.llmPrunedIds, result.toolMetadata);
@@ -603,42 +469,33 @@ export class Janitor {
         }
         return lines.join('\n').trim();
     }
-    /**
-     * Smart mode notification - shows both deduplication and LLM analysis results
-     */
     async sendSmartModeNotification(sessionID, deduplicatedIds, deduplicationDetails, llmPrunedIds, toolMetadata, tokensSaved, sessionStats) {
         const totalPruned = deduplicatedIds.length + llmPrunedIds.length;
         if (totalPruned === 0)
             return;
-        // Check if notifications are disabled
         if (this.pruningSummary === 'off')
             return;
-        // Send minimal notification if configured
         if (this.pruningSummary === 'minimal') {
             await this.sendMinimalNotification(sessionID, totalPruned, tokensSaved, sessionStats);
             return;
         }
-        // Otherwise send detailed notification
         const tokensFormatted = formatTokenCount(tokensSaved);
         let message = `🧹 DCP: Saved ~${tokensFormatted} tokens (${totalPruned} tool${totalPruned > 1 ? 's' : ''} pruned)`;
-        // Add session totals if there's been more than one pruning run
         if (sessionStats.totalToolsPruned > totalPruned) {
             message += ` │ Session: ~${formatTokenCount(sessionStats.totalTokensSaved)} tokens, ${sessionStats.totalToolsPruned} tools`;
         }
         message += '\n';
-        // Section 1: Deduplicated tools
         if (deduplicatedIds.length > 0 && deduplicationDetails) {
             message += `\n📦 Duplicates removed (${deduplicatedIds.length}):\n`;
             const grouped = this.groupDeduplicationDetails(deduplicationDetails);
             for (const [toolName, items] of grouped.entries()) {
                 message += `  ${toolName}:\n`;
                 for (const item of items) {
-                    const removedCount = item.count - 1; // Total occurrences minus the one we kept
+                    const removedCount = item.count - 1;
                     message += `    ${item.key} (${removedCount}× duplicate)\n`;
                 }
             }
         }
-        // Section 2: LLM-pruned tools
         if (llmPrunedIds.length > 0) {
             message += `\n🤖 LLM analysis (${llmPrunedIds.length}):\n`;
             const toolsSummary = this.buildToolsSummary(llmPrunedIds, toolMetadata);
@@ -650,11 +507,12 @@ export class Janitor {
                     }
                 }
             }
-            // Handle any tools that weren't found in metadata (edge case)
             const foundToolNames = new Set(toolsSummary.keys());
             const missingTools = llmPrunedIds.filter(id => {
                 const normalizedId = id.toLowerCase();
                 const metadata = toolMetadata.get(normalizedId);
+                if (metadata?.tool === 'batch')
+                    return false;
                 return !metadata || !foundToolNames.has(metadata.tool);
             });
             if (missingTools.length > 0) {