@playcraft/cli 0.0.44 → 0.0.47

package/project-template/.claude/skills/session-analyzer/scripts/execution-breakdown.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+/**
+ * execution-breakdown.mjs — Generate a phased execution breakdown for a subagent
+ *
+ * Automatically detects "phases" by grouping consecutive tool calls of similar type,
+ * then shows time allocation per phase. Useful for understanding where agent time was spent.
+ *
+ * Usage:
+ *   node execution-breakdown.mjs <subagent.jsonl>
+ *
+ * Output: phase breakdown with duration, percentage, and tool counts
+ */
+
+import { readFileSync } from 'fs';
+
+const filePath = process.argv[2];
+
+if (!filePath) {
+  console.error('Usage: node execution-breakdown.mjs <subagent.jsonl>');
+  process.exit(1);
+}
+
+const lines = readFileSync(filePath, 'utf8').trim().split('\n');
+
+// Collect timestamped events with tool info
+const events = [];
+lines.forEach((line, idx) => {
+  try {
+    const obj = JSON.parse(line);
+    if (!obj.timestamp) return;
+    const ts = new Date(obj.timestamp).getTime();
+
+    if (obj.type === 'assistant') {
+      const blocks = obj.message?.content || [];
+      for (const b of blocks) {
+        if (b.type === 'tool_use') {
+          let detail = '';
+          if (b.name === 'Write' || b.name === 'Edit' || b.name === 'Read') {
+            detail = b.input?.file_path?.split(/[/\\]/).pop() || '';
+          } else if (b.name === 'Bash') {
+            detail = (b.input?.command || '').substring(0, 50);
+          }
+          events.push({ line: idx + 1, ts, type: 'tool', name: b.name, detail });
+        } else if (b.type === 'thinking') {
+          events.push({ line: idx + 1, ts, type: 'thinking', size: b.thinking.length });
+        }
+      }
+    } else if (obj.type === 'user') {
+      const content = obj.message?.content;
+      if (Array.isArray(content) && content[0]?.type === 'tool_result') {
+        events.push({ line: idx + 1, ts, type: 'result', isError: content[0].is_error || false });
+      }
+    }
+  } catch (e) { /* skip */ }
+});
+
+if (events.length < 2) {
+  console.log('Not enough events to analyze.');
+  process.exit(0);
+}
+
+const totalDuration = events[events.length - 1].ts - events[0].ts;
+
+// Auto-detect phases: a "phase" changes when there's a significant thinking block (>5KB)
+// or when tool type shifts from read→write, write→bash, etc.
+const phases = [];
+let currentPhase = { start: events[0], events: [events[0]], label: '' };
+
+function classifyPhase(phaseEvents) {
+  const toolCounts = {};
+  let bigThink = 0;
+  phaseEvents.forEach(e => {
+    if (e.type === 'tool') toolCounts[e.name] = (toolCounts[e.name] || 0) + 1;
+    if (e.type === 'thinking' && e.size > 5000) bigThink++;
+  });
+
+  const dominant = Object.entries(toolCounts).sort((a, b) => b[1] - a[1])[0];
+  if (bigThink > 0 && !dominant) return 'Planning/Thinking';
+  if (!dominant) return 'Thinking';
+
+  const name = dominant[0];
+  const files = phaseEvents.filter(e => e.type === 'tool').map(e => e.detail).filter(Boolean);
+  const uniqueFiles = [...new Set(files)];
+
+  if (name === 'Read' && toolCounts.Read > toolCounts.Write) return 'Reading files';
+  if (name === 'Write') return `Writing files (${uniqueFiles.length} files)`;
+  if (name === 'Edit') return `Editing files (${uniqueFiles.length} files)`;
+  if (name === 'Bash') {
+    const cmds = phaseEvents.filter(e => e.type === 'tool' && e.name === 'Bash').map(e => e.detail);
+    if (cmds.some(c => c.includes('npm install') || c.includes('pnpm install'))) return 'Installing dependencies';
+    if (cmds.some(c => c.includes('http-server') || c.includes('dev') || c.includes('curl'))) return 'Dev server setup/verification';
+    if (cmds.some(c => c.includes('kill') || c.includes('netstat') || c.includes('lsof'))) return 'Process/port debugging';
+    return 'Running commands';
+  }
+  if (name === 'Grep' || name === 'Glob') return 'Searching codebase';
+  return `${name} operations`;
+}
+
+// Split into phases by significant gaps (>15s) or thinking blocks >10KB
+for (let i = 1; i < events.length; i++) {
+  const gap = events[i].ts - events[i - 1].ts;
+  const isBigThink = events[i].type === 'thinking' && events[i].size > 10000;
+  const isLongGap = gap > 15000;
+
+  if (isBigThink || isLongGap) {
+    // Finalize current phase
+    currentPhase.end = events[i - 1];
+    phases.push(currentPhase);
+    // Start new phase
+    currentPhase = { start: events[i], events: [events[i]], label: '' };
+  } else {
+    currentPhase.events.push(events[i]);
+  }
+}
+// Finalize last phase
+currentPhase.end = events[events.length - 1];
+phases.push(currentPhase);
+
+// Classify and calculate
+phases.forEach(p => {
+  p.duration = (p.end?.ts || p.start.ts) - p.start.ts;
+  // If phase is just a start event, estimate from gap
+  if (p.duration === 0 && phases.indexOf(p) < phases.length - 1) {
+    const nextPhase = phases[phases.indexOf(p) + 1];
+    p.duration = nextPhase.start.ts - p.start.ts;
+  }
+  p.label = classifyPhase(p.events);
+  p.toolCount = p.events.filter(e => e.type === 'tool').length;
+});
+
+// Merge very short phases (< 5s) into previous
+const mergedPhases = [];
+for (const p of phases) {
+  if (mergedPhases.length > 0 && p.duration < 5000) {
+    const prev = mergedPhases[mergedPhases.length - 1];
+    prev.events.push(...p.events);
+    prev.end = p.end;
+    prev.duration += p.duration;
+    prev.toolCount += p.toolCount;
+  } else {
+    mergedPhases.push(p);
+  }
+}
+
+// Re-classify merged phases
+mergedPhases.forEach(p => {
+  p.label = classifyPhase(p.events);
+});
+
+// Output
+console.log('=== EXECUTION BREAKDOWN ===');
+console.log(`File: ${filePath}`);
+console.log(`Total duration: ${(totalDuration / 1000).toFixed(1)}s (${(totalDuration / 1000 / 60).toFixed(1)} min)`);
+console.log(`Total events: ${events.length} | Phases detected: ${mergedPhases.length}`);
+console.log('');
+
+console.log('#'.padEnd(4) + 'Duration'.padEnd(12) + '%'.padEnd(8) + 'Tools'.padEnd(8) + 'Phase');
+console.log('-'.repeat(70));
+
+mergedPhases.forEach((p, i) => {
+  const dur = (p.duration / 1000).toFixed(0) + 's';
+  const pct = (p.duration / totalDuration * 100).toFixed(1) + '%';
+  console.log(
+    String(i + 1).padEnd(4) +
+    dur.padEnd(12) +
+    pct.padEnd(8) +
+    String(p.toolCount).padEnd(8) +
+    p.label
+  );
+});
+
+// Time allocation
+console.log('\n=== TIME ALLOCATION ===');
+const categories = {};
+mergedPhases.forEach(p => {
+  const cat = p.label.split(' (')[0]; // Remove file count details
+  categories[cat] = (categories[cat] || 0) + p.duration;
+});
+Object.entries(categories).sort((a, b) => b[1] - a[1]).forEach(([cat, ms]) => {
+  const bar = '#'.repeat(Math.round(ms / totalDuration * 40));
+  console.log(`  ${cat.padEnd(30)} ${(ms / 1000).toFixed(0)}s (${(ms / totalDuration * 100).toFixed(1)}%) ${bar}`);
+});

