takomi 2.1.33 → 2.1.35

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

@@ -35,9 +35,6 @@ const SUBCOMMAND_COMPLETIONS: Record<string, TakomiCompletion[]> = {
     { value: "status", label: "status", description: "Show active subagents" },
     { value: "on", label: "on", description: "Allow subagent delegation" },
     { value: "off", label: "off", description: "Disable subagent delegation" },
-    { value: "expand", label: "expand", description: "Expand native tool results" },
-    { value: "collapse", label: "collapse", description: "Collapse native tool results" },
-    { value: "toggle", label: "toggle", description: "Toggle native tool result expansion" },
   ],
   stats: [
     { value: "overview", label: "overview", description: "Show the full profile-card dashboard" },
@@ -98,7 +95,7 @@ export function commandHelp(): string {
     "/takomi plan [title]",
     "/takomi mode <direct|orchestrate|review>",
     "/takomi gate <auto|review>",
-    "/takomi subagents <on|off|status|expand|collapse|toggle>",
+    "/takomi subagents <on|off|status>",
     "/takomi stats [overview|daily|models|projects|projects-full|sessions|sessions-full|tasks|tasks-full|tools|subagents|sources] [since 7d]",
     "/takomi routing [show|where]",
     "/takomi routing <policy text>              # updates global policy",
@@ -134,6 +131,7 @@ export function statusText(state: TakomiRuntimeCommandState, subagentController:
   return [
     `Takomi: ${state.enabled ? "on" : "off"}`,
     `Mode: ${state.role}`,
+    `Source: ${state.modeSource ?? "idle"}${state.modeReason ? ` (${state.modeReason})` : ""}`,
     `Stage: ${state.stage ?? "-"}`,
     `Workflow: ${state.workflow ?? "-"}`,
     `Plan bias: ${state.planMode ? "on" : "off"}`,

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

@@ -20,6 +20,8 @@ export type TakomiRuntimeCommandState = {
   workflow?: TakomiWorkflowId;
   activeSessionId?: string;
   subagentsEnabled: boolean;
+  modeSource?: "idle" | "manual" | "model" | "board";
+  modeReason?: string;
 };
 
 type RegisterTakomiCommandOptions = {
@@ -36,6 +38,8 @@ export function registerTakomiCommands(pi: ExtensionAPI, options: RegisterTakomi
   async function handleStage(ctx: ExtensionCommandContext, stage: VibeLifecycleStage, prompt?: string): Promise<void> {
     await options.updateState(ctx, () => {
       options.getState().enabled = true;
+      options.getState().modeSource = "manual";
+      options.getState().modeReason = `/${stage}`;
       options.setStageAndWorkflow(stage, { preserveRole: stage === "genesis" && options.getState().role === "orchestrator" });
       options.getState().planMode = stage !== "build";
     }, workflowPrompt(stage, prompt));
@@ -54,17 +58,27 @@ export function registerTakomiCommands(pi: ExtensionAPI, options: RegisterTakomi
         state.autoOrch = false;
         state.planMode = false;
         state.role = "general";
+        state.stage = undefined;
+        state.workflow = undefined;
+        state.modeSource = "idle";
+        state.modeReason = undefined;
       } else if (mode === "orchestrate") {
         state.autoOrch = true;
         state.planMode = true;
         state.role = "orchestrator";
         state.stage = hasGenesis ? "build" : "genesis";
         state.workflow = hasGenesis ? "vibe-build" : "vibe-genesis";
+        state.modeSource = "manual";
+        state.modeReason = "/takomi mode orchestrate";
       } else {
         state.autoOrch = false;
         state.planMode = true;
         state.launchMode = "manual";
         state.role = "review";
+        state.stage = undefined;
+        state.workflow = undefined;
+        state.modeSource = "manual";
+        state.modeReason = "/takomi mode review";
       }
     }, () => `Takomi mode set to ${mode}`);
   }
@@ -198,27 +212,7 @@ export function registerTakomiCommands(pi: ExtensionAPI, options: RegisterTakomi
       ctx.ui.notify(statusText(options.getState(), controller), controller.hasRuns() ? "info" : "warning");
       return;
     }
-    if (action === "expand" || action === "fullscreen") {
-      ctx.ui.setToolsExpanded(true);
-      ctx.ui.notify("Expanded native tool results for Takomi subagent output.", "info");
-      return;
-    }
-    if (action === "collapse") {
-      ctx.ui.setToolsExpanded(false);
-      ctx.ui.notify("Collapsed native tool results.", "info");
-      return;
-    }
-    if (action === "toggle") {
-      const expanded = !ctx.ui.getToolsExpanded();
-      ctx.ui.setToolsExpanded(expanded);
-      ctx.ui.notify(`${expanded ? "Expanded" : "Collapsed"} native tool results.`, "info");
-      return;
-    }
-    if (action === "next" || action === "prev") {
-      ctx.ui.notify("Takomi now uses Pi's native inline result UI. Subagent navigation is handled by the transcript/tool results.", "info");
-      return;
-    }
-    ctx.ui.notify("Usage: /takomi subagents <on|off|status|expand|collapse|toggle>", "warning");
+    ctx.ui.notify("Usage: /takomi subagents <on|off|status>", "warning");
   }
 
   pi.registerCommand("takomi", {

package/.pi/extensions/takomi-runtime/context-panel.ts

@@ -206,6 +206,18 @@ function calculateActiveMs(intervals: ActivityInterval[]): number {
   return mergeIntervals(intervals).reduce((total, interval) => total + (interval.end - interval.start), 0);
 }
 
+function clampActiveMs(activeMs: number, sessionStart: number, now = Date.now()): number {
+  if (!Number.isFinite(activeMs) || activeMs <= 0) return 0;
+  const ageMs = Math.max(0, now - sessionStart);
+  return Math.min(activeMs, ageMs);
+}
+
+function boundedPendingStart(starts: number[], sessionStart: number, now = Date.now()): number | undefined {
+  const valid = starts.filter((start) => Number.isFinite(start) && start <= now);
+  if (valid.length === 0) return undefined;
+  return Math.max(sessionStart, Math.min(...valid));
+}
+
 function formatDisplayPath(filePath: string, cwd?: string): string {
   const normalized = filePath.replace(/^@/, "");
   const absolute = path.isAbsolute(normalized) ? normalized : undefined;
@@ -312,11 +324,13 @@ class ContextPanelComponent implements Component {
     lines.push("");
 
     if (ctx) {
-      const age = formatDuration(Date.now() - state.sessionStart);
+      const now = Date.now();
+      const ageMs = Math.max(0, now - state.sessionStart);
+      const age = formatDuration(ageMs);
       const pendingStarts = Object.values(state.pendingToolStarts ?? {});
-      const pendingStart = pendingStarts.length > 0 ? Math.min(...pendingStarts) : undefined;
-      const activeMs = pendingStart !== undefined ? state.activeMs + Math.max(0, Date.now() - pendingStart) : state.activeMs;
-      const active = formatDuration(activeMs);
+      const pendingStart = boundedPendingStart(pendingStarts, state.sessionStart, now);
+      const rawActiveMs = pendingStart !== undefined ? state.activeMs + Math.max(0, now - pendingStart) : state.activeMs;
+      const active = formatDuration(clampActiveMs(rawActiveMs, state.sessionStart, now));
       lines.push(`${pad}${theme.fg("dim", "Age:")}     ${theme.fg("muted", age)}`);
       lines.push(`${pad}${theme.fg("dim", "Active:")}  ${theme.fg("muted", active)}`);
 
@@ -417,15 +431,18 @@ export class TakomiContextPanel {
     this.requestRender?.();
   }
 
-  private recomputeActiveMs(): void {
-    this.state.activeMs = calculateActiveMs(this.state.activityIntervals);
+  private recomputeActiveMs(now = Date.now()): void {
+    this.state.activeMs = clampActiveMs(calculateActiveMs(this.state.activityIntervals), this.state.sessionStart, now);
   }
 
   private addActivityInterval(start: number, end: number): void {
-    if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) return;
-    this.state.activityIntervals.push({ start, end });
-    this.recomputeActiveMs();
-    this.state.lastActivityAt = Math.max(this.state.lastActivityAt, end);
+    const now = Date.now();
+    const boundedStart = Math.max(this.state.sessionStart, start);
+    const boundedEnd = Math.min(now, end);
+    if (!Number.isFinite(boundedStart) || !Number.isFinite(boundedEnd) || boundedEnd <= boundedStart) return;
+    this.state.activityIntervals.push({ start: boundedStart, end: boundedEnd });
+    this.recomputeActiveMs(now);
+    this.state.lastActivityAt = Math.max(this.state.lastActivityAt, boundedEnd);
   }
 
   private noteActivity(timestamp = Date.now(), allowLongGap = false): void {
@@ -564,10 +581,13 @@ export class TakomiContextPanel {
       lastActivityPoint = ts;
     }
 
+    const now = Date.now();
     next.sessionStart = firstSessionTs ?? next.sessionStart;
-    next.activityIntervals = intervals;
-    next.activeMs = calculateActiveMs(intervals);
-    next.lastActivityAt = lastActivityPoint ?? next.sessionStart;
+    next.activityIntervals = intervals
+      .map((interval) => ({ start: Math.max(next.sessionStart, interval.start), end: Math.min(now, interval.end) }))
+      .filter((interval) => Number.isFinite(interval.start) && Number.isFinite(interval.end) && interval.end > interval.start);
+    next.activeMs = clampActiveMs(calculateActiveMs(next.activityIntervals), next.sessionStart, now);
+    next.lastActivityAt = Math.min(now, Math.max(next.sessionStart, lastActivityPoint ?? next.sessionStart));
 
     this.state = next;
     this.requestRender?.();
@@ -671,6 +691,10 @@ export function wireContextPanel(pi: ExtensionAPI, panel: TakomiContextPanel): v
     panel.rebuildFromSession(ctx);
   });
 
+  pi.on("session_compact", (_event, ctx) => {
+    panel.rebuildFromSession(ctx);
+  });
+
   pi.registerShortcut("alt+c", {
     description: "Toggle Takomi context panel",
     handler: async (ctx) => {

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

@@ -58,6 +58,8 @@ import {
 } from "./profile";
 import { installTakomiRoutingPolicy, previewTakomiRoutingPolicy, renderRoutingPolicyPreview, resolveTakomiRoutingPolicy } from "./routing-policy";
 
+type TakomiModeSource = "idle" | "manual" | "model" | "board";
+
 type TakomiState = {
   enabled: boolean;
   autoOrch: boolean;
@@ -69,15 +71,18 @@ type TakomiState = {
   activeSessionId?: string;
   subagentsEnabled: boolean;
   lastFullPromptKey?: string;
+  modeSource?: TakomiModeSource;
+  modeReason?: string;
 };
 
 const DEFAULT_STATE: TakomiState = {
   enabled: true,
-  autoOrch: true,
+  autoOrch: false,
   launchMode: "auto",
   planMode: false,
   role: "general",
   subagentsEnabled: true,
+  modeSource: "idle",
 };
 
 const STATE_ENTRY = "takomi-runtime-state";
@@ -97,6 +102,8 @@ const ThinkingSchema = Type.Union([
   Type.Literal("xhigh"),
 ]);
 
+const TakomiModeSchema = StringEnum(["idle", "code", "orchestrate", "review", "genesis", "design", "build"] as const);
+
 function cloneState(state: TakomiState): TakomiState {
   return { ...state };
 }
@@ -111,6 +118,8 @@ function formatState(state: TakomiState): string {
     `launch=${state.launchMode}`,
     `plan=${state.planMode ? "on" : "off"}`,
     `subagents=${state.subagentsEnabled ? "on" : "off"}`,
+    `source=${state.modeSource ?? "idle"}`,
+    state.modeReason ? `reason=${state.modeReason}` : "",
     state.activeSessionId ? `session=${state.activeSessionId}` : "",
   ].filter(Boolean).join(" | ");
 }
@@ -766,6 +775,8 @@ export default function takomiRuntime(pi: ExtensionAPI) {
         state.stage = "genesis";
         state.workflow = "vibe-genesis";
         state.role = "orchestrator";
+        state.modeSource = "manual";
+        state.modeReason = "/takomi plan";
       });
       return `Takomi plan created session ${session.sessionId}\nMaster plan: ${paths.masterPlan}`;
     },
@@ -783,34 +794,82 @@ export default function takomiRuntime(pi: ExtensionAPI) {
     },
   });
 
-  pi.registerShortcut("alt+t", {
-    description: "Toggle native tool result expansion",
-    handler: async (ctx) => {
-      const expanded = !ctx.ui.getToolsExpanded();
-      ctx.ui.setToolsExpanded(expanded);
-      ctx.ui.notify(`${expanded ? "Expanded" : "Collapsed"} native tool results.`, "info");
-    },
-  });
 
-  pi.registerShortcut("alt+shift+t", {
-    description: "Expand native tool results",
-    handler: async (ctx) => {
-      ctx.ui.setToolsExpanded(true);
-      ctx.ui.notify("Expanded native tool results for Takomi subagent output.", "info");
-    },
-  });
+  async function applyTakomiMode(ctx: ExtensionContext, mode: string, source: TakomiModeSource, reason?: string): Promise<string> {
+    const hasGenesis = await hasGenesisArtifacts(ctx.cwd);
+    state.enabled = true;
+    state.modeSource = source;
+    state.modeReason = reason?.trim() || undefined;
+
+    switch (mode) {
+      case "idle":
+        state.modeSource = "idle";
+        state.modeReason = undefined;
+        state.autoOrch = false;
+        state.planMode = false;
+        state.role = "general";
+        state.stage = undefined;
+        state.workflow = undefined;
+        break;
+      case "code":
+        state.autoOrch = false;
+        state.planMode = false;
+        state.role = "code";
+        state.stage = undefined;
+        state.workflow = undefined;
+        break;
+      case "review":
+        state.autoOrch = false;
+        state.planMode = true;
+        state.launchMode = "manual";
+        state.role = "review";
+        state.stage = undefined;
+        state.workflow = undefined;
+        break;
+      case "orchestrate":
+        state.autoOrch = true;
+        state.planMode = true;
+        state.role = "orchestrator";
+        state.stage = hasGenesis ? "build" : "genesis";
+        state.workflow = hasGenesis ? "vibe-build" : "vibe-genesis";
+        break;
+      case "genesis":
+      case "design":
+      case "build":
+        setStageAndWorkflow(state, mode);
+        state.autoOrch = mode === "build";
+        state.planMode = mode !== "build";
+        break;
+    }
 
-  pi.registerShortcut("alt+n", {
-    description: "Show native subagent navigation hint",
-    handler: async (ctx) => {
-      ctx.ui.notify("Native subagent results are shown inline by Pi; use the transcript/tool expansion instead of Takomi focus cycling.", "info");
-    },
-  });
+    persistState();
+    syncContextPanelState();
+    await refreshUi(ctx, state);
+    const label = state.modeSource === "idle" ? "idle" : `${state.modeSource}:${state.stage ?? state.role}`;
+    return `Takomi mode set to ${label}${state.modeReason ? ` (${state.modeReason})` : ""}.`;
+  }
 
-  pi.registerShortcut("alt+p", {
-    description: "Show native subagent navigation hint",
-    handler: async (ctx) => {
-      ctx.ui.notify("Native subagent results are shown inline by Pi; use the transcript/tool expansion instead of Takomi focus cycling.", "info");
+  pi.registerTool({
+    name: "takomi_mode",
+    label: "Takomi Mode",
+    description: "Set or clear the visible Takomi runtime mode after the active model decides a task benefits from code, review, lifecycle, or orchestration handling.",
+    promptSnippet: "Optional: call takomi_mode when you decide the current request should visibly enter Takomi code/review/orchestration/lifecycle mode. Do not call it for normal creative/general conversation. Use mode=idle to clear Takomi mode.",
+    promptGuidelines: [
+      "Let the user's request drive the choice; do not switch modes just because a vague word like code/review/build appears alone.",
+      "Prefer mode=code for direct coding in the current chat, mode=orchestrate only for broad/multi-step durable work, and mode=review for critique/audit/QA.",
+      "Use mode=idle when the user asks normal non-coding/non-Takomi questions and Takomi should get out of the way.",
+    ],
+    parameters: Type.Object({
+      mode: TakomiModeSchema,
+      reason: Type.Optional(Type.String({ description: "Short human-readable reason for the switch" })),
+    }),
+    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 },
+      };
     },
   });
 
@@ -1007,6 +1066,12 @@ ${stateJson}`
           }
         }
         sessionState.tasks[idx] = nextTask;
+        state.activeSessionId = params.sessionId;
+        state.modeSource = state.modeSource === "idle" ? "board" : state.modeSource;
+        state.modeReason = state.modeReason ?? "board task update";
+        persistState();
+        syncContextPanelState();
+        await refreshUi(ctx, state);
         const nextState = buildSessionState(
           sessionState.sessionId,
           sessionState.title,
@@ -1062,8 +1127,11 @@ ${stateJson}`
           }
         }
         state.activeSessionId = nextState.sessionId;
+        state.modeSource = "board";
+        state.modeReason = `expanded ${params.stage} stage`;
         persistState();
         syncContextPanelState();
+        await refreshUi(ctx, state);
 
         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)}` }],
@@ -1104,8 +1172,11 @@ ${stateJson}`
       state.role = "orchestrator";
       state.stage = nextState.lifecycle.genesis.status === "completed" ? "build" : "genesis";
       state.workflow = state.stage === "genesis" ? "vibe-genesis" : "vibe-build";
+      state.modeSource = "board";
+      state.modeReason = "orchestrator session";
       persistState();
       syncContextPanelState();
+      await refreshUi(ctx, state);
 
       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."}` }],
@@ -1152,11 +1223,15 @@ ${stateJson}`
 
     if (lowered === "use takomi") {
       state.enabled = true;
+      state.modeSource = "manual";
+      state.modeReason = "explicit user request";
       return { action: "transform", text: "Use the Takomi runtime, identify the correct lifecycle stage, and proceed accordingly." };
     }
 
     if (lowered.startsWith("use takomi ")) {
       state.enabled = true;
+      state.modeSource = "manual";
+      state.modeReason = "explicit user request";
       const route = decideRoute(text.slice("use takomi ".length));
       if (route.stage) setStageAndWorkflow(state, route.stage, { preserveRole: state.role === "orchestrator" && route.stage === "genesis" });
       else if (route.role !== "general") state.role = route.role;
@@ -1164,14 +1239,20 @@ ${stateJson}`
     }
 
     if (/\bvibe genesis\b/i.test(text)) {
+      state.modeSource = "manual";
+      state.modeReason = "vibe genesis";
       setStageAndWorkflow(state, "genesis", { preserveRole: state.role === "orchestrator" });
       return { action: "transform", text };
     }
     if (/\bvibe design\b/i.test(text)) {
+      state.modeSource = "manual";
+      state.modeReason = "vibe design";
       setStageAndWorkflow(state, "design");
       return { action: "transform", text };
     }
     if (/\bvibe build\b/i.test(text)) {
+      state.modeSource = "manual";
+      state.modeReason = "vibe build";
       setStageAndWorkflow(state, "build");
       return { action: "transform", text };
     }
@@ -1180,43 +1261,36 @@ ${stateJson}`
   });
 
   pi.on("before_agent_start", async (event, ctx) => {
-    if (!state.enabled) return;
+    if (!state.enabled || (state.modeSource ?? "idle") === "idle") return;
 
     let effectiveState = cloneState(state);
     const runtimeCwd = ctx.cwd;
     const genesisExists = await hasGenesisArtifacts(runtimeCwd);
     const route = decideRoute(event.prompt);
-    if (state.autoOrch && shouldAutoRoute(event.prompt)) {
-      effectiveState.role = "orchestrator";
-      effectiveState.stage = genesisExists ? "build" : "genesis";
-      effectiveState.workflow = genesisExists ? "vibe-build" : "vibe-genesis";
-    }
-
-    const shouldHonorRoute = route.stage || route.role !== "general" || route.sessionRecommendation !== "none";
-    if (shouldHonorRoute && route.stage) {
-      effectiveState.stage = route.stage;
-      effectiveState.workflow = route.workflow;
-      effectiveState.role = effectiveState.role === "orchestrator" && route.stage === "genesis" ? "orchestrator" : route.role;
-    } else if (shouldHonorRoute && route.role !== "general") {
-      effectiveState.role = route.role;
-    }
-
-    let routingNote = route.reason;
+    let routingNote = state.modeReason
+      ? `Takomi mode selected by ${state.modeSource}: ${state.modeReason}.`
+      : `Takomi mode selected by ${state.modeSource ?? "runtime"}.`;
     const explicitLifecycleWaiver = /skip genesis|waive genesis|genesis complete|already have (a )?(prd|requirements)|design complete|jump straight to build/i.test(event.prompt);
-    const orchestrationActive = effectiveState.role === "orchestrator" || route.executionMode === "orchestrate";
+    const orchestrationActive = effectiveState.role === "orchestrator";
     if (!genesisExists && orchestrationActive && !explicitLifecycleWaiver) {
       effectiveState.stage = "genesis";
       effectiveState.workflow = "vibe-genesis";
       routingNote = "Blank project detected; orchestrator remains in control and must honor Genesis → Design → Build.";
     }
+    if (effectiveState.stage !== state.stage || effectiveState.workflow !== state.workflow || effectiveState.role !== state.role) {
+      state.role = effectiveState.role;
+      state.stage = effectiveState.stage;
+      state.workflow = effectiveState.workflow;
+    }
 
     const promptKey = `${effectiveState.role}:${effectiveState.workflow ?? "none"}`;
     const includeFullWorkflow = Boolean(effectiveState.workflow && effectiveState.lastFullPromptKey !== promptKey);
     if (includeFullWorkflow) {
       state.lastFullPromptKey = promptKey;
-      persistState();
-      syncContextPanelState();
     }
+    persistState();
+    syncContextPanelState();
+    await refreshUi(ctx, state);
 
     const routingPolicy = await resolveTakomiRoutingPolicy(runtimeCwd);
     const optionalFeatureContext = (() => {
@@ -1263,14 +1337,14 @@ ${stateJson}`
       `Execution mode: ${route.executionMode}. Session recommendation: ${route.sessionRecommendation}.`,
       `Takomi execution gate: ${effectiveState.launchMode === "manual" ? "review" : "auto"}. In review gate mode, show the delegation plan before launching and return to the user after each task with results, verification guidance, and the recommended next step.`,
       !effectiveState.subagentsEnabled ? "Takomi subagents are disabled for this session. Do not call takomi_subagent or subagent until the user enables subagents." : "",
-      !genesisExists ? "Project foundation is missing or incomplete. Do not skip Genesis unless the user explicitly waives it." : "",
-      "Takomi is the default orchestration mindset here. Do not wait for the literal phrase 'use Takomi' before applying lifecycle judgment.",
-      "Task fan-out is flexible. Do not force exactly three tasks; decompose Genesis, Design, and Build work to fit the actual scope.",
-      "A new orchestration session should usually begin with one Genesis foundation task that creates or updates the required markdown artifacts, then expand later stages only when the scope justifies it.",
-      "If a follow-up request is small, one-shot it. If it is multi-part or large, create or expand an orchestration session instead of pretending it is a single task.",
+      orchestrationActive && !genesisExists ? "Project foundation is missing or incomplete. Do not skip Genesis unless the user explicitly waives it." : "",
+      "Do not escalate to orchestration or review just because this is coding-related; stay in the selected Takomi mode unless the user asks or a durable board/session is genuinely needed.",
+      orchestrationActive ? "Task fan-out is flexible. Do not force exactly three tasks; decompose Genesis, Design, and Build work to fit the actual scope." : "",
+      orchestrationActive ? "A new orchestration session should usually begin with one Genesis foundation task that creates or updates the required markdown artifacts, then expand later stages only when the scope justifies it." : "",
+      orchestrationActive ? "If a follow-up request is small, one-shot it. If it is multi-part or large, create or expand an orchestration session instead of pretending it is a single task." : "",
       "Before any Takomi subagent dispatch or model override, use the injected Pi model-registry context and project routing policy. Prefer provider-qualified model IDs. Do not run `pi --list-models` unless the registry context is missing or the user asks for a visible diagnostic.",
-      "When useful, state the current Takomi stage and the recommended next stage.",
-      effectiveState.stage === "build"
+      "When useful, state the current Takomi mode/stage and the recommended next step.",
+      orchestrationActive && effectiveState.stage === "build"
         ? "For build orchestration, use takomi_subagent to dispatch work to specialist subagents, then record the result on takomi_board; reuse the same conversation id when sending fixes back to the agent."
         : "",
     ].filter(Boolean);

