@playcraft/cli 0.1.36-beta1 → 0.1.38-beta

package/project-template-v2/.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-v2/.claude/skills/session-analyzer/scripts/resolve-session.mjs

@@ -0,0 +1,102 @@
+#!/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: '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-v2/.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
+      );
+    }
+  });
+}

package/project-template-v2/.claude/skills/session-analyzer/scripts/subagent-tool-timeline.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+/**
+ * subagent-tool-timeline.mjs — Parse a subagent's JSONL to show all tool calls in sequence
+ *
+ * Usage:
+ *   node subagent-tool-timeline.mjs <subagent.jsonl>
+ *   node subagent-tool-timeline.mjs <subagent.jsonl> --compact
+ *
+ * Output: numbered tool call list with timestamps and input previews
+ */
+
+import { readFileSync } from 'fs';
+
+const filePath = process.argv[2];
+const compact = process.argv.includes('--compact');
+
+if (!filePath) {
+  console.error('Usage: node subagent-tool-timeline.mjs <subagent.jsonl> [--compact]');
+  process.exit(1);
+}
+
+const lines = readFileSync(filePath, 'utf8').trim().split('\n');
+const toolCalls = [];
+let startTs = null;
+let endTs = null;
+
+lines.forEach((line, idx) => {
+  try {
+    const obj = JSON.parse(line);
+    const ts = obj.timestamp;
+    if (ts) {
+      if (!startTs) startTs = ts;
+      endTs = ts;
+    }
+
+    if (obj.type === 'assistant') {
+      const blocks = obj.message?.content || [];
+      for (const b of blocks) {
+        if (b.type === 'tool_use') {
+          const inputStr = JSON.stringify(b.input || {});
+          toolCalls.push({
+            line: idx + 1,
+            ts,
+            name: b.name,
+            id: b.id,
+            inputPreview: compact ? inputStr.substring(0, 60) : inputStr.substring(0, 150),
+            // For Write/Edit, capture file path
+            filePath: b.input?.file_path || '',
+            // For Bash, capture command
+            command: b.input?.command?.substring(0, 80) || '',
+          });
+        }
+      }
+    }
+  } catch (e) { /* skip */ }
+});
+
+const totalDuration = startTs && endTs
+  ? ((new Date(endTs).getTime() - new Date(startTs).getTime()) / 1000).toFixed(1)
+  : '?';
+
+console.log(`=== SUBAGENT TOOL TIMELINE ===`);
+console.log(`File: ${filePath}`);
+console.log(`Duration: ${totalDuration}s | Tool calls: ${toolCalls.length}`);
+console.log('');
+
+// Group by phase (consecutive same-type operations)
+toolCalls.forEach((tc, i) => {
+  const time = tc.ts ? new Date(tc.ts).toISOString().substring(11, 19) : '??:??:??';
+  const num = String(i + 1).padStart(3, ' ');
+
+  if (compact) {
+    // Compact: one line per call
+    let detail = '';
+    if (tc.name === 'Write' || tc.name === 'Edit' || tc.name === 'Read') {
+      const fname = tc.filePath.split(/[/\\]/).pop();
+      detail = fname;
+    } else if (tc.name === 'Bash') {
+      detail = tc.command.substring(0, 50);
+    } else {
+      detail = tc.inputPreview.substring(0, 50);
+    }
+    console.log(`${num}. ${time} ${tc.name.padEnd(6)} ${detail}`);
+  } else {
+    // Full: name + input preview
+    console.log(`${num}. [L${tc.line}] ${time} ${tc.name}`);
+    if (tc.name === 'Write' || tc.name === 'Edit' || tc.name === 'Read') {
+      console.log(`     file: ${tc.filePath}`);
+    } else if (tc.name === 'Bash') {
+      console.log(`     cmd: ${tc.command}`);
+    } else if (tc.name === 'Grep' || tc.name === 'Glob') {
+      console.log(`     ${tc.inputPreview}`);
+    } else {
+      console.log(`     ${tc.inputPreview}`);
+    }
+  }
+});
+
+// Tool count summary
+console.log('');
+console.log('=== TOOL COUNT SUMMARY ===');
+const counts = {};
+toolCalls.forEach(tc => { counts[tc.name] = (counts[tc.name] || 0) + 1; });
+Object.entries(counts).sort((a, b) => b[1] - a[1]).forEach(([name, count]) => {
+  console.log(`  ${name}: ${count}`);
+});

