tokengolf 0.3.0

package/hooks/post-tool-use.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STATE_FILE = path.join(os.homedir(), '.tokengolf', 'current-run.json');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const run = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    if (!run || run.status !== 'active') process.exit(0);
+
+    const event = JSON.parse(input);
+    const toolName = event.tool_name || 'Unknown';
+    const toolCalls = run.toolCalls || {};
+    toolCalls[toolName] = (toolCalls[toolName] || 0) + 1;
+
+    const updated = {
+      ...run,
+      toolCalls,
+      totalToolCalls: (run.totalToolCalls || 0) + 1,
+    };
+    fs.writeFileSync(STATE_FILE, JSON.stringify(updated, null, 2));
+
+    // Warn at 80%+
+    const pct = updated.spent / updated.budget;
+    if (pct >= 0.8 && pct < 1.0) {
+      const remaining = (updated.budget - updated.spent).toFixed(4);
+      process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'PostToolUse',
+          systemMessage: `⚠️ TokenGolf: $${updated.spent.toFixed(4)} of $${updated.budget.toFixed(2)} spent (${Math.round(pct * 100)}%). Only $${remaining} left. Be concise and targeted.`,
+        },
+      }));
+    }
+  } catch {
+    // silent fail
+  }
+  process.exit(0);
+});

