takomi 2.1.44 → 2.1.45

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

package/.pi/extensions/takomi-runtime/tool-renderers.ts

@@ -0,0 +1,234 @@
+import { getMarkdownTheme, keyHint } from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Text } from "@earendil-works/pi-tui";
+
+type Theme = {
+  fg(color: string, text: string): string;
+  bold(text: string): string;
+};
+
+type ToolResult = {
+  content?: string | Array<{ type?: string; text?: string }>;
+  details?: unknown;
+  isError?: boolean;
+};
+
+type ResultOptions = { expanded: boolean; isError?: boolean };
+type CardStatus = "success" | "warning" | "error" | "pending";
+
+type ModeDetails = {
+  mode?: string;
+  source?: string;
+  reason?: string;
+  role?: string;
+  stage?: string;
+  workflow?: string;
+};
+
+type RoutingDetails = {
+  result?: { detectedDefaults?: string[] };
+  preview?: { scope?: string };
+};
+
+type WorkflowDetails = { id?: string; title?: string; purpose?: string };
+
+type BoardError = {
+  code: string;
+  message: string;
+  severity: "warning" | "error";
+};
+
+type BoardDetails = {
+  sessionId?: string;
+  taskId?: string;
+  task?: { id?: string; status?: string };
+  tasks?: unknown[];
+  lifecycle?: unknown;
+  error?: BoardError;
+};
+
+type BoardArgs = {
+  action?: "init_session" | "expand_stage" | "show_workflows" | "show_session" | "update_task";
+  sessionId?: string;
+  taskId?: string;
+  stage?: string;
+};
+
+// Tool output is model-facing data. Sanitize only at the TUI boundary so
+// ANSI, OSC, and C0 controls cannot alter terminal presentation.
+function sanitizePresentation(value: string): string {
+  return value
+    .replace(/\x1B\][\s\S]*?(?:\x07|\x1B\\)/g, "") // OSC (BEL or ST terminated)
+    .replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "") // CSI
+    .replace(/[\x00-\x08\x0B-\x1F\x7F-\x9F]/g, "");
+}
+
+function resultText(result: ToolResult): string {
+  const text = typeof result.content === "string"
+    ? result.content
+    : result.content?.filter((part) => part.type === "text").map((part) => part.text ?? "").join("\n") ?? "";
+  return sanitizePresentation(text);
+}
+
+function bounded(value: string | undefined, limit = 36): string {
+  const text = sanitizePresentation(value ?? "").replace(/\s+/g, " ").trim();
+  return text.length > limit ? `${text.slice(0, Math.max(1, limit - 1))}…` : text;
+}
+
+function status(result: ToolResult, options: ResultOptions, details?: { error?: BoardError }): CardStatus {
+  if (details?.error?.severity) return details.error.severity;
+  return result.isError || options.isError ? "error" : "success";
+}
+
+function renderToolCall(name: string, target: string | undefined, theme: Theme): Text {
+  return new Text(
+    `${theme.fg("toolTitle", theme.bold(`${name} `))}${target ? theme.fg("accent", bounded(target)) : ""}`,
+    0,
+    0,
+  );
+}
+
+function renderCompactCard(options: {
+  status: CardStatus;
+  title: string;
+  summary: string;
+  metadata: string;
+}, theme: Theme): Text {
+  const presentation = {
+    success: ["✓", "success"],
+    warning: ["⚠", "warning"],
+    error: ["✗", "error"],
+    pending: ["…", "muted"],
+  } as const;
+  const [icon, color] = presentation[options.status];
+  return new Text([
+    `${theme.fg(color, icon)} ${theme.fg("accent", theme.bold(bounded(options.title)))} ${theme.fg("muted", bounded(options.summary, 72))}`,
+    theme.fg("dim", `${bounded(options.metadata, 64)} · ${keyHint("app.tools.expand", "view details")}`),
+  ].join("\n"), 0, 0);
+}
+
+function renderExpandedCard(options: {
+  status: CardStatus;
+  title: string;
+  summary: string;
+  metadata: string[];
+  markdown: string;
+}, theme: Theme): Container {
+  const presentation = {
+    success: ["✓", "success"],
+    warning: ["⚠", "warning"],
+    error: ["✗", "error"],
+    pending: ["…", "muted"],
+  } as const;
+  const [icon, color] = presentation[options.status];
+  const container = new Container();
+  container.addChild(new Text(
+    `${theme.fg(color, icon)} ${theme.fg("accent", theme.bold(sanitizePresentation(options.title)))} ${theme.fg("muted", sanitizePresentation(options.summary))}`,
+    0,
+    0,
+  ));
+  for (const detail of options.metadata) container.addChild(new Text(theme.fg("dim", sanitizePresentation(detail)), 0, 0));
+  container.addChild(new Text(theme.fg("dim", keyHint("app.tools.expand", "collapse")), 0, 0));
+  container.addChild(new Markdown(sanitizePresentation(options.markdown), 0, 1, getMarkdownTheme()));
+  return container;
+}
+
+export function renderTakomiModeCall(args: { mode?: string } | undefined, theme: Theme): Text {
+  return renderToolCall("takomi_mode", args?.mode ?? "mode", theme);
+}
+
+export function renderTakomiModeResult(result: ToolResult, options: ResultOptions, theme: Theme): Container | Text {
+  const details = result.details as ModeDetails | undefined;
+  const primary = details?.stage ?? details?.role ?? details?.mode ?? "mode";
+  const source = details?.source ?? "model";
+  const metadata = [source, details?.workflow ? `wf:${details.workflow}` : "footer updated"].join(" · ");
+  if (!options.expanded) {
+    return renderCompactCard({ status: status(result, options), title: "Takomi mode", summary: `${source}:${primary}`, metadata }, theme);
+  }
+  return renderExpandedCard({
+    status: status(result, options),
+    title: "Takomi mode",
+    summary: `${source}:${primary}`,
+    metadata: [metadata],
+    markdown: resultText(result),
+  }, theme);
+}
+
+export function renderTakomiRoutingCall(args: { scope?: string } | undefined, theme: Theme): Text {
+  return renderToolCall("takomi_apply_routing_policy", args?.scope ?? "global", theme);
+}
+
+export function renderTakomiRoutingResult(result: ToolResult, options: ResultOptions, theme: Theme): Container | Text {
+  const details = result.details as RoutingDetails | undefined;
+  const scope = details?.preview?.scope ?? "global";
+  const detectedCount = details?.result?.detectedDefaults?.length ?? 0;
+  const summary = status(result, options) === "error" ? "policy was not saved" : `${scope} policy saved`;
+  const metadata = `${detectedCount} routing defaults detected`;
+  if (!options.expanded) return renderCompactCard({ status: status(result, options), title: "Takomi routing", summary, metadata }, theme);
+  return renderExpandedCard({
+    status: status(result, options),
+    title: "Takomi routing",
+    summary,
+    metadata: [`Scope: ${scope}`, metadata],
+    markdown: resultText(result),
+  }, theme);
+}
+
+export function renderTakomiWorkflowCall(args: { workflow?: string } | undefined, theme: Theme): Text {
+  return renderToolCall("takomi_workflow", args?.workflow ?? "library", theme);
+}
+
+export function renderTakomiWorkflowResult(result: ToolResult, options: ResultOptions, theme: Theme): Container | Text {
+  const details = result.details as WorkflowDetails | undefined;
+  const selected = details?.id;
+  const title = selected ? "Takomi workflow" : "Workflow library";
+  const summary = selected ? (details?.title ?? selected) : "embedded lifecycle playbooks";
+  const metadata = selected ? bounded(selected) : "genesis · design · build";
+  if (!options.expanded) return renderCompactCard({ status: status(result, options), title, summary, metadata }, theme);
+  return renderExpandedCard({ status: status(result, options), title, summary, metadata: [metadata], markdown: resultText(result) }, theme);
+}
+
+function boardPresentation(args: BoardArgs, details: BoardDetails | undefined): { title: string; summary: string; metadata: string } {
+  switch (args.action) {
+    case "show_workflows":
+      return { title: "Workflow library", summary: "available lifecycle playbooks", metadata: "genesis · design · build" };
+    case "show_session":
+      return { title: "Takomi session", summary: "session loaded", metadata: `session:${bounded(args.sessionId ?? details?.sessionId, 24)}` };
+    case "update_task":
+      return {
+        title: `Task ${bounded(args.taskId ?? details?.taskId ?? details?.task?.id, 24) || "update"}`,
+        summary: details?.task?.status ? `status: ${details.task.status}` : "task updated",
+        metadata: `session:${bounded(args.sessionId ?? details?.sessionId, 24)}`,
+      };
+    case "expand_stage":
+      return {
+        title: `${args.stage ?? "Lifecycle"} stage`,
+        summary: "stage expanded",
+        metadata: `session:${bounded(args.sessionId ?? details?.sessionId, 24)}`,
+      };
+    default:
+      return {
+        title: "Takomi board",
+        summary: "orchestrator session created",
+        metadata: `session:${bounded(details?.sessionId ?? args.sessionId, 24)}`,
+      };
+  }
+}
+
+export function renderTakomiBoardCall(args: BoardArgs | undefined, theme: Theme): Text {
+  return renderToolCall("takomi_board", args?.action ?? "init_session", theme);
+}
+
+export function renderTakomiBoardResult(result: ToolResult, options: ResultOptions, theme: Theme, args?: BoardArgs): Container | Text {
+  const details = result.details as BoardDetails | undefined;
+  const presentation = boardPresentation(args ?? {}, details);
+  const cardStatus = status(result, options, details);
+  const summary = cardStatus === "success" ? presentation.summary : details?.error?.message ?? "action needs attention";
+  if (!options.expanded) return renderCompactCard({ status: cardStatus, title: presentation.title, summary, metadata: presentation.metadata }, theme);
+  return renderExpandedCard({
+    status: cardStatus,
+    title: presentation.title,
+    summary,
+    metadata: [presentation.metadata],
+    markdown: resultText(result),
+  }, theme);
+}