package/project-template-v2/.claude/skills/session-analyzer/scripts/time-gaps.mjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * time-gaps.mjs — Find the largest time gaps in a session/subagent JSONL
+ *
+ * Identifies performance bottlenecks: long thinking pauses, slow tool executions,
+ * and external command waits.
+ *
+ * Usage:
+ *   node time-gaps.mjs <file.jsonl>
+ *   node time-gaps.mjs <file.jsonl> --threshold 5     (gaps > 5s, default 10)
+ *   node time-gaps.mjs <file.jsonl> --top 20          (show top 20, default 10)
+ *
+ * Output: sorted list of time gaps with before/after context
+ */
+
+import { readFileSync } from 'fs';
+
+const filePath = process.argv[2];
+const thresholdIdx = process.argv.indexOf('--threshold');
+const threshold = thresholdIdx >= 0 ? parseFloat(process.argv[thresholdIdx + 1]) * 1000 : 10000;
+const topIdx = process.argv.indexOf('--top');
+const topN = topIdx >= 0 ? parseInt(process.argv[topIdx + 1], 10) : 10;
+
+if (!filePath) {
+  console.error('Usage: node time-gaps.mjs <file.jsonl> [--threshold <seconds>] [--top <N>]');
+  process.exit(1);
+}
+
+const lines = readFileSync(filePath, 'utf8').trim().split('\n');
+
+// Collect all timestamped events with description
+const events = [];
+lines.forEach((line, idx) => {
+  try {
+    const obj = JSON.parse(line);
+    if (!obj.timestamp) return;
+    const ts = new Date(obj.timestamp).getTime();
+    let desc = obj.type;
+
+    if (obj.type === 'assistant') {
+      const blocks = obj.message?.content || [];
+      const tools = blocks.filter(b => b.type === 'tool_use').map(b => b.name);
+      const hasThink = blocks.some(b => b.type === 'thinking');
+      const hasText = blocks.some(b => b.type === 'text');
+      const thinkSize = blocks.filter(b => b.type === 'thinking').reduce((sum, b) => sum + b.thinking.length, 0);
+
+      if (tools.length) {
+        desc = `TOOL[${tools.join(',')}]`;
+      } else {
+        desc = (hasThink ? `THINK(${(thinkSize / 1024).toFixed(1)}KB)` : '') + (hasText ? '+TEXT' : '');
+      }
+    } else if (obj.type === 'user') {
+      const content = obj.message?.content;
+      if (typeof content === 'string') {
+        desc = `USER: ${content.substring(0, 40)}`;
+      } else if (Array.isArray(content) && content[0]?.type === 'tool_result') {
+        const toolName = ''; // We don't have it here, but we can infer from context
+        const isErr = content[0].is_error;
+        desc = `RESULT${isErr ? '(ERR)' : ''}`;
+      }
+    }
+
+    events.push({ line: idx + 1, ts, desc });
+  } catch (e) { /* skip */ }
+});
+
+if (events.length < 2) {
+  console.log('Not enough timestamped events to analyze.');
+  process.exit(0);
+}
+
+// Find gaps
+const gaps = [];
+for (let i = 1; i < events.length; i++) {
+  const gap = events[i].ts - events[i - 1].ts;
+  if (gap >= threshold) {
+    gaps.push({
+      from: events[i - 1],
+      to: events[i],
+      gapMs: gap,
+    });
+  }
+}
+
+gaps.sort((a, b) => b.gapMs - a.gapMs);
+const shown = gaps.slice(0, topN);
+
+const totalDuration = events[events.length - 1].ts - events[0].ts;
+const totalGapTime = gaps.reduce((sum, g) => sum + g.gapMs, 0);
+
+console.log(`=== TIME GAP ANALYSIS ===`);
+console.log(`File: ${filePath}`);
+console.log(`Total duration: ${(totalDuration / 1000).toFixed(1)}s`);
+console.log(`Gaps > ${(threshold / 1000).toFixed(0)}s: ${gaps.length} found`);
+console.log(`Total gap time: ${(totalGapTime / 1000).toFixed(1)}s (${(totalGapTime / totalDuration * 100).toFixed(1)}% of duration)`);
+console.log('');
+
+console.log(`=== TOP ${shown.length} GAPS (sorted by duration) ===\n`);
+shown.forEach((g, i) => {
+  const dur = (g.gapMs / 1000).toFixed(1);
+  const pct = (g.gapMs / totalDuration * 100).toFixed(1);
+  console.log(`#${i + 1}: ${dur}s (${pct}% of total)`);
+  console.log(`  FROM: L${g.from.line} | ${g.from.desc}`);
+  console.log(`  TO:   L${g.to.line} | ${g.to.desc}`);
+
+  // Classify the gap
+  let category = 'unknown';
+  if (g.to.desc.startsWith('THINK')) category = 'LLM thinking (output generation)';
+  else if (g.to.desc.startsWith('TOOL')) category = 'LLM deciding next tool call';
+  else if (g.to.desc === 'RESULT' || g.to.desc === 'RESULT(ERR)') category = 'Tool execution (external command)';
+  else if (g.from.desc.startsWith('TOOL[Bash]')) category = 'Bash command execution';
+  console.log(`  TYPE: ${category}`);
+  console.log('');
+});
+
+// Summary by category
+console.log('=== GAP CATEGORY SUMMARY ===');
+const categories = {};
+gaps.forEach(g => {
+  let cat = 'other';
+  if (g.to.desc.startsWith('THINK')) cat = 'LLM thinking';
+  else if (g.to.desc.startsWith('TOOL')) cat = 'LLM tool decision';
+  else if (g.to.desc.includes('RESULT')) cat = 'Tool execution';
+  categories[cat] = (categories[cat] || 0) + g.gapMs;
+});
+Object.entries(categories).sort((a, b) => b[1] - a[1]).forEach(([cat, ms]) => {
+  console.log(`  ${cat}: ${(ms / 1000).toFixed(1)}s (${(ms / totalDuration * 100).toFixed(1)}%)`);
+});

