takomi 2.1.44 → 2.5.1

package/.pi/extensions/oauth-router/report-ui.ts

@@ -0,0 +1,205 @@
+import { truncateToWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
+
+export const ROUTER_REPORT_WIDGET_KEY = "oauth-router-report";
+export const ROUTER_REPORT_DISMISS_HINT = "Dismiss: /router-clear";
+
+type RouterTheme = {
+  fg(color: "accent" | "success" | "warning" | "error" | "muted" | "dim", text: string): string;
+  bold(text: string): string;
+};
+
+const SENSITIVE_VALUE_KEYS = new Set([
+  "access_token", "access-token", "accesstoken",
+  "refresh_token", "refresh-token", "refreshtoken",
+  "id_token", "id-token", "idtoken",
+  "auth_token", "auth-token", "authtoken",
+  "api_key", "api-key", "apikey",
+  "authorization",
+  "client_secret", "client-secret", "clientsecret",
+  "password", "secret", "code",
+]);
+const SENSITIVE_QUERY_KEYS = [...SENSITIVE_VALUE_KEYS, "token", "key"];
+const SENSITIVE_QUERY_VALUE = new RegExp(`([?&#](?:${SENSITIVE_QUERY_KEYS.join("|")})=)[^&#\\s"']*`, "gi");
+
+function isKeyCharacter(value: string | undefined): boolean {
+  return Boolean(value && /[A-Za-z0-9_-]/.test(value));
+}
+
+function skipWhitespace(text: string, start: number): number {
+  let index = start;
+  while (/\s/.test(text[index] ?? "")) index += 1;
+  return index;
+}
+
+function quotedEnd(text: string, start: number): number | undefined {
+  const quote = text[start];
+  for (let index = start + 1; index < text.length; index += 1) {
+    if (text[index] === "\\") {
+      index += 1;
+      continue;
+    }
+    if (text[index] === quote) return index + 1;
+  }
+  return undefined;
+}
+
+type SensitiveAssignment = { key: string; valueStart: number };
+
+/**
+ * Locate a complete assignment key rather than using a word-boundary regex.
+ * Underscores and hyphens are key characters, so `zipcode`, `account_code`,
+ * and `authorization_status` cannot be mistaken for sensitive keys.
+ */
+function sensitiveAssignmentAt(text: string, start: number): SensitiveAssignment | undefined {
+  if (isKeyCharacter(text[start - 1])) return undefined;
+
+  let key: string;
+  let afterKey: number;
+  if (text[start] === '"' || text[start] === "'") {
+    const end = quotedEnd(text, start);
+    if (!end) return undefined;
+    key = text.slice(start + 1, end - 1);
+    afterKey = end;
+  } else {
+    if (!isKeyCharacter(text[start])) return undefined;
+    afterKey = start;
+    while (isKeyCharacter(text[afterKey])) afterKey += 1;
+    key = text.slice(start, afterKey);
+  }
+
+  if (!SENSITIVE_VALUE_KEYS.has(key.toLowerCase())) return undefined;
+  const delimiter = skipWhitespace(text, afterKey);
+  if (text[delimiter] !== ":" && text[delimiter] !== "=") return undefined;
+  return { key: key.toLowerCase(), valueStart: skipWhitespace(text, delimiter + 1) };
+}
+
+function redactSensitiveAssignments(text: string): string {
+  let output = "";
+  let cursor = 0;
+
+  for (let start = 0; start < text.length; start += 1) {
+    const assignment = sensitiveAssignmentAt(text, start);
+    if (!assignment || assignment.valueStart >= text.length) continue;
+
+    const valueStart = assignment.valueStart;
+    const quote = text[valueStart];
+    if (quote === '"' || quote === "'") {
+      const valueEnd = quotedEnd(text, valueStart);
+      if (!valueEnd) continue;
+      output += `${text.slice(cursor, valueStart + 1)}[redacted]${quote}`;
+      cursor = valueEnd;
+      start = valueEnd - 1;
+      continue;
+    }
+
+    let valueEnd = valueStart;
+    if (assignment.key === "authorization") {
+      while (valueEnd < text.length && text[valueEnd] !== "|" && text[valueEnd] !== "\r" && text[valueEnd] !== "\n") valueEnd += 1;
+      while (valueEnd > valueStart && /\s/.test(text[valueEnd - 1])) valueEnd -= 1;
+    } else {
+      while (valueEnd < text.length && !/[\s|,;"'&#]/.test(text[valueEnd])) valueEnd += 1;
+    }
+    if (valueEnd === valueStart) continue;
+
+    output += `${text.slice(cursor, valueStart)}[redacted]`;
+    cursor = valueEnd;
+    start = valueEnd - 1;
+  }
+
+  return output + text.slice(cursor);
+}
+
+/**
+ * Remove terminal controls and credentials from presentation only. Router data
+ * remains untouched; this boundary exists because labels and upstream errors
+ * can originate outside the extension.
+ */
+export function sanitizeReportText(value: unknown): string {
+  let text = String(value ?? "")
+    .replace(/\x1b(?:\][^\x07]*(?:\x07|\x1b\\)|\[[0-?]*[ -/]*[@-~]|[PX^_][^\x1b]*(?:\x1b\\))/g, "")
+    .replace(/[\x00-\x1f\x7f-\x9f]/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+
+  // Bearer credentials can occur outside a key/value field. Assignment
+  // parsing below handles every quoted/bare sensitive-key combination and
+  // keeps Authorization's multi-word field value intact while redacting it.
+  text = text
+    .replace(/\b(Bearer\s+)(?:"[^"]*"|'[^']*'|[^\s,;|"']+)/gi, "$1[redacted]")
+    .replace(SENSITIVE_QUERY_VALUE, "$1[redacted]");
+  text = redactSensitiveAssignments(text)
+    .replace(/\b(sk-[A-Za-z0-9_-]{8,}|(?:eyJ[A-Za-z0-9_-]+\.){2}[A-Za-z0-9_-]+)\b/gi, "[redacted]");
+
+  return text;
+}
+
+/** Return the RPC-compatible report representation without terminal controls. */
+export function createRouterReportLines(text: string): string[] {
+  return text.split(/\r?\n/).map(sanitizeReportText);
+}
+
+function fitQuotaBar(line: string, width: number): string {
+  const match = /\[([█░]+)\]/.exec(line);
+  if (!match) return line;
+  const source = match[1];
+  const targetWidth = width <= 45 ? 8 : width <= 70 ? 12 : 18;
+  if (source.length <= targetWidth) return line;
+  const filled = [...source].filter((cell) => cell === "█").length;
+  const targetFilled = Math.round((filled / source.length) * targetWidth);
+  return `${line.slice(0, match.index)}[${"█".repeat(targetFilled)}${"░".repeat(targetWidth - targetFilled)}]${line.slice(match.index + match[0].length)}`;
+}
+
+function styleLine(theme: RouterTheme, line: string): string {
+  if (line === ROUTER_REPORT_DISMISS_HINT) return theme.fg("accent", theme.bold(line));
+  if (line.startsWith("# ")) return theme.fg("accent", theme.bold(line.slice(2)));
+  if (line.startsWith("## ")) return theme.fg("accent", theme.bold(line.slice(3)));
+
+  // State words must win over incidental success counters or a prior healthy
+  // status. In particular, an explicitly disabled account is never success.
+  if (/\b(auth=invalid|auth invalid|invalid)\b/i.test(line)) return theme.fg("error", line);
+  if (/\b(degraded|cooldown|penalty)\b/i.test(line)) return theme.fg("warning", line);
+  if (/\b(enabled\s*=\s*false|disabled|inactive)\b/i.test(line)) return theme.fg("muted", line);
+  if (/^Provider:\s*/.test(line)) return theme.fg("accent", line);
+  if (/^Local:\s*/.test(line)) return theme.fg("muted", line);
+
+  const quota = /(\d+)% left/.exec(line);
+  if (quota) {
+    const remaining = Number(quota[1]);
+    return theme.fg(remaining <= 20 ? "error" : remaining <= 50 ? "warning" : "success", line);
+  }
+  if (/\b(healthy|enabled|ok)\b/i.test(line) && !/\b(unhealthy|not healthy)\b/i.test(line)) return theme.fg("success", line);
+  if (/\b(failures?|429s?|error)\b/i.test(line)) return theme.fg("warning", line);
+  if (/^(Raw:|Usage:|Aliases:|Valid values:|Compact account list|Provider bars show)/.test(line)) return theme.fg("muted", line);
+  if (/^(note:|headers:|claimKeys:|endpoint:|tokenExpires=)/.test(line)) return theme.fg("dim", line);
+  return line;
+}
+
+class RouterReportComponent implements Component {
+  constructor(private readonly lines: string[], private readonly theme: RouterTheme) {}
+
+  invalidate() {
+    // Rendering is derived solely from the report snapshot and current width.
+  }
+
+  render(width: number): string[] {
+    const usableWidth = Math.max(1, width);
+    const rendered: string[] = [];
+    for (const line of this.lines) {
+      if (!line) {
+        rendered.push("");
+        continue;
+      }
+      const styled = styleLine(this.theme, fitQuotaBar(line, usableWidth));
+      const wrapped = wrapTextWithAnsi(styled, usableWidth);
+      rendered.push(...(wrapped.length ? wrapped.map((part) => truncateToWidth(part, usableWidth)) : [""]));
+    }
+    return rendered;
+  }
+}
+
+export function createRouterReportWidget(text: string) {
+  // Snapshot and sanitize now as well as at render time so replacement has no
+  // mutable dependency and no stale report can reappear on a later lifecycle event.
+  const safeLines = createRouterReportLines(text);
+  return (_tui: unknown, theme: RouterTheme): Component => new RouterReportComponent(safeLines, theme);
+}

package/.pi/extensions/takomi-context-manager/diagnostics-tools.ts

@@ -2,9 +2,10 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AutocompleteItem } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { ContextManagerState } from "./state";
-import { renderReport, type ContextReportMode } from "./diagnostics";
+import { contextReportPresentation, renderReport, type ContextReportMode } from "./diagnostics";
 import { discoverSkillsFromFilesystem, mergeSkills } from "./skill-registry";
 import { persistReportSnapshot, restoreReportFromSession } from "./session-state";
+import { renderCompactCard, renderExpandedMarkdown, renderToolCall, resultText, sanitizePresentation } from "./tool-renderers";
 
 export function registerDiagnostics(pi: ExtensionAPI, state: ContextManagerState): void {
   pi.registerTool({
@@ -29,7 +30,44 @@ export function registerDiagnostics(pi: ExtensionAPI, state: ContextManagerState
       state.report.toolCalls.contextReport += 1;
       persistReportSnapshot(pi, state, "context_report");
       const mode = (params.verbose ? "verbose" : params.mode ?? "summary") as ContextReportMode;
-      return { content: [{ type: "text", text: renderReport(state, mode) }], details: { ...state.report, mode } };
+      const text = renderReport(state, mode);
+      // Keep model-facing content exactly as requested. Expanded presentation
+      // renders that same mode-specific report rather than silently promoting
+      // summary/problems requests to verbose diagnostics.
+      const presentation = contextReportPresentation(state);
+      return { content: [{ type: "text", text }], details: { ...state.report, mode, presentation } };
+    },
+    renderCall(args, theme) {
+      return renderToolCall("context_report", args.verbose ? "verbose" : args.mode ?? "summary", theme);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as {
+        mode?: ContextReportMode;
+        skillCount?: number;
+        loadedByTool?: string[];
+        loadedPolicies?: string[];
+        presentation?: {
+          status?: "success" | "warning" | "error" | "pending";
+          summary?: string;
+          attentionCount?: number;
+        };
+      } | undefined;
+      const presentation = details?.presentation;
+      const text = resultText(result);
+      const status = presentation?.status ?? "pending";
+      const summary = presentation?.summary ?? "Informational";
+      const attentionCount = presentation?.attentionCount ?? 0;
+      const metadata = `${details?.skillCount ?? 0} skills · ${details?.loadedPolicies?.length ?? 0} policies loaded · ${attentionCount} attention items`;
+      if (!expanded) {
+        return renderCompactCard({ status, title: "Context health", summary, metadata }, theme);
+      }
+      return renderExpandedMarkdown({
+        status,
+        title: "Context report",
+        summary,
+        metadata: [metadata, `Requested mode: ${details?.mode ?? "summary"}`],
+        markdown: text,
+      }, theme);
     },
   });
 
@@ -55,7 +93,7 @@ export function registerDiagnostics(pi: ExtensionAPI, state: ContextManagerState
       persistReportSnapshot(pi, state, "context-report-command");
       const requested = args.trim();
       const mode: ContextReportMode = requested === "verbose" || requested === "problems" || requested === "summary" ? requested : "summary";
-      ctx.ui.notify(renderReport(state, mode), "info");
+      ctx.ui.notify(sanitizePresentation(renderReport(state, mode)), "info");
     },
   });
 }

package/.pi/extensions/takomi-context-manager/diagnostics.ts

@@ -139,6 +139,32 @@ function overallStatus(issues: ReportIssue[]): { label: string; next: string; wa
   return { label: "⚠ Attention Required", next: actionable[0].fix, warningCount: actionable.length };
 }
 
+export type ContextReportPresentation = {
+  status: "success" | "warning" | "error" | "pending";
+  summary: string;
+  attentionCount: number;
+};
+
+/** Structured execution metadata shared by context_report renderers. */
+export function contextReportPresentation(state: ContextManagerState): ContextReportPresentation {
+  syncReportLedger(state);
+  const issues = collectIssues(state);
+  const overall = overallStatus(issues);
+  const actionable = issues.filter((issue) => issue.severity !== "info");
+  const status = issues.length === 0
+    ? "success"
+    : actionable.some((issue) => issue.severity === "failed" || issue.severity === "blocked")
+      ? "error"
+      : actionable.length > 0
+        ? "warning"
+        : "pending";
+  return {
+    status,
+    summary: overall.label.replace(/^[^\w]+\s*/, ""),
+    attentionCount: overall.warningCount,
+  };
+}
+
 function promptRewriteState(state: ContextManagerState): string {
   const rewrite = state.report.promptRewrite;
   if (!rewrite.attempted) return "Not run yet";

package/.pi/extensions/takomi-context-manager/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadConfig, DEFAULT_CONFIG } from "./config";
 import { createState } from "./state";
-import { collectSkillsFromOptions, collectSkillsFromXml, discoverSkillsFromFilesystem, mergeSkills } from "./skill-registry";
+import { collectSkillsFromOptions, collectSkillsFromXml, discoverSkillsFromFilesystem, enrichSkillsWithInstallerTaxonomy, mergeSkills } from "./skill-registry";
 import { discoverPolicies } from "./policy-registry";
 import { findCandidates } from "./context-router";
 import { rewritePrompt } from "./prompt-rewriter";
@@ -48,10 +48,11 @@ export default function takomiContextManager(pi: ExtensionAPI) {
     const optionSkills = collectSkillsFromOptions(event.systemPromptOptions);
     const xmlSkills = collectSkillsFromXml(event.systemPrompt);
     const suppliedSkills = [...optionSkills, ...xmlSkills];
+    const enrichedSuppliedSkills = await enrichSkillsWithInstallerTaxonomy(suppliedSkills);
     const filesystemSkills = suppliedSkills.length === 0
       ? await discoverSkillsFromFilesystem(ctx.cwd)
       : [];
-    state.skills = mergeSkills([...filesystemSkills, ...suppliedSkills]);
+    state.skills = mergeSkills([...filesystemSkills, ...enrichedSuppliedSkills]);
 
     const candidates = findCandidates(event.prompt, state.skills, config);
     const rewrite = rewritePrompt(event.systemPrompt, state.skills, candidates, config);

package/.pi/extensions/takomi-context-manager/model-policy-gate.ts

@@ -1,114 +1,27 @@
-import { readFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ContextManagerState } from "./state";
 import { recordBlocked } from "./state";
-import { resolveTakomiRoutingPolicy } from "../takomi-runtime/routing-policy";
-import { approvedModelEquivalent, isTakomiModelApproved } from "../takomi-runtime/model-routing-defaults";
+import { isTakomiModelApproved, loadTakomiModelRoutingSnapshot } from "../takomi-runtime/model-routing-defaults";
 import { persistReportSnapshot } from "./session-state";
-
-type Settings = {
-  takomi?: { modelRoutingPolicyFile?: string };
-  subagents?: { agentOverrides?: Record<string, unknown> };
-};
+import { sanitizePresentation } from "./tool-renderers";
 
 type ModelPolicySnapshot = {
   approvedModels: string[];
   preferredModels: string[];
   sourceFiles: string[];
+  policyConflicts?: string[];
 };
 
-function asRecord(value: unknown): Record<string, unknown> {
-  return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
-}
-
-async function readSettingsFile(filePath: string): Promise<Settings> {
-  try {
-    return JSON.parse(await readFile(filePath, "utf8")) as Settings;
-  } catch {
-    return {};
-  }
-}
-
-function mergeSettings(globalSettings: Settings, projectSettings: Settings): Settings {
-  const globalOverrides = asRecord(globalSettings.subagents?.agentOverrides);
-  const projectOverrides = asRecord(projectSettings.subagents?.agentOverrides);
+async function loadSnapshot(cwd: string): Promise<ModelPolicySnapshot> {
+  const snapshot = await loadTakomiModelRoutingSnapshot(cwd);
   return {
-    ...globalSettings,
-    ...projectSettings,
-    takomi: { ...(globalSettings.takomi ?? {}), ...(projectSettings.takomi ?? {}) },
-    subagents: {
-      ...(globalSettings.subagents ?? {}),
-      ...(projectSettings.subagents ?? {}),
-      agentOverrides: { ...globalOverrides, ...projectOverrides },
-    },
+    approvedModels: snapshot.approvedModels,
+    preferredModels: snapshot.preferredModels,
+    sourceFiles: snapshot.sourceFiles,
+    policyConflicts: snapshot.policyConflicts,
   };
 }
 
-async function readSettings(cwd: string): Promise<Settings> {
-  const globalSettings = await readSettingsFile(path.join(os.homedir(), ".pi", "agent", "settings.json"));
-  const projectSettings = await readSettingsFile(path.resolve(cwd, ".pi/settings.json"));
-  return mergeSettings(globalSettings, projectSettings);
-}
-
-function modelFamily(model: string): string {
-  return model.split("/").at(-1)?.toLowerCase() ?? model.toLowerCase();
-}
-
-function unique(values: string[]): string[] {
-  return [...new Set(values.filter(Boolean))];
-}
-
-function collectModelsFromSettings(settings: Settings): string[] {
-  const overrides = asRecord(settings.subagents?.agentOverrides);
-  const models: string[] = [];
-  for (const value of Object.values(overrides)) {
-    const record = asRecord(value);
-    if (typeof record.model === "string") models.push(record.model);
-    if (Array.isArray(record.fallbackModels)) {
-      for (const fallback of record.fallbackModels) if (typeof fallback === "string") models.push(fallback.split(":")[0]);
-    }
-  }
-  return models;
-}
-
-function isModelLike(value: string): boolean {
-  const lower = value.toLowerCase();
-  return /(^|\/)(gpt|claude|gemini|o[0-9]|qwen|deepseek|llama|mistral|kimi|grok|sonnet|haiku|opus|codex|mini|max)/i.test(lower)
-    || lower.includes("oauth-router/")
-    || lower.includes("openai-codex/")
-    || lower.includes("lmstudio/");
-}
-
-function extractPreferredProvider(text: string): string | undefined {
-  const match = text.match(/(?:preferred|default)\s+(?:provider|router)(?:\s*\/\s*(?:provider|router))?\s*:\s*([a-z0-9-]+)/i)
-    ?? text.match(/use\s+([a-z0-9-]+)\s+as\s+(?:the\s+)?(?:provider|router)/i);
-  return match?.[1];
-}
-
-function collectModelsFromPolicy(text: string): string[] {
-  // Providerless names such as "GPT-5.5" are intent labels unless the policy
-  // declares a preferred provider/router header.
-  const explicit = (text.match(/[a-z0-9-]+\/[a-z0-9._-]+/gi) ?? []).filter(isModelLike);
-  const preferredProvider = extractPreferredProvider(text);
-  const inferred: string[] = [];
-  if (preferredProvider && /gpt[- ]?5\.5/i.test(text)) inferred.push(`${preferredProvider}/gpt-5.5`);
-  if (preferredProvider && /gpt[- ]?5\.4(?!\s*mini)/i.test(text)) inferred.push(`${preferredProvider}/gpt-5.4`);
-  if (preferredProvider && /gpt[- ]?5\.4\s*mini/i.test(text)) inferred.push(`${preferredProvider}/gpt-5.4-mini`);
-  return unique([...explicit, ...inferred]);
-}
-
-async function loadSnapshot(cwd: string): Promise<ModelPolicySnapshot> {
-  const settings = await readSettings(cwd);
-  const settingsModels = collectModelsFromSettings(settings);
-  const resolvedPolicy = await resolveTakomiRoutingPolicy(cwd);
-  const sourceFiles = resolvedPolicy.policyPath ? [resolvedPolicy.policyPath] : [];
-  const policyModels = resolvedPolicy.text ? collectModelsFromPolicy(resolvedPolicy.text) : [];
-  const approvedModels = unique([...settingsModels, ...policyModels]);
-  return { approvedModels, preferredModels: settingsModels.length ? unique(settingsModels) : approvedModels, sourceFiles };
-}
-
 function collectRequestedModelRefs(input: unknown): Array<{ holder: Record<string, unknown>; key: string; value: string; index?: number }> {
   const refs: Array<{ holder: Record<string, unknown>; key: string; value: string; index?: number }> = [];
   function visit(value: unknown): void {
@@ -162,18 +75,40 @@ type RecoveryChoice =
   | { action: "retry"; model: string }
   | { action: "stop" };
 
+type RecoveryOptions = {
+  options: string[];
+  retryModels: Map<string, string>;
+};
+
+/**
+ * Keep policy model IDs raw for selection and mutation, while passing only
+ * presentation-safe labels to the terminal UI. Disambiguate labels that become
+ * identical after sanitization so a selected label still maps to one raw ID.
+ */
+function recoveryOptions(approved: string[]): RecoveryOptions {
+  const retryModels = new Map<string, string>();
+  const options: string[] = [];
+  for (const model of approved) {
+    const baseLabel = `Retry with ${sanitizePresentation(model)}`;
+    let label = baseLabel;
+    let duplicate = 2;
+    while (retryModels.has(label)) label = `${baseLabel} (${duplicate++})`;
+    retryModels.set(label, model);
+    options.push(label);
+  }
+  options.push("Stop and let me send a new prompt");
+  return { options, retryModels };
+}
+
 async function askForInvalidModelRecovery(ctx: { ui: { select(title: string, options: string[]): Promise<string | undefined>; notify(message: string, level?: string): void }; abort?: () => void }, requested: string, approved: string[]): Promise<RecoveryChoice> {
   if (approved.length === 0) return { action: "stop" };
-  const options = [
-    ...approved.map((model) => `Retry with ${model}`),
-    "Stop and let me send a new prompt",
-  ];
+  const recovery = recoveryOptions(approved);
   const choice = await ctx.ui.select(
-    `takomi_subagent requested a model outside your routing policy: ${requested}`,
-    options,
+    sanitizePresentation(`takomi_subagent requested a model outside your routing policy: ${requested}`),
+    recovery.options,
   );
-  if (choice?.startsWith("Retry with ")) return { action: "retry", model: choice.replace("Retry with ", "") };
-  return { action: "stop" };
+  const model = choice ? recovery.retryModels.get(choice) : undefined;
+  return model ? { action: "retry", model } : { action: "stop" };
 }
 
 export function installModelPolicyGate(pi: ExtensionAPI, state: ContextManagerState): void {
@@ -181,18 +116,18 @@ export function installModelPolicyGate(pi: ExtensionAPI, state: ContextManagerSt
     if (event.toolName !== "takomi_subagent") return;
     const snapshot = await loadSnapshot(ctx.cwd);
     const approved = snapshot.approvedModels;
+    if (snapshot.policyConflicts?.length) {
+      const reason = ["Blocked by conflicting Takomi routing guidance and executable settings.", "", ...snapshot.policyConflicts.map((item) => `- ${item}`)].join("\n");
+      recordBlocked(state, event.toolName, reason);
+      persistReportSnapshot(pi, state, "model-policy-conflict");
+      return { block: true, reason };
+    }
     if (approved.length === 0) return;
 
     const refs = collectRequestedModelRefs(event.input);
     const corrections: Array<{ from: string; to: string; recovery?: string }> = [];
     for (const ref of refs) {
       if (isTakomiModelApproved(ref.value, approved)) continue;
-      const equivalent = approvedModelEquivalent(ref.value, approved);
-      if (equivalent) {
-        setModelRef(ref, equivalent);
-        corrections.push({ from: ref.value, to: equivalent });
-        continue;
-      }
       const recovery = await askForInvalidModelRecovery(ctx, ref.value, approved);
       if (recovery.action === "retry") {
         setModelRef(ref, recovery.model);
@@ -221,7 +156,8 @@ export function installModelPolicyGate(pi: ExtensionAPI, state: ContextManagerSt
         timestamp,
       })));
       persistReportSnapshot(pi, state, "model-policy-correction");
-      ctx.ui.notify(`Takomi context manager corrected subagent model routing:\n- ${corrections.map((correction) => `${correction.from} -> ${correction.to}${correction.recovery ? ` (${correction.recovery})` : ""}`).join("\n- ")}\n\nBe careful to follow /takomi routing policy next time.`, "warning");
+      const notification = `Takomi model routing changed only after explicit user selection:\n- ${corrections.map((correction) => `${sanitizePresentation(correction.from)} -> ${sanitizePresentation(correction.to)}${correction.recovery ? ` (${sanitizePresentation(correction.recovery)})` : ""}`).join("\n- ")}`;
+      ctx.ui.notify(notification, "warning");
     }
   });
 
@@ -231,12 +167,9 @@ export function installModelPolicyGate(pi: ExtensionAPI, state: ContextManagerSt
     if (!isModelFailure(content)) return;
 
     const snapshot = await loadSnapshot(ctx.cwd);
-    const options = [
-      ...snapshot.approvedModels.map((model) => `Retry with ${model}`),
-      "Stop and let me send a new prompt",
-    ];
-    const choice = await ctx.ui.select("Takomi subagent model/provider failure. How do you want to continue?", options);
-    const retryModel = choice?.startsWith("Retry with ") ? choice.replace("Retry with ", "") : undefined;
+    const recovery = recoveryOptions(snapshot.approvedModels);
+    const choice = await ctx.ui.select("Takomi subagent model/provider failure. How do you want to continue?", recovery.options);
+    const retryModel = choice ? recovery.retryModels.get(choice) : undefined;
     const stopped = !retryModel;
     const guidance = [
       "Takomi subagent failed with a model/provider-related error.",