package/project-template/.claude/skills/session-analyzer/scripts/find-turns.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+/**
+ * find-turns.mjs — Locate all user-initiated turns in a session JSONL
+ *
+ * Usage:
+ *   node find-turns.mjs <session.jsonl>
+ *   node find-turns.mjs <session.jsonl> --verbose
+ *
+ * Output: line number, timestamp, promptSource, and message preview for each turn start
+ */
+
+import { readFileSync } from 'fs';
+
+const sessionPath = process.argv[2];
+const verbose = process.argv.includes('--verbose');
+
+if (!sessionPath) {
+  console.error('Usage: node find-turns.mjs <session.jsonl> [--verbose]');
+  process.exit(1);
+}
+
+const lines = readFileSync(sessionPath, 'utf8').trim().split('\n');
+const turns = [];
+
+lines.forEach((line, idx) => {
+  try {
+    const obj = JSON.parse(line);
+    if (obj.type !== 'user') return;
+
+    const content = obj.message?.content;
+    // Skip tool_result lines — they're continuations, not new turns
+    if (Array.isArray(content) && content[0]?.type === 'tool_result') return;
+    // Skip system notifications unless they have promptSource
+    if (obj.origin?.kind === 'task-notification' && !obj.promptSource) return;
+
+    const ts = obj.timestamp || '';
+    const promptSource = obj.promptSource || 'tool_result';
+    const isTyped = promptSource === 'typed';
+    const isSystem = promptSource === 'system';
+
+    let preview = '';
+    if (typeof content === 'string') {
+      preview = content.substring(0, 100);
+    } else if (Array.isArray(content) && content[0]?.text) {
+      preview = content[0].text.substring(0, 100);
+    }
+
+    turns.push({ line: idx + 1, ts, promptSource, isTyped, preview });
+  } catch (e) { /* skip parse errors */ }
+});
+
+console.log(`=== TURNS FOUND: ${turns.length} ===\n`);
+
+turns.forEach((t, i) => {
+  const marker = t.isTyped ? '>>> ' : '    ';
+  const srcTag = `[${t.promptSource}]`.padEnd(10);
+  console.log(`${marker}Turn ${i + 1} | Line ${t.line} | ${t.ts} ${srcTag}`);
+  if (verbose || t.isTyped) {
+    console.log(`     ${t.preview}`);
+  }
+  console.log('');
+});
+
+// Print summary
+const typed = turns.filter(t => t.isTyped).length;
+const system = turns.filter(t => t.promptSource === 'system').length;
+console.log(`--- Summary: ${typed} user-typed, ${system} system-triggered, ${turns.length} total ---`);
+if (turns.length >= 2) {
+  const first = new Date(turns[0].ts).getTime();
+  const last = new Date(turns[turns.length - 1].ts).getTime();
+  console.log(`--- Session span: ${((last - first) / 1000 / 60).toFixed(1)} minutes ---`);
+}

