takomi 2.1.18 → 2.1.20

package/.pi/extensions/notify-sound/index.ts

@@ -8,7 +8,12 @@ type NotifySoundConfig = {
   enabled: boolean;
 };
 
+type NotifyMethod = "auto" | "wav";
+
 const CONFIG_PATH = join(process.cwd(), ".pi", "notify-sound.json");
+const WAV_PATH = join(process.cwd(), ".pi", "notify-sound.wav");
+const PS1_PATH = join(process.cwd(), ".pi", "notify-sound.ps1");
+const VBS_PATH = join(process.cwd(), ".pi", "notify-sound.vbs");
 const STALE_AGENT_START_MS = 24 * 60 * 60 * 1000;
 
 let config: NotifySoundConfig = { enabled: true };
@@ -16,6 +21,7 @@ let lastAgentStartedAt = 0;
 
 export default async function notifySoundExtension(pi: ExtensionAPI) {
   await loadConfig();
+  await ensureTuneWav();
 
   pi.on("session_start", async (_event, ctx) => {
     updateStatus(ctx);
@@ -37,12 +43,34 @@ export default async function notifySoundExtension(pi: ExtensionAPI) {
 
   const command = {
     description: "Toggle or test the agent completion tune notification",
+    getArgumentCompletions: (argumentPrefix: string) => {
+      const token = argumentPrefix.trim().toLowerCase();
+      return [
+        { value: "status", label: "status", description: "Show whether the completion tune is on" },
+        { value: "test", label: "test", description: "Play the completion tune" },
+        { value: "test wav", label: "test wav", description: "Play the generated WAV completion tune" },
+        { value: "on", label: "on", description: "Enable the completion tune" },
+        { value: "off", label: "off", description: "Disable the completion tune" },
+        { value: "toggle", label: "toggle", description: "Toggle the completion tune" },
+      ].filter((completion) => !token || completion.value.startsWith(token));
+    },
     handler: async (args: string, ctx: ExtensionCommandContext) => {
       const action = args.trim().toLowerCase() || "toggle";
 
       if (action === "test") {
-        playCompletionTune();
-        ctx.ui.notify("Played completion tune.", "info");
+        playCompletionTune("wav");
+        ctx.ui.notify("Played completion tune using WAV mode. This is the default reliable Windows path.", "info");
+        return;
+      }
+
+      if (action === "test wav") {
+        playCompletionTune("wav");
+        ctx.ui.notify("Played completion tune using WAV mode.", "info");
+        return;
+      }
+
+      if (action.startsWith("test ")) {
+        ctx.ui.notify("Usage: /notify test", "warning");
         return;
       }
 
@@ -101,16 +129,89 @@ async function setEnabled(enabled: boolean, ctx: ExtensionContext): Promise<void
   ctx.ui.notify(`Completion tune ${enabled ? "enabled" : "disabled"}.`, "info");
 }
 
+async function ensureTuneWav(): Promise<void> {
+  await mkdir(dirname(WAV_PATH), { recursive: true });
+  await writeFile(WAV_PATH, createTuneWav(), "binary");
+  const wav = WAV_PATH.replace(/'/g, "''");
+  await writeFile(PS1_PATH, [
+    "$ErrorActionPreference = 'SilentlyContinue'",
+    `if (Test-Path '${wav}') {`,
+    `  $p = New-Object System.Media.SoundPlayer '${wav}'`,
+    "  $p.Load()",
+    "  $p.PlaySync()",
+    "}",
+    "[System.Media.SystemSounds]::Asterisk.Play()",
+    "Start-Sleep -Milliseconds 250",
+    "",
+  ].join("\n"), "utf8");
+  const ps1 = PS1_PATH.replace(/"/g, "\"\"");
+  await writeFile(VBS_PATH, [
+    "Set shell = CreateObject(\"WScript.Shell\")",
+    `shell.Run "powershell.exe -NoProfile -ExecutionPolicy Bypass -File ""${ps1}""", 0, False`,
+    "",
+  ].join("\r\n"), "utf8");
+}
+
+function createTuneWav(): Buffer {
+  const sampleRate = 44100;
+  const notes = [
+    [659, 0.11],
+    [784, 0.11],
+    [988, 0.15],
+    [1319, 0.21],
+    [1175, 0.12],
+    [1319, 0.26],
+  ];
+  const gapSeconds = 0.035;
+  const samples: number[] = [];
+
+  for (const [freq, seconds] of notes) {
+    const count = Math.floor(sampleRate * seconds);
+    for (let i = 0; i < count; i++) {
+      const t = i / sampleRate;
+      const fadeIn = Math.min(1, i / 120);
+      const fadeOut = Math.min(1, (count - i) / 300);
+      const env = Math.min(fadeIn, fadeOut) * 0.28;
+      samples.push(Math.sin(2 * Math.PI * freq * t) * env);
+    }
+    for (let i = 0; i < Math.floor(sampleRate * gapSeconds); i++) samples.push(0);
+  }
+
+  const dataSize = samples.length * 2;
+  const buffer = Buffer.alloc(44 + dataSize);
+  buffer.write("RIFF", 0);
+  buffer.writeUInt32LE(36 + dataSize, 4);
+  buffer.write("WAVE", 8);
+  buffer.write("fmt ", 12);
+  buffer.writeUInt32LE(16, 16);
+  buffer.writeUInt16LE(1, 20);
+  buffer.writeUInt16LE(1, 22);
+  buffer.writeUInt32LE(sampleRate, 24);
+  buffer.writeUInt32LE(sampleRate * 2, 28);
+  buffer.writeUInt16LE(2, 32);
+  buffer.writeUInt16LE(16, 34);
+  buffer.write("data", 36);
+  buffer.writeUInt32LE(dataSize, 40);
+
+  let offset = 44;
+  for (const sample of samples) {
+    const value = Math.max(-1, Math.min(1, sample));
+    buffer.writeInt16LE(Math.round(value * 32767), offset);
+    offset += 2;
+  }
+  return buffer;
+}
+
 function updateStatus(ctx: ExtensionContext): void {
   if (!ctx.hasUI) return;
   ctx.ui.setStatus("notify-sound", ctx.ui.theme.fg("dim", `tune:${config.enabled ? "on" : "off"}`));
 }
 
-function playCompletionTune(): void {
+function playCompletionTune(method: NotifyMethod = "auto"): void {
   const os = platform();
 
   if (os === "win32") {
-    playWindowsTune();
+    playWindowsTune(method);
     return;
   }
 
@@ -122,28 +223,16 @@ function playCompletionTune(): void {
   playLinuxTune();
 }
 
-function playWindowsTune(): void {
-  // A short ascending arpeggio + resolution. This is a tune, not a single alert beep.
-  const melody = [
-    [659, 110], // E5
-    [784, 110], // G5
-    [988, 150], // B5
-    [1319, 210], // E6
-    [1175, 120], // D6
-    [1319, 260], // E6
-  ];
-
-  const commands = melody
-    .map(([frequency, duration]) => `[Console]::Beep(${frequency}, ${duration})`)
-    .join("; Start-Sleep -Milliseconds 35; ");
+function playWindowsTune(method: NotifyMethod): void {
+  // Windows uses the generated WAV path because Console.Beep, system sounds,
+  // and terminal bells are silent on many modern Windows machines.
+  playWindowsWav();
+}
 
-  runDetached("powershell.exe", [
-    "-NoProfile",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-Command",
-    commands,
-  ]);
+function playWindowsWav(): void {
+  // WScript launches the PowerShell player hidden without stealing focus. This
+  // is more reliable than spawning hidden PowerShell directly from Pi's TUI.
+  runDetached("wscript.exe", [VBS_PATH]);
 }
 
 function playLinuxTune(): void {
@@ -163,6 +252,7 @@ function runDetached(command: string, args: string[]): void {
       detached: true,
       stdio: "ignore",
       windowsHide: true,
+      shell: false,
     });
     child.unref();
   } catch {

package/.pi/extensions/takomi-runtime/command-text.ts

@@ -17,7 +17,7 @@ const ROOT_COMPLETIONS: TakomiCompletion[] = [
   { value: "mode", label: "mode", description: "Set direct, orchestrate, or review mode" },
   { value: "gate", label: "gate", description: "Set auto or review-gated execution" },
   { value: "subagents", label: "subagents", description: "Control subagent usage and view" },
-  { value: "stats", label: "stats", description: "Show token, model, project, and subagent usage stats" },
+  { value: "stats", label: "stats", description: "Show token, model, project, session, tool, and subagent usage stats" },
   { value: "routing", label: "routing", description: "Show or update Takomi model routing policy" },
 ];
 
@@ -44,7 +44,10 @@ const SUBCOMMAND_COMPLETIONS: Record<string, TakomiCompletion[]> = {
     { value: "daily", label: "daily", description: "Show daily usage rows" },
     { value: "models", label: "models", description: "Show model usage leaderboard" },
     { value: "projects", label: "projects", description: "Show project usage leaderboard" },
-    { value: "agents", label: "agents", description: "Show subagent run leaderboard" },
+    { value: "sessions", label: "sessions", description: "Show longest/busiest main sessions" },
+    { value: "tools", label: "tools", description: "Show most used tools" },
+    { value: "agents", label: "agents", description: "Show main agent role leaderboard" },
+    { value: "subagents", label: "subagents", description: "Show subagent run leaderboard" },
     { value: "sources", label: "sources", description: "Show global/project source split" },
     { value: "since 7d", label: "since 7d", description: "Filter stats to the last 7 days" },
     { value: "since 14d", label: "since 14d", description: "Filter stats to the last 14 days" },
@@ -92,7 +95,7 @@ export function commandHelp(): string {
     "/takomi mode <direct|orchestrate|review>",
     "/takomi gate <auto|review>",
     "/takomi subagents <on|off|status|expand|collapse|toggle>",
-    "/takomi stats [overview|daily|models|projects|agents|sources] [since 7d]",
+    "/takomi stats [overview|daily|models|projects|sessions|tools|subagents|sources] [since 7d]",
     "/takomi routing [show|where]",
     "/takomi routing <policy text>              # updates global policy",
     "/takomi routing local <policy text>        # project override",

package/.pi/extensions/takomi-runtime/commands.ts

@@ -8,7 +8,7 @@ import type {
 import { commandHelp, completions, statusText, workflowPrompt } from "./command-text";
 import type { TakomiSubagentController } from "./subagent-types";
 import { installTakomiRoutingPolicy, resolveTakomiRoutingPolicy, type RoutingPolicyInstallScope } from "./routing-policy";
-import { collectTakomiStats, renderTakomiStats } from "../../../src/takomi-stats.js";
+import { collectTakomiStats, renderTakomiStats } from "./takomi-stats.js";
 
 export type TakomiRuntimeCommandState = {
   enabled: boolean;
@@ -257,7 +257,7 @@ export function registerTakomiCommands(pi: ExtensionAPI, options: RegisterTakomi
   });
 
   pi.registerCommand("takomi-stats", {
-    description: "Show bundled Takomi/Pi token, model, project, and subagent usage stats",
+    description: "Show Takomi token, model, project, session, tool, and subagent usage stats",
     getArgumentCompletions: (argumentPrefix: string) => completions(`stats ${argumentPrefix}`).map((completion) => ({
       ...completion,
       value: completion.value.replace(/^stats\s+/, ""),

package/.pi/extensions/takomi-runtime/takomi-stats.d.ts

@@ -0,0 +1,3 @@
+export function collectTakomiStats(opts?: { home?: string; cwd?: string; json?: boolean; limit?: number; view?: string; since?: string }): Promise<any>;
+export function renderTakomiStats(stats: any, opts?: { limit?: number; view?: string }): string;
+export function printTakomiStats(options?: { home?: string; cwd?: string; json?: boolean; limit?: number; view?: string; since?: string }): Promise<void>;

package/.pi/extensions/takomi-runtime/takomi-stats.js

@@ -0,0 +1,544 @@
+import { promises as fs } from 'node:fs';
+import os from 'os';
+import path from 'path';
+
+const colorEnabled = process.env.NO_COLOR !== '1' && process.env.NO_COLOR !== 'true';
+const ansi = (open, close) => (value) => colorEnabled ? `\u001b[${open}m${value}\u001b[${close}m` : String(value);
+const pc = {
+  bold: ansi(1, 22),
+  dim: ansi(2, 22),
+  white: ansi(37, 39),
+  gray: ansi(90, 39),
+  cyan: ansi(36, 39),
+  blue: ansi(34, 39),
+  magenta: ansi(35, 39),
+};
+
+const PRICES = {
+  'gpt-5.5': [5.00, 0.50, 30.00],
+  'gpt-5.4': [2.50, 0.25, 15.00],
+  'gpt-5.4-mini': [0.75, 0.075, 4.50],
+  'gpt-5.4-nano': [0.20, 0.02, 1.25],
+  'gpt-5.3-codex': [2.50, 0.25, 15.00],
+  'gpt-5.2-codex': [1.75, 0.175, 14.00],
+  'gpt-5-codex': [1.25, 0.125, 10.00],
+  'gpt-5.2': [1.75, 0.175, 14.00],
+  'gpt-5.1': [1.25, 0.125, 10.00],
+  'gpt-5': [1.25, 0.125, 10.00],
+  'gpt-5-mini': [0.25, 0.025, 2.00],
+  'gpt-4.1': [2.00, 0.50, 8.00],
+  'gpt-4o': [2.50, 1.25, 10.00],
+  'o4-mini': [1.10, 0.275, 4.40],
+  'claude-sonnet-4-6': [3.00, 0.30, 15.00],
+};
+
+async function exists(target) { try { await fs.access(target); return true; } catch { return false; } }
+function safeJson(line) { try { return JSON.parse(line); } catch { return null; } }
+function dayOf(ts) { return typeof ts === 'string' && ts.length >= 10 ? ts.slice(0, 10) : 'unknown'; }
+function add(map, key, patch) { const row = map.get(key) || { key, input: 0, cache: 0, output: 0, total: 0, cost: 0, events: 0 }; for (const [k,v] of Object.entries(patch)) row[k] = (row[k] || 0) + (Number(v) || 0); if (!Object.prototype.hasOwnProperty.call(patch, 'events')) row.events += 1; map.set(key, row); }
+function cost(model, input, cache, output, additiveCache = true) { const p = PRICES[model]; if (!p) return 0; const nonCached = additiveCache ? input : Math.max(input - cache, 0); return (nonCached*p[0] + cache*p[1] + output*p[2]) / 1_000_000; }
+function fmtTokens(n) { if (n >= 1e9) return `${(n/1e9).toFixed(2)}B`; if (n >= 1e6) return `${(n/1e6).toFixed(1)}M`; if (n >= 1e3) return `${(n/1e3).toFixed(1)}K`; return String(Math.round(n || 0)); }
+function fmtMoney(n) { return `$${(n || 0).toFixed(n > 100 ? 0 : 2)}`; }
+function ms(n) { if (!n) return '-'; const s = Math.round(n/1000); if (s < 60) return `${s}s`; const m = Math.floor(s/60); if (m < 60) return `${m}m ${s%60}s`; const h = Math.floor(m/60); return `${h}h ${m%60}m`; }
+function parseSince(value) {
+  if (!value) return null;
+  const raw = String(value).trim().toLowerCase();
+  const rel = raw.match(/^(\d+)(d|day|days|w|week|weeks|m|month|months)$/);
+  const d = new Date(); d.setHours(0,0,0,0);
+  if (rel) {
+    const n = Number(rel[1]);
+    const unit = rel[2][0];
+    d.setDate(d.getDate() - (unit === 'w' ? n * 7 : unit === 'm' ? n * 30 : n));
+    return d.toISOString().slice(0, 10);
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) return raw;
+  return null;
+}
+function projectKey(file) {
+  const normalized = String(file || '').replace(/\\/g, '/');
+  const marker = '/sessions/';
+  const idx = normalized.indexOf(marker);
+  if (idx >= 0) {
+    const encoded = normalized.slice(idx + marker.length).split('/')[0];
+    return encoded.replace(/^--/, '').replace(/--$/, '').replace(/--/g, '/').replace(/-/g, ' ').trim() || 'global';
+  }
+  const cwdMarker = '/.pi/';
+  const pidx = normalized.indexOf(cwdMarker);
+  if (pidx >= 0) return normalized.slice(0, pidx).split('/').slice(-2).join('/');
+  return 'unknown';
+}
+
+// ── ANSI-aware string helpers ───────────────────────────────────────────────
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\u001b\[[0-9;]*m/g;
+function stripAnsi(s) { return String(s).replace(ANSI_RE, ''); }
+function visLen(s) { return stripAnsi(s).length; }
+function ansiPadEnd(s, w) { return s + ' '.repeat(Math.max(0, w - visLen(s))); }
+function ansiPadStart(s, w) { return ' '.repeat(Math.max(0, w - visLen(s))) + s; }
+
+async function files(root, suffix = '.jsonl') {
+  const out = [];
+  if (!root || !(await exists(root))) return out;
+  async function walk(dir) {
+    for (const ent of await fs.readdir(dir, { withFileTypes: true })) {
+      const p = path.join(dir, ent.name);
+      if (ent.isDirectory()) await walk(p); else if (ent.name.endsWith(suffix)) out.push(p);
+    }
+  }
+  await walk(root); return out;
+}
+
+async function scanPiSessions(root, source, events, sessionRows = []) {
+  for (const file of await files(root)) {
+    let provider = 'unknown', model = 'unknown', session = path.basename(file, '.jsonl'), cwd = '';
+    const row = { key: session, session, source, file, project: projectKey(file), cwd, start: '', end: '', turns: 0, messages: 0, toolCalls: 0, subagentCalls: 0, roles: new Map(), stages: new Map(), workflows: new Map() };
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    for (const line of text.split(/\r?\n/)) {
+      const obj = safeJson(line); if (!obj) continue;
+      if (obj.timestamp) { row.start ||= obj.timestamp; row.end = obj.timestamp; }
+      if (obj.type === 'session') { session = obj.id || session; cwd = obj.cwd || cwd; row.key = session; row.session = session; row.cwd = cwd; }
+      if (obj.type === 'model_change') { provider = obj.provider || provider; model = obj.modelId || model; }
+      if (obj.type === 'custom' && obj.customType === 'takomi-runtime-state' && obj.data) {
+        const role = obj.data.role || 'unknown';
+        const stage = obj.data.stage || 'unknown';
+        const workflow = obj.data.workflow || 'unknown';
+        row.roles.set(role, (row.roles.get(role) || 0) + 1);
+        row.stages.set(stage, (row.stages.get(stage) || 0) + 1);
+        row.workflows.set(workflow, (row.workflows.get(workflow) || 0) + 1);
+        events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'role', role, stage, workflow, input: 0, cache: 0, output: 0, total: 0, cost: 0 });
+      }
+      const msg = obj.type === 'message' && obj.message ? obj.message : null;
+      if (msg) {
+        row.messages += 1;
+        if (msg.role === 'user') row.turns += 1;
+        for (const part of msg.content || []) {
+          if (!part || part.type !== 'toolCall') continue;
+          const name = part.name || 'unknown';
+          row.toolCalls += 1;
+          if (name === 'takomi_subagent') {
+            const args = part.arguments || {};
+            const count = Array.isArray(args.tasks) ? args.tasks.length : Array.isArray(args.chain) ? args.chain.length : 1;
+            row.subagentCalls += count;
+          }
+          events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'tool', tool: name, input: 0, cache: 0, output: 0, total: 0, cost: 0 });
+        }
+      }
+      const u = msg && msg.usage;
+      if (u) events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'usage', input: +u.input||0, cache: +u.cacheRead||0, output: +u.output||0, total: +u.totalTokens||0, cost: cost(model, +u.input||0, +u.cacheRead||0, +u.output||0, true) });
+    }
+    if (row.messages || row.toolCalls || row.turns) sessionRows.push(row);
+  }
+}
+
+async function scanRunHistory(file) {
+  const runs = [];
+  if (!(await exists(file))) return runs;
+  const text = await fs.readFile(file, 'utf8').catch(() => '');
+  for (const line of text.split(/\r?\n/)) { const o = safeJson(line); if (o) runs.push(o); }
+  return runs;
+}
+
+export async function collectTakomiStats(opts = {}) {
+  const home = opts.home || os.homedir();
+  const cwd = opts.cwd || process.cwd();
+  const rawEvents = [], rawSessions = [];
+  await scanPiSessions(path.join(home, '.pi', 'agent', 'sessions'), 'pi-global', rawEvents, rawSessions);
+  await scanPiSessions(path.join(cwd, '.pi', 'agent', 'sessions'), 'pi-project', rawEvents, rawSessions);
+  await scanPiSessions(path.join(cwd, '.pi', 'takomi'), 'takomi-project', rawEvents, rawSessions);
+  const sinceDay = parseSince(opts.since);
+  const events = rawEvents.filter(e => !sinceDay || e.day >= sinceDay);
+  const sessionRows = rawSessions.filter(s => !sinceDay || dayOf(s.end || s.start) >= sinceDay);
+  const runs = await scanRunHistory(path.join(home, '.pi', 'agent', 'run-history.jsonl'));
+  const byDay = new Map(), byModel = new Map(), bySource = new Map(), byProject = new Map(), byTool = new Map(), byRole = new Map(), byStage = new Map(), byWorkflow = new Map();
+  let totals = { input: 0, cache: 0, output: 0, total: 0, cost: 0, events: events.filter(e => e.kind === 'usage').length, toolCalls: 0, turns: 0 };
+  for (const s of sessionRows) { totals.toolCalls += s.toolCalls; totals.turns += s.turns; }
+  for (const e of events) {
+    if (e.kind === 'tool') { add(byTool, e.tool || 'unknown', { total: 0, events: 1 }); continue; }
+    if (e.kind === 'role') {
+      add(byRole, e.role || 'unknown', { total: 0, events: 1 });
+      add(byStage, e.stage || 'unknown', { total: 0, events: 1 });
+      add(byWorkflow, e.workflow || 'unknown', { total: 0, events: 1 });
+      continue;
+    }
+    totals.input += e.input; totals.cache += e.cache; totals.output += e.output; totals.total += e.total; totals.cost += e.cost;
+    add(byDay, e.day, e); add(byModel, e.model, e); add(bySource, e.source, e); add(byProject, e.project, e);
+  }
+  const byAgent = new Map(); let longestRun = null;
+  for (const r of runs) { add(byAgent, r.agent || 'unknown', { total: 0, events: 1 }); if (!longestRun || (+r.duration||0) > (+longestRun.duration||0)) longestRun = r; }
+  const topSessions = [...sessionRows].sort((a,b)=>b.turns-a.turns || b.toolCalls-a.toolCalls).slice(0, 20);
+  const mostSubagentsSession = [...sessionRows].sort((a,b)=>b.subagentCalls-a.subagentCalls)[0] || null;
+  return { generatedAt: new Date().toISOString(), cwd, since: sinceDay, totals, sessions: new Set([...events.map(e => e.session), ...sessionRows.map(s => s.session)]).size, byDay: [...byDay.values()].sort((a,b)=>a.key.localeCompare(b.key)), byModel: [...byModel.values()].sort((a,b)=>b.total-a.total), bySource: [...bySource.values()].sort((a,b)=>b.total-a.total), byProject: [...byProject.values()].sort((a,b)=>b.total-a.total), byTool: [...byTool.values()].sort((a,b)=>b.events-a.events), byRole: [...byRole.values()].sort((a,b)=>b.events-a.events), byStage: [...byStage.values()].sort((a,b)=>b.events-a.events), byWorkflow: [...byWorkflow.values()].sort((a,b)=>b.events-a.events), byAgent: [...byAgent.values()].sort((a,b)=>b.events-a.events), sessionRows, topSessions, mostSubagentsSession, runs, longestRun, recent: events.sort((a,b)=>(b.timestamp||'').localeCompare(a.timestamp||'')).slice(0, 10) };
+}
+
+// ── Streak Calculation ──────────────────────────────────────────────────────
+function calcStreaks(byDay) {
+  if (!byDay.length) return { current: 0, longest: 0, quietDays: 0 };
+  const daySet = new Set(byDay.map(d => d.key));
+  const today = new Date(); today.setHours(0,0,0,0);
+  // current streak: walk back from today
+  let current = 0;
+  for (let d = new Date(today); ; d.setDate(d.getDate() - 1)) {
+    const key = d.toISOString().slice(0, 10);
+    if (daySet.has(key)) current++; else break;
+  }
+  // longest streak: walk all sorted days
+  const sorted = [...daySet].sort();
+  let longest = 0, run = 1;
+  for (let i = 1; i < sorted.length; i++) {
+    const prev = new Date(sorted[i - 1]); prev.setDate(prev.getDate() + 1);
+    if (prev.toISOString().slice(0, 10) === sorted[i]) { run++; } else { longest = Math.max(longest, run); run = 1; }
+  }
+  longest = Math.max(longest, run);
+  // quiet days
+  const first = new Date(sorted[0]);
+  const span = Math.round((today - first) / 86400000) + 1;
+  return { current, longest, quietDays: Math.max(0, span - sorted.length) };
+}
+
+// ── GitHub-style Heatmap Grid ───────────────────────────────────────────────
+function heatmapGrid(byDay) {
+  const dayMap = new Map(byDay.map(d => [d.key, d.total]));
+  const max = Math.max(1, ...byDay.map(d => d.total));
+
+  // Determine range: last ~26 weeks (half year) ending at current week
+  const today = new Date(); today.setHours(0,0,0,0);
+  // End at end of current week (Sunday)
+  const endDate = new Date(today);
+  const todayDow = endDate.getDay(); // 0=Sun, 1=Mon...
+  if (todayDow !== 0) endDate.setDate(endDate.getDate() + (7 - todayDow));
+  // Start 26 weeks back on Monday
+  const startDate = new Date(endDate);
+  startDate.setDate(startDate.getDate() - (26 * 7) + 1);
+  while (startDate.getDay() !== 1) startDate.setDate(startDate.getDate() - 1);
+
+  // Build grid: 7 rows (Mon..Sun), N columns (weeks)
+  const weeks = [];
+  const monthPositions = []; // { col, label }
+  const cursor = new Date(startDate);
+  let col = 0;
+  let lastMonth = -1;
+
+  while (cursor <= endDate) {
+    const week = [];
+    for (let dow = 0; dow < 7; dow++) {
+      const key = cursor.toISOString().slice(0, 10);
+      const val = cursor <= today ? (dayMap.get(key) || 0) : -1; // -1 = future
+      week.push(val);
+      // Track month transitions on the Monday of each week
+      if (dow === 0) {
+        const m = cursor.getMonth();
+        if (m !== lastMonth) {
+          const monthNames = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+          monthPositions.push({ col, label: monthNames[m] });
+          lastMonth = m;
+        }
+      }
+      cursor.setDate(cursor.getDate() + 1);
+    }
+    weeks.push(week);
+    col++;
+  }
+
+  // Intensity cell — use ■ for filled, · for empty
+  const SQ = '■';
+  const EMPTY = '·';
+  function cell(val) {
+    if (val < 0) return ' ';  // future
+    if (val === 0) return pc.gray(EMPTY);
+    const x = val / max;
+    if (x < 0.12) return pc.dim(pc.cyan(SQ));
+    if (x < 0.30) return pc.cyan(SQ);
+    if (x < 0.55) return pc.blue(SQ);
+    if (x < 0.80) return pc.magenta(SQ);
+    return pc.bold(pc.magenta(SQ));
+  }
+
+  const dayLabels = ['Mon','   ','Wed','   ','Fri','   ','Sun'];
+  const rows = [];
+
+  // Each cell is 2 chars wide (char + space) in the grid
+  for (let dow = 0; dow < 7; dow++) {
+    const prefix = pc.dim(dayLabels[dow]);
+    const cells = weeks.map(w => cell(w[dow]));
+    rows.push(`    ${prefix} ${cells.join(' ')}`);
+  }
+
+  // Month label row — positioned under the correct columns
+  // Each column is 2 chars wide (cell + space separator)
+  let labelStr = '';
+  let prevEnd = 0;
+  for (const ml of monthPositions) {
+    const targetPos = ml.col * 2; // 2 chars per column (char + space)
+    const gap = Math.max(0, targetPos - prevEnd);
+    labelStr += ' '.repeat(gap) + ml.label;
+    prevEnd = targetPos + ml.label.length;
+  }
+  rows.push(`        ${pc.dim(labelStr)}`);
+
+  // Legend row
+  rows.push('');
+  rows.push(`    ${pc.dim('Less')} ${pc.gray(EMPTY)} ${pc.dim(pc.cyan(SQ))} ${pc.cyan(SQ)} ${pc.blue(SQ)} ${pc.magenta(SQ)} ${pc.bold(pc.magenta(SQ))} ${pc.dim('More')}`);
+
+  return rows.join('\n');
+}
+
+// ── Box Drawing Helpers ─────────────────────────────────────────────────────
+function hrule(w, ch = '─') { return ch.repeat(w); }
+
+function center(text, width) {
+  const vl = visLen(text);
+  const pad = Math.max(0, Math.floor((width - vl) / 2));
+  return ' '.repeat(pad) + text;
+}
+
+function statCard(value, label) {
+  return { value: String(value), label };
+}
+
+// ── Table Helper ────────────────────────────────────────────────────────────
+function renderTable(title, rows, columns) {
+  const lines = [];
+  lines.push('  ' + pc.bold(pc.cyan(title)));
+  lines.push('  ' + pc.dim(hrule(columns.reduce((s, c) => s + c.width, 0) + columns.length * 2)));
+  for (const row of rows) {
+    let line = '  ';
+    for (const col of columns) {
+      const val = String(col.get(row));
+      line += col.align === 'right' ? ansiPadStart(val, col.width) : ansiPadEnd(val, col.width);
+      line += '  ';
+    }
+    lines.push(line);
+  }
+  return lines.join('\n');
+}
+
+function sessionLabel(row, width = 36) {
+  const project = row.project || row.cwd || row.key || 'unknown';
+  return project.length > width ? '…' + project.slice(-(width - 1)) : project;
+}
+function sessionDay(row) { return dayOf(row.start || row.end).slice(5) || '??-??'; }
+
+function renderFocusedView(stats, opts = {}) {
+  const view = opts.view;
+  const limit = opts.limit || 20;
+  if (!view || view === 'overview') return null;
+  const tables = {
+    models: ['Top Models', stats.byModel, [
+      { width: 26, align: 'left', get: r => pc.white(r.key) },
+      { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
+      { width: 10, align: 'right', get: r => pc.dim(fmtMoney(r.cost)) },
+      { width: 12, align: 'right', get: r => pc.dim(r.events + ' calls') },
+    ]],
+    sources: ['Sources', stats.bySource, [
+      { width: 22, align: 'left', get: r => pc.white(r.key) },
+      { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
+      { width: 14, align: 'right', get: r => pc.dim(r.events + ' events') },
+    ]],
+    projects: ['Top Projects', stats.byProject, [
+      { width: 42, align: 'left', get: r => pc.white(r.key.length > 42 ? '…' + r.key.slice(-41) : r.key) },
+      { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
+      { width: 10, align: 'right', get: r => pc.dim(fmtMoney(r.cost)) },
+      { width: 12, align: 'right', get: r => pc.dim(r.events + ' calls') },
+    ]],
+    agents: ['Main Agent Roles', stats.byRole, [
+      { width: 24, align: 'left', get: r => pc.white(r.key) },
+      { width: 8, align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 12, align: 'left', get: () => pc.dim('state hits') },
+    ]],
+    subagents: ['Top Subagents', stats.byAgent, [
+      { width: 24, align: 'left', get: r => pc.white(r.key) },
+      { width: 8, align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 8, align: 'left', get: () => pc.dim('runs') },
+    ]],
+    tools: ['Top Tools', stats.byTool, [
+      { width: 28, align: 'left', get: r => pc.white(r.key) },
+      { width: 10, align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 8, align: 'left', get: () => pc.dim('calls') },
+    ]],
+    sessions: ['Longest Main Sessions', stats.topSessions, [
+      { width: 6, align: 'left', get: r => pc.dim(sessionDay(r)) },
+      { width: 34, align: 'left', get: r => pc.white(sessionLabel(r, 34)) },
+      { width: 8, align: 'right', get: r => pc.cyan(String(r.turns)) },
+      { width: 8, align: 'left', get: () => pc.dim('turns') },
+      { width: 8, align: 'right', get: r => pc.cyan(String(r.toolCalls)) },
+      { width: 8, align: 'left', get: () => pc.dim('tools') },
+    ]],
+    daily: ['Daily Usage', [...stats.byDay].reverse(), [
+      { width: 12, align: 'left', get: r => pc.white(r.key) },
+      { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
+      { width: 10, align: 'right', get: r => pc.dim(fmtMoney(r.cost)) },
+      { width: 12, align: 'right', get: r => pc.dim(r.events + ' calls') },
+    ]],
+  };
+  const spec = tables[view === 'project' ? 'projects' : view];
+  if (!spec) return null;
+  const [title, rows, cols] = spec;
+  const suffix = stats.since ? pc.dim(`\n  Since: ${stats.since}`) : '';
+  return ['\n' + pc.bold(pc.magenta('Takomi Stats')), suffix, renderTable(title, rows.slice(0, limit), cols), '\n' + pc.dim('Privacy: metadata only · no raw prompts or transcripts')].filter(Boolean).join('\n');
+}
+
+// ── Main Render ─────────────────────────────────────────────────────────────
+export function renderTakomiStats(stats, opts = {}) {
+  const focused = renderFocusedView(stats, opts);
+  if (focused) return focused;
+  const W = Math.min(process.stdout.columns || 80, 86);
+  const topModel = stats.byModel[0]?.key || 'unknown';
+  const peak = stats.byDay.reduce((a,b) => b.total > (a?.total||0) ? b : a, null);
+  const streaks = calcStreaks(stats.byDay);
+  const lines = [];
+
+  // ── Header ────────────────────────────────────────────────────────────
+  lines.push('');
+  lines.push(pc.cyan('  ' + hrule(W - 4, '━')));
+  lines.push('');
+  lines.push(center(pc.bold(pc.white('T A K O M I   S T A T S')), W));
+  const user = process.env.USERNAME || process.env.USER || 'local';
+  lines.push(center(pc.dim(`@${user}  ·  Takomi`), W));
+  lines.push('');
+  lines.push(pc.cyan('  ' + hrule(W - 4)));
+
+  // ── Stat Cards Row 1 ─────────────────────────────────────────────────
+  const cards1 = [
+    statCard(fmtTokens(stats.totals.total), 'Lifetime Tokens'),
+    statCard(fmtTokens(stats.totals.cache), 'Cache Tokens'),
+    statCard(fmtMoney(stats.totals.cost), 'Est. Cost'),
+    statCard(String(stats.sessions), 'Sessions'),
+    statCard(String(stats.totals.turns), 'Main Turns'),
+  ];
+
+  const cardW = Math.floor((W - 4) / cards1.length);
+
+
+  function buildCardLines(cards) {
+    let vStr = '  ';
+    let lStr = '  ';
+    for (const c of cards) {
+      const vPad = Math.max(0, Math.floor((cardW - c.value.length) / 2));
+      const lPad = Math.max(0, Math.floor((cardW - c.label.length) / 2));
+      const vContent = ' '.repeat(vPad) + pc.bold(pc.white(c.value));
+      const lContent = ' '.repeat(lPad) + pc.dim(c.label);
+      // Pad to cardW visible chars
+      vStr += ansiPadEnd(vContent, cardW);
+      lStr += ansiPadEnd(lContent, cardW);
+    }
+    return [vStr, lStr];
+  }
+
+  lines.push('');
+  const [v1, l1] = buildCardLines(cards1);
+  lines.push(v1);
+  lines.push(l1);
+
+  // ── Stat Cards Row 2 ─────────────────────────────────────────────────
+  lines.push('');
+  const cards2 = [
+    statCard(peak ? fmtTokens(peak.total) : '-', 'Peak Day'),
+    statCard(topModel, 'Top Model'),
+    statCard(String(stats.totals.toolCalls), 'Tool Calls'),
+    statCard(`${streaks.current} days`, 'Current Streak'),
+    statCard(`${streaks.longest} days`, 'Longest Streak'),
+  ];
+
+  const [v2, l2] = buildCardLines(cards2);
+  lines.push(v2);
+  lines.push(l2);
+
+  // ── Info line ─────────────────────────────────────────────────────────
+  lines.push('');
+  const infoText = `Peak: ${peak?.key || '-'}  ·  ${streaks.quietDays} quiet days  ·  ${stats.totals.events.toLocaleString()} events${stats.since ? `  ·  since ${stats.since}` : ''}`;
+  lines.push(center(pc.dim(infoText), W));
+
+  lines.push('');
+  lines.push(pc.cyan('  ' + hrule(W - 4, '━')));
+
+  // ── Activity Heatmap ────────────────────────────────────────────────────
+  lines.push('');
+  lines.push('  ' + pc.bold(pc.cyan('Token Activity')));
+  lines.push('  ' + pc.dim(hrule(W - 4)));
+  lines.push(heatmapGrid(stats.byDay));
+
+  // ── Models Table ────────────────────────────────────────────────────────
+  lines.push('');
+  const modelLimit = opts.limit || 8;
+  lines.push(renderTable('Top Models', stats.byModel.slice(0, modelLimit), [
+    { width: 24, align: 'left',  get: r => pc.white(r.key) },
+    { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
+    { width: 10, align: 'right', get: r => pc.dim(fmtMoney(r.cost)) },
+    { width: 12, align: 'right', get: r => pc.dim(r.events + ' calls') },
+  ]));
+
+  // ── Projects Table ──────────────────────────────────────────────────────
+  if (stats.byProject.length) {
+    lines.push('');
+    lines.push(renderTable('Top Projects', stats.byProject.slice(0, 5), [
+      { width: 34, align: 'left',  get: r => pc.white(r.key.length > 34 ? '…' + r.key.slice(-33) : r.key) },
+      { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
+      { width: 10, align: 'right', get: r => pc.dim(fmtMoney(r.cost)) },
+    ]));
+  }
+
+  // ── Main Agent Roles Table ──────────────────────────────────────────────
+  if (stats.byRole.length) {
+    lines.push('');
+    lines.push(renderTable('Main Agent Roles', stats.byRole.slice(0, modelLimit), [
+      { width: 20, align: 'left',  get: r => pc.white(r.key) },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 10, align: 'left',  get: r => pc.dim('state hits') },
+    ]));
+  }
+
+  // ── Main Session Table ──────────────────────────────────────────────────
+  if (stats.topSessions.length) {
+    lines.push('');
+    lines.push(renderTable('Longest Main Sessions', stats.topSessions.slice(0, 5), [
+      { width: 6,  align: 'left',  get: r => pc.dim(sessionDay(r)) },
+      { width: 32, align: 'left',  get: r => pc.white(sessionLabel(r, 32)) },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.turns)) },
+      { width: 8,  align: 'left',  get: r => pc.dim('turns') },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.toolCalls)) },
+      { width: 6,  align: 'left',  get: r => pc.dim('tools') },
+    ]));
+  }
+
+  // ── Tools Table ─────────────────────────────────────────────────────────
+  if (stats.byTool.length) {
+    lines.push('');
+    lines.push(renderTable('Top Tools', stats.byTool.slice(0, modelLimit), [
+      { width: 24, align: 'left',  get: r => pc.white(r.key) },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 6,  align: 'left',  get: r => pc.dim('calls') },
+    ]));
+  }
+
+  // ── Sources Table ───────────────────────────────────────────────────────
+  lines.push('');
+  lines.push(renderTable('Sources', stats.bySource, [
+    { width: 20, align: 'left',  get: r => pc.white(r.key) },
+    { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
+    { width: 14, align: 'right', get: r => pc.dim(r.events + ' events') },
+  ]));
+
+  // ── Subagents Table ─────────────────────────────────────────────────────
+  if (stats.byAgent.length) {
+    lines.push('');
+    lines.push(renderTable('Top Subagents', stats.byAgent.slice(0, modelLimit), [
+      { width: 20, align: 'left',  get: r => pc.white(r.key) },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 6,  align: 'left',  get: r => pc.dim('runs') },
+    ]));
+  }
+
+  // ── Footer ──────────────────────────────────────────────────────────────
+  lines.push('');
+  lines.push('  ' + pc.dim(hrule(W - 4)));
+  lines.push('  ' + pc.dim('Privacy: metadata only · no raw prompts or transcripts'));
+  lines.push('  ' + pc.dim('Costs are estimates when provider prices are unknown.'));
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+export async function printTakomiStats(options = {}) {
+  const stats = await collectTakomiStats(options);
+  if (options.json) console.log(JSON.stringify(stats, null, 2)); else console.log(renderTakomiStats(stats, options));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.18",
+  "version": "2.1.20",
   "description": "🎯 Stop wrestling with AI. Start building with purpose. The artisan's toolkit for agent workflows, Codex skills, and original Takomi capabilities like 21st.dev integration.",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -846,7 +846,7 @@ program
 
 program
   .command('stats [view]')
-  .description('Show bundled Takomi/Pi token, model, project, and subagent usage stats')
+  .description('Show Takomi token, model, project, session, tool, and subagent usage stats')
   .option('--json', 'Print machine-readable JSON')
   .option('--home <path>', 'Override home directory for Pi history scanning')
   .option('--cwd <path>', 'Override project directory for project-local stats')

package/src/pi-installer.js

@@ -173,6 +173,7 @@ export async function validatePiHarnessInstall() {
     subagents: await fs.pathExists(path.join(targets.extensions, 'takomi-subagents')),
     contextManager: await fs.pathExists(path.join(targets.extensions, 'takomi-context-manager')),
     oauthRouter: await fs.pathExists(path.join(targets.extensions, 'oauth-router')),
+    notifySound: await fs.pathExists(path.join(targets.extensions, 'notify-sound')),
     prompts: await fs.pathExists(targets.prompts),
     agents: await fs.pathExists(targets.agents),
     themes: await fs.pathExists(targets.themes),
@@ -187,7 +188,7 @@ export function printPiInstallSummary(result, validation) {
   console.log(pc.green('\n✔ Installed Takomi Pi harness assets'));
   console.log(pc.white(`  Root:       ${result.targets.root}`));
   console.log(pc.white(`  Manifest:   ${PI_MANIFEST_PATH}`));
-  console.log(pc.white(`  Extensions: ${validation.runtime && validation.subagents && validation.contextManager && validation.oauthRouter ? 'ok' : 'check needed'}`));
+  console.log(pc.white(`  Extensions: ${validation.runtime && validation.subagents && validation.contextManager && validation.oauthRouter && validation.notifySound ? 'ok' : 'check needed'}`));
   console.log(pc.white(`  Prompts:    ${validation.prompts ? 'ok' : 'missing'}`));
   console.log(pc.white(`  Agents:     ${validation.agents ? 'ok' : 'missing'}`));
   console.log(pc.white(`  Themes:     ${validation.themes ? 'ok' : 'missing'}`));

package/src/takomi-stats.js

@@ -1,7 +1,18 @@
-import fs from 'fs-extra';
+import { promises as fs } from 'node:fs';
 import os from 'os';
 import path from 'path';
-import pc from 'picocolors';
+
+const colorEnabled = process.env.NO_COLOR !== '1' && process.env.NO_COLOR !== 'true';
+const ansi = (open, close) => (value) => colorEnabled ? `\u001b[${open}m${value}\u001b[${close}m` : String(value);
+const pc = {
+  bold: ansi(1, 22),
+  dim: ansi(2, 22),
+  white: ansi(37, 39),
+  gray: ansi(90, 39),
+  cyan: ansi(36, 39),
+  blue: ansi(34, 39),
+  magenta: ansi(35, 39),
+};
 
 const PRICES = {
   'gpt-5.5': [5.00, 0.50, 30.00],
@@ -21,6 +32,7 @@ const PRICES = {
   'claude-sonnet-4-6': [3.00, 0.30, 15.00],
 };
 
+async function exists(target) { try { await fs.access(target); return true; } catch { return false; } }
 function safeJson(line) { try { return JSON.parse(line); } catch { return null; } }
 function dayOf(ts) { return typeof ts === 'string' && ts.length >= 10 ? ts.slice(0, 10) : 'unknown'; }
 function add(map, key, patch) { const row = map.get(key) || { key, input: 0, cache: 0, output: 0, total: 0, cost: 0, events: 0 }; for (const [k,v] of Object.entries(patch)) row[k] = (row[k] || 0) + (Number(v) || 0); if (!Object.prototype.hasOwnProperty.call(patch, 'events')) row.events += 1; map.set(key, row); }
@@ -66,7 +78,7 @@ function ansiPadStart(s, w) { return ' '.repeat(Math.max(0, w - visLen(s))) + s;
 
 async function files(root, suffix = '.jsonl') {
   const out = [];
-  if (!root || !(await fs.pathExists(root))) return out;
+  if (!root || !(await exists(root))) return out;
   async function walk(dir) {
     for (const ent of await fs.readdir(dir, { withFileTypes: true })) {
       const p = path.join(dir, ent.name);
@@ -76,23 +88,51 @@ async function files(root, suffix = '.jsonl') {
   await walk(root); return out;
 }
 
-async function scanPiSessions(root, source, events) {
+async function scanPiSessions(root, source, events, sessionRows = []) {
   for (const file of await files(root)) {
-    let provider = 'unknown', model = 'unknown', session = path.basename(file, '.jsonl');
+    let provider = 'unknown', model = 'unknown', session = path.basename(file, '.jsonl'), cwd = '';
+    const row = { key: session, session, source, file, project: projectKey(file), cwd, start: '', end: '', turns: 0, messages: 0, toolCalls: 0, subagentCalls: 0, roles: new Map(), stages: new Map(), workflows: new Map() };
     const text = await fs.readFile(file, 'utf8').catch(() => '');
     for (const line of text.split(/\r?\n/)) {
       const obj = safeJson(line); if (!obj) continue;
-      if (obj.type === 'session') session = obj.id || session;
+      if (obj.timestamp) { row.start ||= obj.timestamp; row.end = obj.timestamp; }
+      if (obj.type === 'session') { session = obj.id || session; cwd = obj.cwd || cwd; row.key = session; row.session = session; row.cwd = cwd; }
       if (obj.type === 'model_change') { provider = obj.provider || provider; model = obj.modelId || model; }
-      const u = obj.type === 'message' && obj.message && obj.message.usage;
-      if (u) events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, input: +u.input||0, cache: +u.cacheRead||0, output: +u.output||0, total: +u.totalTokens||0, cost: cost(model, +u.input||0, +u.cacheRead||0, +u.output||0, true) });
+      if (obj.type === 'custom' && obj.customType === 'takomi-runtime-state' && obj.data) {
+        const role = obj.data.role || 'unknown';
+        const stage = obj.data.stage || 'unknown';
+        const workflow = obj.data.workflow || 'unknown';
+        row.roles.set(role, (row.roles.get(role) || 0) + 1);
+        row.stages.set(stage, (row.stages.get(stage) || 0) + 1);
+        row.workflows.set(workflow, (row.workflows.get(workflow) || 0) + 1);
+        events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'role', role, stage, workflow, input: 0, cache: 0, output: 0, total: 0, cost: 0 });
+      }
+      const msg = obj.type === 'message' && obj.message ? obj.message : null;
+      if (msg) {
+        row.messages += 1;
+        if (msg.role === 'user') row.turns += 1;
+        for (const part of msg.content || []) {
+          if (!part || part.type !== 'toolCall') continue;
+          const name = part.name || 'unknown';
+          row.toolCalls += 1;
+          if (name === 'takomi_subagent') {
+            const args = part.arguments || {};
+            const count = Array.isArray(args.tasks) ? args.tasks.length : Array.isArray(args.chain) ? args.chain.length : 1;
+            row.subagentCalls += count;
+          }
+          events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'tool', tool: name, input: 0, cache: 0, output: 0, total: 0, cost: 0 });
+        }
+      }
+      const u = msg && msg.usage;
+      if (u) events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'usage', input: +u.input||0, cache: +u.cacheRead||0, output: +u.output||0, total: +u.totalTokens||0, cost: cost(model, +u.input||0, +u.cacheRead||0, +u.output||0, true) });
     }
+    if (row.messages || row.toolCalls || row.turns) sessionRows.push(row);
   }
 }
 
 async function scanRunHistory(file) {
   const runs = [];
-  if (!(await fs.pathExists(file))) return runs;
+  if (!(await exists(file))) return runs;
   const text = await fs.readFile(file, 'utf8').catch(() => '');
   for (const line of text.split(/\r?\n/)) { const o = safeJson(line); if (o) runs.push(o); }
   return runs;
@@ -101,24 +141,33 @@ async function scanRunHistory(file) {
 export async function collectTakomiStats(opts = {}) {
   const home = opts.home || os.homedir();
   const cwd = opts.cwd || process.cwd();
-  const rawEvents = [];
-  await scanPiSessions(path.join(home, '.pi', 'agent', 'sessions'), 'pi-global', rawEvents);
-  await scanPiSessions(path.join(cwd, '.pi', 'agent', 'sessions'), 'pi-project', rawEvents);
-  await scanPiSessions(path.join(cwd, '.pi', 'takomi'), 'takomi-project', rawEvents);
+  const rawEvents = [], rawSessions = [];
+  await scanPiSessions(path.join(home, '.pi', 'agent', 'sessions'), 'pi-global', rawEvents, rawSessions);
+  await scanPiSessions(path.join(cwd, '.pi', 'agent', 'sessions'), 'pi-project', rawEvents, rawSessions);
+  await scanPiSessions(path.join(cwd, '.pi', 'takomi'), 'takomi-project', rawEvents, rawSessions);
   const sinceDay = parseSince(opts.since);
-  const events = rawEvents
-    .filter(e => !sinceDay || e.day >= sinceDay)
-    .map(e => ({ ...e, project: projectKey(e.file) }));
+  const events = rawEvents.filter(e => !sinceDay || e.day >= sinceDay);
+  const sessionRows = rawSessions.filter(s => !sinceDay || dayOf(s.end || s.start) >= sinceDay);
   const runs = await scanRunHistory(path.join(home, '.pi', 'agent', 'run-history.jsonl'));
-  const byDay = new Map(), byModel = new Map(), bySource = new Map(), byProject = new Map();
-  let totals = { input: 0, cache: 0, output: 0, total: 0, cost: 0, events: events.length };
+  const byDay = new Map(), byModel = new Map(), bySource = new Map(), byProject = new Map(), byTool = new Map(), byRole = new Map(), byStage = new Map(), byWorkflow = new Map();
+  let totals = { input: 0, cache: 0, output: 0, total: 0, cost: 0, events: events.filter(e => e.kind === 'usage').length, toolCalls: 0, turns: 0 };
+  for (const s of sessionRows) { totals.toolCalls += s.toolCalls; totals.turns += s.turns; }
   for (const e of events) {
+    if (e.kind === 'tool') { add(byTool, e.tool || 'unknown', { total: 0, events: 1 }); continue; }
+    if (e.kind === 'role') {
+      add(byRole, e.role || 'unknown', { total: 0, events: 1 });
+      add(byStage, e.stage || 'unknown', { total: 0, events: 1 });
+      add(byWorkflow, e.workflow || 'unknown', { total: 0, events: 1 });
+      continue;
+    }
     totals.input += e.input; totals.cache += e.cache; totals.output += e.output; totals.total += e.total; totals.cost += e.cost;
     add(byDay, e.day, e); add(byModel, e.model, e); add(bySource, e.source, e); add(byProject, e.project, e);
   }
   const byAgent = new Map(); let longestRun = null;
   for (const r of runs) { add(byAgent, r.agent || 'unknown', { total: 0, events: 1 }); if (!longestRun || (+r.duration||0) > (+longestRun.duration||0)) longestRun = r; }
-  return { generatedAt: new Date().toISOString(), cwd, since: sinceDay, totals, sessions: new Set(events.map(e => e.session)).size, byDay: [...byDay.values()].sort((a,b)=>a.key.localeCompare(b.key)), byModel: [...byModel.values()].sort((a,b)=>b.total-a.total), bySource: [...bySource.values()].sort((a,b)=>b.total-a.total), byProject: [...byProject.values()].sort((a,b)=>b.total-a.total), byAgent: [...byAgent.values()].sort((a,b)=>b.events-a.events), runs, longestRun, recent: events.sort((a,b)=>(b.timestamp||'').localeCompare(a.timestamp||'')).slice(0, 10) };
+  const topSessions = [...sessionRows].sort((a,b)=>b.turns-a.turns || b.toolCalls-a.toolCalls).slice(0, 20);
+  const mostSubagentsSession = [...sessionRows].sort((a,b)=>b.subagentCalls-a.subagentCalls)[0] || null;
+  return { generatedAt: new Date().toISOString(), cwd, since: sinceDay, totals, sessions: new Set([...events.map(e => e.session), ...sessionRows.map(s => s.session)]).size, byDay: [...byDay.values()].sort((a,b)=>a.key.localeCompare(b.key)), byModel: [...byModel.values()].sort((a,b)=>b.total-a.total), bySource: [...bySource.values()].sort((a,b)=>b.total-a.total), byProject: [...byProject.values()].sort((a,b)=>b.total-a.total), byTool: [...byTool.values()].sort((a,b)=>b.events-a.events), byRole: [...byRole.values()].sort((a,b)=>b.events-a.events), byStage: [...byStage.values()].sort((a,b)=>b.events-a.events), byWorkflow: [...byWorkflow.values()].sort((a,b)=>b.events-a.events), byAgent: [...byAgent.values()].sort((a,b)=>b.events-a.events), sessionRows, topSessions, mostSubagentsSession, runs, longestRun, recent: events.sort((a,b)=>(b.timestamp||'').localeCompare(a.timestamp||'')).slice(0, 10) };
 }
 
 // ── Streak Calculation ──────────────────────────────────────────────────────
@@ -263,6 +312,12 @@ function renderTable(title, rows, columns) {
   return lines.join('\n');
 }
 
+function sessionLabel(row, width = 36) {
+  const project = row.project || row.cwd || row.key || 'unknown';
+  return project.length > width ? '…' + project.slice(-(width - 1)) : project;
+}
+function sessionDay(row) { return dayOf(row.start || row.end).slice(5) || '??-??'; }
+
 function renderFocusedView(stats, opts = {}) {
   const view = opts.view;
   const limit = opts.limit || 20;
@@ -285,11 +340,29 @@ function renderFocusedView(stats, opts = {}) {
       { width: 10, align: 'right', get: r => pc.dim(fmtMoney(r.cost)) },
       { width: 12, align: 'right', get: r => pc.dim(r.events + ' calls') },
     ]],
-    agents: ['Top Agents', stats.byAgent, [
+    agents: ['Main Agent Roles', stats.byRole, [
+      { width: 24, align: 'left', get: r => pc.white(r.key) },
+      { width: 8, align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 12, align: 'left', get: () => pc.dim('state hits') },
+    ]],
+    subagents: ['Top Subagents', stats.byAgent, [
       { width: 24, align: 'left', get: r => pc.white(r.key) },
       { width: 8, align: 'right', get: r => pc.cyan(String(r.events)) },
       { width: 8, align: 'left', get: () => pc.dim('runs') },
     ]],
+    tools: ['Top Tools', stats.byTool, [
+      { width: 28, align: 'left', get: r => pc.white(r.key) },
+      { width: 10, align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 8, align: 'left', get: () => pc.dim('calls') },
+    ]],
+    sessions: ['Longest Main Sessions', stats.topSessions, [
+      { width: 6, align: 'left', get: r => pc.dim(sessionDay(r)) },
+      { width: 34, align: 'left', get: r => pc.white(sessionLabel(r, 34)) },
+      { width: 8, align: 'right', get: r => pc.cyan(String(r.turns)) },
+      { width: 8, align: 'left', get: () => pc.dim('turns') },
+      { width: 8, align: 'right', get: r => pc.cyan(String(r.toolCalls)) },
+      { width: 8, align: 'left', get: () => pc.dim('tools') },
+    ]],
     daily: ['Daily Usage', [...stats.byDay].reverse(), [
       { width: 12, align: 'left', get: r => pc.white(r.key) },
       { width: 10, align: 'right', get: r => pc.cyan(fmtTokens(r.total)) },
@@ -330,7 +403,7 @@ export function renderTakomiStats(stats, opts = {}) {
     statCard(fmtTokens(stats.totals.cache), 'Cache Tokens'),
     statCard(fmtMoney(stats.totals.cost), 'Est. Cost'),
     statCard(String(stats.sessions), 'Sessions'),
-    statCard(String(stats.runs.length), 'Agent Runs'),
+    statCard(String(stats.totals.turns), 'Main Turns'),
   ];
 
   const cardW = Math.floor((W - 4) / cards1.length);
@@ -361,7 +434,7 @@ export function renderTakomiStats(stats, opts = {}) {
   const cards2 = [
     statCard(peak ? fmtTokens(peak.total) : '-', 'Peak Day'),
     statCard(topModel, 'Top Model'),
-    statCard(ms(stats.longestRun?.duration), 'Longest Run'),
+    statCard(String(stats.totals.toolCalls), 'Tool Calls'),
     statCard(`${streaks.current} days`, 'Current Streak'),
     statCard(`${streaks.longest} days`, 'Longest Streak'),
   ];
@@ -404,6 +477,39 @@ export function renderTakomiStats(stats, opts = {}) {
     ]));
   }
 
+  // ── Main Agent Roles Table ──────────────────────────────────────────────
+  if (stats.byRole.length) {
+    lines.push('');
+    lines.push(renderTable('Main Agent Roles', stats.byRole.slice(0, modelLimit), [
+      { width: 20, align: 'left',  get: r => pc.white(r.key) },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 10, align: 'left',  get: r => pc.dim('state hits') },
+    ]));
+  }
+
+  // ── Main Session Table ──────────────────────────────────────────────────
+  if (stats.topSessions.length) {
+    lines.push('');
+    lines.push(renderTable('Longest Main Sessions', stats.topSessions.slice(0, 5), [
+      { width: 6,  align: 'left',  get: r => pc.dim(sessionDay(r)) },
+      { width: 32, align: 'left',  get: r => pc.white(sessionLabel(r, 32)) },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.turns)) },
+      { width: 8,  align: 'left',  get: r => pc.dim('turns') },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.toolCalls)) },
+      { width: 6,  align: 'left',  get: r => pc.dim('tools') },
+    ]));
+  }
+
+  // ── Tools Table ─────────────────────────────────────────────────────────
+  if (stats.byTool.length) {
+    lines.push('');
+    lines.push(renderTable('Top Tools', stats.byTool.slice(0, modelLimit), [
+      { width: 24, align: 'left',  get: r => pc.white(r.key) },
+      { width: 8,  align: 'right', get: r => pc.cyan(String(r.events)) },
+      { width: 6,  align: 'left',  get: r => pc.dim('calls') },
+    ]));
+  }
+
   // ── Sources Table ───────────────────────────────────────────────────────
   lines.push('');
   lines.push(renderTable('Sources', stats.bySource, [
@@ -412,10 +518,10 @@ export function renderTakomiStats(stats, opts = {}) {
     { width: 14, align: 'right', get: r => pc.dim(r.events + ' events') },
   ]));
 
-  // ── Agents Table ────────────────────────────────────────────────────────
+  // ── Subagents Table ─────────────────────────────────────────────────────
   if (stats.byAgent.length) {
     lines.push('');
-    lines.push(renderTable('Top Agents', stats.byAgent.slice(0, modelLimit), [
+    lines.push(renderTable('Top Subagents', stats.byAgent.slice(0, modelLimit), [
       { width: 20, align: 'left',  get: r => pc.white(r.key) },
       { width: 8,  align: 'right', get: r => pc.cyan(String(r.events)) },
       { width: 6,  align: 'left',  get: r => pc.dim('runs') },