takomi 2.1.43 → 2.1.45

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

@@ -13,7 +13,6 @@ import {
   getSessionPaths,
   getNextTaskId,
   getWorkflowDefinition,
-  listWorkflowDefinitions,
   markStageExpanded,
   normalizeSessionState,
   renderMasterPlan,
@@ -34,7 +33,6 @@ import {
   type VibeLifecycleStage,
 } from "../../../src/pi-takomi-core";
 import {
-  renderRuntimeStatus,
   renderRuntimeWidget,
   renderTakomiHeader,
   TakomiFooterComponent,
@@ -51,12 +49,27 @@ import {
 } from "./shared";
 import { TakomiContextPanel, wireContextPanel } from "./context-panel";
 import { registerTakomiCommands } from "./commands";
+import { USER_GATE_AUTO_PROVENANCE_ENTRY } from "./gate-provenance";
 import {
   DEFAULT_TAKOMI_PROFILE,
   getProfileDefaults,
   loadTakomiProfile,
 } from "./profile";
 import { installTakomiRoutingPolicy, previewTakomiRoutingPolicy, renderRoutingPolicyPreview, resolveTakomiRoutingPolicy } from "./routing-policy";
+import {
+  discoverWorkflowPlaybooks,
+  showWorkflowCatalogForBoard,
+} from "./workflow-catalog";
+import {
+  renderTakomiBoardCall,
+  renderTakomiBoardResult,
+  renderTakomiModeCall,
+  renderTakomiModeResult,
+  renderTakomiRoutingCall,
+  renderTakomiRoutingResult,
+  renderTakomiWorkflowCall,
+  renderTakomiWorkflowResult,
+} from "./tool-renderers";
 
 type TakomiModeSource = "idle" | "manual" | "model" | "board";
 
@@ -400,6 +413,24 @@ function getIncompleteChecklistItems(checklist?: OrchestratorTask["checklist"]):
     .map((item) => item.text);
 }
 
+type BoardErrorSeverity = "warning" | "error";
+
+function createBoardErrorResult(
+  text: string,
+  code: string,
+  severity: BoardErrorSeverity,
+  details: Record<string, unknown> = {},
+) {
+  return {
+    content: [{ type: "text" as const, text }],
+    // Keep this semantic error independent of Pi's transport-level isError.
+    // Renderers use it to retain warning/error meaning even when Pi does not
+    // pass top-level result flags back into renderResult.
+    details: { ...details, error: { code, message: text, severity } },
+    isError: true,
+  };
+}
+
 function getCompletionGateError(task: Pick<OrchestratorTask, "id" | "title" | "checklist">): string | undefined {
   if (!task.checklist?.length) {
     return `Task ${task.id} cannot be marked completed until it has a checklist.`;
@@ -689,10 +720,15 @@ function installTakomiFooter(ctx: ExtensionContext, stateRef: { current: TakomiS
   ctx.ui.setFooter((tui, theme, footerData) => new TakomiFooterComponent(tui, theme, footerData, ctx, () => stateRef.current));
 }
 
-// Mutable state ref so the footer closure always reads the latest state
-const footerStateRef: { current: TakomiState; installed: boolean } = { current: cloneState(DEFAULT_STATE), installed: false };
+function hasVisibleRuntimeWidget(state: TakomiState): boolean {
+  return state.enabled && (state.modeSource ?? "idle") !== "idle";
+}
 
-async function refreshUi(ctx: ExtensionContext, state: TakomiState) {
+async function refreshUi(
+  ctx: ExtensionContext,
+  state: TakomiState,
+  footerStateRef: { current: TakomiState; context?: ExtensionContext },
+) {
   if (!ctx.hasUI) return;
   ctx.ui.setTitle("Takomi");
   ctx.ui.setHeader((_tui, theme) => ({
@@ -702,17 +738,25 @@ async function refreshUi(ctx: ExtensionContext, state: TakomiState) {
     },
   }));
   footerStateRef.current = state;
-  ctx.ui.setStatus("takomi-runtime", renderRuntimeStatus(ctx.ui.theme, state));
+
+  // The mode indicator belongs in the widget above the editor. Keeping a
+  // second setStatus copy makes Pi's default footer duplicate it whenever a
+  // custom footer is replaced or a session is rebound.
+  ctx.ui.setStatus("takomi-runtime", undefined);
   const widget = renderRuntimeWidget(ctx.ui.theme, state);
   ctx.ui.setWidget("takomi-runtime", widget.length > 0 ? widget : undefined);
-  if (!footerStateRef.installed) {
+
+  // A replacement session receives a fresh UI context even when extension
+  // modules remain cached. Install once per context, not once per module.
+  if (footerStateRef.context !== ctx) {
     installTakomiFooter(ctx, footerStateRef);
-    footerStateRef.installed = true;
+    footerStateRef.context = ctx;
   }
 }
 
 export default function takomiRuntime(pi: ExtensionAPI) {
   let state = cloneState(DEFAULT_STATE);
+  const footerStateRef: { current: TakomiState; context?: ExtensionContext } = { current: state };
   const subagentController = getTakomiSubagentController();
   const contextPanel = new TakomiContextPanel();
   let runtimeCtx: ExtensionContext | undefined;
@@ -734,6 +778,12 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     pi.appendEntry(STATE_ENTRY, state);
   }
 
+  // This is intentionally separate from generic runtime-state persistence.
+  // Only user slash-command handlers receive the recorder below.
+  function recordUserGateAutoProvenance(authorized: boolean): void {
+    pi.appendEntry(USER_GATE_AUTO_PROVENANCE_ENTRY, { authorized });
+  }
+
   function syncContextPanelState() {
     contextPanel.setRuntimeState({
       role: state.role,
@@ -798,7 +848,7 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     mutator();
     persistState();
     syncContextPanelState();
-    await refreshUi(ctx, state);
+    await refreshUi(ctx, state, footerStateRef);
     const resolvedMessage = typeof message === "function" ? message() : message;
     if (resolvedMessage) ctx.ui.notify(resolvedMessage, "info");
   }
@@ -821,6 +871,7 @@ export default function takomiRuntime(pi: ExtensionAPI) {
   registerTakomiCommands(pi, {
     getState: () => state,
     updateState,
+    recordUserGateAutoProvenance,
     setStageAndWorkflow: (stage, options) => setStageAndWorkflow(state, stage, options),
     hasGenesisArtifacts,
     subagentController,
@@ -849,12 +900,13 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     },
     resetRuntime: async (ctx) => {
       await updateState(ctx, () => {
+        recordUserGateAutoProvenance(false);
         state = cloneState(DEFAULT_STATE);
         activeSubagentLabel = undefined;
         activeSubagentAgent = undefined;
         activeSubagentTask = undefined;
         activeSubagentStatus = undefined;
-      }, "Takomi runtime state reset");
+      }, () => hasVisibleRuntimeWidget(state) ? "" : "Takomi runtime state reset");
       subagentController.reset(ctx);
       contextPanel.resetSession();
       contextPanel.show(ctx);
@@ -910,9 +962,11 @@ export default function takomiRuntime(pi: ExtensionAPI) {
 
     persistState();
     syncContextPanelState();
-    await refreshUi(ctx, state);
+    await refreshUi(ctx, state, footerStateRef);
     const label = state.modeSource === "idle" ? "idle" : `${state.modeSource}:${state.stage ?? state.role}`;
-    return `Takomi mode set to ${label}${state.modeReason ? ` (${state.modeReason})` : ""}.`;
+    const text = `Takomi mode set to ${label}${state.modeReason ? ` (${state.modeReason})` : ""}.`;
+    if (!hasVisibleRuntimeWidget(state)) ctx.ui.notify(text, "info");
+    return text;
   }
 
   pi.registerTool({
@@ -931,12 +985,13 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const text = await applyTakomiMode(ctx, params.mode, "model", params.reason);
-      ctx.ui.notify(text, "info");
       return {
         content: [{ type: "text", text }],
         details: { mode: params.mode, source: state.modeSource, reason: state.modeReason, role: state.role, stage: state.stage, workflow: state.workflow },
       };
     },
+    renderCall: renderTakomiModeCall,
+    renderResult: (result, options, theme) => renderTakomiModeResult(result, options, theme),
   });
 
   pi.registerTool({
@@ -955,7 +1010,15 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const scope = params.scope ?? "global";
-      const preview = previewTakomiRoutingPolicy(ctx.cwd, params.policyText, { scope });
+      const availableModels = (() => {
+        try {
+          const available = (ctx as typeof ctx & { modelRegistry?: { getAvailable?: () => Array<{ provider?: string; id?: string; name?: string }> } }).modelRegistry?.getAvailable?.() ?? [];
+          return available.map((model) => `${model.provider ? `${model.provider}/` : ""}${model.id ?? model.name ?? ""}`).filter(Boolean);
+        } catch {
+          return [];
+        }
+      })();
+      const preview = previewTakomiRoutingPolicy(ctx.cwd, params.policyText, { scope, availableModels });
       const result = await installTakomiRoutingPolicy(ctx.cwd, params.policyText, { scope });
       const scopeNote = scope === "global"
         ? "This global policy applies unless a project-local override exists."
@@ -978,6 +1041,8 @@ export default function takomiRuntime(pi: ExtensionAPI) {
         details: { result, preview, reviewNotes: params.reviewNotes },
       };
     },
+    renderCall: renderTakomiRoutingCall,
+    renderResult: (result, options, theme) => renderTakomiRoutingResult(result, options, theme),
   });
 
   pi.registerTool({
@@ -989,20 +1054,10 @@ export default function takomiRuntime(pi: ExtensionAPI) {
       workflow: Type.Optional(StringEnum(["vibe-genesis", "vibe-design", "vibe-build"] as const)),
     }),
     async execute(_toolCallId, params) {
-      if (params.workflow) {
-        const workflow = getWorkflowDefinition(params.workflow);
-        return {
-          content: [{ type: "text", text: `${workflow.title}\n\n${workflow.playbook}` }],
-          details: workflow,
-        };
-      }
-
-      const workflows = listWorkflowDefinitions();
-      return {
-        content: [{ type: "text", text: workflows.map((workflow) => `${workflow.id}: ${workflow.purpose}`).join("\n") }],
-        details: undefined,
-      };
+      return discoverWorkflowPlaybooks(params.workflow);
     },
+    renderCall: renderTakomiWorkflowCall,
+    renderResult: (result, options, theme) => renderTakomiWorkflowResult(result, options, theme),
   });
 
   pi.registerTool({
@@ -1072,16 +1127,12 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       if (params.action === "show_workflows") {
-        const workflows = listWorkflowDefinitions();
-        return {
-          content: [{ type: "text", text: workflows.map((workflow) => `${workflow.id}: ${workflow.playbook}`).join("\n\n") }],
-          details: { workflows },
-        };
+        return showWorkflowCatalogForBoard();
       }
 
       if (params.action === "show_session") {
         if (!params.sessionId) {
-          return { content: [{ type: "text", text: "sessionId is required for show_session" }], details: {}, isError: true };
+          return createBoardErrorResult("sessionId is required for show_session", "missing-session-id", "warning");
         }
         assertSafeSessionId(params.sessionId);
         const paths = getSessionPaths(ctx.cwd, params.sessionId);
@@ -1100,13 +1151,18 @@ ${stateJson}`
 
       if (params.action === "update_task") {
         if (!params.sessionId || !params.taskId) {
-          return { content: [{ type: "text", text: "sessionId and taskId are required for update_task" }], details: {}, isError: true };
+          return createBoardErrorResult("sessionId and taskId are required for update_task", "missing-task-context", "warning");
         }
         assertSafeTaskId(params.taskId);
         const { state: sessionState } = await loadSessionState(ctx.cwd, params.sessionId);
         const idx = sessionState.tasks.findIndex((task) => task.id === params.taskId);
         if (idx === -1) {
-          return { content: [{ type: "text", text: `Task ${params.taskId} not found in session ${params.sessionId}` }], details: {}, isError: true };
+          return createBoardErrorResult(
+            `Task ${params.taskId} not found in session ${params.sessionId}`,
+            "task-not-found",
+            "error",
+            { sessionId: params.sessionId, taskId: params.taskId },
+          );
         }
         const current = sessionState.tasks[idx];
         const checklist = resolveChecklistState(current.checklist, params.checklist, params.checklistUpdates);
@@ -1119,16 +1175,12 @@ ${stateJson}`
         if (params.status === "completed") {
           const completionGateError = getCompletionGateError(nextTask);
           if (completionGateError) {
-            return {
-              content: [{ type: "text", text: completionGateError }],
-              details: {
-                sessionId: params.sessionId,
-                taskId: current.id,
-                incompleteChecklistItems: getIncompleteChecklistItems(nextTask.checklist),
-                checklist: nextTask.checklist,
-              },
-              isError: true,
-            };
+            return createBoardErrorResult(completionGateError, "completion-gate", "warning", {
+              sessionId: params.sessionId,
+              taskId: current.id,
+              incompleteChecklistItems: getIncompleteChecklistItems(nextTask.checklist),
+              checklist: nextTask.checklist,
+            });
           }
         }
         sessionState.tasks[idx] = nextTask;
@@ -1137,7 +1189,7 @@ ${stateJson}`
         state.modeReason = state.modeReason ?? "board task update";
         persistState();
         syncContextPanelState();
-        await refreshUi(ctx, state);
+        await refreshUi(ctx, state, footerStateRef);
         const nextState = buildSessionState(
           sessionState.sessionId,
           sessionState.title,
@@ -1166,7 +1218,11 @@ ${stateJson}`
 
       if (params.action === "expand_stage") {
         if (!params.sessionId || !params.stage || !params.tasks?.length) {
-          return { content: [{ type: "text", text: "sessionId, stage, and at least one task are required for expand_stage" }], details: {}, isError: true };
+          return createBoardErrorResult(
+            "sessionId, stage, and at least one task are required for expand_stage",
+            "invalid-expansion",
+            "warning",
+          );
         }
 
         const { state: sessionState } = await loadSessionState(ctx.cwd, params.sessionId);
@@ -1197,7 +1253,7 @@ ${stateJson}`
         state.modeReason = `expanded ${params.stage} stage`;
         persistState();
         syncContextPanelState();
-        await refreshUi(ctx, state);
+        await refreshUi(ctx, state, footerStateRef);
 
         return {
           content: [{ type: "text", text: `Expanded ${params.stage} stage in session ${nextState.sessionId}.\n\nDocs: ${paths.root}\nState: ${paths.stateFile}\n\n${buildTaskRows(nextState.tasks)}` }],
@@ -1242,13 +1298,15 @@ ${stateJson}`
       state.modeReason = "orchestrator session";
       persistState();
       syncContextPanelState();
-      await refreshUi(ctx, state);
+      await refreshUi(ctx, state, footerStateRef);
 
       return {
         content: [{ type: "text", text: `Created Takomi orchestrator session ${nextState.sessionId} in hybrid mode\n\nDocs: ${paths.root}\nState: ${paths.stateFile}\n\n${buildTaskRows(nextState.tasks) || "No tasks provided."}` }],
         details: { sessionId: nextState.sessionId, paths, tasks: nextState.tasks, lifecycle: nextState.lifecycle, mode: nextState.mode },
       };
     },
+    renderCall: renderTakomiBoardCall,
+    renderResult: (result, options, theme, context) => renderTakomiBoardResult(result, options, theme, context?.args),
   });
 
   pi.on("input", async (event) => {
@@ -1263,20 +1321,39 @@ ${stateJson}`
       state.enabled = true;
       try {
         const cwd = runtimeCtx?.cwd ?? process.cwd();
-        const preview = previewTakomiRoutingPolicy(cwd, text, { scope: "global" });
+        const availableModels = (() => {
+          try {
+            const available = (runtimeCtx as typeof runtimeCtx & { modelRegistry?: { getAvailable?: () => Array<{ provider?: string; id?: string; name?: string }> } })?.modelRegistry?.getAvailable?.() ?? [];
+            return available.map((model) => `${model.provider ? `${model.provider}/` : ""}${model.id ?? model.name ?? ""}`).filter(Boolean);
+          } catch {
+            return [];
+          }
+        })();
+        const preview = previewTakomiRoutingPolicy(cwd, text, { scope: "global", availableModels });
+        const activePolicy = await resolveTakomiRoutingPolicy(cwd);
+        const replacementWarning = activePolicy.text && activePolicy.text.trim().length > preview.policy.trim().length * 2
+          ? `WARNING: This input is much shorter than the active policy (${preview.policy.length} vs ${activePolicy.text.length} characters). It will replace the file, not merge into it. Inspect any referenced full source before applying.`
+          : "The supplied text replaces the policy file exactly; it is not merged with the current policy.";
         return { action: "transform", text: [
           "Review this Takomi routing policy extraction before it is saved.",
           "",
           "Rules:",
           "- Do not invent providers or model IDs not grounded in the policy.",
-          "- Providerless names like GPT-5.5 are routing intent unless a preferred provider/router is declared.",
-          "- Valid Takomi roles are: general, orchestrator, architect, designer, coder, reviewer.",
-          "- If the extraction is correct and safe, call takomi_apply_routing_policy with scope=global and the exact original policy text.",
-          "- If it is ambiguous or wrong, explain what the user should clarify and do not call the tool.",
+          "- Providerless names are valid routing intent. Require a provider only for executable model overrides.",
+          "- Check the available Pi model registry below before asking whether a named model exists or what its exact ID is.",
+          "- Conditional task routes need not be forced into role-wide agentOverrides.",
+          "- Valid role-wide Takomi overrides are: general, orchestrator, architect, designer, coder, reviewer. Other headings may be policy concepts or execution routes.",
+          "- Preserve the user's complete authored policy. If this is a summary/excerpt and a referenced full source exists, inspect and apply that source rather than overwriting it with the excerpt.",
+          "- If correct and safe, call takomi_apply_routing_policy with scope=global and the complete intended policy text.",
+          "- Ask only for unresolved provider/account choices or genuine ambiguity; do not ask for facts available in registry or files.",
           "",
           "Deterministic extraction:",
           renderRoutingPolicyPreview(preview),
           "",
+          replacementWarning,
+          "",
+          availableModels.length ? `Available Pi models:\n${availableModels.map((model) => `- ${model}`).join("\n")}` : "Available Pi models: registry unavailable; inspect it before asking the user if possible.",
+          "",
           "Original policy text:",
           "```",
           preview.policy,
@@ -1356,7 +1433,7 @@ ${stateJson}`
     }
     persistState();
     syncContextPanelState();
-    await refreshUi(ctx, state);
+    await refreshUi(ctx, state, footerStateRef);
 
     const routingPolicy = await resolveTakomiRoutingPolicy(runtimeCwd);
     const optionalFeatureContext = (() => {
@@ -1458,7 +1535,7 @@ ${stateJson}`
 
     syncContextPanelState();
     contextPanel.rebuildFromSession(ctx);
-    await refreshUi(ctx, state);
+    await refreshUi(ctx, state, footerStateRef);
     contextPanel.show(ctx);
     flushPendingSubagentEvents();
   });

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

@@ -205,7 +205,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.");
 
@@ -217,7 +217,19 @@ export function previewTakomiRoutingPolicy(cwd: string, input: string, options:
     ? path.join(cwd, PROJECT_PI_SETTINGS_RELATIVE)
     : GLOBAL_PI_SETTINGS_PATH;
   const { overrides, detected } = deriveSubagentDefaults(policy);
-  return { scope, policy, policyPath, settingsPath, detectedDefaults: detected, overrides };
+
+  // Resolve named model families from Pi's registry for review visibility. These
+  // 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> {

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');