tokengolf 0.3.0

package/src/components/ActiveRun.js

@@ -0,0 +1,85 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { ProgressBar } from '@inkjs/ui';
+import { getCurrentRun } from '../lib/state.js';
+import { getModelClass, getEfficiencyRating, getBudgetPct, formatCost, formatElapsed, FLOORS } from '../lib/score.js';
+
+export function ActiveRun({ run: initialRun }) {
+  const { exit } = useApp();
+  const [run, setRun] = useState(initialRun);
+  const [tick, setTick] = useState(0);
+
+  useEffect(() => {
+    const interval = setInterval(() => {
+      const latest = getCurrentRun();
+      if (latest) setRun(latest);
+      setTick(t => t + 1);
+    }, 2000);
+    return () => clearInterval(interval);
+  }, []);
+
+  useInput((input) => { if (input === 'q') exit(); });
+
+  const mc = getModelClass(run.model);
+  const pct = getBudgetPct(run.spent, run.budget);
+  const efficiency = getEfficiencyRating(run.spent, run.budget);
+  const barColor = pct >= 80 ? 'red' : pct >= 50 ? 'yellow' : 'green';
+
+  return (
+    <Box flexDirection="column" gap={1} paddingX={1} paddingY={1}>
+      <Box gap={2}>
+        <Text bold color="yellow">⛳ TokenGolf</Text>
+        <Text color="gray">Active Run</Text>
+        <Text color="gray" dimColor>{formatElapsed(run.startedAt)}</Text>
+      </Box>
+
+      <Box borderStyle="round" borderColor="yellow" paddingX={1} paddingY={1} flexDirection="column" gap={1}>
+        <Text bold color="white">{run.quest}</Text>
+
+        <Box gap={3}>
+          <Text>{mc.emoji} <Text color="cyan">{mc.name}</Text></Text>
+          <Text color="gray">Budget <Text color="green">${run.budget.toFixed(2)}</Text></Text>
+          <Text color="gray">Spent  <Text color={barColor}>{formatCost(run.spent)}</Text></Text>
+          <Text color={efficiency.color}>{efficiency.emoji} {efficiency.label}</Text>
+        </Box>
+
+        <Box gap={1} alignItems="center">
+          <Text color="gray">💰 </Text>
+          <Box width={24}><ProgressBar value={Math.min(pct, 100)} /></Box>
+          <Text color={barColor}> {pct}%</Text>
+        </Box>
+
+        <Box flexDirection="column" gap={0} marginTop={1}>
+          {FLOORS.map((floor, i) => {
+            const n = i + 1;
+            const done = n < run.floor;
+            const active = n === run.floor;
+            return (
+              <Box key={i} gap={1}>
+                <Text color={done ? 'green' : active ? 'yellow' : 'gray'}>
+                  {done ? '✓' : active ? '▶' : '○'}
+                </Text>
+                <Text color={done ? 'green' : active ? 'white' : 'gray'} dimColor={!done && !active}>
+                  Floor {n}: {floor}
+                </Text>
+              </Box>
+            );
+          })}
+        </Box>
+
+        <Box gap={3} marginTop={1}>
+          <Text color="gray">Prompts <Text color="white">{run.promptCount || 0}</Text></Text>
+          <Text color="gray">Tools   <Text color="white">{run.totalToolCalls || 0}</Text></Text>
+        </Box>
+
+        {pct >= 80 && pct < 100 && (
+          <Box borderStyle="single" borderColor="red" paddingX={1}>
+            <Text color="red" bold>⚠️  BUDGET WARNING — {formatCost(run.budget - run.spent)} left</Text>
+          </Box>
+        )}
+      </Box>
+
+      <Text color="gray" dimColor>tokengolf win [--spent 0.18]  ·  tokengolf bust  ·  q to close</Text>
+    </Box>
+  );
+}

package/src/components/ScoreCard.js