package/project-template/.claude/skills/session-analyzer/scripts/heavy-output.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * heavy-output.mjs — Find turns with heavy thinking/writing output in a session/subagent
+ *
+ * Identifies which turns generated the most content (large thinking blocks, big file writes)
+ * to understand where the model spent its output budget.
+ *
+ * Usage:
+ *   node heavy-output.mjs <file.jsonl>
+ *   node heavy-output.mjs <file.jsonl> --min-kb 3     (minimum 3KB, default 5)
+ *   node heavy-output.mjs <file.jsonl> --top 20       (show top 20, default 15)
+ *
+ * Output: sorted list of heaviest output turns with content breakdown
+ */
+
+import { readFileSync } from 'fs';
+
+const filePath = process.argv[2];
+const minIdx = process.argv.indexOf('--min-kb');
+const minKB = minIdx >= 0 ? parseFloat(process.argv[minIdx + 1]) : 5;
+const topIdx = process.argv.indexOf('--top');
+const topN = topIdx >= 0 ? parseInt(process.argv[topIdx + 1], 10) : 15;
+
+if (!filePath) {
+  console.error('Usage: node heavy-output.mjs <file.jsonl> [--min-kb <N>] [--top <N>]');
+  process.exit(1);
+}
+
+const lines = readFileSync(filePath, 'utf8').trim().split('\n');
+const heavyTurns = [];
+
+lines.forEach((line, idx) => {
+  try {
+    const obj = JSON.parse(line);
+    if (obj.type !== 'assistant') return;
+
+    const blocks = obj.message?.content || [];
+    let thinkLen = 0;
+    let textLen = 0;
+    let writeBytes = 0;
+    let toolNames = [];
+    let writePaths = [];
+
+    for (const b of blocks) {
+      if (b.type === 'thinking') {
+        thinkLen += b.thinking.length;
+      } else if (b.type === 'text') {
+        textLen += b.text.length;
+      } else if (b.type === 'tool_use') {
+        toolNames.push(b.name);
+        if (b.name === 'Write' && b.input?.content) {
+          writeBytes += b.input.content.length;
+          writePaths.push(b.input.file_path?.split(/[/\\]/).pop() || '?');
+        } else if (b.name === 'Edit' && b.input?.new_string) {
+          writeBytes += b.input.new_string.length;
+          writePaths.push(b.input.file_path?.split(/[/\\]/).pop() || '?');
+        }
+      }
+    }
+
+    const totalKB = (thinkLen + textLen + writeBytes) / 1024;
+    if (totalKB >= minKB) {
+      heavyTurns.push({
+        line: idx + 1,
+        ts: obj.timestamp,
+        thinkKB: (thinkLen / 1024).toFixed(1),
+        textKB: (textLen / 1024).toFixed(1),
+        writeKB: (writeBytes / 1024).toFixed(1),
+        totalKB: totalKB.toFixed(1),
+        toolNames,
+        writePaths,
+      });
+    }
+  } catch (e) { /* skip */ }
+});
+
+heavyTurns.sort((a, b) => parseFloat(b.totalKB) - parseFloat(a.totalKB));
+const shown = heavyTurns.slice(0, topN);
+
+const totalOutput = heavyTurns.reduce((sum, t) => sum + parseFloat(t.totalKB), 0);
+
+console.log(`=== HEAVY OUTPUT ANALYSIS ===`);
+console.log(`File: ${filePath}`);
+console.log(`Turns with output >= ${minKB}KB: ${heavyTurns.length}`);
+console.log(`Total heavy output: ${totalOutput.toFixed(1)}KB`);
+console.log('');
+
+console.log('=== TOP HEAVY TURNS ===\n');
+console.log('Line'.padEnd(8) + 'Time'.padEnd(10) + 'Think'.padEnd(9) + 'Text'.padEnd(8) + 'Write'.padEnd(9) + 'Total'.padEnd(9) + 'Details');
+console.log('-'.repeat(90));
+
+shown.forEach(t => {
+  const time = t.ts ? new Date(t.ts).toISOString().substring(11, 19) : '??:??:??';
+  let details = '';
+  if (parseFloat(t.thinkKB) > 0 && t.toolNames.length === 0) {
+    details = '[pure thinking]';
+  } else if (t.writePaths.length > 0) {
+    details = t.writePaths.join(', ');
+  } else if (t.toolNames.length > 0) {
+    details = t.toolNames.join(', ');
+  }
+
+  console.log(
+    `L${t.line}`.padEnd(8) +
+    time.padEnd(10) +
+    `${t.thinkKB}KB`.padEnd(9) +
+    `${t.textKB}KB`.padEnd(8) +
+    `${t.writeKB}KB`.padEnd(9) +
+    `${t.totalKB}KB`.padEnd(9) +
+    details.substring(0, 40)
+  );
+});
+
+// Category breakdown
+console.log('\n=== OUTPUT CATEGORY BREAKDOWN ===');
+const totalThink = heavyTurns.reduce((s, t) => s + parseFloat(t.thinkKB), 0);
+const totalText = heavyTurns.reduce((s, t) => s + parseFloat(t.textKB), 0);
+const totalWrite = heavyTurns.reduce((s, t) => s + parseFloat(t.writeKB), 0);
+console.log(`  Thinking: ${totalThink.toFixed(1)}KB (${(totalThink / totalOutput * 100).toFixed(0)}%)`);
+console.log(`  Text: ${totalText.toFixed(1)}KB (${(totalText / totalOutput * 100).toFixed(0)}%)`);
+console.log(`  File writes: ${totalWrite.toFixed(1)}KB (${(totalWrite / totalOutput * 100).toFixed(0)}%)`);

