@tarquinen/opencode-dcp 0.3.9 → 0.3.11

package/dist/lib/janitor.d.ts

@@ -1,8 +1,12 @@
 import type { Logger } from "./logger";
-import type { StateManager } from "./state";
+export interface SessionStats {
+    totalToolsPruned: number;
+    totalTokensSaved: number;
+}
 export declare class Janitor {
     private client;
-    private stateManager;
+    private prunedIdsState;
+    private statsState;
     private logger;
     private toolParametersCache;
     private protectedTools;
@@ -12,7 +16,7 @@ export declare class Janitor {
     private pruningMode;
     private pruningSummary;
     private workingDirectory?;
-    constructor(client: any, stateManager: StateManager, logger: Logger, toolParametersCache: Map<string, any>, protectedTools: string[], modelCache: Map<string, {
+    constructor(client: any, prunedIdsState: Map<string, string[]>, statsState: Map<string, SessionStats>, logger: Logger, toolParametersCache: Map<string, any>, protectedTools: string[], modelCache: Map<string, {
         providerID: string;
         modelID: string;
     }>, configModel?: string | undefined, // Format: "provider/model"
@@ -29,6 +33,10 @@ export declare class Janitor {
      * Helper function to shorten paths for display
      */
     private shortenPath;
+    /**
+     * Shorten a single path string
+     */
+    private shortenSinglePath;
     /**
      * 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

package/dist/lib/janitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"janitor.d.ts","sourceRoot":"","sources":["../../lib/janitor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAM3C,qBAAa,OAAO;IAEZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,YAAY;IACpB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,gBAAgB,CAAC;gBAVjB,MAAM,EAAE,GAAG,EACX,YAAY,EAAE,YAAY,EAC1B,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,cAAc,EAAE,MAAM,EAAE,EACxB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,EAChE,WAAW,CAAC,EAAE,MAAM,YAAA,EAAE,2BAA2B;IACjD,oBAAoB,GAAE,OAAc,EAAE,yCAAyC;IAC/E,WAAW,GAAE,MAAM,GAAG,OAAiB,EAAE,mBAAmB;IAC5D,cAAc,GAAE,KAAK,GAAG,SAAS,GAAG,UAAuB,EAAE,0BAA0B;IACvF,gBAAgB,CAAC,EAAE,MAAM,YAAA;IAGrC;;OAEG;YACW,kBAAkB;IA4B1B,GAAG,CAAC,SAAS,EAAE,MAAM;IAua3B;;OAEG;IACH,OAAO,CAAC,WAAW;IAiCnB;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;OAEG;YACW,oBAAoB;IAmBlC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAoCzB;;OAEG;YACW,uBAAuB;IAiBrC;;OAEG;YACW,wBAAwB;IAyDtC;;OAEG;YACW,yBAAyB;CAuF1C"}
+{"version":3,"file":"janitor.d.ts","sourceRoot":"","sources":["../../lib/janitor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAMtC,MAAM,WAAW,YAAY;IACzB,gBAAgB,EAAE,MAAM,CAAA;IACxB,gBAAgB,EAAE,MAAM,CAAA;CAC3B;AAED,qBAAa,OAAO;IAEZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,mBAAmB;IAC3B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,WAAW,CAAC;IACpB,OAAO,CAAC,oBAAoB;IAC5B,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,gBAAgB,CAAC;gBAXjB,MAAM,EAAE,GAAG,EACX,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,EACrC,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EACrC,cAAc,EAAE,MAAM,EAAE,EACxB,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,EAChE,WAAW,CAAC,EAAE,MAAM,YAAA,EAAE,2BAA2B;IACjD,oBAAoB,GAAE,OAAc,EAAE,yCAAyC;IAC/E,WAAW,GAAE,MAAM,GAAG,OAAiB,EAAE,mBAAmB;IAC5D,cAAc,GAAE,KAAK,GAAG,SAAS,GAAG,UAAuB,EAAE,0BAA0B;IACvF,gBAAgB,CAAC,EAAE,MAAM,YAAA;IAGrC;;OAEG;YACW,kBAAkB;IAsB1B,GAAG,CAAC,SAAS,EAAE,MAAM;IAkR3B;;OAEG;IACH,OAAO,CAAC,WAAW;IAcnB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA0CzB;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;OAEG;YACW,oBAAoB;IAmBlC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;IAoCzB;;OAEG;YACW,uBAAuB;IAqBrC;;OAEG;YACW,wBAAwB;IA8DtC;;OAEG;YACW,yBAAyB;CA0F1C"}

package/dist/lib/janitor.js

@@ -5,7 +5,8 @@ import { estimateTokensBatch, formatTokenCount } from "./tokenizer";
 import { detectDuplicates, extractParameterKey } from "./deduplicator";
 export class Janitor {
     client;
-    stateManager;
+    prunedIdsState;
+    statsState;
     logger;
     toolParametersCache;
     protectedTools;
@@ -15,14 +16,15 @@ export class Janitor {
     pruningMode;
     pruningSummary;
     workingDirectory;
-    constructor(client, stateManager, logger, toolParametersCache, protectedTools, modelCache, configModel, // Format: "provider/model"
+    constructor(client, prunedIdsState, statsState, logger, toolParametersCache, protectedTools, modelCache, configModel, // Format: "provider/model"
     showModelErrorToasts = true, // Whether to show toast for model errors
     pruningMode = "smart", // Pruning strategy
     pruningSummary = "detailed", // UI summary display mode
     workingDirectory // Current working directory for relative path display
     ) {
         this.client = client;
-        this.stateManager = stateManager;
+        this.prunedIdsState = prunedIdsState;
+        this.statsState = statsState;
         this.logger = logger;
         this.toolParametersCache = toolParametersCache;
         this.protectedTools = protectedTools;
@@ -51,24 +53,16 @@ export class Janitor {
                         }]
                 }
             });
-            this.logger.debug("janitor", "Sent ignored message to session", {
-                sessionID,
-                textLength: text.length
-            });
         }
         catch (error) {
-            this.logger.error("janitor", "Failed to send ignored message", {
-                sessionID,
+            this.logger.error("janitor", "Failed to send notification", {
                 error: error.message
             });
-            // Don't fail the operation if sending the message fails
         }
     }
     async run(sessionID) {
-        this.logger.info("janitor", "Starting analysis", { sessionID });
         try {
             // Fetch session info and messages from OpenCode API
-            this.logger.debug("janitor", "Fetching session info and messages", { sessionID });
             const [sessionInfoResponse, messagesResponse] = await Promise.all([
                 this.client.session.get({ path: { id: sessionID } }),
                 this.client.session.messages({ path: { id: sessionID }, query: { limit: 100 } })
@@ -76,16 +70,8 @@ export class Janitor {
             const sessionInfo = sessionInfoResponse.data;
             // Handle the response format - it should be { data: Array<{info, parts}> } or just the array
             const messages = messagesResponse.data || messagesResponse;
-            this.logger.debug("janitor", "Retrieved messages", {
-                sessionID,
-                messageCount: messages.length
-            });
             // If there are no messages or very few, skip analysis
             if (!messages || messages.length < 3) {
-                this.logger.debug("janitor", "Too few messages to analyze, skipping", {
-                    sessionID,
-                    messageCount: messages?.length || 0
-                });
                 return;
             }
             // Extract tool call IDs from the session and track their output sizes
@@ -111,83 +97,32 @@ export class Janitor {
                                 tool: part.tool,
                                 parameters: parameters
                             });
-                            // Debug: log what we're storing
-                            if (normalizedId.startsWith('prt_') || part.tool === "read" || part.tool === "list") {
-                                this.logger.debug("janitor", "Storing tool metadata", {
-                                    sessionID,
-                                    callID: normalizedId,
-                                    tool: part.tool,
-                                    hasParameters: !!parameters,
-                                    hasCached: !!cachedData,
-                                    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") {
-                                const batchId = normalizedId;
-                                currentBatchId = batchId;
-                                batchToolChildren.set(batchId, []);
-                                this.logger.debug("janitor", "Found batch tool", {
-                                    sessionID,
-                                    batchID: currentBatchId
-                                });
+                                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_')) {
-                                const children = batchToolChildren.get(currentBatchId);
-                                children.push(normalizedId);
-                                this.logger.debug("janitor", "Added child to batch tool", {
-                                    sessionID,
-                                    batchID: currentBatchId,
-                                    childID: normalizedId,
-                                    totalChildren: children.length
-                                });
+                                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_')) {
-                                this.logger.debug("janitor", "Batch tool ended", {
-                                    sessionID,
-                                    batchID: currentBatchId,
-                                    totalChildren: batchToolChildren.get(currentBatchId).length
-                                });
                                 currentBatchId = null;
                             }
                         }
                     }
                 }
             }
-            // Log summary of batch tools found
-            if (batchToolChildren.size > 0) {
-                this.logger.debug("janitor", "Batch tool summary", {
-                    sessionID,
-                    batchCount: batchToolChildren.size,
-                    batches: Array.from(batchToolChildren.entries()).map(([id, children]) => ({
-                        batchID: id,
-                        childCount: children.length,
-                        childIDs: children
-                    }))
-                });
-            }
             // Get already pruned IDs to filter them out
-            const alreadyPrunedIds = await this.stateManager.get(sessionID);
+            const alreadyPrunedIds = this.prunedIdsState.get(sessionID) ?? [];
             const unprunedToolCallIds = toolCallIds.filter(id => !alreadyPrunedIds.includes(id));
-            this.logger.debug("janitor", "Found tool calls in session", {
-                sessionID,
-                toolCallCount: toolCallIds.length,
-                toolCallIds,
-                alreadyPrunedCount: alreadyPrunedIds.length,
-                alreadyPrunedIds: alreadyPrunedIds.slice(0, 5), // Show first 5 for brevity
-                unprunedCount: unprunedToolCallIds.length
-            });
             // If there are no unpruned tool calls, skip analysis
             if (unprunedToolCallIds.length === 0) {
-                this.logger.debug("janitor", "No unpruned tool calls found, skipping analysis", {
-                    sessionID
-                });
                 return;
             }
             // ============================================================
@@ -196,11 +131,11 @@ export class Janitor {
             const dedupeResult = detectDuplicates(toolMetadata, unprunedToolCallIds, this.protectedTools);
             const deduplicatedIds = dedupeResult.duplicateIds;
             const deduplicationDetails = dedupeResult.deduplicationDetails;
-            this.logger.info("janitor", "Duplicate detection complete", {
-                sessionID,
-                duplicatesFound: deduplicatedIds.length,
-                uniqueToolPatterns: deduplicationDetails.size
-            });
+            // 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 (only runs in "smart" mode)
             // ============================================================
@@ -220,39 +155,15 @@ export class Janitor {
                     }
                     return true;
                 });
-                if (protectedToolCallIds.length > 0) {
-                    this.logger.debug("janitor", "Protected tools excluded from pruning", {
-                        sessionID,
-                        protectedCount: protectedToolCallIds.length,
-                        protectedTools: protectedToolCallIds.map(id => {
-                            const metadata = toolMetadata.get(id);
-                            return { id, tool: metadata?.tool };
-                        })
-                    });
-                }
                 // Run LLM analysis only if there are prunable tools
                 if (prunableToolCallIds.length > 0) {
-                    this.logger.info("janitor", "Starting LLM analysis", {
-                        sessionID,
-                        candidateCount: prunableToolCallIds.length
-                    });
                     // Select appropriate model with intelligent fallback
                     const cachedModelInfo = this.modelCache.get(sessionID);
                     const sessionModelInfo = extractModelFromSession(sessionInfo, this.logger);
                     const currentModelInfo = cachedModelInfo || sessionModelInfo;
-                    if (cachedModelInfo) {
-                        this.logger.debug("janitor", "Using cached model info", {
-                            sessionID,
-                            providerID: cachedModelInfo.providerID,
-                            modelID: cachedModelInfo.modelID
-                        });
-                    }
                     const modelSelection = await selectModel(currentModelInfo, this.logger, this.configModel, this.workingDirectory);
-                    this.logger.info("janitor", "Model selected for analysis", {
-                        sessionID,
-                        modelInfo: modelSelection.modelInfo,
-                        source: modelSelection.source,
-                        reason: modelSelection.reason
+                    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) {
@@ -265,53 +176,27 @@ export class Janitor {
                                     duration: 5000
                                 }
                             });
-                            this.logger.info("janitor", "Toast notification shown for model fallback", {
-                                failedModel: modelSelection.failedModel,
-                                selectedModel: modelSelection.modelInfo
-                            });
                         }
                         catch (toastError) {
-                            this.logger.error("janitor", "Failed to show toast notification", {
-                                error: toastError.message
-                            });
                             // Don't fail the whole operation if toast fails
                         }
                     }
-                    else if (modelSelection.failedModel && !this.showModelErrorToasts) {
-                        this.logger.info("janitor", "Model fallback occurred but toast disabled by config", {
-                            failedModel: modelSelection.failedModel,
-                            selectedModel: modelSelection.modelInfo
-                        });
-                    }
-                    // Log comprehensive stats before AI call
-                    this.logger.info("janitor", "Preparing AI analysis", {
-                        sessionID,
-                        totalToolCallsInSession: toolCallIds.length,
-                        alreadyPrunedCount: alreadyPrunedIds.length,
-                        deduplicatedCount: deduplicatedIds.length,
-                        protectedToolsCount: protectedToolCallIds.length,
-                        candidatesForPruning: prunableToolCallIds.length,
-                        candidateTools: prunableToolCallIds.map(id => {
-                            const meta = toolMetadata.get(id);
-                            return meta ? `${meta.tool}[${id.substring(0, 12)}...]` : id.substring(0, 12) + '...';
-                        }).slice(0, 10), // Show first 10 for brevity
-                        batchToolCount: batchToolChildren.size,
-                        batchDetails: Array.from(batchToolChildren.entries()).map(([batchId, children]) => ({
-                            batchId: batchId.substring(0, 20) + '...',
-                            childCount: children.length
-                        }))
-                    });
-                    this.logger.debug("janitor", "Starting shadow inference", { sessionID });
+                    // 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);
-                    this.logger.debug("janitor", "Sanitized messages for analysis", {
+                    // Build the prompt for analysis
+                    const analysisPrompt = buildAnalysisPrompt(prunableToolCallIds, sanitizedMessages, this.protectedTools, allPrunedSoFar, protectedToolCallIds);
+                    // Save janitor shadow context directly (auth providers may bypass globalThis.fetch)
+                    await this.logger.saveWrappedContext("janitor-shadow", [{ role: "user", content: analysisPrompt }], {
                         sessionID,
-                        totalPrunedBeforeAnalysis: allPrunedSoFar.length,
-                        prunedIds: allPrunedSoFar.slice(0, 5) // Show first 5
+                        modelProvider: modelSelection.modelInfo.providerID,
+                        modelID: modelSelection.modelInfo.modelID,
+                        candidateToolCount: prunableToolCallIds.length,
+                        alreadyPrunedCount: allPrunedSoFar.length,
+                        protectedToolCount: protectedToolCallIds.length
                     });
-                    // Lazy import - only load the 2.8MB ai package when actually needed
-                    const { generateObject } = await import('ai');
                     // Analyze which tool calls are obsolete
                     const result = await generateObject({
                         model: modelSelection.model,
@@ -319,47 +204,23 @@ export class Janitor {
                             pruned_tool_call_ids: z.array(z.string()),
                             reasoning: z.string(),
                         }),
-                        prompt: buildAnalysisPrompt(prunableToolCallIds, sanitizedMessages, this.protectedTools, allPrunedSoFar, protectedToolCallIds)
+                        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 (rawLlmPrunedIds.length !== llmPrunedIds.length) {
-                        this.logger.warn("janitor", "LLM returned non-candidate IDs (filtered out)", {
-                            sessionID,
-                            rawCount: rawLlmPrunedIds.length,
-                            filteredCount: llmPrunedIds.length,
-                            invalidIds: 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 ? '...' : ''}`);
                     }
-                    this.logger.info("janitor", "LLM analysis complete", {
-                        sessionID,
-                        llmPrunedCount: llmPrunedIds.length,
-                        reasoning: result.object.reasoning
-                    });
-                }
-                else {
-                    this.logger.info("janitor", "No prunable tools for LLM analysis", {
-                        sessionID,
-                        deduplicatedCount: deduplicatedIds.length,
-                        protectedCount: protectedToolCallIds.length
-                    });
                 }
             }
-            else {
-                this.logger.info("janitor", "Skipping LLM analysis (auto mode)", {
-                    sessionID,
-                    deduplicatedCount: deduplicatedIds.length
-                });
-            }
-            // If mode is "auto", llmPrunedIds stays empty
             // ============================================================
             // PHASE 3: COMBINE & EXPAND
             // ============================================================
             const newlyPrunedIds = [...deduplicatedIds, ...llmPrunedIds];
             if (newlyPrunedIds.length === 0) {
-                this.logger.info("janitor", "No tools to prune", { sessionID });
                 return;
             }
             // Expand batch tool IDs to include their children
@@ -370,12 +231,6 @@ export class Janitor {
                 // If this is a batch tool, add all its children
                 const children = batchToolChildren.get(normalizedId);
                 if (children) {
-                    this.logger.debug("janitor", "Expanding batch tool to include children", {
-                        sessionID,
-                        batchID: normalizedId,
-                        childCount: children.length,
-                        childIDs: children
-                    });
                     children.forEach(childId => expandedPrunedIds.add(childId));
                 }
             }
@@ -383,48 +238,41 @@ export class Janitor {
             const finalNewlyPrunedIds = Array.from(expandedPrunedIds).filter(id => !alreadyPrunedIds.includes(id));
             // finalPrunedIds includes everything (new + already pruned) for logging
             const finalPrunedIds = Array.from(expandedPrunedIds);
-            this.logger.info("janitor", "Analysis complete", {
-                sessionID,
-                prunedCount: finalPrunedIds.length,
-                deduplicatedCount: deduplicatedIds.length,
-                llmPrunedCount: llmPrunedIds.length,
-                prunedIds: finalPrunedIds
-            });
-            this.logger.debug("janitor", "Pruning ID details", {
-                sessionID,
-                alreadyPrunedCount: alreadyPrunedIds.length,
-                alreadyPrunedIds: alreadyPrunedIds,
-                finalPrunedCount: finalPrunedIds.length,
-                finalPrunedIds: finalPrunedIds,
-                newlyPrunedCount: finalNewlyPrunedIds.length,
-                newlyPrunedIds: finalNewlyPrunedIds
-            });
             // ============================================================
             // PHASE 4: 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);
             if (this.pruningMode === "auto") {
-                await this.sendAutoModeNotification(sessionID, deduplicatedIds, deduplicationDetails, toolOutputs);
+                await this.sendAutoModeNotification(sessionID, deduplicatedIds, deduplicationDetails, tokensSaved, sessionStats);
             }
             else {
-                await this.sendSmartModeNotification(sessionID, deduplicatedIds, deduplicationDetails, llmPrunedIds, toolMetadata, toolOutputs);
+                await this.sendSmartModeNotification(sessionID, deduplicatedIds, deduplicationDetails, llmPrunedIds, toolMetadata, tokensSaved, sessionStats);
             }
             // ============================================================
             // PHASE 5: STATE UPDATE
             // ============================================================
             // Merge newly pruned IDs with existing ones (using expanded IDs)
             const allPrunedIds = [...new Set([...alreadyPrunedIds, ...finalPrunedIds])];
-            await this.stateManager.set(sessionID, allPrunedIds);
-            this.logger.debug("janitor", "Updated state manager", {
-                sessionID,
-                totalPrunedCount: allPrunedIds.length,
-                newlyPrunedCount: finalNewlyPrunedIds.length
-            });
+            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)` : "";
+            this.logger.info("janitor", `Pruned ${prunedCount}/${candidateCount} tools${breakdown}, ${keptCount} kept (~${formatTokenCount(tokensSaved)} tokens)`);
         }
         catch (error) {
             this.logger.error("janitor", "Analysis failed", {
-                sessionID,
-                error: error.message,
-                stack: error.stack
+                error: error.message
             });
             // Don't throw - this is a fire-and-forget background process
             // Silently fail and try again on next idle event
@@ -433,9 +281,34 @@ export class Janitor {
     /**
      * Helper function to shorten paths for display
      */
-    shortenPath(path) {
-        // Replace home directory with ~
+    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];
+            const pathPart = inPathMatch[2];
+            const shortenedPath = this.shortenSinglePath(pathPart);
+            return `${prefix} in ${shortenedPath}`;
+        }
+        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);
         }
@@ -444,19 +317,17 @@ export class Janitor {
         if (nodeModulesMatch) {
             return `${nodeModulesMatch[1]}/${nodeModulesMatch[2]}`;
         }
-        // Strip working directory to show relative paths
+        // Try matching against ~ version of working directory (for paths already with ~)
         if (this.workingDirectory) {
-            // Try to match against the absolute working directory first
-            if (path.startsWith(this.workingDirectory + '/')) {
-                return path.slice(this.workingDirectory.length + 1);
-            }
-            // Also try matching against ~ version of working directory
             const workingDirWithTilde = this.workingDirectory.startsWith(homeDir)
                 ? '~' + this.workingDirectory.slice(homeDir.length)
                 : null;
             if (workingDirWithTilde && path.startsWith(workingDirWithTilde + '/')) {
                 return path.slice(workingDirWithTilde.length + 1);
             }
+            if (workingDirWithTilde && path === workingDirWithTilde) {
+                return '.';
+            }
         }
         return path;
     }
@@ -506,7 +377,7 @@ export class Janitor {
         }
         if (outputsToTokenize.length > 0) {
             // Use batch tokenization for efficiency (lazy loads gpt-tokenizer)
-            const tokenCounts = await estimateTokensBatch(outputsToTokenize, this.logger);
+            const tokenCounts = await estimateTokensBatch(outputsToTokenize);
             return tokenCounts.reduce((sum, count) => sum + count, 0);
         }
         return 0;
@@ -553,19 +424,22 @@ export class Janitor {
     /**
      * Send minimal summary notification (just tokens saved and count)
      */
-    async sendMinimalNotification(sessionID, totalPruned, toolOutputs, prunedIds) {
+    async sendMinimalNotification(sessionID, totalPruned, tokensSaved, sessionStats) {
         if (totalPruned === 0)
             return;
-        const tokensSaved = await this.calculateTokensSaved(prunedIds, toolOutputs);
         const tokensFormatted = formatTokenCount(tokensSaved);
         const toolText = totalPruned === 1 ? 'tool' : 'tools';
-        const message = `🧹 DCP: Saved ~${tokensFormatted} tokens (${totalPruned} ${toolText} pruned)`;
+        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, toolOutputs) {
+    async sendAutoModeNotification(sessionID, deduplicatedIds, deduplicationDetails, tokensSaved, sessionStats) {
         if (deduplicatedIds.length === 0)
             return;
         // Check if notifications are disabled
@@ -573,15 +447,18 @@ export class Janitor {
             return;
         // Send minimal notification if configured
         if (this.pruningSummary === 'minimal') {
-            await this.sendMinimalNotification(sessionID, deduplicatedIds.length, toolOutputs, deduplicatedIds);
+            await this.sendMinimalNotification(sessionID, deduplicatedIds.length, tokensSaved, sessionStats);
             return;
         }
         // Otherwise send detailed notification
-        // Calculate token savings
-        const tokensSaved = await this.calculateTokensSaved(deduplicatedIds, toolOutputs);
         const tokensFormatted = formatTokenCount(tokensSaved);
         const toolText = deduplicatedIds.length === 1 ? 'tool' : 'tools';
-        let message = `🧹 DCP: Saved ~${tokensFormatted} tokens (${deduplicatedIds.length} duplicate ${toolText} removed)\n`;
+        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
         const grouped = new Map();
         for (const [_, details] of deduplicationDetails) {
@@ -611,7 +488,7 @@ export class Janitor {
     /**
      * Smart mode notification - shows both deduplication and LLM analysis results
      */
-    async sendSmartModeNotification(sessionID, deduplicatedIds, deduplicationDetails, llmPrunedIds, toolMetadata, toolOutputs) {
+    async sendSmartModeNotification(sessionID, deduplicatedIds, deduplicationDetails, llmPrunedIds, toolMetadata, tokensSaved, sessionStats) {
         const totalPruned = deduplicatedIds.length + llmPrunedIds.length;
         if (totalPruned === 0)
             return;
@@ -620,16 +497,17 @@ export class Janitor {
             return;
         // Send minimal notification if configured
         if (this.pruningSummary === 'minimal') {
-            const allPrunedIds = [...deduplicatedIds, ...llmPrunedIds];
-            await this.sendMinimalNotification(sessionID, totalPruned, toolOutputs, allPrunedIds);
+            await this.sendMinimalNotification(sessionID, totalPruned, tokensSaved, sessionStats);
             return;
         }
         // Otherwise send detailed notification
-        // Calculate token savings
-        const allPrunedIds = [...deduplicatedIds, ...llmPrunedIds];
-        const tokensSaved = await this.calculateTokensSaved(allPrunedIds, toolOutputs);
         const tokensFormatted = formatTokenCount(tokensSaved);
-        let message = `🧹 DCP: Saved ~${tokensFormatted} tokens (${totalPruned} tool${totalPruned > 1 ? 's' : ''} pruned)\n`;
+        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`;