package/hooks/pre-compact.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STATE_FILE = path.join(os.homedir(), '.tokengolf', 'current-run.json');
+
+try {
+  let stdin = '';
+  try { stdin = fs.readFileSync('/dev/stdin', 'utf8'); } catch {}
+
+  let event = {};
+  try { event = JSON.parse(stdin); } catch {}
+
+  const trigger = event.trigger || 'auto'; // 'manual' or 'auto'
+
+  let run = null;
+  try { run = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch {}
+  if (!run || run.status !== 'active') process.exit(0);
+
+  const compactionEvents = run.compactionEvents || [];
+  compactionEvents.push({
+    trigger,
+    timestamp: new Date().toISOString(),
+    contextPct: event.context_window?.used_percentage ?? event.context_window_usage_pct ?? null,
+    customInstructions: event.custom_instructions || null,
+  });
+
+  run = { ...run, compactionEvents };
+  fs.writeFileSync(STATE_FILE, JSON.stringify(run, null, 2));
+} catch {
+  // silent fail
+}
+
+process.exit(0);

package/hooks/session-end.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+const { autoDetectCost } = await import(path.join(__dir, '../src/lib/cost.js'));
+const { getCurrentRun, clearCurrentRun } = await import(path.join(__dir, '../src/lib/state.js'));
+const { saveRun } = await import(path.join(__dir, '../src/lib/store.js'));
+const { getTier, getModelClass, getEffortLevel, getEfficiencyRating, getBudgetPct } = await import(path.join(__dir, '../src/lib/score.js'));
+
+function writeTTY(text) {
+  try {
+    const ttyFd = fs.openSync('/dev/tty', 'w');
+    fs.writeSync(ttyFd, text);
+    fs.closeSync(ttyFd);
+  } catch {
+    process.stdout.write(text); // fallback
+  }
+}
+
+function renderScorecard(run) {
+  const W = Math.min(Math.max((process.stdout.columns || 88) - 4, 72), 120);
+  const won = run.status === 'won';
+  const flowMode = !run.budget;
+
+  const R = '\x1b[31m', G = '\x1b[32m', Y = '\x1b[33m', C = '\x1b[36m';
+  const M = '\x1b[35m', DIM = '\x1b[2m', RESET = '\x1b[0m', BOLD = '\x1b[1m';
+  const bc = won ? Y : R;
+
+  const tl = '╔', tr = '╗', bl = '╚', br = '╝';
+  const h = '═', v = '║';
+  const ml = '╠', mr = '╣';
+
+  function bar() { return bc + ml + h.repeat(W) + mr + RESET; }
+  function top() { return bc + tl + h.repeat(W) + tr + RESET; }
+  function bot() { return bc + bl + h.repeat(W) + br + RESET; }
+  function row(content) {
+    // Strip ANSI for length calculation
+    const plain = content.replace(/\x1b\[[0-9;]*m/g, '');
+    const pad = Math.max(0, W - plain.length - 2);
+    return bc + v + RESET + ' ' + content + ' '.repeat(pad) + ' ' + bc + v + RESET;
+  }
+
+  const mc = getModelClass(run.model);
+  const tier = getTier(run.spent);
+
+  const fainted = run.fainted;
+  const sessions = run.sessionCount || 1;
+  const header = won
+    ? `${BOLD}${Y}🏆  SESSION COMPLETE${RESET}`
+    : fainted
+    ? `${BOLD}${Y}💤  FAINTED — Run Continues${RESET}`
+    : `${BOLD}${R}💀  BUDGET BUSTED${RESET}`;
+
+  const questStr = run.quest
+    ? `${BOLD}${run.quest.slice(0, 60)}${RESET}`
+    : `${DIM}Flow Mode${RESET}`;
+
+  const spentBefore = run.spentBeforeThisSession || 0;
+  const spentThisSession = run.spent - spentBefore;
+  const multiSession = sessions > 1 && spentBefore > 0;
+
+  const spentStr = `${won ? G : R}$${run.spent.toFixed(4)}${RESET}` +
+    (multiSession ? `  ${DIM}(+$${spentThisSession.toFixed(4)} this session)${RESET}` : '');
+
+  let midRow = spentStr;
+  if (!flowMode) {
+    const pct = getBudgetPct(run.spent, run.budget);
+    const eff = getEfficiencyRating(run.spent, run.budget);
+    const effC = eff.color === 'magenta' ? M : eff.color === 'cyan' ? C : eff.color === 'green' ? G : eff.color === 'yellow' ? Y : R;
+    midRow += `  ${DIM}/${RESET}$${run.budget.toFixed(2)}  ${pct}%  ${effC}${eff.emoji} ${eff.label}${RESET}`;
+  }
+
+  const effortInfo = run.effort ? getEffortLevel(run.effort) : null;
+  const modelSuffix = [
+    run.effort && run.effort !== 'medium' && effortInfo ? effortInfo.label : null,
+    run.fastMode ? '⚡Fast' : null,
+  ].filter(Boolean).join('·');
+  midRow += `  ${C}${mc.emoji} ${mc.name}${modelSuffix ? '·' + modelSuffix : ''}${RESET}`;
+  midRow += `  ${tier.emoji} ${tier.label}`;
+  if (multiSession) midRow += `  ${DIM}${sessions} sessions${RESET}`;
+
+  const achievements = run.achievements || [];
+  const achStr = achievements.map(a => `${a.emoji} ${a.key}`).join('  ');
+
+  const ti = run.thinkingInvocations || 0;
+  const thinkRow = ti > 0
+    ? `${M}🔮 ${ti} ultrathink${ti > 1 ? ' invocations' : ' invocation'}${RESET}`
+    : null;
+
+  const lines = [
+    top(),
+    row(header),
+    row(questStr),
+    bar(),
+    row(midRow),
+  ];
+
+  if (thinkRow) {
+    lines.push(bar());
+    lines.push(row(thinkRow));
+  }
+
+  if (achievements.length > 0) {
+    lines.push(bar());
+    lines.push(row(achStr));
+  }
+
+  lines.push(bar());
+  lines.push(row(`${DIM}tokengolf scorecard${RESET}  ·  ${DIM}tokengolf start${RESET}  ·  ${DIM}tokengolf stats${RESET}`));
+  lines.push(bot());
+
+  return lines.join('\n');
+}
+
+try {
+  let stdin = '';
+  try { stdin = fs.readFileSync('/dev/stdin', 'utf8'); } catch {}
+
+  let event = {};
+  try { event = JSON.parse(stdin); } catch {}
+  const reason = event.reason || 'other';
+
+  const run = getCurrentRun();
+  if (!run || run.status !== 'active') process.exit(0);
+
+  const result = autoDetectCost(run);
+  if (!result) process.exit(0); // no transcripts found, nothing to save
+
+  // reason 'other' = unexpected exit (usage limit hit = Fainted)
+  // clean exits: 'clear', 'logout', 'prompt_input_exit', 'bypass_permissions_disabled'
+  const cleanExits = ['clear', 'logout', 'prompt_input_exit', 'bypass_permissions_disabled'];
+  const fainted = !cleanExits.includes(reason) && reason !== 'other' ? false
+    : reason === 'other';
+
+  let status;
+  if (run.budget && result.spent > run.budget) status = 'died';
+  else if (fainted) status = 'resting'; // hit limit, run continues next session
+  else status = 'won';
+
+  const thinkingFields = {
+    thinkingInvocations: result.thinkingInvocations ?? 0,
+    thinkingTokens: result.thinkingTokens ?? 0,
+  };
+
+  // For resting runs: update state but don't clear — run continues next session
+  if (status === 'resting') {
+    const { setCurrentRun } = await import(path.join(__dir, '../src/lib/state.js'));
+    setCurrentRun({ ...run, spent: result.spent, fainted: true, ...thinkingFields });
+    const saved = { ...run, spent: result.spent, modelBreakdown: result.modelBreakdown, status, fainted: true, ...thinkingFields };
+    writeTTY('\n' + renderScorecard({ ...saved, achievements: [] }) + '\n\n');
+    process.exit(0);
+  }
+
+  const saved = saveRun({
+    ...run,
+    spent: result.spent,
+    modelBreakdown: result.modelBreakdown,
+    status,
+    endedAt: new Date().toISOString(),
+    ...thinkingFields,
+  });
+
+  clearCurrentRun();
+
+  writeTTY('\n' + renderScorecard(saved) + '\n\n');
+} catch {
+  // silent fail
+}
+
+process.exit(0);

package/hooks/session-start.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STATE_FILE = path.join(os.homedir(), '.tokengolf', 'current-run.json');
+const STATE_DIR  = path.join(os.homedir(), '.tokengolf');
+
+function detectEffort() {
+  const fromEnv = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+  if (fromEnv) return fromEnv;
+  for (const p of [
+    path.join(os.homedir(), '.claude', 'settings.json'),
+    path.join(process.env.PWD || process.cwd(), '.claude', 'settings.json'),
+  ]) {
+    try { const s = JSON.parse(fs.readFileSync(p, 'utf8')); if (s.effortLevel) return s.effortLevel; } catch {}
+  }
+  return null;
+}
+
+function detectFastMode() {
+  try {
+    const s = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.claude', 'settings.json'), 'utf8'));
+    return s.fastMode === true;
+  } catch { return false; }
+}
+
+try {
+  const cwd = process.env.PWD || process.cwd();
+
+  let run = null;
+  try { run = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8')); } catch { /* no run */ }
+
+  if (!run || run.status !== 'active') {
+    // Flow mode: auto-start a tracking run for this session
+    if (!fs.existsSync(STATE_DIR)) fs.mkdirSync(STATE_DIR, { recursive: true });
+    run = {
+      quest: null,
+      model: 'claude-sonnet-4-6',
+      budget: null,
+      effort: detectEffort(),
+      fastMode: detectFastMode(),
+      spent: 0,
+      status: 'active',
+      mode: 'flow',
+      floor: 1,
+      totalFloors: 5,
+      promptCount: 0,
+      totalToolCalls: 0,
+      toolCalls: {},
+      cwd,
+      sessionCount: 1,
+      compactionEvents: [],
+      startedAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(STATE_FILE, JSON.stringify(run, null, 2));
+  } else {
+    // Continuing an existing run — increment session count, snapshot spent for per-session tracking
+    run = {
+      ...run,
+      sessionCount: (run.sessionCount || 1) + 1,
+      spentBeforeThisSession: run.spent || 0,
+      cwd: run.cwd || cwd,
+      effort: 'effort' in run ? run.effort : detectEffort(),
+      fastMode: 'fastMode' in run ? run.fastMode : detectFastMode(),
+    };
+    fs.writeFileSync(STATE_FILE, JSON.stringify(run, null, 2));
+  }
+
+  const pct = run.budget ? run.spent / run.budget : 0;
+  const urgency = run.budget && pct >= 0.8 ? '⚠️  BUDGET CRITICAL — be concise. ' : '';
+  const questLine = run.quest ? `Quest: ${run.quest}` : 'Mode: Flow (auto-tracking)';
+  const budgetLine = run.budget
+    ? `Budget: $${run.budget.toFixed(2)} | Spent: $${run.spent.toFixed(4)} (${Math.round(pct * 100)}%) | Remaining: $${(run.budget - run.spent).toFixed(4)}`
+    : '';
+
+  const effortStr = run.effort ? run.effort : 'default';
+  const fastStr = run.fastMode ? ' ⚡ Fast' : '';
+  const context = `## ⛳ TokenGolf Active
+${urgency}Every token counts.
+
+${questLine}
+Model: ${run.model} | Effort: ${effortStr}${fastStr} | Floor: ${run.floor}/${run.totalFloors}
+${budgetLine}
+
+Efficiency tips:
+- Use Read with start_line/end_line instead of reading whole files
+- Be specific — avoid exploratory reads when you know the target
+- Scope bash commands tightly`;
+
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'SessionStart',
+      additionalContext: context,
+    },
+  }));
+} catch {
+  // silent fail
+}
+process.exit(0);