package/project-template/.claude/skills/session-analyzer/scripts/resolve-session.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * resolve-session.mjs — Resolve a project name + session ID to the actual file path
+ *
+ * Searches across all three session stores (Claude Code, Claude Internal, CodeBuddy).
+ *
+ * Usage:
+ *   node resolve-session.mjs <project-keyword> <session-uuid>
+ *   node resolve-session.mjs tencent-test10 55f43f72-d61e-4847-8133-be9d600d9816
+ *   node resolve-session.mjs <project-keyword>    (list all sessions for matching project)
+ *
+ * Output: full path to session.jsonl + subagents directory
+ */
+
+import { readdirSync, existsSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+const keyword = process.argv[2];
+const sessionId = process.argv[3];
+
+if (!keyword) {
+  console.error('Usage: node resolve-session.mjs <project-keyword> [session-uuid]');
+  process.exit(1);
+}
+
+const home = homedir();
+const stores = [
+  { name: 'Claude Code', path: join(home, '.claude', 'projects') },
+  { name: 'Claude Internal', path: join(home, '.claude-internal', 'projects') },
+  { name: 'CodeBuddy', path: join(home, '.codebuddy', 'projects') },
+];
+
+const matches = [];
+
+for (const store of stores) {
+  if (!existsSync(store.path)) continue;
+  const projects = readdirSync(store.path);
+  const matching = projects.filter(p => p.toLowerCase().includes(keyword.toLowerCase()));
+
+  for (const proj of matching) {
+    const projPath = join(store.path, proj);
+    const stat = statSync(projPath);
+    if (!stat.isDirectory()) continue;
+
+    if (sessionId) {
+      // Look for specific session
+      const sessionFile = join(projPath, `${sessionId}.jsonl`);
+      if (existsSync(sessionFile)) {
+        const subagentsDir = join(projPath, sessionId, 'subagents');
+        const hasSubagents = existsSync(subagentsDir);
+        matches.push({ store: store.name, project: proj, sessionFile, subagentsDir: hasSubagents ? subagentsDir : null });
+      }
+    } else {
+      // List all sessions in project
+      const files = readdirSync(projPath).filter(f => f.endsWith('.jsonl'));
+      for (const f of files) {
+        const fullPath = join(projPath, f);
+        const size = statSync(fullPath).size;
+        const sid = f.replace('.jsonl', '');
+        const subDir = join(projPath, sid, 'subagents');
+        const subCount = existsSync(subDir) ? readdirSync(subDir).filter(s => s.endsWith('.jsonl')).length : 0;
+        matches.push({ store: store.name, project: proj, file: f, path: fullPath, sizeKB: (size / 1024).toFixed(0), subagents: subCount });
+      }
+    }
+  }
+}
+
+if (matches.length === 0) {
+  console.log(`No matches found for keyword "${keyword}"${sessionId ? ` / session "${sessionId}"` : ''}`);
+  process.exit(1);
+}
+
+if (sessionId) {
+  console.log('=== SESSION RESOLVED ===');
+  matches.forEach(m => {
+    console.log(`Store: ${m.store}`);
+    console.log(`Project: ${m.project}`);
+    console.log(`Session JSONL: ${m.sessionFile}`);
+    if (m.subagentsDir) {
+      console.log(`Subagents dir: ${m.subagentsDir}`);
+      const subFiles = readdirSync(m.subagentsDir).filter(f => f.endsWith('.jsonl'));
+      console.log(`Subagent count: ${subFiles.length}`);
+      subFiles.forEach(f => console.log(`  - ${f}`));
+    } else {
+      console.log('Subagents: none');
+    }
+  });
+} else {
+  console.log(`=== SESSIONS IN "${keyword}" PROJECTS ===\n`);
+  matches.sort((a, b) => parseInt(b.sizeKB) - parseInt(a.sizeKB));
+  console.log('Store'.padEnd(18) + 'Size'.padEnd(10) + 'Subs'.padEnd(6) + 'Session');
+  console.log('-'.repeat(80));
+  matches.forEach(m => {
+    console.log(
+      m.store.padEnd(18) +
+      `${m.sizeKB}KB`.padEnd(10) +
+      String(m.subagents).padEnd(6) +
+      m.file.replace('.jsonl', '')
+    );
+  });
+  console.log(`\nTotal: ${matches.length} sessions`);
+}

package/project-template/.claude/skills/session-analyzer/scripts/subagent-stats.mjs

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * subagent-stats.mjs — Extract execution stats for all Agent calls in a session/turn
+ *
+ * Usage:
+ *   node subagent-stats.mjs <session.jsonl>
+ *   node subagent-stats.mjs <session.jsonl> <startLine> <endLine>
+ *
+ * Output: for each Agent tool_result, prints agentId, type, duration, tokens, tool counts
+ */
+
+import { readFileSync } from 'fs';
+
+const sessionPath = process.argv[2];
+const startLine = process.argv[3] ? parseInt(process.argv[3], 10) : 1;
+const endLine = process.argv[4] ? parseInt(process.argv[4], 10) : Infinity;
+
+if (!sessionPath) {
+  console.error('Usage: node subagent-stats.mjs <session.jsonl> [startLine] [endLine]');
+  process.exit(1);
+}
+
+const lines = readFileSync(sessionPath, 'utf8').trim().split('\n');
+const end = Math.min(endLine, lines.length);
+
+// Phase 1: Find all Agent tool_use calls
+const agentCalls = [];
+for (let i = startLine - 1; i < end; i++) {
+  try {
+    const obj = JSON.parse(lines[i]);
+    if (obj.type === 'assistant') {
+      const blocks = obj.message?.content || [];
+      for (const b of blocks) {
+        if (b.type === 'tool_use' && b.name === 'Agent') {
+          agentCalls.push({
+            line: i + 1,
+            ts: obj.timestamp,
+            toolUseId: b.id,
+            description: b.input?.description || '',
+            prompt: (b.input?.prompt || '').substring(0, 80),
+            subagentType: b.input?.subagent_type || 'general-purpose',
+          });
+        }
+      }
+    }
+  } catch (e) { /* skip */ }
+}
+
+// Phase 2: Find corresponding tool_results
+for (const call of agentCalls) {
+  for (let i = call.line; i < end; i++) {
+    try {
+      const obj = JSON.parse(lines[i]);
+      if (obj.type === 'user' && obj.toolUseResult?.agentId) {
+        // Check if this result matches our call
+        const content = obj.message?.content;
+        if (Array.isArray(content) && content[0]?.tool_use_id === call.toolUseId) {
+          const r = obj.toolUseResult;
+          call.result = {
+            line: i + 1,
+            ts: obj.timestamp,
+            agentId: r.agentId,
+            agentType: r.agentType || call.subagentType,
+            status: r.status,
+            totalDurationMs: r.totalDurationMs,
+            totalTokens: r.totalTokens,
+            totalToolUseCount: r.totalToolUseCount,
+            toolStats: r.toolStats,
+          };
+          break;
+        }
+      }
+    } catch (e) { /* skip */ }
+  }
+}
+
+// Output
+console.log(`=== SUBAGENT STATS (Lines ${startLine}-${end}) ===`);
+console.log(`Found ${agentCalls.length} Agent calls\n`);
+
+agentCalls.forEach((call, idx) => {
+  console.log(`--- Agent #${idx + 1}: ${call.description} ---`);
+  console.log(`  Type: ${call.subagentType}`);
+  console.log(`  Called at: L${call.line} | ${call.ts}`);
+  console.log(`  Prompt: ${call.prompt}...`);
+
+  if (call.result) {
+    const r = call.result;
+    const durationMin = (r.totalDurationMs / 1000 / 60).toFixed(1);
+    const durationSec = (r.totalDurationMs / 1000).toFixed(1);
+    console.log(`  Returned at: L${r.line} | ${r.ts}`);
+    console.log(`  Agent ID: ${r.agentId}`);
+    console.log(`  Status: ${r.status}`);
+    console.log(`  Duration: ${durationSec}s (${durationMin} min)`);
+    console.log(`  Tokens: ${r.totalTokens}`);
+    console.log(`  Tool calls: ${r.totalToolUseCount}`);
+    if (r.toolStats) {
+      const s = r.toolStats;
+      console.log(`  Tool breakdown: Read=${s.readCount || 0} | Search=${s.searchCount || 0} | Bash=${s.bashCount || 0} | Edit=${s.editFileCount || 0} | Other=${s.otherToolCount || 0}`);
+      console.log(`  Lines: +${s.linesAdded || 0} / -${s.linesRemoved || 0}`);
+    }
+  } else {
+    console.log(`  [NO RESULT FOUND - may be outside line range or still running]`);
+  }
+  console.log('');
+});
+
+// Summary table
+if (agentCalls.length > 1) {
+  console.log('=== SUMMARY TABLE ===');
+  console.log('Agent'.padEnd(40) + 'Duration'.padEnd(12) + 'Tokens'.padEnd(10) + 'Tools'.padEnd(8) + 'Lines+');
+  console.log('-'.repeat(78));
+  agentCalls.forEach(call => {
+    if (call.result) {
+      const r = call.result;
+      const dur = (r.totalDurationMs / 1000).toFixed(0) + 's';
+      const lines = r.toolStats ? `+${r.toolStats.linesAdded || 0}` : '-';
+      console.log(
+        call.description.substring(0, 38).padEnd(40) +
+        dur.padEnd(12) +
+        String(r.totalTokens || 0).padEnd(10) +
+        String(r.totalToolUseCount || 0).padEnd(8) +
+        lines
+      );
+    }
+  });
+}