package/project-template-v2/.claude/skills/session-analyzer/scripts/turn-timeline.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+/**
+ * turn-timeline.mjs — Parse and display event timeline for a specific turn range
+ *
+ * Usage:
+ *   node turn-timeline.mjs <session.jsonl> <startLine> [endLine]
+ *
+ * Output: chronological event list with timestamps, types, and previews
+ * If endLine is omitted, reads to end of file.
+ */
+
+import { readFileSync } from 'fs';
+
+const sessionPath = process.argv[2];
+const startLine = parseInt(process.argv[3], 10);
+const endLine = process.argv[4] ? parseInt(process.argv[4], 10) : Infinity;
+
+if (!sessionPath || isNaN(startLine)) {
+  console.error('Usage: node turn-timeline.mjs <session.jsonl> <startLine> [endLine]');
+  process.exit(1);
+}
+
+const lines = readFileSync(sessionPath, 'utf8').trim().split('\n');
+const end = Math.min(endLine, lines.length);
+
+console.log(`=== TURN TIMELINE: Lines ${startLine}-${end} ===\n`);
+
+for (let i = startLine - 1; i < end; i++) {
+  const lineNum = i + 1;
+  try {
+    const obj = JSON.parse(lines[i]);
+    const ts = obj.timestamp ? new Date(obj.timestamp).toISOString().substring(11, 19) : '        ';
+
+    if (obj.type === 'assistant') {
+      const blocks = obj.message?.content || [];
+      for (const b of blocks) {
+        if (b.type === 'thinking') {
+          const len = b.thinking.length;
+          const sizeTag = len > 10000 ? ` [${(len / 1024).toFixed(1)}KB]` : '';
+          console.log(`[${lineNum}] ${ts} THINK${sizeTag}: ${b.thinking.substring(0, 120)}`);
+        } else if (b.type === 'text') {
+          console.log(`[${lineNum}] ${ts} TEXT: ${b.text.substring(0, 150)}`);
+        } else if (b.type === 'tool_use') {
+          const inputPreview = JSON.stringify(b.input).substring(0, 100);
+          console.log(`[${lineNum}] ${ts} TOOL: ${b.name} | ${inputPreview}`);
+        }
+      }
+    } else if (obj.type === 'user') {
+      const content = obj.message?.content;
+      if (typeof content === 'string') {
+        console.log(`[${lineNum}] ${ts} USER: ${content.substring(0, 150)}`);
+      } else if (Array.isArray(content) && content[0]?.type === 'tool_result') {
+        const isErr = content[0].is_error;
+        const c = content[0].content;
+        const preview = typeof c === 'string' ? c.substring(0, 100) : JSON.stringify(c).substring(0, 100);
+        console.log(`[${lineNum}] ${ts} RESULT${isErr ? '(ERR)' : '(OK)'}: ${preview}`);
+      } else if (obj.promptSource === 'system' || obj.origin?.kind === 'task-notification') {
+        const text = Array.isArray(content) && content[0]?.text
+          ? content[0].text.substring(0, 100)
+          : typeof content === 'string' ? content.substring(0, 100) : '';
+        console.log(`[${lineNum}] ${ts} NOTIFY: ${text}`);
+      }
+    } else if (obj.type === 'system') {
+      console.log(`[${lineNum}] ${ts} SYSTEM: ${obj.subtype || ''}`);
+    }
+  } catch (e) { /* skip */ }
+}