package/.pi/extensions/takomi-runtime/model-routing-defaults.ts

@@ -11,6 +11,8 @@ import {
 } from "./routing-policy";
 
 export const TAKOMI_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+const PROJECT_TAKOMI_POLICY_ROOT_RELATIVE = path.join(".pi", "takomi");
+const MAX_POLICY_BYTES = 128 * 1024;
 
 type Settings = {
   takomi?: { modelRoutingPolicyFile?: string };
@@ -140,6 +142,8 @@ function collectModelsFromPolicy(text: string): string[] {
 
 function readPolicyTextSync(filePath: string): string | undefined {
   try {
+    const info = fs.statSync(filePath);
+    if (!info.isFile() || info.size > MAX_POLICY_BYTES) return undefined;
     const text = fs.readFileSync(filePath, "utf8").trim();
     return text || undefined;
   } catch {
@@ -147,18 +151,44 @@ function readPolicyTextSync(filePath: string): string | undefined {
   }
 }
 
+function isPathInside(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+function resolveSafeProjectPolicyPathSync(cwd: string, configured: string): string | undefined {
+  if (!configured) return undefined;
+
+  const projectPolicyRoot = path.resolve(cwd, PROJECT_TAKOMI_POLICY_ROOT_RELATIVE);
+  const resolvedPath = path.isAbsolute(configured) ? path.resolve(configured) : path.resolve(cwd, configured);
+  if (!isPathInside(projectPolicyRoot, resolvedPath)) return undefined;
+
+  try {
+    const realCwd = fs.realpathSync(cwd);
+    const realRoot = fs.realpathSync(projectPolicyRoot);
+    const realFile = fs.realpathSync(resolvedPath);
+    if (!isPathInside(realCwd, realRoot)) return undefined;
+    if (!isPathInside(realRoot, realFile)) return undefined;
+    return realFile;
+  } catch {
+    return resolvedPath;
+  }
+}
+
 function resolvePolicySync(cwd: string): { policyPath?: string; text?: string } {
   const projectSettings = readSettingsFileSync(path.join(cwd, PROJECT_PI_SETTINGS_RELATIVE));
   const projectTakomi = asRecord(projectSettings.takomi);
   const configuredProject = typeof projectTakomi.modelRoutingPolicyFile === "string"
     ? projectTakomi.modelRoutingPolicyFile
     : TAKOMI_ROUTING_POLICY_RELATIVE;
-  const configuredProjectPath = path.isAbsolute(configuredProject) ? configuredProject : path.join(cwd, configuredProject);
-  const configuredProjectText = readPolicyTextSync(configuredProjectPath);
-  if (configuredProjectText) return { policyPath: configuredProjectPath, text: configuredProjectText };
+  const configuredProjectPath = resolveSafeProjectPolicyPathSync(cwd, configuredProject);
+  if (configuredProjectPath) {
+    const configuredProjectText = readPolicyTextSync(configuredProjectPath);
+    if (configuredProjectText) return { policyPath: configuredProjectPath, text: configuredProjectText };
+  }
 
-  const defaultProjectPath = path.join(cwd, TAKOMI_ROUTING_POLICY_RELATIVE);
-  if (path.resolve(defaultProjectPath) !== path.resolve(configuredProjectPath)) {
+  const defaultProjectPath = resolveSafeProjectPolicyPathSync(cwd, TAKOMI_ROUTING_POLICY_RELATIVE);
+  if (defaultProjectPath && path.resolve(defaultProjectPath) !== path.resolve(configuredProjectPath ?? "")) {
     const defaultProjectText = readPolicyTextSync(defaultProjectPath);
     if (defaultProjectText) return { policyPath: defaultProjectPath, text: defaultProjectText };
   }

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

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -14,6 +14,8 @@ export const BUNDLED_TAKOMI_ROUTING_POLICY_PATH = path.resolve(
   "takomi",
   "model-routing.md",
 );
+const PROJECT_TAKOMI_POLICY_ROOT_RELATIVE = path.join(".pi", "takomi");
+const MAX_POLICY_BYTES = 128 * 1024;
 
 export type RoutingPolicyInstallResult = {
   policyPath: string;
@@ -56,6 +58,8 @@ async function readJsonObject(filePath: string): Promise<JsonObject> {
 
 async function readPolicyText(filePath: string): Promise<string | undefined> {
   try {
+    const info = await stat(filePath);
+    if (!info.isFile() || info.size > MAX_POLICY_BYTES) return undefined;
     const text = (await readFile(filePath, "utf8")).trim();
     return text || undefined;
   } catch {
@@ -63,6 +67,28 @@ async function readPolicyText(filePath: string): Promise<string | undefined> {
   }
 }
 
+function isPathInside(root: string, candidate: string): boolean {
+  const relative = path.relative(root, candidate);
+  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+
+async function resolveSafeProjectPolicyPath(cwd: string, configured: string): Promise<string | undefined> {
+  if (!configured) return undefined;
+
+  const projectPolicyRoot = path.resolve(cwd, PROJECT_TAKOMI_POLICY_ROOT_RELATIVE);
+  const resolvedPath = path.isAbsolute(configured) ? path.resolve(configured) : path.resolve(cwd, configured);
+  if (!isPathInside(projectPolicyRoot, resolvedPath)) return undefined;
+
+  try {
+    const [realCwd, realRoot, realFile] = await Promise.all([realpath(cwd), realpath(projectPolicyRoot), realpath(resolvedPath)]);
+    if (!isPathInside(realCwd, realRoot)) return undefined;
+    if (!isPathInside(realRoot, realFile)) return undefined;
+    return realFile;
+  } catch {
+    return resolvedPath;
+  }
+}
+
 function extractQuotedPolicy(text: string): string {
   const triple = text.match(/"""([\s\S]*?)"""|```(?:\w+)?\s*([\s\S]*?)```/);
   const raw = (triple?.[1] ?? triple?.[2] ?? text).trim();
@@ -133,14 +159,16 @@ export async function resolveTakomiRoutingPolicy(cwd: string): Promise<ResolvedR
   const configuredProject = typeof projectTakomi.modelRoutingPolicyFile === "string"
     ? projectTakomi.modelRoutingPolicyFile
     : TAKOMI_ROUTING_POLICY_RELATIVE;
-  const configuredProjectPath = path.isAbsolute(configuredProject) ? configuredProject : path.join(cwd, configuredProject);
-  const configuredProjectText = await readPolicyText(configuredProjectPath);
-  if (configuredProjectText) {
-    return { source: "project", policyPath: configuredProjectPath, text: configuredProjectText };
+  const configuredProjectPath = await resolveSafeProjectPolicyPath(cwd, configuredProject);
+  if (configuredProjectPath) {
+    const configuredProjectText = await readPolicyText(configuredProjectPath);
+    if (configuredProjectText) {
+      return { source: "project", policyPath: configuredProjectPath, text: configuredProjectText };
+    }
   }
 
-  const defaultProjectPath = path.join(cwd, TAKOMI_ROUTING_POLICY_RELATIVE);
-  if (path.resolve(defaultProjectPath) !== path.resolve(configuredProjectPath)) {
+  const defaultProjectPath = await resolveSafeProjectPolicyPath(cwd, TAKOMI_ROUTING_POLICY_RELATIVE);
+  if (defaultProjectPath && path.resolve(defaultProjectPath) !== path.resolve(configuredProjectPath ?? "")) {
     const defaultProjectText = await readPolicyText(defaultProjectPath);
     if (defaultProjectText) {
       return { source: "project", policyPath: defaultProjectPath, text: defaultProjectText };