package/hooks/session-stop.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STATE_FILE = path.join(os.homedir(), '.tokengolf', 'current-run.json');
+
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    const event = JSON.parse(input);
+
+    // Claude Code passes total_cost_usd in the Stop event
+    const cost = event.total_cost_usd ?? event.cost_usd ?? event.totalCostUsd ?? null;
+    if (cost == null) process.exit(0);
+
+    const run = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    if (!run || run.status !== 'active') process.exit(0);
+
+    fs.writeFileSync(STATE_FILE, JSON.stringify({ ...run, spent: cost }, null, 2));
+  } catch { /* no run or no cost data */ }
+  process.exit(0);
+});

package/hooks/statusline.sh

@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+STATE_FILE="$HOME/.tokengolf/current-run.json"
+SESSION_JSON=$(cat)
+[ ! -f "$STATE_FILE" ] && exit 0
+
+TG_SESSION_JSON="$SESSION_JSON" python3 - "$STATE_FILE" <<'PYEOF'
+import sys, json, os
+
+try:
+    session = json.loads(os.environ.get('TG_SESSION_JSON') or '{}')
+except: session = {}
+
+try:
+    with open(sys.argv[1]) as f: run = json.load(f)
+except: sys.exit(0)
+
+cost    = (session.get('cost') or {}).get('total_cost_usd') or run.get('spent', 0)
+ctx_pct = (session.get('context_window') or {}).get('used_percentage') or None
+quest   = (run.get('quest') or 'Flow')[:32]
+budget  = run.get('budget')
+floor   = f"{run.get('floor',1)}/{run.get('totalFloors',5)}"
+m       = run.get('model', '').lower()
+if   'haiku'  in m: model, model_emoji = 'Haiku',  '🏹'
+elif 'sonnet' in m: model, model_emoji = 'Sonnet', '⚔️'
+elif 'opus'   in m: model, model_emoji = 'Opus',   '🧙'
+else:               model, model_emoji = '?',       '?'
+effort  = run.get('effort')
+fast    = run.get('fastMode', False)
+fainted = run.get('fainted', False)
+
+label_parts = [f'{model_emoji} {model}']
+if effort and effort != 'medium': label_parts.append(effort.capitalize())
+if fast: label_parts.append('⚡Fast')
+model_label = '·'.join(label_parts)
+
+R, B, G, Y, M, C, DIM, RESET = '\033[31m','\033[34m','\033[32m','\033[33m','\033[35m','\033[36m','\033[2m','\033[0m'
+BOLD = '\033[1m'
+
+if   cost < 0.10: tier_emoji = '💎'
+elif cost < 0.30: tier_emoji = '🥇'
+elif cost < 1.00: tier_emoji = '🥈'
+elif cost < 3.00: tier_emoji = '🥉'
+else:             tier_emoji = '💸'
+
+if budget:
+    pct = cost / budget * 100
+    if   pct <= 25:  rating, rc = 'LEGENDARY',  M
+    elif pct <= 50:  rating, rc = 'EFFICIENT',  C
+    elif pct <= 75:  rating, rc = 'SOLID',      G
+    elif pct <= 100: rating, rc = 'CLOSE CALL', Y
+    else:            rating, rc = 'BUSTED',     R
+    cost_str   = f"{tier_emoji} ${cost:.4f}/${budget:.2f} {pct:.0f}%"
+    rating_str = f"{rc}{rating}{RESET}"
+else:
+    cost_str   = f"{tier_emoji} ${cost:.4f}"
+    rating_str = None
+
+sep = f" {DIM}|{RESET} "
+ctx_str = None
+if ctx_pct is not None:
+    if   ctx_pct >= 90: ctx_str = f"{R}📦 {ctx_pct:.0f}%{RESET}"
+    elif ctx_pct >= 75: ctx_str = f"{Y}🎒 {ctx_pct:.0f}%{RESET}"
+    elif ctx_pct >= 50: ctx_str = f"{G}🪶 {ctx_pct:.0f}%{RESET}"
+
+prefix = f"{BOLD}{C}{'💤' if fainted else '⛳'}{RESET}"
+parts = [f"{prefix} {quest}", cost_str]
+if rating_str: parts.append(rating_str)
+if ctx_str: parts.append(ctx_str)
+parts.append(f"{C}{model_label}{RESET}")
+if budget: parts.append(f"Floor {floor}")
+print('\n' + f'{DIM} ───────────────{RESET}' + '\n' + sep.join(parts) + '\n' + f'{DIM} ───────────────{RESET}')
+PYEOF