@@ -0,0 +1,157 @@
+import React, { useEffect } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { getTier, getModelClass, getEffortLevel, getEfficiencyRating, getBudgetPct, formatCost, getHaikuPct } from '../lib/score.js';
+
+export function ScoreCard({ run }) {
+  const { exit } = useApp();
+  const won = run.status === 'won';
+
+  useInput((input) => { if (input === 'q') exit(); });
+
+  useEffect(() => {
+    const t = setTimeout(() => exit(), 60000);
+    return () => clearTimeout(t);
+  }, [exit]);
+
+  const tier = getTier(run.spent);
+  const mc = getModelClass(run.model);
+  const flowMode = !run.budget;
+  const efficiency = flowMode ? null : getEfficiencyRating(run.spent, run.budget);
+  const pct = flowMode ? null : getBudgetPct(run.spent, run.budget);
+  const haikuPct = getHaikuPct(run.modelBreakdown, run.spent);
+
+  return (
+    <Box flexDirection="column" paddingX={1} paddingY={1} gap={1}>
+
+      {/* Big status header */}
+      <Box borderStyle="double" borderColor={won ? 'yellow' : 'red'} paddingX={2} paddingY={1} flexDirection="column" gap={1}>
+        <Text bold color={won ? 'yellow' : 'red'} >
+          {won ? '🏆  SESSION COMPLETE' : '💀  BUDGET BUSTED'}
+        </Text>
+
+        <Text color="white" bold>{run.quest ?? <Text color="gray">Flow Mode</Text>}</Text>
+
+        {/* Score row */}
+        <Box gap={4} flexWrap="wrap" marginTop={1}>
+          <Box flexDirection="column">
+            <Text color="gray" dimColor>SPENT</Text>
+            <Text bold color={won ? 'green' : 'red'}>{formatCost(run.spent)}</Text>
+          </Box>
+          {!flowMode && (
+            <>
+              <Box flexDirection="column">
+                <Text color="gray" dimColor>BUDGET</Text>
+                <Text color="white">${run.budget.toFixed(2)}</Text>
+              </Box>
+              <Box flexDirection="column">
+                <Text color="gray" dimColor>USED</Text>
+                <Text color={pct > 100 ? 'red' : pct > 80 ? 'yellow' : 'green'}>{pct}%</Text>
+              </Box>
+            </>
+          )}
+          <Box flexDirection="column">
+            <Text color="gray" dimColor>MODEL</Text>
+            <Text color="cyan">{mc.emoji} {mc.name}{[
+              run.effort && run.effort !== 'medium' ? getEffortLevel(run.effort)?.label : null,
+              run.fastMode ? 'Fast' : null,
+            ].filter(Boolean).map(s => `·${s}`).join('')}</Text>
+          </Box>
+          {run.effort && (
+            <Box flexDirection="column">
+              <Text color="gray" dimColor>EFFORT</Text>
+              <Text color={getEffortLevel(run.effort)?.color}>{getEffortLevel(run.effort)?.emoji} {getEffortLevel(run.effort)?.label}</Text>
+            </Box>
+          )}
+          {run.fastMode && (
+            <Box flexDirection="column">
+              <Text color="gray" dimColor>MODE</Text>
+              <Text color="yellow">↯ Fast</Text>
+            </Box>
+          )}
+          <Box flexDirection="column">
+            <Text color="gray" dimColor>TIER</Text>
+            <Text color={tier.color}>{tier.emoji} {tier.label}</Text>
+          </Box>
+        </Box>
+
+        {/* Efficiency (roguelike mode only) */}
+        {efficiency && (
+          <Box gap={2}>
+            <Text bold color={efficiency.color}>{efficiency.emoji} {efficiency.label}</Text>
+          </Box>
+        )}
+
+        {/* Achievements */}
+        {run.achievements?.length > 0 && (
+          <Box flexDirection="column" gap={0} marginTop={1}>
+            <Text color="gray" dimColor>Achievements unlocked:</Text>
+            {run.achievements.map((a, i) => (
+              <Text key={i} color="yellow">  {a.emoji} {a.label}</Text>
+            ))}
+          </Box>
+        )}
+
+        {/* Extended thinking */}
+        {run.thinkingInvocations > 0 && (
+          <Box flexDirection="column" gap={0} marginTop={1}>
+            <Box gap={3} alignItems="center">
+              <Text color="gray" dimColor>Extended thinking:</Text>
+              <Text color="magenta">🔮 {run.thinkingInvocations}× invoked</Text>
+            </Box>
+          </Box>
+        )}
+
+        {/* Model breakdown */}
+        {run.modelBreakdown && Object.keys(run.modelBreakdown).length > 0 && (
+          <Box flexDirection="column" gap={0} marginTop={1}>
+            <Box gap={2} alignItems="center">
+              <Text color="gray" dimColor>Model usage:</Text>
+              {haikuPct !== null && (
+                <Text color={haikuPct >= 75 ? 'magenta' : haikuPct >= 50 ? 'cyan' : 'yellow'}>
+                  🏹 {haikuPct}% Haiku
+                </Text>
+              )}
+            </Box>
+            <Box gap={3} flexWrap="wrap">
+              {Object.entries(run.modelBreakdown).map(([model, cost]) => {
+                const short = model.includes('haiku') ? 'Haiku' : model.includes('sonnet') ? 'Sonnet' : 'Opus';
+                const pctOfTotal = Math.round((cost / run.spent) * 100);
+                return (
+                  <Text key={model} color="gray">{short} <Text color="white">{pctOfTotal}%</Text> <Text dimColor>{formatCost(cost)}</Text></Text>
+                );
+              })}
+            </Box>
+          </Box>
+        )}
+
+        {/* Tool breakdown */}
+        {run.toolCalls && Object.keys(run.toolCalls).length > 0 && (
+          <Box flexDirection="column" gap={0} marginTop={1}>
+            <Text color="gray" dimColor>Tool calls:</Text>
+            <Box gap={2} flexWrap="wrap">
+              {Object.entries(run.toolCalls).map(([tool, count]) => (
+                <Text key={tool} color="gray"><Text color="white">{tool}</Text> ×{count}</Text>
+              ))}
+            </Box>
+          </Box>
+        )}
+
+        {/* Death tip */}
+        {!won && run.budget && (
+          <Box borderStyle="single" borderColor="red" paddingX={1} marginTop={1} flexDirection="column">
+            <Text color="red" bold>Cause of death: Budget exceeded by {formatCost(run.spent - run.budget)}</Text>
+            <Text color="gray" dimColor>Tip: Use Read with line ranges instead of full file reads.</Text>
+          </Box>
+        )}
+      </Box>
+
+      <Box gap={2}>
+        <Text color="gray" dimColor>tokengolf start — run again</Text>
+        <Text color="gray" dimColor>·</Text>
+        <Text color="gray" dimColor>tokengolf stats — career stats</Text>
+        <Text color="gray" dimColor>·</Text>
+        <Text color="gray" dimColor>q to exit</Text>
+      </Box>
+    </Box>
+  );
+}

