takomi 2.1.34 → 2.1.36

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

@@ -92,6 +92,73 @@ let activeSubagentLabel: string | undefined;
 let activeSubagentAgent: string | undefined;
 let activeSubagentTask: string | undefined;
 let activeSubagentStatus: string | undefined;
+let delayedPiVersionCheckStarted = false;
+
+const PI_LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
+
+function parseVersionParts(version: string): number[] | undefined {
+  const core = version.trim().replace(/^v/, "").split("-")[0];
+  if (!/^\d+(?:\.\d+)*$/.test(core)) return undefined;
+  return core.split(".").map((part) => Number.parseInt(part, 10) || 0);
+}
+
+function isNewerVersion(candidate: string, current: string): boolean {
+  const left = parseVersionParts(candidate);
+  const right = parseVersionParts(current);
+  if (!left || !right) return candidate.trim() !== current.trim();
+  for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+    const a = left[i] ?? 0;
+    const b = right[i] ?? 0;
+    if (a > b) return true;
+    if (a < b) return false;
+  }
+  return false;
+}
+
+async function readCurrentPiVersion(): Promise<string | undefined> {
+  const candidates = [
+    path.resolve(path.dirname(process.argv[1] ?? ""), "..", "package.json"),
+    path.resolve(path.dirname(process.argv[1] ?? ""), "package.json"),
+  ];
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(await readFile(candidate, "utf8")) as { name?: string; version?: string };
+      if (parsed.name === "@earendil-works/pi-coding-agent" && typeof parsed.version === "string") return parsed.version;
+    } catch { }
+  }
+  return undefined;
+}
+
+function scheduleDelayedPiVersionCheck(ctx: ExtensionContext): void {
+  if (delayedPiVersionCheckStarted) return;
+  if (process.env.TAKOMI_DELAYED_PI_VERSION_CHECK !== "1") return;
+  if (process.env.TAKOMI_SKIP_DELAYED_PI_VERSION_CHECK === "1" || process.env.PI_OFFLINE === "1") return;
+  delayedPiVersionCheckStarted = true;
+
+  const delayMs = Math.max(0, Number(process.env.TAKOMI_PI_VERSION_CHECK_DELAY_MS || 3000) || 3000);
+  const timeoutMs = Math.max(500, Number(process.env.TAKOMI_PI_VERSION_CHECK_TIMEOUT_MS || 2500) || 2500);
+  setTimeout(() => {
+    void (async () => {
+      try {
+        const currentVersion = await readCurrentPiVersion();
+        if (!currentVersion) return;
+        const response = await fetch(PI_LATEST_VERSION_URL, {
+          headers: { accept: "application/json", "user-agent": `takomi-delayed-pi-version-check/${currentVersion}` },
+          signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) return;
+        const data = await response.json() as { version?: unknown; note?: unknown };
+        if (typeof data.version !== "string" || !isNewerVersion(data.version, currentVersion)) return;
+        if (ctx.hasUI) {
+          const note = typeof data.note === "string" && data.note.trim() ? ` ${data.note.trim()}` : "";
+          ctx.ui.notify(`Pi ${data.version} is available (installed: ${currentVersion}). Run: takomi refresh pi.${note}`, "info");
+        }
+      } catch {
+        // Best-effort only. Delayed version checks must never affect startup or usage.
+      }
+    })();
+  }, delayMs).unref?.();
+}
 
 const ThinkingSchema = Type.Union([
   Type.Literal("off"),
@@ -821,7 +888,6 @@ export default function takomiRuntime(pi: ExtensionAPI) {
       case "review":
         state.autoOrch = false;
         state.planMode = true;
-        state.launchMode = "manual";
         state.role = "review";
         state.stage = undefined;
         state.workflow = undefined;
@@ -1365,6 +1431,7 @@ ${stateJson}`
 
   pi.on("session_start", async (_event, ctx) => {
     runtimeCtx = ctx;
+    scheduleDelayedPiVersionCheck(ctx);
     activeProfile = await loadTakomiProfile(ctx.cwd);
     activeSubagentLabel = undefined;
     activeSubagentAgent = undefined;

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 };

package/.pi/extensions/takomi-runtime/takomi-stats.js

@@ -1,4 +1,5 @@
-import { promises as fs } from 'node:fs';
+import { createReadStream, promises as fs } from 'node:fs';
+import readline from 'node:readline';
 import os from 'os';
 import path from 'path';
 
@@ -120,8 +121,14 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
   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: [] };
-    const text = await fs.readFile(file, 'utf8').catch(() => '');
-    for (const line of text.split(/\r?\n/)) {
+    let lines;
+    try {
+      lines = readline.createInterface({ input: createReadStream(file, { encoding: 'utf8' }), crlfDelay: Infinity });
+    } catch {
+      continue;
+    }
+    try {
+      for await (const line of lines) {
       const obj = safeJson(line); if (!obj) continue;
       if (obj.timestamp) { row.start ||= obj.timestamp; row.end = obj.timestamp; addTimestamp(row.activityTimestamps, obj.timestamp); }
       if (obj.type === 'session') { session = obj.id || session; cwd = obj.cwd || cwd; row.key = session; row.session = session; row.cwd = cwd; }
@@ -164,6 +171,9 @@ 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) });
+      }
+    } catch {
+      continue;
     }
     pushTask(taskRows, currentTask);
     row.activeMs = activeDuration(row.activityTimestamps);

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

@@ -81,9 +81,9 @@ export function renderRuntimeStatus(theme: Theme, state: RuntimeHudState): strin
   const sourceLabel = source === "manual" ? theme.fg("warning", "manual") : theme.fg("success", source);
   const role = state.stage && state.role !== state.stage ? theme.fg("dim", state.role) : "";
   const plan = state.planMode ? theme.fg("warning", "plan") : theme.fg("dim", "direct");
-  const gate = state.launchMode === "manual" ? theme.fg("warning", "review-gate") : "";
+  const gate = state.launchMode === "manual" ? theme.fg("warning", "review-gate") : theme.fg("success", "auto-gate");
   const subagents = state.subagentsEnabled === false ? theme.fg("error", "subagents:off") : "";
-  return [theme.fg("accent", "Takomi"), sourceLabel, stageBadge, role, gate || plan, subagents].filter(Boolean).join(" ");
+  return [theme.fg("accent", "Takomi"), sourceLabel, stageBadge, role, gate, plan, subagents].filter(Boolean).join(" ");
 }
 
 export function renderRuntimeWidget(theme: Theme, state: RuntimeHudState): string[] {
@@ -95,7 +95,7 @@ export function renderRuntimeWidget(theme: Theme, state: RuntimeHudState): strin
     sourceLabel,
     badge(theme, primary, stageTone(state.stage)),
     state.stage && state.role !== state.stage ? theme.fg("dim", `role:${state.role}`) : "",
-    state.launchMode === "manual" ? theme.fg("warning", "review-gate") : "",
+    state.launchMode === "manual" ? theme.fg("warning", "review-gate") : theme.fg("success", "auto-gate"),
     state.planMode ? theme.fg("warning", "plan") : theme.fg("dim", "direct"),
     state.subagentsEnabled === false ? theme.fg("error", "subagents:off") : theme.fg("dim", "subagents:on"),
     state.workflow ? theme.fg("dim", `wf:${state.workflow}`) : "",

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

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { renderTakomiSubagentCall, renderTakomiSubagentResult } from "./native-render";
+import { loadPiSubagentsInternals } from "./pi-subagents-internal";
 import { executeTakomiSubagentTool } from "./tool-runner";
 
 const ChecklistItemSchema = Type.Object({
@@ -47,8 +48,8 @@ const SubagentParameters = Type.Object({
   clarify: Type.Optional(Type.Boolean({ description: "Show the native pi-subagents TUI to preview/edit before execution. Especially useful for chains; requires an interactive Pi TUI." })),
   chain: Type.Optional(Type.Array(TaskSchema, { description: "Sequential chain of subagent tasks" })),
   agentScope: Type.Optional(Type.Union([Type.Literal("user"), Type.Literal("project"), Type.Literal("both")])),
-  confirmProjectAgents: Type.Optional(Type.Boolean({ description: "Prompt before running project-local agents. Default: true." })),
-  overrideUserBlock: Type.Optional(Type.Boolean({ description: "Only set true when the user explicitly approves retrying after a blocked/cancelled/review-gated launch." })),
+  // Project-agent confirmation and hard-stop overrides are enforced server-side;
+  // they are intentionally not model-callable parameters.
 });
 
 function registerSubagentTool(pi: ExtensionAPI): void {
@@ -63,7 +64,7 @@ function registerSubagentTool(pi: ExtensionAPI): void {
       "Set clarify=true when the user asks to preview/edit a subagent run in the native Pi TUI before launch.",
       "Use model, fallbackModels, and thinking only when deliberate; otherwise let the agent/profile defaults apply.",
       "If review sends work back to the same agent, reuse the same conversationId for continuity.",
-      "If a launch is blocked, cancelled, paused, or review-gated, do not retry automatically; wait for the user's next prompt. Use overrideUserBlock only after explicit user approval.",
+      "If a launch is blocked, cancelled, paused, or review-gated, do not retry automatically; wait for the user's next prompt."
     ],
     parameters: SubagentParameters,
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
@@ -74,6 +75,11 @@ function registerSubagentTool(pi: ExtensionAPI): void {
   });
 }
 
-export default function takomiSubagents(pi: ExtensionAPI) {
+export default async function takomiSubagents(pi: ExtensionAPI) {
+  // Preload the native pi-subagents renderer before tool registration. Rendering
+  // callbacks are synchronous, so if we only lazy-load internals during execution
+  // a completed takomi_subagent result can fall back to Takomi's plain text
+  // renderer and lose the native compact/expanded details shown by `subagent`.
+  await loadPiSubagentsInternals();
   registerSubagentTool(pi);
 }

package/.pi/extensions/takomi-subagents/native-render.ts

@@ -38,28 +38,148 @@ function resultText(result: ToolResult): string {
       : JSON.stringify((result as any)?.details ?? {}, null, 2);
 }
 
-function summarizeCollapsedResult(text: string, status: string, theme: Theme): string {
+function extractPolicyNames(text: string): string[] {
   const policyMatch = text.match(/Required policies:\n((?:- .+\n?)+)/);
-  const policies = policyMatch?.[1]
+  return policyMatch?.[1]
     ?.split("\n")
     .map((line) => line.replace(/^[-\s]+/, "").trim())
     .filter(Boolean) ?? [];
+}
+
+function summarizeCollapsedResult(text: string, status: string, theme: Theme): string {
+  const policies = extractPolicyNames(text);
   const lineCount = text ? text.split(/\r?\n/).length : 0;
   const label = policies.length > 0
     ? `policy context loaded: ${policies.join(", ")}`
     : `${lineCount} result line${lineCount === 1 ? "" : "s"} hidden`;
-  const icon = status === "failed" ? "⚠" : "✓";
-  const color = status === "failed" ? "warning" : "success";
+  const icon = status === "failed" ? "⚠" : status === "running" ? "…" : "✓";
+  const color = status === "failed" ? "warning" : status === "running" ? "accent" : "success";
   return `${theme.fg(color, `${icon} takomi_subagent ${status}`)}${theme.fg("dim", ` · ${label} (ctrl+o to expand)`)}`;
 }
 
+function isPolicyGateBlock(text: string): boolean {
+  return /^Blocked\s+takomi_subagent:\s+required policy context had not been loaded yet\./m.test(text)
+    && /\nRequired policies:\n/.test(text)
+    && /\nLoaded policy context:\n/.test(text);
+}
+
+function renderPolicyGateBlock(text: string, expanded: boolean | undefined, theme: Theme): string {
+  const policies = extractPolicyNames(text);
+  const lineCount = text ? text.split(/\r?\n/).length : 0;
+  const policyLabel = policies.length ? policies.join(", ") : "required policy";
+  if (!expanded) {
+    return [
+      theme.fg("warning", "⚠ takomi_subagent blocked"),
+      theme.fg("dim", `Required policy context loaded for this session: ${policyLabel}.`),
+      theme.fg("dim", `Retry the original tool call. ${lineCount} policy lines hidden (ctrl+o to expand).`),
+    ].join("\n");
+  }
+  return [
+    theme.fg("warning", "⚠ takomi_subagent blocked"),
+    theme.fg("dim", "Policy context was loaded and passed back to the model; retry the original call."),
+    theme.fg("dim", "Press ctrl+o again to collapse."),
+    "",
+    text,
+  ].join("\n");
+}
+
+function recentOutputLines(value: unknown): string[] {
+  if (Array.isArray(value)) return value.map(String).filter(Boolean).slice(-3);
+  if (typeof value === "string") return value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-3);
+  return [];
+}
+
+function normalizeLiveStatus(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  if (value === "complete") return "completed";
+  if (value === "in-progress") return "running";
+  if (value === "timed-out") return "failed";
+  return value;
+}
+
+function rawLiveStatus(row: any): string {
+  const explicit = normalizeLiveStatus(
+    typeof row?.progress?.status === "string" ? row.progress.status
+      : typeof row?.status === "string" ? row.status
+        : undefined,
+  );
+  if (explicit) return explicit;
+
+  const exitCode = typeof row?.exitCode === "number" ? row.exitCode
+    : typeof row?.code === "number" ? row.code
+      : undefined;
+  if (exitCode === 0) return "completed";
+  if (exitCode === undefined || exitCode === null || exitCode === -1) return "running";
+  return "failed";
+}
+
+function isLiveTerminalStatus(status: string): boolean {
+  return ["completed", "failed", "blocked", "detached", "paused"].includes(status);
+}
+
+function displayLiveStatus(status: string, allRowsTerminal: boolean): string {
+  // Native pi-subagents can emit one last partial update after the child process
+  // reaches exitCode 0 but before the takomi_subagent tool result has actually
+  // settled. In that window the tool card is still partial/running, so showing a
+  // child as "completed" is misleading. Call it finalizing until Pi renders the
+  // real final result.
+  if (allRowsTerminal && status === "completed") return "finalizing";
+  return status;
+}
+
+function livePartialText(result: ToolResult, theme: Theme): string {
+  const details = (result as any)?.details ?? {};
+  const results = Array.isArray(details.results) ? details.results : [];
+  const progress = Array.isArray(details.progress) ? details.progress : [];
+  const rows = results.length ? results : progress;
+  const rawStatuses = rows.map(rawLiveStatus);
+  const allRowsTerminal = rows.length > 0 && rawStatuses.every(isLiveTerminalStatus);
+  const titleStatus = allRowsTerminal ? "finalizing" : "running";
+  const lines = [
+    theme.fg("toolTitle", theme.bold(`takomi_subagent ${titleStatus}`)),
+    theme.fg("dim", "Live detail is bounded while streaming so manual scroll/ctrl+o does not jump on every token."),
+  ];
+
+  if (!rows.length) {
+    const text = resultText(result).split(/\r?\n/).find((line) => line.trim())?.trim();
+    lines.push(theme.fg("dim", text || "Waiting for subagent progress…"));
+    return lines.join("\n");
+  }
+
+  rows.slice(0, 6).forEach((row: any, index: number) => {
+    const status = displayLiveStatus(rawStatuses[index] ?? rawLiveStatus(row), allRowsTerminal);
+    const agent = row.agent ?? `task ${index + 1}`;
+    const task = String(row.task ?? "").replace(/\s+/g, " ").trim();
+    const currentTool = row.currentTool ?? row.progress?.currentTool;
+    const tokens = row.tokens ?? row.progress?.tokens ?? row.usage?.output;
+    const tail = recentOutputLines(row.recentOutput ?? row.progress?.recentOutput ?? row.finalOutput ?? row.output);
+    lines.push(theme.fg("accent", `${index + 1}. ${agent} ${theme.fg("dim", `[${status}]`)}`));
+    if (task) lines.push(theme.fg("dim", `   ${task.slice(0, 140)}${task.length > 140 ? "…" : ""}`));
+    if (currentTool || tokens) lines.push(theme.fg("muted", `   ${[currentTool ? `tool:${currentTool}` : "", tokens ? `tokens:${tokens}` : ""].filter(Boolean).join(" | ")}`));
+    for (const line of tail) lines.push(theme.fg("dim", `   › ${line.slice(0, 160)}${line.length > 160 ? "…" : ""}`));
+  });
+  if (rows.length > 6) lines.push(theme.fg("muted", `… ${rows.length - 6} more running item${rows.length - 6 === 1 ? "" : "s"}`));
+  lines.push(theme.fg("muted", "Final output will use the normal expandable native subagent renderer."));
+  return lines.join("\n");
+}
+
 export function renderTakomiSubagentResult(result: ToolResult, options: { expanded?: boolean; isPartial?: boolean }, theme: Theme, context: any): any {
+  const status = ((result as any)?.isError || context?.isError) ? "failed" : options.isPartial ? "running" : "completed";
+  const text = resultText(result);
+
+  if (isPolicyGateBlock(text)) {
+    return new Text(renderPolicyGateBlock(text, options.expanded, theme), 0, 0);
+  }
+
+  if (options.isPartial) {
+    if (options.expanded) return new Text(livePartialText(result, theme), 0, 0);
+    return new Text(summarizeCollapsedResult(text, status, theme), 0, 0);
+  }
+
   const native = renderNativeSubagentResult(result, options, theme, context);
   if (native) return native;
 
-  const status = (result as any)?.isError ? "failed" : "completed";
-  const text = resultText(result);
-  if (!options.expanded && !options.isPartial) {
+  if (!options.expanded) {
     return new Text(summarizeCollapsedResult(text, status, theme), 0, 0);
   }
   return new Text(`${theme.fg("toolTitle", theme.bold(`takomi_subagent ${status}`))}\n${text || "No result content."}`, 0, 0);