package/hooks/user-prompt-submit.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STATE_FILE = path.join(os.homedir(), '.tokengolf', 'current-run.json');
+
+try {
+  const run = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  if (!run || run.status !== 'active') process.exit(0);
+
+  const updated = { ...run, promptCount: (run.promptCount || 0) + 1 };
+  fs.writeFileSync(STATE_FILE, JSON.stringify(updated, null, 2));
+
+  const pct = updated.spent / updated.budget;
+
+  // Nudge at 50% — once (between 50-60%)
+  if (pct >= 0.5 && pct < 0.6) {
+    process.stdout.write(JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: 'UserPromptSubmit',
+        additionalContext: `[TokenGolf] Halfway point. $${updated.spent.toFixed(4)} of $${updated.budget.toFixed(2)} spent. Quest: "${updated.quest}" — stay focused.`,
+      },
+    }));
+  }
+} catch {
+  // silent fail
+}
+process.exit(0);

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "tokengolf",
+  "version": "0.3.0",
+  "description": "Gamify your Claude Code sessions. Flow mode tracks you. Roguelike mode trains you.",
+  "type": "module",
+  "bin": {
+    "tokengolf": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "esbuild src/cli.js --bundle --platform=node --format=esm --loader:.js=jsx --packages=external --outfile=dist/cli.js && chmod +x dist/cli.js",
+    "prepare": "npm run build",
+    "dev": "node --import tsx/esm src/cli.js",
+    "postversion": "git push && git push --tags"
+  },
+  "dependencies": {
+    "@inkjs/ui": "^2.0.0",
+    "commander": "^12.0.0",
+    "ink": "^5.0.0",
+    "react": "^18.0.0"
+  },
+  "devDependencies": {
+    "esbuild": "^0.25.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/cli.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { render } from 'ink';
+import React from 'react';
+
+import { getCurrentRun, clearCurrentRun, updateCurrentRun } from './lib/state.js';
+import { saveRun, getLastRun, getStats } from './lib/store.js';
+import { autoDetectCost } from './lib/cost.js';
+import { StartRun } from './components/StartRun.js';
+import { ActiveRun } from './components/ActiveRun.js';
+import { ScoreCard } from './components/ScoreCard.js';
+import { StatsView } from './components/StatsView.js';
+
+program
+  .name('tokengolf')
+  .description('⛳ Gamify your Claude Code sessions')
+  .version('0.1.0');
+
+program
+  .command('start')
+  .description('Declare a quest and start a new run')
+  .action(() => {
+    render(React.createElement(StartRun));
+  });
+
+program
+  .command('status')
+  .description('Show current run status')
+  .action(() => {
+    const run = getCurrentRun();
+    if (!run) {
+      console.log('No active run. Start one with: tokengolf start');
+      process.exit(0);
+    }
+    render(React.createElement(ActiveRun, { run }));
+  });
+
+program
+  .command('win')
+  .description('Mark current run as complete (won)')
+  .option('--spent <amount>', 'How much did you spend? (e.g. 0.18)')
+  .action((opts) => {
+    const run = getCurrentRun();
+    if (!run) {
+      console.log('No active run.');
+      process.exit(1);
+    }
+    const detected = opts.spent ? null : autoDetectCost(run);
+    const spent = opts.spent ? parseFloat(opts.spent) : (detected?.spent ?? run.spent);
+    const completed = { ...run, spent, status: 'won', modelBreakdown: detected?.modelBreakdown ?? run.modelBreakdown ?? null, endedAt: new Date().toISOString() };
+    const saved = saveRun(completed);
+    clearCurrentRun();
+    render(React.createElement(ScoreCard, { run: saved }));
+  });
+
+program
+  .command('bust')
+  .description('Mark current run as budget busted (died)')
+  .option('--spent <amount>', 'How much did you spend? (e.g. 0.45)')
+  .action((opts) => {
+    const run = getCurrentRun();
+    if (!run) {
+      console.log('No active run.');
+      process.exit(1);
+    }
+    const detected = opts.spent ? null : autoDetectCost(run);
+    const spent = opts.spent ? parseFloat(opts.spent) : (detected?.spent ?? run.budget + 0.01);
+    const died = { ...run, spent, status: 'died', modelBreakdown: detected?.modelBreakdown ?? run.modelBreakdown ?? null, endedAt: new Date().toISOString() };
+    const saved = saveRun(died);
+    clearCurrentRun();
+    render(React.createElement(ScoreCard, { run: saved }));
+  });
+
+program
+  .command('floor')
+  .description('Advance to the next floor')
+  .action(() => {
+    const run = getCurrentRun();
+    if (!run) {
+      console.log('No active run.');
+      process.exit(1);
+    }
+    const nextFloor = Math.min((run.floor || 1) + 1, run.totalFloors || 5);
+    updateCurrentRun({ floor: nextFloor });
+    console.log(`Floor ${nextFloor} / ${run.totalFloors}`);
+  });
+
+program
+  .command('scorecard')
+  .description('Show the last run scorecard')
+  .action(() => {
+    const run = getLastRun();
+    if (!run) {
+      console.log('No runs yet. Start one with: tokengolf start');
+      process.exit(0);
+    }
+    render(React.createElement(ScoreCard, { run }));
+  });
+
+program
+  .command('stats')
+  .description('Show career stats dashboard')
+  .action(() => {
+    render(React.createElement(StatsView, { stats: getStats() }));
+  });
+
+program
+  .command('install')
+  .description('Install Claude Code hooks into ~/.claude/settings.json')
+  .action(async () => {
+    const { installHooks } = await import('./lib/install.js');
+    installHooks();
+  });
+
+program.parse();