package/src/components/StartRun.js

@@ -0,0 +1,156 @@
+import React, { useState } from 'react';
+import { Box, Text, useApp } from 'ink';
+import { TextInput, Select, ConfirmInput } from '@inkjs/ui';
+import { setCurrentRun } from '../lib/state.js';
+import { getModelClass, getEffortLevel, getModelBudgets, FLOORS } from '../lib/score.js';
+
+const MODEL_OPTIONS = [
+  { label: '⚔️  Sonnet  — Balanced. The default run.  [Normal]', value: 'claude-sonnet-4-6' },
+  { label: '🏹 Haiku   — Glass cannon. Hard mode.     [Hard]',   value: 'claude-haiku-4-5-20251001' },
+  { label: '🧙 Opus    — Powerful but expensive.      [Easy]',   value: 'claude-opus-4-6' },
+];
+
+const EFFORT_OPTIONS_BASE = [
+  { label: '⚖️  Medium — Balanced (Anthropic recommended for Sonnet)', value: 'medium' },
+  { label: '🪶 Low    — Fewest tokens, fastest, cheapest',             value: 'low'    },
+  { label: '🔥 High   — Most thorough, costs more',                    value: 'high'   },
+];
+const EFFORT_OPTIONS_OPUS = [
+  ...EFFORT_OPTIONS_BASE,
+  { label: '💥 Max    — Absolute max, no token constraints (Opus only)', value: 'max'  },
+];
+const getEffortOptions = (model) =>
+  model.toLowerCase().includes('opus') ? EFFORT_OPTIONS_OPUS : EFFORT_OPTIONS_BASE;
+
+function getBudgetOptions(model) {
+  const b = getModelBudgets(model);
+  return [
+    { label: `💎 Diamond  — $${b.diamond.toFixed(2)}   surgical micro-task`, value: String(b.diamond) },
+    { label: `🥇 Gold     — $${b.gold.toFixed(2)}   focused small task`,    value: String(b.gold)    },
+    { label: `🥈 Silver   — $${b.silver.toFixed(2)}   medium task`,          value: String(b.silver)  },
+    { label: `🥉 Bronze   — $${b.bronze.toFixed(2)}  heavy / complex`,       value: String(b.bronze)  },
+    { label: `✏️  Custom   — set your own`,                                   value: 'custom'          },
+  ];
+}
+
+export function StartRun() {
+  const { exit } = useApp();
+  const [step, setStep] = useState('quest');
+  const [quest, setQuest] = useState('');
+  const [model, setModel] = useState('');
+  const [effort, setEffort] = useState('medium');
+  const [budgetVal, setBudgetVal] = useState('');
+
+  const budget = parseFloat(budgetVal) || 0;
+  const mc = model ? getModelClass(model) : null;
+
+  return (
+    <Box flexDirection="column" gap={1} paddingX={1} paddingY={1}>
+      <Box gap={2}>
+        <Text bold color="yellow">⛳ TokenGolf</Text>
+        <Text color="gray">New Run</Text>
+      </Box>
+
+      <Box flexDirection="column" gap={1} borderStyle="single" borderColor="gray" paddingX={1} paddingY={1}>
+
+        {/* Quest */}
+        <Box gap={2} alignItems="flex-start">
+          <Text color={step === 'quest' ? 'cyan' : 'gray'}>📋 Quest    </Text>
+          {step === 'quest'
+            ? <TextInput placeholder="What are you shipping?" onSubmit={v => { if (v.trim()) { setQuest(v.trim()); setStep('model'); } }} />
+            : <Text color="white">{quest}</Text>}
+        </Box>
+
+        {/* Model */}
+        {step !== 'quest' && (
+          <Box flexDirection="column" gap={0}>
+            <Box gap={2}>
+              <Text color={step === 'model' ? 'cyan' : 'gray'}>🎮 Class    </Text>
+              {step !== 'model' && <Text color="white">{mc?.emoji} {mc?.name} [{mc?.difficulty}]</Text>}
+            </Box>
+            {step === 'model' && <Select options={MODEL_OPTIONS} onChange={v => {
+              setModel(v);
+              if (v.toLowerCase().includes('haiku')) { setEffort(null); setStep('budget'); }
+              else setStep('effort');
+            }} />}
+          </Box>
+        )}
+
+        {/* Effort */}
+        {(step === 'effort' || step === 'budget' || step === 'custom' || step === 'confirm') && effort !== null && (
+          <Box flexDirection="column" gap={0}>
+            <Box gap={2}>
+              <Text color={step === 'effort' ? 'cyan' : 'gray'}>⚡ Effort   </Text>
+              {step !== 'effort' && effort && <Text color="white">{getEffortLevel(effort)?.emoji} {getEffortLevel(effort)?.label}</Text>}
+            </Box>
+            {step === 'effort' && (
+              <Select options={getEffortOptions(model)} onChange={v => { setEffort(v); setStep('budget'); }} />
+            )}
+          </Box>
+        )}
+
+        {/* Budget */}
+        {(step === 'budget' || step === 'custom' || step === 'confirm') && (
+          <Box flexDirection="column" gap={0}>
+            <Box gap={2}>
+              <Text color={step === 'budget' || step === 'custom' ? 'cyan' : 'gray'}>💰 Budget   </Text>
+              {step === 'confirm' && <Text color="green">${budget.toFixed(2)}</Text>}
+            </Box>
+            {step === 'budget' && (
+              <Select options={getBudgetOptions(model)} onChange={v => {
+                if (v === 'custom') { setStep('custom'); }
+                else { setBudgetVal(v); setStep('confirm'); }
+              }} />
+            )}
+            {step === 'custom' && (
+              <TextInput placeholder="Enter amount e.g. 0.50" onSubmit={v => {
+                const n = parseFloat(v);
+                if (!isNaN(n) && n > 0) { setBudgetVal(String(n)); setStep('confirm'); }
+              }} />
+            )}
+          </Box>
+        )}
+
+        {/* Confirm */}
+        {step === 'confirm' && (
+          <Box flexDirection="column" gap={1} marginTop={1}>
+            <Box borderStyle="round" borderColor="yellow" paddingX={1} paddingY={1} flexDirection="column">
+              <Text bold color="yellow">Ready?</Text>
+              <Text color="gray">Quest   <Text color="white">{quest}</Text></Text>
+              <Text color="gray">Model   <Text color="white">{mc?.emoji} {mc?.name} [{mc?.difficulty}]</Text></Text>
+              {effort && <Text color="gray">Effort  <Text color="white">{getEffortLevel(effort)?.emoji} {getEffortLevel(effort)?.label}</Text></Text>}
+              <Text color="gray">Budget  <Text color="green">${budget.toFixed(2)}</Text></Text>
+            </Box>
+            <Box gap={1}>
+              <Text color="gray">Confirm? </Text>
+              <ConfirmInput
+                onConfirm={() => {
+                  setCurrentRun({
+                    quest, model, budget, effort,
+                    spent: 0,
+                    status: 'active',
+                    floor: 1,
+                    totalFloors: FLOORS.length,
+                    promptCount: 0,
+                    totalToolCalls: 0,
+                    toolCalls: {},
+                    startedAt: new Date().toISOString(),
+                  });
+                  exit();
+                }}
+                onCancel={() => setStep('quest')}
+              />
+            </Box>
+          </Box>
+        )}
+      </Box>
+
+      {step !== 'confirm' && (
+        <Text color="gray" dimColor>Use ↑↓ to navigate, Enter to select</Text>
+      )}
+      {step === 'confirm' && (
+        <Text color="gray" dimColor>After confirming, work normally in Claude Code. Run `tokengolf win` or `tokengolf bust` when done.</Text>
+      )}
+    </Box>
+  );
+}

