takomi 2.1.13 → 2.1.15

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

@@ -1,80 +1,80 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { Type } from "typebox";
-import type { ContextManagerState } from "./state";
-import { findSkill, normalizeName, sortedSkills } from "./skill-registry";
-
-function renderSkillIndex(state: ContextManagerState): string {
-  const skills = sortedSkills(state.skills);
-  if (skills.length === 0) return "Available skills (names only): none discovered.";
-  return ["Available skills (names only):", ...skills.map((skill) => `- ${skill.name}`)].join("\n");
-}
-
-function renderManifest(state: ContextManagerState, names: string[]): string {
-  if (names.length === 0) return "No skills requested.";
-  return names.map((name) => {
-    const skill = findSkill(state.skills, name);
-    if (!skill) {
-      const close = sortedSkills(state.skills).filter((candidate) => normalizeName(candidate.name).includes(normalizeName(name).slice(0, 4))).slice(0, 5).map((candidate) => candidate.name);
-      return [`Skill not found: ${name}`, close.length ? `Known close matches: ${close.join(", ")}` : ""].filter(Boolean).join("\n");
-    }
-    return [`Skill: ${skill.name}`, `Description: ${skill.description ?? "(no description discovered)"}`, `Location: ${skill.location ?? "(no location discovered)"}`].join("\n");
-  }).join("\n\n");
-}
-
-async function loadSkillContent(location: string): Promise<string> {
-  const fileName = path.basename(location).toLowerCase();
-  if (fileName !== "skill.md" && !location.toLowerCase().endsWith(".md")) throw new Error(`Refusing to load non-markdown skill location: ${location}`);
-  return readFile(location, "utf8");
-}
-
-export function registerSkillTools(pi: ExtensionAPI, state: ContextManagerState): void {
-  pi.registerTool({
-    name: "skill_index",
-    label: "Skill Index",
-    description: "Return the available skill names only. Use this to inspect capability names without loading descriptions or full instructions.",
-    promptSnippet: "List available skill names only for progressive skill loading",
-    parameters: Type.Object({}),
-    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
-      state.report.cwd = ctx.cwd;
-      state.report.toolCalls.skillIndex += 1;
-      return { content: [{ type: "text", text: renderSkillIndex(state) }], details: { skillCount: state.skills.size } };
-    },
-  });
-
-  pi.registerTool({
-    name: "skill_manifest",
-    label: "Skill Manifest",
-    description: "Return descriptions and locations for selected skills without loading full SKILL.md instructions.",
-    promptSnippet: "Show selected skill descriptions and locations without full instructions",
-    parameters: Type.Object({ skills: Type.Array(Type.String({ description: "Skill name to inspect" })) }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      state.report.cwd = ctx.cwd;
-      state.report.toolCalls.skillManifest += 1;
-      return { content: [{ type: "text", text: renderManifest(state, params.skills) }], details: { requested: params.skills } };
-    },
-  });
-
-  pi.registerTool({
-    name: "skill_load",
-    label: "Skill Load",
-    description: "Load the full SKILL.md content for one selected skill that will actually be used.",
-    promptSnippet: "Load full SKILL.md instructions for one selected skill",
-    parameters: Type.Object({ skill: Type.String({ description: "Exact skill name to load" }) }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      state.report.cwd = ctx.cwd;
-      state.report.toolCalls.skillLoad += 1;
-      const skill = findSkill(state.skills, params.skill);
-      if (!skill?.location) return { content: [{ type: "text", text: renderManifest(state, [params.skill]) }], details: { found: false, requested: params.skill }, isError: true };
-      try {
-        const content = await loadSkillContent(skill.location);
-        state.report.loadedByTool.push(skill.name);
-        return { content: [{ type: "text", text: [`Skill: ${skill.name}`, `Location: ${skill.location}`, "", content].join("\n") }], details: { found: true, skill: skill.name, location: skill.location } };
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { content: [{ type: "text", text: message }], details: { found: true, skill: skill.name, error: message }, isError: true };
-      }
-    },
-  });
-}
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "typebox";
+import type { ContextManagerState } from "./state";
+import { findSkill, normalizeName, sortedSkills } from "./skill-registry";
+
+function renderSkillIndex(state: ContextManagerState): string {
+  const skills = sortedSkills(state.skills);
+  if (skills.length === 0) return "Available skills (names only): none discovered.";
+  return ["Available skills (names only):", ...skills.map((skill) => `- ${skill.name}`)].join("\n");
+}
+
+function renderManifest(state: ContextManagerState, names: string[]): string {
+  if (names.length === 0) return "No skills requested.";
+  return names.map((name) => {
+    const skill = findSkill(state.skills, name);
+    if (!skill) {
+      const close = sortedSkills(state.skills).filter((candidate) => normalizeName(candidate.name).includes(normalizeName(name).slice(0, 4))).slice(0, 5).map((candidate) => candidate.name);
+      return [`Skill not found: ${name}`, close.length ? `Known close matches: ${close.join(", ")}` : ""].filter(Boolean).join("\n");
+    }
+    return [`Skill: ${skill.name}`, `Description: ${skill.description ?? "(no description discovered)"}`, `Location: ${skill.location ?? "(no location discovered)"}`].join("\n");
+  }).join("\n\n");
+}
+
+async function loadSkillContent(location: string): Promise<string> {
+  const fileName = path.basename(location).toLowerCase();
+  if (fileName !== "skill.md" && !location.toLowerCase().endsWith(".md")) throw new Error(`Refusing to load non-markdown skill location: ${location}`);
+  return readFile(location, "utf8");
+}
+
+export function registerSkillTools(pi: ExtensionAPI, state: ContextManagerState): void {
+  pi.registerTool({
+    name: "skill_index",
+    label: "Skill Index",
+    description: "Return the available skill names only. Use this to inspect capability names without loading descriptions or full instructions.",
+    promptSnippet: "List available skill names only for progressive skill loading",
+    parameters: Type.Object({}),
+    async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
+      state.report.cwd = ctx.cwd;
+      state.report.toolCalls.skillIndex += 1;
+      return { content: [{ type: "text", text: renderSkillIndex(state) }], details: { skillCount: state.skills.size } };
+    },
+  });
+
+  pi.registerTool({
+    name: "skill_manifest",
+    label: "Skill Manifest",
+    description: "Return descriptions and locations for selected skills without loading full SKILL.md instructions.",
+    promptSnippet: "Show selected skill descriptions and locations without full instructions",
+    parameters: Type.Object({ skills: Type.Array(Type.String({ description: "Skill name to inspect" })) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      state.report.cwd = ctx.cwd;
+      state.report.toolCalls.skillManifest += 1;
+      return { content: [{ type: "text", text: renderManifest(state, params.skills) }], details: { requested: params.skills } };
+    },
+  });
+
+  pi.registerTool({
+    name: "skill_load",
+    label: "Skill Load",
+    description: "Load the full SKILL.md content for one selected skill that will actually be used.",
+    promptSnippet: "Load full SKILL.md instructions for one selected skill",
+    parameters: Type.Object({ skill: Type.String({ description: "Exact skill name to load" }) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      state.report.cwd = ctx.cwd;
+      state.report.toolCalls.skillLoad += 1;
+      const skill = findSkill(state.skills, params.skill);
+      if (!skill?.location) return { content: [{ type: "text", text: renderManifest(state, [params.skill]) }], details: { found: false, requested: params.skill }, isError: true };
+      try {
+        const content = await loadSkillContent(skill.location);
+        state.report.loadedByTool.push(skill.name);
+        return { content: [{ type: "text", text: [`Skill: ${skill.name}`, `Location: ${skill.location}`, "", content].join("\n") }], details: { found: true, skill: skill.name, location: skill.location } };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { content: [{ type: "text", text: message }], details: { found: true, skill: skill.name, error: message }, isError: true };
+      }
+    },
+  });
+}

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

@@ -1,68 +1,68 @@
-import type { ContextReport, PolicyPack, SkillRecord } from "./types";
-
-export type ContextManagerState = {
-  skills: Map<string, SkillRecord>;
-  policies: Map<string, PolicyPack>;
-  loadedPolicies: Set<string>;
-  readFiles: Set<string>;
-  editedFiles: Set<string>;
-  writtenFiles: Set<string>;
-  report: ContextReport;
-};
-
-export function createEmptyReport(): ContextReport {
-  return {
-    timestamp: new Date().toISOString(),
-    cwd: "",
-    userPrompt: "",
-    skillCount: 0,
-    candidates: [],
-    loadedByTool: [],
-    loadedPolicies: [],
-    readFiles: [],
-    editedFiles: [],
-    writtenFiles: [],
-    blockedActions: [],
-    duplicateExtensionWarnings: [],
-    promptRewrite: {
-      attempted: false,
-      changed: false,
-      originalLength: 0,
-      rewrittenLength: 0,
-      removedSections: [],
-      warnings: [],
-    },
-    toolCalls: {
-      skillIndex: 0,
-      skillManifest: 0,
-      skillLoad: 0,
-      policyManifest: 0,
-      policyLoad: 0,
-      contextReport: 0,
-    },
-  };
-}
-
-export function createState(): ContextManagerState {
-  return {
-    skills: new Map(),
-    policies: new Map(),
-    loadedPolicies: new Set(),
-    readFiles: new Set(),
-    editedFiles: new Set(),
-    writtenFiles: new Set(),
-    report: createEmptyReport(),
-  };
-}
-
-export function syncReportLedger(state: ContextManagerState): void {
-  state.report.loadedPolicies = [...state.loadedPolicies].sort();
-  state.report.readFiles = [...state.readFiles].sort();
-  state.report.editedFiles = [...state.editedFiles].sort();
-  state.report.writtenFiles = [...state.writtenFiles].sort();
-}
-
-export function recordBlocked(state: ContextManagerState, toolName: string, reason: string): void {
-  state.report.blockedActions.push({ toolName, reason, timestamp: new Date().toISOString() });
-  syncReportLedger(state);
-}
+import type { ContextReport, PolicyPack, SkillRecord } from "./types";
+
+export type ContextManagerState = {
+  skills: Map<string, SkillRecord>;
+  policies: Map<string, PolicyPack>;
+  loadedPolicies: Set<string>;
+  readFiles: Set<string>;
+  editedFiles: Set<string>;
+  writtenFiles: Set<string>;
+  report: ContextReport;
+};
+
+export function createEmptyReport(): ContextReport {
+  return {
+    timestamp: new Date().toISOString(),
+    cwd: "",
+    userPrompt: "",
+    skillCount: 0,
+    candidates: [],
+    loadedByTool: [],
+    loadedPolicies: [],
+    readFiles: [],
+    editedFiles: [],
+    writtenFiles: [],
+    blockedActions: [],
+    duplicateExtensionWarnings: [],
+    promptRewrite: {
+      attempted: false,
+      changed: false,
+      originalLength: 0,
+      rewrittenLength: 0,
+      removedSections: [],
+      warnings: [],
+    },
+    toolCalls: {
+      skillIndex: 0,
+      skillManifest: 0,
+      skillLoad: 0,
+      policyManifest: 0,
+      policyLoad: 0,
+      contextReport: 0,
+    },
+  };
+}
+
+export function createState(): ContextManagerState {
+  return {
+    skills: new Map(),
+    policies: new Map(),
+    loadedPolicies: new Set(),
+    readFiles: new Set(),
+    editedFiles: new Set(),
+    writtenFiles: new Set(),
+    report: createEmptyReport(),
+  };
+}
+
+export function syncReportLedger(state: ContextManagerState): void {
+  state.report.loadedPolicies = [...state.loadedPolicies].sort();
+  state.report.readFiles = [...state.readFiles].sort();
+  state.report.editedFiles = [...state.editedFiles].sort();
+  state.report.writtenFiles = [...state.writtenFiles].sort();
+}
+
+export function recordBlocked(state: ContextManagerState, toolName: string, reason: string): void {
+  state.report.blockedActions.push({ toolName, reason, timestamp: new Date().toISOString() });
+  syncReportLedger(state);
+}

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

@@ -1,77 +1,77 @@
-export type SkillRecord = {
-  name: string;
-  description?: string;
-  location?: string;
-  source: "systemPromptOptions" | "xml" | "tool";
-};
-
-export type CandidateContext = {
-  name: string;
-  score: number;
-  confidence: "high" | "medium";
-  suggestedAction: "skill_load" | "skill_manifest";
-  reasons: string[];
-};
-
-export type PolicyPack = {
-  name: string;
-  description: string;
-  content: string;
-  path?: string;
-};
-
-export type Prerequisite = { type: "policies"; policies: string[] };
-
-export type SkillIndexDisplayMode = "hidden" | "candidates" | "all-names" | "auto";
-
-export type ContextManagerConfig = {
-  skillDisplay: {
-    mode: SkillIndexDisplayMode;
-    maxVisibleSkillNames: number;
-    alwaysShowToolInstructions: boolean;
-  };
-  candidateRouter: {
-    maxCandidates: number;
-    highConfidence: number;
-    mediumConfidence: number;
-  };
-  policyPaths: string[];
-  policyFiles?: Record<string, string>;
-  toolPrerequisites: Record<string, Prerequisite[]>;
-  promptCompaction: {
-    compactModelRouting: boolean;
-    compactModelRegistry: boolean;
-    compactSkillDescriptions: boolean;
-  };
-};
-
-export type ContextReport = {
-  timestamp: string;
-  cwd: string;
-  userPrompt: string;
-  skillCount: number;
-  candidates: CandidateContext[];
-  loadedByTool: string[];
-  loadedPolicies: string[];
-  readFiles: string[];
-  editedFiles: string[];
-  writtenFiles: string[];
-  blockedActions: Array<{ toolName: string; reason: string; timestamp: string }>;
-  duplicateExtensionWarnings: Array<{ toolName: string; paths: string[] }>;
-  promptRewrite: {
-    attempted: boolean;
-    changed: boolean;
-    originalLength: number;
-    rewrittenLength: number;
-    removedSections: string[];
-    warnings: string[];
-  };
-  toolCalls: {
-    skillIndex: number;
-    skillManifest: number;
-    skillLoad: number;
-    policyManifest: number;
-    policyLoad: number;
-    contextReport: number;
-  };
-};
+export type SkillRecord = {
+  name: string;
+  description?: string;
+  location?: string;
+  source: "systemPromptOptions" | "xml" | "tool";
+};
+
+export type CandidateContext = {
+  name: string;
+  score: number;
+  confidence: "high" | "medium";
+  suggestedAction: "skill_load" | "skill_manifest";
+  reasons: string[];
+};
+
+export type PolicyPack = {
+  name: string;
+  description: string;
+  content: string;
+  path?: string;
+};
+
+export type Prerequisite = { type: "policies"; policies: string[] };
+
+export type SkillIndexDisplayMode = "hidden" | "candidates" | "all-names" | "auto";
+
+export type ContextManagerConfig = {
+  skillDisplay: {
+    mode: SkillIndexDisplayMode;
+    maxVisibleSkillNames: number;
+    alwaysShowToolInstructions: boolean;
+  };
+  candidateRouter: {
+    maxCandidates: number;
+    highConfidence: number;
+    mediumConfidence: number;
+  };
+  policyPaths: string[];
+  policyFiles?: Record<string, string>;
+  toolPrerequisites: Record<string, Prerequisite[]>;
+  promptCompaction: {
+    compactModelRouting: boolean;
+    compactModelRegistry: boolean;
+    compactSkillDescriptions: boolean;
+  };
+};
+
+export type ContextReport = {
+  timestamp: string;
+  cwd: string;
+  userPrompt: string;
+  skillCount: number;
+  candidates: CandidateContext[];
+  loadedByTool: string[];
+  loadedPolicies: string[];
+  readFiles: string[];
+  editedFiles: string[];
+  writtenFiles: string[];
+  blockedActions: Array<{ toolName: string; reason: string; timestamp: string }>;
+  duplicateExtensionWarnings: Array<{ toolName: string; paths: string[] }>;
+  promptRewrite: {
+    attempted: boolean;
+    changed: boolean;
+    originalLength: number;
+    rewrittenLength: number;
+    removedSections: string[];
+    warnings: string[];
+  };
+  toolCalls: {
+    skillIndex: number;
+    skillManifest: number;
+    skillLoad: number;
+    policyManifest: number;
+    policyLoad: number;
+    contextReport: number;
+  };
+};

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

@@ -16,7 +16,7 @@ const ROOT_COMPLETIONS: TakomiCompletion[] = [
   { value: "mode", label: "mode", description: "Set direct, orchestrate, or review mode" },
   { value: "gate", label: "gate", description: "Set auto or review-gated execution" },
   { value: "subagents", label: "subagents", description: "Control subagent usage and view" },
-  { value: "routing", label: "routing", description: "Install/update Takomi model routing policy" },
+  { value: "routing", label: "routing", description: "Show or update Takomi model routing policy" },
 ];
 
 const SUBCOMMAND_COMPLETIONS: Record<string, TakomiCompletion[]> = {
@@ -37,6 +37,12 @@ const SUBCOMMAND_COMPLETIONS: Record<string, TakomiCompletion[]> = {
     { value: "collapse", label: "collapse", description: "Collapse native tool results" },
     { value: "toggle", label: "toggle", description: "Toggle native tool result expansion" },
   ],
+  routing: [
+    { value: "show", label: "show", description: "Show active routing policy source, path, and contents" },
+    { value: "global", label: "global", description: "Save following policy text globally" },
+    { value: "local", label: "local", description: "Save following policy text as a project override" },
+    { value: "where", label: "where", description: "Show where the active routing policy is loaded from" },
+  ],
 };
 
 const SUBCOMMAND_ALIASES: Record<string, string> = {
@@ -71,7 +77,9 @@ export function commandHelp(): string {
     "/takomi mode <direct|orchestrate|review>",
     "/takomi gate <auto|review>",
     "/takomi subagents <on|off|status|expand|collapse|toggle>",
-    "/takomi routing <policy text>",
+    "/takomi routing [show|where]",
+    "/takomi routing <policy text>              # updates global policy",
+    "/takomi routing local <policy text>        # project override",
     "/takomi-status",
     "/takomi-reset",
   ].join("\n");

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

@@ -7,7 +7,7 @@ import type {
 } from "../../../src/pi-takomi-core";
 import { commandHelp, completions, statusText, workflowPrompt } from "./command-text";
 import type { TakomiSubagentController } from "./subagent-types";
-import { installTakomiRoutingPolicy } from "./routing-policy";
+import { installTakomiRoutingPolicy, resolveTakomiRoutingPolicy, type RoutingPolicyInstallScope } from "./routing-policy";
 
 export type TakomiRuntimeCommandState = {
   enabled: boolean;
@@ -82,14 +82,87 @@ export function registerTakomiCommands(pi: ExtensionAPI, options: RegisterTakomi
   }
 
   async function handleRouting(ctx: ExtensionCommandContext, body?: string): Promise<void> {
-    if (!body?.trim()) {
-      ctx.ui.notify("Usage: /takomi routing <policy text>\nTip: paste the policy after the command, or say: Update Takomi routing logic: \"\"\"...\"\"\"", "warning");
+    const trimmed = body?.trim() ?? "";
+
+    const usage = [
+      "Usage:",
+      "/takomi routing show                 Print the full active policy",
+      "/takomi routing where                Show source/path only",
+      "/takomi routing <policy text>        Update the global policy",
+      "/takomi routing local <policy text>  Create/update this project's override",
+    ].join("\n");
+
+    async function showRoutingHelp(): Promise<void> {
+      const resolved = await resolveTakomiRoutingPolicy(ctx.cwd);
+      ctx.ui.notify([
+        "Takomi routing options",
+        "",
+        `Active source: ${resolved.source}`,
+        `Active path: ${resolved.policyPath ?? "not found"}`,
+        "",
+        usage,
+        "",
+        "Resolution order: project .pi/takomi/model-routing.md → global ~/.pi/takomi/model-routing.md → bundled fallback.",
+      ].join("\n"), "warning");
+    }
+
+    async function showRoutingLocation(): Promise<void> {
+      const resolved = await resolveTakomiRoutingPolicy(ctx.cwd);
+      ctx.ui.notify([
+        "Active Takomi routing policy location",
+        "",
+        `Source: ${resolved.source}`,
+        `Path: ${resolved.policyPath ?? "not found"}`,
+        "",
+        usage,
+      ].join("\n"), resolved.source === "missing" ? "warning" : "info");
+    }
+
+    async function showActivePolicy(): Promise<void> {
+      const resolved = await resolveTakomiRoutingPolicy(ctx.cwd);
+      const text = resolved.text ?? "No Takomi routing policy found.";
+      const clipped = text.length > 6000 ? `${text.slice(0, 6000)}\n\n…truncated; open the file above for the full policy.` : text;
+      ctx.ui.notify([
+        "Active Takomi routing policy",
+        "",
+        `Source: ${resolved.source}`,
+        `Path: ${resolved.policyPath ?? "not found"}`,
+        "",
+        clipped,
+        "",
+        usage,
+      ].join("\n"), resolved.source === "missing" ? "warning" : "info");
+    }
+
+    if (!trimmed) {
+      await showRoutingHelp();
       return;
     }
+    if (/^(where|path|status)$/i.test(trimmed)) {
+      await showRoutingLocation();
+      return;
+    }
+    if (/^(show|view)$/i.test(trimmed)) {
+      await showActivePolicy();
+      return;
+    }
+
+    if (/^(global|local|project|set)$/i.test(trimmed)) {
+      ctx.ui.notify(usage, "warning");
+      return;
+    }
+
+    const scopeMatch = trimmed.match(/^(global|local|project)\s+([\s\S]+)$/i);
+    const scope: RoutingPolicyInstallScope = scopeMatch?.[1]?.toLowerCase() === "local" || scopeMatch?.[1]?.toLowerCase() === "project" ? "project" : "global";
+    const policyText = scopeMatch?.[2] ?? trimmed.replace(/^set\s+/i, "");
+
     try {
-      const result = await installTakomiRoutingPolicy(ctx.cwd, body);
+      const result = await installTakomiRoutingPolicy(ctx.cwd, policyText, { scope });
       const detected = result.detectedDefaults.length ? `\n\nDetected defaults:\n- ${result.detectedDefaults.join("\n- ")}` : "\n\nNo model names were auto-detected; saved policy only.";
-      ctx.ui.notify(`Takomi routing policy updated.\n\nPolicy: ${result.policyPath}\nSettings: ${result.settingsPath}${detected}`, "info");
+      const overrideNote = scope === "global"
+        ? "\n\nThis will be used by every project unless that project has its own .pi/takomi/model-routing.md override."
+        : "\n\nThis project-local policy overrides the global policy for the current project.";
+      ctx.ui.notify(`Takomi routing policy updated (${scope}).\n\nPolicy: ${result.policyPath}\nSettings: ${result.settingsPath}${detected}${overrideNote}`, "info");
     } catch (error) {
       ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
     }