takomi 2.1.44 → 2.5.1

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

@@ -4,7 +4,7 @@ import path from "node:path";
 import type {
   TakomiDispatchDefaults,
   TakomiProfile,
-  TakomiRole,
+  TakomiPersona,
   VibeLifecycleStage,
 } from "../../../src/pi-takomi-core";
 
@@ -18,14 +18,15 @@ export const DEFAULT_TAKOMI_PROFILE: TakomiProfile = {
   roles: {
     orchestrator: { agent: "orchestrator", dispatchPolicy: "subagent" },
     architect: { agent: "architect", dispatchPolicy: "subagent" },
-    design: { agent: "designer", dispatchPolicy: "subagent" },
-    code: { agent: "coder", dispatchPolicy: "subagent" },
-    review: { agent: "reviewer", dispatchPolicy: "review-first" },
+    designer: { agent: "designer", dispatchPolicy: "subagent" },
+    coder: { agent: "coder", dispatchPolicy: "subagent" },
+    worker: { agent: "worker", dispatchPolicy: "subagent" },
+    reviewer: { agent: "reviewer", dispatchPolicy: "review-first" },
   },
   stages: {
     genesis: { agent: "architect", dispatchPolicy: "subagent" },
     design: { agent: "designer", dispatchPolicy: "subagent" },
-    build: { agent: "orchestrator", dispatchPolicy: "subagent" },
+    build: { agent: "coder", dispatchPolicy: "subagent" },
   },
   review: {
     enabled: true,
@@ -57,7 +58,7 @@ function mergeDefaults(
 function mergeProfile(base: TakomiProfile, next?: Partial<TakomiProfile>): TakomiProfile {
   if (!next) return base;
   const roles = { ...(base.roles ?? {}) };
-  for (const [role, defaults] of Object.entries(next.roles ?? {}) as Array<[TakomiRole, TakomiDispatchDefaults]>) {
+  for (const [role, defaults] of Object.entries(next.roles ?? {}) as Array<[TakomiPersona, TakomiDispatchDefaults]>) {
     roles[role] = mergeDefaults(roles[role], defaults);
   }
 
@@ -99,12 +100,12 @@ export async function loadTakomiProfile(cwd: string): Promise<TakomiProfile> {
   const userProfilePath = path.join(os.homedir(), ".pi", "agent", "takomi", "profile.json");
   const projectProfile = await readProfileFile(projectProfilePath);
   const userProfile = await readProfileFile(userProfilePath);
-  return mergeProfile(mergeProfile(DEFAULT_TAKOMI_PROFILE, projectProfile), userProfile);
+  return mergeProfile(mergeProfile(DEFAULT_TAKOMI_PROFILE, userProfile), projectProfile);
 }
 
 export function getProfileDefaults(
   profile: TakomiProfile,
-  role: TakomiRole,
+  role: TakomiPersona,
   stage?: VibeLifecycleStage,
 ): TakomiDispatchDefaults {
   return {

package/.pi/extensions/takomi-runtime/routing-policy.ts

@@ -4,7 +4,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 export const TAKOMI_ROUTING_POLICY_RELATIVE = path.join(".pi", "takomi", "model-routing.md");
-export const GLOBAL_TAKOMI_ROUTING_POLICY_PATH = path.join(os.homedir(), ".pi", "takomi", "model-routing.md");
+export const GLOBAL_TAKOMI_ROUTING_POLICY_PATH = path.join(os.homedir(), ".pi", "agent", "takomi", "model-routing.md");
 export const GLOBAL_PI_SETTINGS_PATH = path.join(os.homedir(), ".pi", "agent", "settings.json");
 export const PROJECT_PI_SETTINGS_RELATIVE = path.join(".pi", "settings.json");
 export const BUNDLED_TAKOMI_ROUTING_POLICY_PATH = path.resolve(
@@ -99,59 +99,6 @@ function normalizeForSettings(filePath: string): string {
   return filePath.replaceAll(path.sep, "/");
 }
 
-function extractPreferredProvider(policy: string): string | undefined {
-  const match = policy.match(/(?:preferred|default)\s+(?:provider|router)(?:\s*\/\s*(?:provider|router))?\s*:\s*([a-z0-9-]+)/i)
-    ?? policy.match(/use\s+([a-z0-9-]+)\s+as\s+(?:the\s+)?(?:provider|router)/i);
-  return match?.[1];
-}
-
-function findExplicitProviderModel(policy: string, family: RegExp): string | undefined {
-  const refs = policy.match(/[a-z0-9-]+\/[a-z0-9._-]+/gi) ?? [];
-  return refs.find((ref) => family.test(ref));
-}
-
-function providerModel(preferredProvider: string | undefined, model: string): string | undefined {
-  return preferredProvider ? `${preferredProvider}/${model}` : undefined;
-}
-
-function withOptionalModel(model: string | undefined, thinking: string, extra: JsonObject = {}): JsonObject {
-  return model ? { model, thinking, ...extra } : { thinking, ...extra };
-}
-
-function deriveSubagentDefaults(policy: string): { overrides: JsonObject; detected: string[] } {
-  const lower = policy.toLowerCase();
-  const has55 = /gpt[- ]?5\.5/.test(lower);
-  const has54 = /gpt[- ]?5\.4(?!\s*mini)/.test(lower);
-  const hasMini = /gpt[- ]?5\.4\s*mini/.test(lower);
-  if (!has55 && !has54 && !hasMini) return { overrides: {}, detected: [] };
-
-  // Keep generated settings provider-agnostic unless the policy explicitly
-  // declares provider-qualified models or a preferred provider/router header.
-  const preferredProvider = extractPreferredProvider(policy);
-  const model55 = findExplicitProviderModel(policy, /gpt[-_.]?5\.5/i) ?? providerModel(preferredProvider, "gpt-5.5");
-  const model54 = findExplicitProviderModel(policy, /gpt[-_.]?5\.4(?![-_.]?mini)/i) ?? providerModel(preferredProvider, "gpt-5.4");
-  const modelMini = findExplicitProviderModel(policy, /gpt[-_.]?5\.4[-_.]?mini/i) ?? providerModel(preferredProvider, "gpt-5.4-mini");
-  const overrides: JsonObject = {};
-  const detected: string[] = [];
-
-  if (has55) {
-    overrides.orchestrator = withOptionalModel(model55, "high");
-    overrides.architect = withOptionalModel(model55, "high");
-    overrides.reviewer = withOptionalModel(model55, "high");
-    detected.push(model55 ? `orchestrator/architect/reviewer → ${model55} high` : "orchestrator/architect/reviewer → GPT-5.5 high intent");
-  }
-  if (has54) {
-    overrides.general = withOptionalModel(model54, "high", model55 ? { fallbackModels: [`${model55}:low`] } : {});
-    overrides.coder = withOptionalModel(model54, "high", model55 ? { fallbackModels: [`${model55}:low`] } : {});
-    overrides.designer = withOptionalModel(model54, "high", model55 ? { fallbackModels: [`${model55}:low`] } : {});
-    detected.push(model54 ? `general/coder/designer → ${model54} high` : "general/coder/designer → GPT-5.4 high intent");
-  }
-  if (hasMini) {
-    detected.push(modelMini ? `GPT-5.4 Mini available for explicit small-task overrides: ${modelMini}` : "GPT-5.4 Mini available as small-task intent only");
-  }
-  return { overrides, detected };
-}
-
 export async function resolveTakomiRoutingPolicy(cwd: string): Promise<ResolvedRoutingPolicy> {
   const projectSettingsPath = path.join(cwd, PROJECT_PI_SETTINGS_RELATIVE);
   const projectSettings = await readJsonObject(projectSettingsPath);
@@ -205,7 +152,7 @@ export async function resolveTakomiRoutingPolicy(cwd: string): Promise<ResolvedR
   return { source: "missing" };
 }
 
-export function previewTakomiRoutingPolicy(cwd: string, input: string, options: { scope?: RoutingPolicyInstallScope } = {}): RoutingPolicyPreviewResult {
+export function previewTakomiRoutingPolicy(cwd: string, input: string, options: { scope?: RoutingPolicyInstallScope; availableModels?: string[] } = {}): RoutingPolicyPreviewResult {
   const policy = extractQuotedPolicy(input);
   if (!policy) throw new Error("No routing policy text found. Paste the policy after /takomi routing or inside triple quotes.");
 
@@ -216,8 +163,22 @@ export function previewTakomiRoutingPolicy(cwd: string, input: string, options:
   const settingsPath = scope === "project"
     ? path.join(cwd, PROJECT_PI_SETTINGS_RELATIVE)
     : GLOBAL_PI_SETTINGS_PATH;
-  const { overrides, detected } = deriveSubagentDefaults(policy);
-  return { scope, policy, policyPath, settingsPath, detectedDefaults: detected, overrides };
+  const overrides: JsonObject = {};
+  const detected: string[] = [];
+
+  // Markdown is advisory model-facing guidance. It is never parsed into executable defaults.
+  // Resolve named model families from Pi's registry only for preview visibility.
+  // are conditional routing intents, not role-wide defaults, so do not invent
+  // agentOverrides merely to make the extraction non-empty.
+  const availableModels = [...new Set(options.availableModels ?? [])];
+  for (const alias of ["luna", "sol", "terra"]) {
+    if (!new RegExp(`\\b${alias}\\b`, "i").test(policy)) continue;
+    const matches = availableModels.filter((model) => new RegExp(`(?:^|/)gpt[-_.]?5\\.6[-_.]?${alias}$`, "i").test(model));
+    if (matches.length === 1) detected.push(`${alias[0].toUpperCase()}${alias.slice(1)} intent resolves to ${matches[0]} (conditional route)`);
+    else if (matches.length > 1) detected.push(`${alias[0].toUpperCase()}${alias.slice(1)} intent matches available models: ${matches.join(", ")}`);
+    else detected.push(`${alias[0].toUpperCase()}${alias.slice(1)} remains a providerless conditional routing intent`);
+  }
+  return { scope, policy, policyPath, settingsPath, detectedDefaults: [...new Set(detected)], overrides };
 }
 
 export async function installTakomiRoutingPolicy(cwd: string, input: string, options: { scope?: RoutingPolicyInstallScope } = {}): Promise<RoutingPolicyInstallResult> {
@@ -234,13 +195,6 @@ export async function installTakomiRoutingPolicy(cwd: string, input: string, opt
     : normalizeForSettings(GLOBAL_TAKOMI_ROUTING_POLICY_PATH);
   settings.takomi = takomi;
 
-  if (Object.keys(overrides).length > 0) {
-    const subagents = asObject(settings.subagents);
-    const existingOverrides = asObject(subagents.agentOverrides);
-    subagents.agentOverrides = { ...existingOverrides, ...overrides };
-    settings.subagents = subagents;
-  }
-
   await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
   return { policyPath, settingsPath, settingsUpdated: true, detectedDefaults };
 }
@@ -252,14 +206,91 @@ export function renderRoutingPolicyPreview(preview: RoutingPolicyPreviewResult):
     `Policy path: ${preview.policyPath}`,
     `Settings path: ${preview.settingsPath}`,
     "",
-    preview.detectedDefaults.length ? "Detected routing defaults:" : "Detected routing defaults: none",
+    preview.detectedDefaults.length ? "Advisory model concepts recognized:" : "Advisory model concepts recognized: none",
     ...preview.detectedDefaults.map((item) => `- ${item}`),
     "",
-    overrideLines.length ? "Settings overrides to write:" : "Settings overrides to write: none",
+    overrideLines.length ? "Executable settings changes:" : "Executable settings changes: none (Markdown is advisory only)",
     ...overrideLines,
   ].join("\n");
 }
 
+export type TakomiRoutingConfigUpdate = {
+  defaultProvider?: string;
+  approvedModels?: string[];
+  roleDefaults?: Record<string, { model?: string; thinking?: string; fallbackModels?: string[] }>;
+};
+
+export type TakomiRoutingConfigPreview = {
+  scope: RoutingPolicyInstallScope;
+  settingsPath: string;
+  before: JsonObject;
+  after: JsonObject;
+};
+
+const CANONICAL_ROUTING_ROLES = new Set(["architect", "designer", "coder", "worker", "reviewer", "orchestrator"]);
+
+function validateRoutingConfig(update: TakomiRoutingConfigUpdate, availableModels: string[] = []): void {
+  const allConfigured = [
+    ...(update.approvedModels ?? []),
+    ...Object.values(update.roleDefaults ?? {}).flatMap((entry) => [entry.model, ...(entry.fallbackModels ?? [])]).filter((item): item is string => Boolean(item)),
+  ];
+  for (const role of Object.keys(update.roleDefaults ?? {})) {
+    if (!CANONICAL_ROUTING_ROLES.has(role)) throw new Error(`Unknown Takomi persona '${role}'. Use architect, designer, coder, worker, reviewer, or orchestrator.`);
+  }
+  for (const model of allConfigured) {
+    const base = model.replace(/:(?:off|minimal|low|medium|high|xhigh)$/i, "");
+    if (!base.includes("/")) throw new Error(`Model '${model}' must be provider-qualified.`);
+    if (availableModels.length && !availableModels.includes(base)) throw new Error(`Model '${base}' is not enabled in Pi's available model registry.`);
+  }
+}
+
+export async function previewTakomiRoutingConfig(
+  cwd: string,
+  scope: RoutingPolicyInstallScope,
+  update: TakomiRoutingConfigUpdate,
+  availableModels: string[] = [],
+): Promise<TakomiRoutingConfigPreview> {
+  validateRoutingConfig(update, availableModels);
+  const settingsPath = scope === "project" ? path.join(cwd, PROJECT_PI_SETTINGS_RELATIVE) : GLOBAL_PI_SETTINGS_PATH;
+  const settings = await readJsonObject(settingsPath);
+  const takomi = asObject(settings.takomi);
+  const before = asObject(takomi.routing);
+  const existingRoles = asObject(before.roleDefaults);
+  const nextRoles = { ...existingRoles };
+  for (const [role, value] of Object.entries(update.roleDefaults ?? {})) {
+    nextRoles[role] = { ...asObject(existingRoles[role]), ...value };
+  }
+  const after: JsonObject = {
+    ...before,
+    ...(update.defaultProvider !== undefined ? { defaultProvider: update.defaultProvider } : {}),
+    ...(update.approvedModels !== undefined ? { approvedModels: [...new Set(update.approvedModels)] } : {}),
+    ...(update.roleDefaults !== undefined ? { roleDefaults: nextRoles } : {}),
+  };
+  return { scope, settingsPath, before, after };
+}
+
+export async function installTakomiRoutingConfig(preview: TakomiRoutingConfigPreview): Promise<void> {
+  const settings = await readJsonObject(preview.settingsPath);
+  const takomi = asObject(settings.takomi);
+  takomi.routing = preview.after;
+  settings.takomi = takomi;
+  await mkdir(path.dirname(preview.settingsPath), { recursive: true });
+  await writeFile(preview.settingsPath, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+}
+
+export function renderTakomiRoutingConfigPreview(preview: TakomiRoutingConfigPreview): string {
+  return [
+    `Scope: ${preview.scope}`,
+    `Settings: ${preview.settingsPath}`,
+    "",
+    "Before:",
+    JSON.stringify(preview.before, null, 2),
+    "",
+    "After:",
+    JSON.stringify(preview.after, null, 2),
+  ].join("\n");
+}
+
 export async function loadTakomiRoutingPolicy(cwd: string): Promise<string | undefined> {
   return (await resolveTakomiRoutingPolicy(cwd)).text;
 }

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

@@ -443,38 +443,15 @@ function modelCandidates(requested?: string, fallback?: string | string[]): stri
   return [requested, ...fallbackList].filter(Boolean) as string[];
 }
 
-export async function resolvePreferredModel(ctx: ExtensionContext, requested?: string, fallback?: string | string[]): Promise<{ model?: string; warning?: string }> {
-  const candidates = modelCandidates(requested, fallback);
-  if (candidates.length === 0) return {};
+export async function resolvePreferredModel(ctx: ExtensionContext, requested?: string, _fallback?: string | string[]): Promise<{ model?: string; warning?: string }> {
+  if (!requested) return {};
   const keys = await getAvailableModelKeys(ctx);
-  const exact = candidates.find((candidate) => keys.includes(candidate));
+  const exact = keys.find((key) => key === requested) ?? keys.find((key) => key.toLowerCase() === requested.toLowerCase());
   if (exact) return { model: exact };
-
-  const loweredKeys = keys.map((key) => key.toLowerCase());
-  for (const candidate of candidates) {
-    const idx = loweredKeys.findIndex((key) => key === candidate.toLowerCase());
-    if (idx >= 0) return { model: keys[idx] };
-  }
-
-  for (const candidate of candidates) {
-    const idx = loweredKeys.findIndex((key) => key.includes(candidate.toLowerCase()) || candidate.toLowerCase().includes(key));
-    if (idx >= 0) {
-      return {
-        model: keys[idx],
-        warning: `Requested model '${candidate}' was unavailable; using '${keys[idx]}' instead.`,
-      };
-    }
-  }
-
-  const firstAvailable = keys.find((key) => key.includes("/"));
-  if (firstAvailable) {
-    return {
-      model: firstAvailable,
-      warning: `Requested models '${candidates.join("', '")}' were unavailable; using '${firstAvailable}' instead.`,
-    };
-  }
-
-  return { warning: `No available signed-in model matched '${candidates.join("', '")}'.` };
+  return {
+    model: requested,
+    warning: `Requested model '${requested}' is not currently enabled in Pi's model registry. The exact provider-qualified ID was preserved; no equivalent provider was substituted.`,
+  };
 }
 
 export async function listModelsViaPi(cwd: string, signal?: AbortSignal): Promise<{ ok: boolean; output: string }> {

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

@@ -15,29 +15,47 @@ const pc = {
   magenta: ansi(35, 39),
 };
 
+// USD per million tokens: input, cache read, output, cache write.
+// OAuth-router's configured catalog is merged over these fallbacks at runtime,
+// keeping Stats aligned with custom/new models without another hard-coded edit.
 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],
+  'gpt-5.6-luna': [1.00, 0.10, 6.00, 1.25],
+  'gpt-5.6-sol': [5.00, 0.50, 30.00, 6.25],
+  'gpt-5.6-terra': [2.50, 0.25, 15.00, 3.125],
+  'gpt-5.5': [5.00, 0.50, 30.00, 6.25],
+  'gpt-5.4': [2.50, 0.25, 15.00, 3.125],
+  'gpt-5.4-mini': [0.75, 0.075, 4.50, 0.9375],
+  'gpt-5.4-nano': [0.20, 0.02, 1.25, 0.25],
+  'gpt-5.3-codex': [2.50, 0.25, 15.00, 3.125],
+  'gpt-5.2-codex': [1.75, 0.175, 14.00, 2.1875],
+  'gpt-5-codex': [1.25, 0.125, 10.00, 1.5625],
+  'gpt-5.2': [1.75, 0.175, 14.00, 2.1875],
+  'gpt-5.1': [1.25, 0.125, 10.00, 1.5625],
+  'gpt-5': [1.25, 0.125, 10.00, 1.5625],
+  'gpt-5-mini': [0.25, 0.025, 2.00, 0.3125],
+  'gpt-4.1': [2.00, 0.50, 8.00, 2.00],
+  'gpt-4o': [2.50, 1.25, 10.00, 2.50],
+  'o4-mini': [1.10, 0.275, 4.40, 1.10],
+  'claude-sonnet-4-6': [3.00, 0.30, 15.00, 3.75],
 };
 
 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 add(map, key, patch) { const row = map.get(key) || { key, input: 0, cache: 0, cacheWrite: 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, cacheWrite = 0, prices = PRICES) { const p = prices[model]; if (!p) return 0; return (input*p[0] + cache*p[1] + output*p[2] + cacheWrite*(p[3] ?? p[0])) / 1_000_000; }
+async function loadPrices(home) {
+  const prices = { ...PRICES };
+  const configPath = path.join(home, '.pi', 'agent', 'oauth-router', 'config.json');
+  try {
+    const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
+    for (const model of config.models || []) {
+      if (!model?.id || !model?.cost) continue;
+      prices[model.id] = [model.cost.input || 0, model.cost.cacheRead || 0, model.cost.output || 0, model.cost.cacheWrite ?? model.cost.input ?? 0];
+    }
+  } catch {}
+  return prices;
+}
 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`; }
@@ -117,7 +135,7 @@ function pushTask(taskRows, task) {
   taskRows.push(task);
 }
 
-async function scanPiSessions(root, source, events, sessionRows = [], taskRows = []) {
+async function scanPiSessions(root, source, events, sessionRows = [], taskRows = [], prices = PRICES) {
   for (const file of await files(root)) {
     let provider = 'unknown', model = 'unknown', session = path.basename(file, '.jsonl'), cwd = '', currentTask = null;
     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(), activeMs: 0, activityTimestamps: [] };
@@ -170,7 +188,7 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
         }
       }
       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 (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, cacheWrite: +u.cacheWrite||0, output: +u.output||0, total: +u.totalTokens||0, cost: cost(model, +u.input||0, +u.cacheRead||0, +u.output||0, +u.cacheWrite||0, prices) });
       }
     } catch {
       continue;
@@ -193,18 +211,19 @@ export async function collectTakomiStats(opts = {}) {
   const home = opts.home || os.homedir();
   const cwd = opts.cwd || process.cwd();
   const rawEvents = [], rawSessions = [], rawTasks = [];
+  const prices = await loadPrices(home);
   const globalSessions = path.resolve(path.join(home, '.pi', 'agent', 'sessions'));
   const projectSessions = path.resolve(path.join(cwd, '.pi', 'agent', 'sessions'));
-  await scanPiSessions(globalSessions, 'pi-global', rawEvents, rawSessions, rawTasks);
-  if (projectSessions !== globalSessions) await scanPiSessions(projectSessions, 'pi-project', rawEvents, rawSessions, rawTasks);
-  await scanPiSessions(path.join(cwd, '.pi', 'takomi'), 'takomi-project', rawEvents, rawSessions, rawTasks);
+  await scanPiSessions(globalSessions, 'pi-global', rawEvents, rawSessions, rawTasks, prices);
+  if (projectSessions !== globalSessions) await scanPiSessions(projectSessions, 'pi-project', rawEvents, rawSessions, rawTasks, prices);
+  await scanPiSessions(path.join(cwd, '.pi', 'takomi'), 'takomi-project', rawEvents, rawSessions, rawTasks, prices);
   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 taskRows = rawTasks.filter(t => !sinceDay || dayOf(t.end || t.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 };
+  let totals = { input: 0, cache: 0, cacheWrite: 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; }
@@ -214,7 +233,7 @@ export async function collectTakomiStats(opts = {}) {
       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;
+    totals.input += e.input; totals.cache += e.cache; totals.cacheWrite += e.cacheWrite || 0; 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;
@@ -509,7 +528,8 @@ export function renderTakomiStats(stats, opts = {}) {
   // ── Stat Cards Row 1 ─────────────────────────────────────────────────
   const cards1 = [
     statCard(fmtTokens(stats.totals.total), 'Lifetime Tokens'),
-    statCard(fmtTokens(stats.totals.cache), 'Cache Tokens'),
+    statCard(fmtTokens(stats.totals.cache), 'Cache Reads'),
+    statCard(fmtTokens(stats.totals.cacheWrite), 'Cache Writes'),
     statCard(fmtMoney(stats.totals.cost), 'Est. Cost'),
     statCard(String(stats.sessions), 'Sessions'),
     statCard(String(stats.totals.turns), 'Main Turns'),
@@ -677,7 +697,7 @@ export function renderTakomiStats(stats, opts = {}) {
   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('  ' + pc.dim('Costs use the oauth-router catalog when available; cache reads and writes are priced separately.'));
   lines.push('');
 
   return lines.join('\n');