package/src/components/StatsView.js

@@ -0,0 +1,112 @@
+import React from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { getTier, getModelClass, getBudgetPct, formatCost } from '../lib/score.js';
+
+export function StatsView({ stats }) {
+  const { exit } = useApp();
+
+  useInput((input) => { if (input === 'q') exit(); });
+
+  if (stats.total === 0) {
+    return (
+      <Box paddingX={1} paddingY={1} flexDirection="column" gap={1}>
+        <Text bold color="yellow">⛳ TokenGolf Stats</Text>
+        <Text color="gray">No completed runs yet.</Text>
+        <Text color="gray">Start one: <Text color="cyan">tokengolf start</Text></Text>
+      </Box>
+    );
+  }
+
+  return (
+    <Box flexDirection="column" paddingX={1} paddingY={1} gap={1}>
+      <Box gap={2}>
+        <Text bold color="yellow">⛳ TokenGolf</Text>
+        <Text color="gray">Career Stats</Text>
+      </Box>
+
+      {/* Top line */}
+      <Box borderStyle="single" borderColor="gray" paddingX={1} paddingY={1} gap={4}>
+        <Box flexDirection="column">
+          <Text color="gray" dimColor>RUNS</Text>
+          <Text bold color="white">{stats.total}</Text>
+        </Box>
+        <Box flexDirection="column">
+          <Text color="gray" dimColor>WINS</Text>
+          <Text bold color="green">{stats.wins}</Text>
+        </Box>
+        <Box flexDirection="column">
+          <Text color="gray" dimColor>DEATHS</Text>
+          <Text bold color="red">{stats.deaths}</Text>
+        </Box>
+        <Box flexDirection="column">
+          <Text color="gray" dimColor>WIN RATE</Text>
+          <Text bold color={stats.winRate >= 70 ? 'green' : stats.winRate >= 40 ? 'yellow' : 'red'}>
+            {stats.winRate}%
+          </Text>
+        </Box>
+        <Box flexDirection="column">
+          <Text color="gray" dimColor>AVG SPEND</Text>
+          <Text bold color="cyan">{formatCost(stats.avgSpend)}</Text>
+        </Box>
+      </Box>
+
+      {/* Personal best */}
+      {stats.bestRun && (() => {
+        const bestTier = getTier(stats.bestRun.spent);
+        const bestMc = getModelClass(stats.bestRun.model);
+        return (
+          <Box flexDirection="column" gap={0}>
+            <Text color="yellow">🏆 Personal Best</Text>
+            <Box borderStyle="round" borderColor="yellow" paddingX={1} paddingY={1} flexDirection="column">
+              <Text color="white">{stats.bestRun.quest}</Text>
+              <Box gap={3} marginTop={1}>
+                <Text color="green">{formatCost(stats.bestRun.spent)}</Text>
+                <Text color="gray">of ${stats.bestRun.budget?.toFixed(2)}</Text>
+                <Text>{bestMc.emoji}</Text>
+                <Text color={bestTier.color}>{bestTier.emoji} {bestTier.label}</Text>
+              </Box>
+            </Box>
+          </Box>
+        );
+      })()}
+
+      {/* Recent runs */}
+      <Box flexDirection="column" gap={0}>
+        <Text color="gray" dimColor>Recent runs:</Text>
+        {stats.recentRuns.slice(0, 8).map((run, i) => {
+          const won = run.status === 'won';
+          const tier = getTier(run.spent);
+          const mc = getModelClass(run.model);
+          const pct = getBudgetPct(run.spent, run.budget);
+          return (
+            <Box key={i} gap={2}>
+              <Text color={won ? 'green' : 'red'}>{won ? '✓' : '✗'}</Text>
+              <Text color="white">{(run.quest || '').slice(0, 34).padEnd(34)}</Text>
+              <Text color={won ? 'green' : 'red'}>{formatCost(run.spent)}</Text>
+              <Text color="gray">/{formatCost(run.budget)}</Text>
+              <Text>{mc.emoji}</Text>
+              <Text color={tier.color}>{tier.emoji}</Text>
+              <Text color="gray" dimColor>{pct}%</Text>
+            </Box>
+          );
+        })}
+      </Box>
+
+      {/* Achievements */}
+      {stats.achievements.length > 0 && (
+        <Box flexDirection="column" gap={0}>
+          <Text color="gray" dimColor>Recent achievements:</Text>
+          <Box flexWrap="wrap" gap={1}>
+            {stats.achievements.slice(0, 12).map((a, i) => (
+              <Box key={i} borderStyle="single" borderColor="gray" paddingX={1}>
+                <Text>{a.emoji} <Text color="gray" dimColor>{a.label}</Text></Text>
+              </Box>
+            ))}
+          </Box>
+        </Box>
+      )}
+
+      <Text color="gray" dimColor>q to exit</Text>
+    </Box>
+  );
+}