package/.pi/extensions/takomi-runtime/workflow-catalog.ts

@@ -0,0 +1,54 @@
+import {
+  getWorkflowDefinition,
+  listWorkflowCatalog,
+  type TakomiWorkflowId,
+  type WorkflowCatalogEntry,
+  type WorkflowDefinition,
+} from "../../../src/pi-takomi-core";
+
+type WorkflowCatalogPayload = {
+  content: Array<{ type: "text"; text: string }>;
+  details: { workflows: readonly WorkflowCatalogEntry[] };
+};
+
+type WorkflowPlaybookPayload = {
+  content: Array<{ type: "text"; text: string }>;
+  details: WorkflowDefinition & { workflows: readonly WorkflowCatalogEntry[] };
+};
+
+function formatCatalogEntry(workflow: WorkflowCatalogEntry): string {
+  return `${workflow.id} (${workflow.stage}) — ${workflow.name}: ${workflow.description} [${workflow.availability}]`;
+}
+
+/** Discovery/load adapter for the direct workflow API. */
+export function discoverWorkflowPlaybooks(workflowId?: TakomiWorkflowId): WorkflowPlaybookPayload | WorkflowCatalogPayload {
+  if (workflowId) {
+    const workflow = getWorkflowDefinition(workflowId);
+    return {
+      content: [{ type: "text", text: `${workflow.title}\n\n${workflow.playbook}` }],
+      details: { ...workflow, workflows: listWorkflowCatalog() },
+    };
+  }
+
+  const workflows = listWorkflowCatalog();
+  return {
+    content: [{ type: "text", text: workflows.map(formatCatalogEntry).join("\n") }],
+    details: { workflows },
+  };
+}
+
+/** Lifecycle-board adapter; intentionally catalog-oriented and playbook-free. */
+export function showWorkflowCatalogForBoard(): WorkflowCatalogPayload {
+  const workflows = listWorkflowCatalog();
+  return {
+    content: [{
+      type: "text",
+      text: [
+        "Takomi lifecycle workflow catalog",
+        "",
+        ...workflows.map((workflow) => `- ${formatCatalogEntry(workflow)}`),
+      ].join("\n"),
+    }],
+    details: { workflows },
+  };
+}

package/.pi/extensions/takomi-subagents/agents.ts

@@ -12,6 +12,7 @@ export type TakomiAgentConfig = {
   model?: string;
   fallbackModels?: string[];
   thinking?: TakomiThinkingLevel;
+  defaultContext?: "fresh" | "fork";
   systemPrompt: string;
   filePath: string;
   source: "user" | "project";
@@ -59,6 +60,9 @@ function loadAgentsFromDirectory(agentsDir: string, source: "user" | "project"):
       model: frontmatter.model,
       fallbackModels: splitList(frontmatter.fallbackModels ?? frontmatter.fallback_models),
       thinking: normalizeThinking(frontmatter.thinking),
+      defaultContext: frontmatter.defaultContext === "fork" || frontmatter.defaultContext === "fresh"
+        ? frontmatter.defaultContext
+        : undefined,
       systemPrompt: body,
       filePath,
       source,