refactor: simplify notification UI and remove unused code

Author: Tarquinen

lib/core/janitor.ts

@@ -16,6 +16,7 @@ export interface SessionStats {
     totalToolsPruned: number
     totalTokensSaved: number
     totalGCTokens: number
+    totalGCTools: number
 }
 
 export interface GCStats {
@@ -181,14 +182,16 @@ async function runWithStrategies(
         const currentStats = state.stats.get(sessionID) ?? {
             totalToolsPruned: 0,
             totalTokensSaved: 0,
-            totalGCTokens: 0
+            totalGCTokens: 0,
+            totalGCTools: 0
         }
 
         // Update session stats including GC contribution
         const sessionStats: SessionStats = {
             totalToolsPruned: currentStats.totalToolsPruned + finalNewlyPrunedIds.length,
             totalTokensSaved: currentStats.totalTokensSaved + tokensSaved,
-            totalGCTokens: currentStats.totalGCTokens + (gcPending?.tokensCollected ?? 0)
+            totalGCTokens: currentStats.totalGCTokens + (gcPending?.tokensCollected ?? 0),
+            totalGCTools: currentStats.totalGCTools + (gcPending?.toolsDeduped ?? 0)
         }
         state.stats.set(sessionID, sessionStats)
 
@@ -466,7 +469,9 @@ async function calculateTokensSaved(prunedIds: string[], toolOutputs: Map<string
     const outputsToTokenize: string[] = []
 
     for (const prunedId of prunedIds) {
-        const output = toolOutputs.get(prunedId)
+        // toolOutputs uses lowercase keys, so normalize the lookup
+        const normalizedId = prunedId.toLowerCase()
+        const output = toolOutputs.get(normalizedId)
         if (output) {
             outputsToTokenize.push(output)
         }

lib/state/index.ts

@@ -64,7 +64,8 @@ export async function ensureSessionRestored(
             const stats: SessionStats = {
                 totalToolsPruned: persisted.stats.totalToolsPruned,
                 totalTokensSaved: persisted.stats.totalTokensSaved,
-                totalGCTokens: persisted.stats.totalGCTokens ?? 0
+                totalGCTokens: persisted.stats.totalGCTokens ?? 0,
+                totalGCTools: persisted.stats.totalGCTools ?? 0
             }
             state.stats.set(sessionId, stats)
         }

lib/ui/notification.ts

@@ -75,105 +75,84 @@ export async function sendUnifiedNotification(
 }
 
 function buildMinimalMessage(data: NotificationData): string {
-    const hasAiPruning = data.aiPrunedCount > 0
-    const hasGcActivity = data.gcPending && data.gcPending.toolsDeduped > 0
+    const { justNowTokens, totalTokens } = calculateStats(data)
 
-    if (hasAiPruning) {
-        const gcTokens = hasGcActivity ? data.gcPending!.tokensCollected : 0
-        const totalSaved = formatTokenCount(data.aiTokensSaved + gcTokens)
-        const toolText = data.aiPrunedCount === 1 ? 'tool' : 'tools'
-
-        let cycleStats = `${data.aiPrunedCount} ${toolText}`
-        if (hasGcActivity) {
-            cycleStats += `, ~${formatTokenCount(data.gcPending!.tokensCollected)} 🗑️`
-        }
+    return formatStatsHeader(totalTokens, justNowTokens)
+}
 
-        let message = `🧹 DCP: ~${totalSaved} saved (${cycleStats})`
-        message += buildSessionSuffix(data.sessionStats, data.aiPrunedCount)
+function calculateStats(data: NotificationData): {
+    justNowTokens: number
+    totalTokens: number
+} {
+    // "Just now" = AI pruning + pending GC from this notification cycle
+    const justNowTokens = data.aiTokensSaved + (data.gcPending?.tokensCollected ?? 0)
 
-        return message
-    } else {
-        const tokensCollected = formatTokenCount(data.gcPending!.tokensCollected)
+    // Session stats are updated BEFORE notification is sent, so they already include
+    // the current cycle's values (totalTokensSaved includes current cycle, totalGCTokens includes current cycle)
+    const totalTokens = data.sessionStats
+        ? data.sessionStats.totalTokensSaved + data.sessionStats.totalGCTokens
+        : justNowTokens
 
-        let message = `🗑️ DCP: ~${tokensCollected} collected`
-        message += buildSessionSuffix(data.sessionStats, 0)
+    return { justNowTokens, totalTokens }
+}
 
-        return message
-    }
+function formatStatsHeader(
+    totalTokens: number,
+    justNowTokens: number
+): string {
+    // Format token counts (formatTokenCount already includes "tokens" suffix)
+    const totalTokensStr = `~${formatTokenCount(totalTokens)}`
+    const justNowTokensStr = `~${formatTokenCount(justNowTokens)}`
+
+    // Pad token strings to align columns
+    const maxTokenLen = Math.max(totalTokensStr.length, justNowTokensStr.length)
+    const totalTokensPadded = totalTokensStr.padStart(maxTokenLen)
+    const justNowTokensPadded = justNowTokensStr.padStart(maxTokenLen)
+
+    return [
+        `▣ DCP Stats`,
+        `  Total saved │ ${totalTokensPadded}`,
+        `  Just now    │ ${justNowTokensPadded}`,
+    ].join('\n')
 }
 
 function buildDetailedMessage(data: NotificationData, workingDirectory?: string): string {
-    const hasAiPruning = data.aiPrunedCount > 0
-    const hasGcActivity = data.gcPending && data.gcPending.toolsDeduped > 0
-
-    let message: string
-
-    if (hasAiPruning) {
-        const gcTokens = hasGcActivity ? data.gcPending!.tokensCollected : 0
-        const totalSaved = formatTokenCount(data.aiTokensSaved + gcTokens)
-        const toolText = data.aiPrunedCount === 1 ? 'tool' : 'tools'
-
-        let cycleStats = `${data.aiPrunedCount} ${toolText}`
-        if (hasGcActivity) {
-            cycleStats += `, ~${formatTokenCount(data.gcPending!.tokensCollected)} 🗑️`
-        }
+    const { justNowTokens, totalTokens } = calculateStats(data)
 
-        message = `🧹 DCP: ~${totalSaved} saved (${cycleStats})`
-        message += buildSessionSuffix(data.sessionStats, data.aiPrunedCount)
-        message += '\n'
+    let message = formatStatsHeader(totalTokens, justNowTokens)
 
-        message += `\n🤖 LLM analysis (${data.aiPrunedIds.length}):\n`
-        const toolsSummary = buildToolsSummary(data.aiPrunedIds, data.toolMetadata, workingDirectory)
-
-        for (const [toolName, params] of toolsSummary.entries()) {
-            if (params.length > 0) {
-                message += `  ${toolName} (${params.length}):\n`
-                for (const param of params) {
-                    message += `    ${param}\n`
+    // Add tool breakdown if there was AI pruning
+    if (data.aiPrunedCount > 0) {
+        message += '\n\n▣ Pruned tools:'
+        
+        for (const prunedId of data.aiPrunedIds) {
+            const normalizedId = prunedId.toLowerCase()
+            const metadata = data.toolMetadata.get(normalizedId)
+            
+            if (metadata) {
+                const paramKey = extractParameterKey(metadata)
+                if (paramKey) {
+                    const displayKey = truncate(shortenPath(paramKey, workingDirectory), 60)
+                    message += `\n→ ${metadata.tool}: ${displayKey}`
+                } else {
+                    message += `\n→ ${metadata.tool}`
                 }
             }
         }
 
-        const foundToolNames = new Set(toolsSummary.keys())
-        const missingTools = data.aiPrunedIds.filter(id => {
-            const normalizedId = id.toLowerCase()
-            const metadata = data.toolMetadata.get(normalizedId)
-            return !metadata || !foundToolNames.has(metadata.tool)
-        })
+        const knownCount = data.aiPrunedIds.filter(id => 
+            data.toolMetadata.has(id.toLowerCase())
+        ).length
+        const unknownCount = data.aiPrunedIds.length - knownCount
 
-        if (missingTools.length > 0) {
-            message += `  (${missingTools.length} tool${missingTools.length > 1 ? 's' : ''} with unknown metadata)\n`
+        if (unknownCount > 0) {
+            message += `\n→ (${unknownCount} tool${unknownCount > 1 ? 's' : ''} with unknown metadata)`
         }
-    } else {
-        const tokensCollected = formatTokenCount(data.gcPending!.tokensCollected)
-
-        message = `🗑️ DCP: ~${tokensCollected} collected`
-        message += buildSessionSuffix(data.sessionStats, 0)
     }
 
     return message.trim()
 }
 
-function buildSessionSuffix(sessionStats: SessionStats | null, currentAiPruned: number): string {
-    if (!sessionStats) {
-        return ''
-    }
-
-    if (sessionStats.totalToolsPruned <= currentAiPruned) {
-        return ''
-    }
-
-    const totalSaved = sessionStats.totalTokensSaved + sessionStats.totalGCTokens
-    let suffix = ` │ Session: ~${formatTokenCount(totalSaved)} (${sessionStats.totalToolsPruned} tools`
-
-    if (sessionStats.totalGCTokens > 0) {
-        suffix += `, ~${formatTokenCount(sessionStats.totalGCTokens)} 🗑️`
-    }
-
-    suffix += ')'
-    return suffix
-}
-
 export function formatPruningResultForTool(
     result: PruningResult,
     workingDirectory?: string