package/src/lib/cost.js

@@ -0,0 +1,149 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+// Pricing per million tokens (Anthropic list prices)
+const PRICING = {
+  'claude-opus-4':   { input: 15.00, output: 75.00, cacheWrite: 18.75, cacheRead: 1.50 },
+  'claude-sonnet-4': { input:  3.00, output: 15.00, cacheWrite:  3.75, cacheRead: 0.30 },
+  'claude-haiku-4':  { input:  0.80, output:  4.00, cacheWrite:  1.00, cacheRead: 0.08 },
+};
+
+function getPrice(model) {
+  const lower = (model || '').toLowerCase();
+  for (const [key, price] of Object.entries(PRICING)) {
+    if (lower.includes(key)) return price;
+  }
+  return PRICING['claude-sonnet-4'];
+}
+
+export function getProjectDir(cwd) {
+  return path.join(os.homedir(), '.claude', 'projects', cwd.replace(/\//g, '-'));
+}
+
+export function parseCostFromTranscript(transcriptPath) {
+  try {
+    const lines = fs.readFileSync(transcriptPath, 'utf8').trim().split('\n');
+    let total = 0;
+    const byModel = {};
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === 'assistant' && entry.message?.usage && entry.message?.model) {
+          const model = entry.message.model;
+          const p = getPrice(model);
+          const u = entry.message.usage;
+          const cost = (u.input_tokens || 0) / 1e6 * p.input
+            + (u.output_tokens || 0) / 1e6 * p.output
+            + (u.cache_creation_input_tokens || 0) / 1e6 * p.cacheWrite
+            + (u.cache_read_input_tokens || 0) / 1e6 * p.cacheRead;
+          total += cost;
+          byModel[model] = (byModel[model] || 0) + cost;
+        }
+      } catch { /* skip malformed lines */ }
+    }
+    return total > 0 ? { total, byModel } : null;
+  } catch {
+    return null;
+  }
+}
+
+// Returns all transcript paths modified at or after sinceMs
+function findTranscriptsSince(projectDir, sinceMs) {
+  try {
+    return fs.readdirSync(projectDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => ({ p: path.join(projectDir, f), mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+      .filter(({ mtime }) => mtime >= sinceMs)
+      .map(({ p }) => p);
+  } catch {
+    return [];
+  }
+}
+
+export function parseThinkingFromTranscripts(paths) {
+  let invocations = 0;
+  let tokens = 0;
+  for (const p of paths) {
+    try {
+      const lines = fs.readFileSync(p, 'utf8').trim().split('\n');
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.type === 'assistant' && Array.isArray(entry.message?.content)) {
+            const thinkBlocks = entry.message.content.filter(b => b.type === 'thinking');
+            if (thinkBlocks.length > 0) {
+              invocations++;
+              for (const block of thinkBlocks) {
+                tokens += Math.round((block.thinking?.length || 0) / 4);
+              }
+            }
+          }
+        } catch { /* skip malformed lines */ }
+      }
+    } catch { /* skip unreadable files */ }
+  }
+  return invocations > 0 ? { thinkingInvocations: invocations, thinkingTokens: tokens } : null;
+}
+
+// Aggregate costs across multiple transcript files
+function parseAllTranscripts(paths) {
+  let total = 0;
+  const byModel = {};
+  for (const p of paths) {
+    const result = parseCostFromTranscript(p);
+    if (!result) continue;
+    total += result.total;
+    for (const [model, cost] of Object.entries(result.byModel)) {
+      byModel[model] = (byModel[model] || 0) + cost;
+    }
+  }
+  return total > 0 ? { total, byModel } : null;
+}
+
+export function findTranscript(sessionId, projectDir) {
+  if (sessionId) {
+    try {
+      const p = path.join(projectDir, `${sessionId}.jsonl`);
+      fs.accessSync(p);
+      return p;
+    } catch { /* fall through */ }
+  }
+  // Fall back to most recently modified transcript
+  try {
+    const files = fs.readdirSync(projectDir)
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => ({ f, mtime: fs.statSync(path.join(projectDir, f)).mtimeMs }))
+      .sort((a, b) => b.mtime - a.mtime);
+    return files.length ? path.join(projectDir, files[0].f) : null;
+  } catch {
+    return null;
+  }
+}
+
+// Returns { spent, modelBreakdown } or null
+export function autoDetectCost(run) {
+  const projectDir = getProjectDir(process.cwd());
+
+  // Scan all transcripts modified since session start to capture subagent sidechains
+  const sinceMs = run.startedAt ? new Date(run.startedAt).getTime() : 0;
+  const paths = sinceMs > 0
+    ? findTranscriptsSince(projectDir, sinceMs)
+    : [findTranscript(run.sessionId, projectDir)].filter(Boolean);
+
+  const parsed = paths.length > 0 ? parseAllTranscripts(paths) : null;
+
+  // Always prefer fresh transcript parse; fall back to run.spent if no transcripts found
+  const spent = parsed?.total ?? (run.spent > 0 ? run.spent : null);
+  if (spent === null) return null;
+
+  // Always use parsed model breakdown (Stop hook doesn't capture it)
+  const modelBreakdown = parsed?.byModel ?? run.modelBreakdown ?? null;
+  const thinking = parseThinkingFromTranscripts(paths);
+  return {
+    spent,
+    modelBreakdown,
+    thinkingInvocations: thinking?.thinkingInvocations ?? 0,
+    thinkingTokens: thinking?.thinkingTokens ?? 0,
+  };
+}