fix: recognize Agent tool as subagent + harden Ctrl+C exit

The analyzer hardcoded 'Task' for subagent detection but Claude Code's
tool is called 'Agent', causing all subagent time to be miscategorized
as tool execution. Now recognizes both names via SUBAGENT_TOOLS set.

Also wraps live mode cleanup in try/catch/finally so process.exit(0)
always runs, and adds a re-entrancy guard for force-exit on second Ctrl+C.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Dennis

src/analyzer.test.ts

@@ -111,7 +111,7 @@ describe('analyzer: enhanced phases', () => {
     expect(result.enhancedStats.claudeThink).toBe(6000);
   });
 
-  it('should classify Task tool as subagent time', () => {
+  it('should classify Task tool as subagent time (legacy)', () => {
     const result = analyzeSession('s1', [
       userMsg('2026-01-01T00:00:00Z'),
       assistantMsg('2026-01-01T00:00:02Z', { toolUses: [{ id: 'tu1', name: 'Task' }] }),
@@ -122,6 +122,27 @@ describe('analyzer: enhanced phases', () => {
     expect(result.enhancedStats.toolExec).toBe(0);
   });
 
+  it('should classify Agent tool as subagent time', () => {
+    const result = analyzeSession('s1', [
+      userMsg('2026-01-01T00:00:00Z'),
+      assistantMsg('2026-01-01T00:00:02Z', { toolUses: [{ id: 'tu1', name: 'Agent' }] }),
+      toolResultMsg('2026-01-01T00:01:00Z', ['tu1']), // 58s subagent
+    ]);
+
+    expect(result.enhancedStats.subagent).toBe(58000);
+    expect(result.enhancedStats.toolExec).toBe(0);
+  });
+
+  it('should classify Agent tool as subagent in legacy phases', () => {
+    const result = analyzeSession('s1', [
+      userMsg('2026-01-01T00:00:00Z'),
+      assistantMsg('2026-01-01T00:00:02Z', { toolUses: [{ id: 'tu1', name: 'Agent' }] }),
+      toolResultMsg('2026-01-01T00:01:00Z', ['tu1']),
+    ]);
+
+    expect(result.stats.subagent).toBeGreaterThan(0);
+  });
+
   it('should not double-count away time in active duration', () => {
     const result = analyzeSession('s1', [
       userMsg('2026-01-01T00:00:00Z'),

src/analyzer.ts

@@ -6,6 +6,7 @@ import type {
 import { estimateCost } from './pricing.js';
 
 const IDLE_THRESHOLD_MS = 2 * 60 * 1000; // 2 minutes
+const SUBAGENT_TOOLS = new Set(['Task', 'Agent']);
 
 export function analyzeSession(sessionId: string, messages: SessionMessage[]): SessionAnalysis {
   const mainMessages = messages.filter(m => !m.isSidechain);
@@ -120,7 +121,7 @@ function detectPhases(messages: SessionMessage[]): TimeSegment[] {
           if (!planModeActive) { closeCurrentPhase(ts); planModeActive = true; currentPhase = 'planning'; }
         } else if (c.name === 'ExitPlanMode') {
           if (planModeActive) { closeCurrentPhase(ts); planModeActive = false; currentPhase = 'coding'; }
-        } else if (c.name === 'Task' && c.id) {
+        } else if (c.name && SUBAGENT_TOOLS.has(c.name) && c.id) {
           activeSubagents.set(c.id, ts);
           if (activeSubagents.size === 1) { closeCurrentPhase(ts); currentPhase = 'subagent'; }
         }
@@ -163,8 +164,8 @@ function detectEnhancedPhases(messages: SessionMessage[]): EnhancedTimeSegment[]
 
   // Track pending tool_use calls: id -> { name, timestamp }
   const pendingTools = new Map<string, { name: string; ts: number }>();
-  // Track pending subagent calls (Task tool): id -> timestamp
-  const pendingSubagents = new Map<string, number>();
+  // Track pending subagent calls (Task/Agent tool): id -> { name, timestamp }
+  const pendingSubagents = new Map<string, { name: string; ts: number }>();
 
   let lastAssistantEndTs: number | null = null;
   let lastExternalUserTs: number | null = null;
@@ -189,8 +190,8 @@ function detectEnhancedPhases(messages: SessionMessage[]): EnhancedTimeSegment[]
           if (c.type !== 'tool_result' || !c.tool_use_id) continue;
 
           if (pendingSubagents.has(c.tool_use_id)) {
-            const startTs = pendingSubagents.get(c.tool_use_id)!;
-            emit('subagent', startTs, ts, 'Task');
+            const { name, ts: startTs } = pendingSubagents.get(c.tool_use_id)!;
+            emit('subagent', startTs, ts, name);
             pendingSubagents.delete(c.tool_use_id);
           } else if (pendingTools.has(c.tool_use_id)) {
             const { name, ts: startTs } = pendingTools.get(c.tool_use_id)!;
@@ -245,8 +246,8 @@ function detectEnhancedPhases(messages: SessionMessage[]): EnhancedTimeSegment[]
           planModeActive = true;
         } else if (c.name === 'ExitPlanMode') {
           planModeActive = false;
-        } else if (c.name === 'Task') {
-          pendingSubagents.set(c.id, ts);
+        } else if (c.name && SUBAGENT_TOOLS.has(c.name)) {
+          pendingSubagents.set(c.id, { name: c.name, ts });
         } else {
           pendingTools.set(c.id, { name: c.name ?? 'unknown', ts });
         }

src/live.ts

@@ -135,16 +135,25 @@ export async function startLiveMode(projectFilter?: string): Promise<void> {
   const periodicTimer = setInterval(refresh, 5000);
 
   // Graceful shutdown
+  let cleaningUp = false;
   function cleanup() {
-    if (watcher) {
-      watcher.close();
-      watcher = null;
+    if (cleaningUp) {
+      process.exit(1);
+    }
+    cleaningUp = true;
+    try {
+      if (watcher) {
+        watcher.close();
+        watcher = null;
+      }
+      if (debounceTimer) clearTimeout(debounceTimer);
+      clearInterval(periodicTimer);
+      process.stdout.write('\x1b[?25h');
+    } catch {
+      // Ignore cleanup errors
+    } finally {
+      process.exit(0);
     }
-    if (debounceTimer) clearTimeout(debounceTimer);
-    clearInterval(periodicTimer);
-    // Restore cursor
-    process.stdout.write('\x1b[?25h');
-    process.exit(0);
   }
 
   process.on('SIGINT', cleanup);
@@ -237,12 +246,22 @@ export async function startAggregateLiveMode(
   // Periodic refresh (picks up new sessions, updates wall-clock timers)
   const periodicTimer = setInterval(refresh, 5000);
 
+  let cleaningUp = false;
   function cleanup() {
-    if (watcher) { watcher.close(); watcher = null; }
-    if (debounceTimer) clearTimeout(debounceTimer);
-    clearInterval(periodicTimer);
-    process.stdout.write('\x1b[?25h');
-    process.exit(0);
+    if (cleaningUp) {
+      process.exit(1);
+    }
+    cleaningUp = true;
+    try {
+      if (watcher) { watcher.close(); watcher = null; }
+      if (debounceTimer) clearTimeout(debounceTimer);
+      clearInterval(periodicTimer);
+      process.stdout.write('\x1b[?25h');
+    } catch {
+      // Ignore cleanup errors
+    } finally {
+      process.exit(0);
+    }
   }
 
   process.on('SIGINT', cleanup);