takomi 2.1.44 → 2.1.45

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

@@ -1,14 +1,30 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { initializeTakomiAsyncLifecycle, resetTakomiAsyncLifecycle } from "./async-lifecycle";
+import {
+  clearDetachedResults,
+  initializeDetachedSession,
+  registerDetachedCompletionNotifications,
+} from "./detached-results";
 import { renderTakomiSubagentCall, renderTakomiSubagentResult } from "./native-render";
 import { loadPiSubagentsInternals } from "./pi-subagents-internal";
-import { executeTakomiSubagentTool } from "./tool-runner";
+import { clearAllTakomiSubagentResultHeartbeats } from "./result-heartbeat";
+import { executeTakomiSubagentTool, invalidateTakomiPiSubagentsEngine, type TakomiAcceptanceInput } from "./tool-runner";
 
 const ChecklistItemSchema = Type.Object({
   text: Type.String(),
   done: Type.Optional(Type.Boolean()),
 });
 
+const AcceptanceSchema = Type.Unsafe<TakomiAcceptanceInput>({
+  anyOf: [
+    { type: "string", enum: ["auto", "none", "attested", "checked", "verified", "reviewed"] },
+    { type: "boolean", enum: [false] },
+    { type: "object", additionalProperties: true },
+  ],
+  description: "Optional explicit acceptance policy. Omitted Takomi tasks do not enforce acceptance; explicit contracts are forwarded to pi-subagents.",
+});
+
 const ThinkingSchema = Type.Union([
   Type.Literal("off"),
   Type.Literal("minimal"),
@@ -29,6 +45,7 @@ const TaskSchema = Type.Object({
   conversationId: Type.Optional(Type.String()),
   cwd: Type.Optional(Type.String()),
   checklist: Type.Optional(Type.Array(Type.Union([Type.String(), ChecklistItemSchema]))),
+  acceptance: Type.Optional(AcceptanceSchema),
 });
 
 const ContextSchema = Type.Union([
@@ -58,6 +75,7 @@ const SubagentParameters = Type.Object({
   conversationId: Type.Optional(Type.String({ description: "Persistent conversation id to resume the same subagent session" })),
   cwd: Type.Optional(Type.String({ description: "Working directory override" })),
   checklist: Type.Optional(Type.Array(Type.Union([Type.String(), ChecklistItemSchema]), { description: "Optional checklist for the subagent" })),
+  acceptance: Type.Optional(AcceptanceSchema),
   tasks: Type.Optional(Type.Array(TaskSchema, { description: "Parallel subagent tasks" })),
   confirmLaunch: Type.Optional(Type.Boolean({ description: "Required to launch immediately in manual Takomi launch mode" })),
   previewOnly: Type.Optional(Type.Boolean({ description: "Return the delegation plan without launching" })),
@@ -108,5 +126,32 @@ export default async function takomiSubagents(pi: ExtensionAPI) {
   // 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();
+  // A same-process Takomi reload reuses the ExtensionAPI identity, so explicitly
+  // discard the cached engine before replacing its lifecycle generation.
+  invalidateTakomiPiSubagentsEngine(pi);
+  const cleanupAsyncLifecycle = await initializeTakomiAsyncLifecycle(pi);
   registerSubagentTool(pi);
+
+  // Replace native completion notification through pi-subagents' own reload-safe
+  // registration slot. The shared renderer and dedupe key remain authoritative;
+  // Takomi enriches the single native notice without adding polling or timers.
+  const unregisterCompletionNotifications = registerDetachedCompletionNotifications(pi);
+
+  // Tool rows normally settle and clear their own heartbeat. A turn can also end
+  // without Pi rendering a final result (for example, after an abnormal tool
+  // interruption), so clear abandoned rows and rehydrate only authenticated
+  // launch provenance from the replacement session's own custom entries.
+  pi.on("agent_end", () => clearAllTakomiSubagentResultHeartbeats());
+  pi.on("session_start", async (_event, ctx) => {
+    clearAllTakomiSubagentResultHeartbeats();
+    await resetTakomiAsyncLifecycle(pi, ctx);
+    await initializeDetachedSession(pi, ctx);
+  });
+  pi.on("session_shutdown", () => {
+    clearAllTakomiSubagentResultHeartbeats();
+    clearDetachedResults(pi);
+    invalidateTakomiPiSubagentsEngine(pi);
+    cleanupAsyncLifecycle();
+    unregisterCompletionNotifications();
+  });
 }

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

@@ -1,188 +1,250 @@
-import type { AgentToolResult } from "@earendil-works/pi-agent-core";
-import type { Theme } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
-import type { TakomiSubagentToolParams } from "./tool-runner";
-import { renderNativeSubagentResult, type Details } from "./pi-subagents-internal";
-
-type ToolResult = AgentToolResult<Details>;
-
-function taskList(params: TakomiSubagentToolParams): Array<{ agent: string; task: string }> {
-  if (params.chain?.length) return params.chain;
-  if (params.tasks?.length) return params.tasks;
-  if (params.agent || params.task) return [{ agent: params.agent ?? "...", task: params.task ?? "..." }];
-  return [];
-}
-
-export function renderTakomiSubagentCall(params: TakomiSubagentToolParams, theme: Theme) {
-  const tasks = taskList(params);
-  const mode = params.chain?.length ? "chain" : params.tasks?.length ? "parallel" : "single";
-  if (tasks.length === 1) {
-    return new Text(
-      `${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${theme.fg("accent", tasks[0]?.agent || "?")}`,
-      0,
-      0,
-    );
-  }
-  return new Text(
-    `${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${mode} (${tasks.length})`,
-    0,
-    0,
-  );
-}
-
-function resultText(result: ToolResult): string {
-  return typeof (result as any)?.content === "string"
-    ? (result as any).content
-    : Array.isArray((result as any)?.content)
-      ? (result as any).content.map((part: any) => part?.text ?? "").filter(Boolean).join("\n")
-      : JSON.stringify((result as any)?.details ?? {}, null, 2);
-}
-
-function extractPolicyNames(text: string): string[] {
-  const policyMatch = text.match(/Required policies:\n((?:- .+\n?)+)/);
-  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" ? "⚠" : 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);
-  }
-
-  const native = renderNativeSubagentResult(result, options, theme, context);
-  if (options.isPartial && native) return native;
-
-  if (options.isPartial) {
-    if (options.expanded) return new Text(livePartialText(result, theme), 0, 0);
-    return new Text(summarizeCollapsedResult(text, status, theme), 0, 0);
-  }
-
-  if (native) return native;
-
-  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);
-}
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Container, Spacer, Text, type Component } from "@earendil-works/pi-tui";
+import type { TakomiSubagentToolParams } from "./tool-runner";
+import { renderNativeSubagentResult, type Details } from "./pi-subagents-internal";
+import {
+  boundNarrative,
+  explicitAssistantTexts,
+  finalAnswer,
+  resolvedChecklist,
+  sanitizeUntrustedText,
+  sanitizeUntrustedValue,
+  type TakomiUxTask,
+} from "./subagent-ux";
+import {
+  clearTakomiSubagentResultHeartbeat,
+  ensureTakomiSubagentResultHeartbeat,
+  getTakomiSubagentHeartbeatFrame,
+  type TakomiSubagentRenderContext,
+} from "./result-heartbeat";
+
+type ToolResult = AgentToolResult<Details>;
+const FALLBACK_RENDER_WIDTH = 80;
+const COMPACT_CUSTOM_LINE_BUDGET = 3;
+const EXPANDED_CUSTOM_LINE_BUDGET = 2;
+const COMPACT_NARRATIVE_LINE_BUDGET = 2;
+const NARRATIVE_PREFIX = "  ↳ ";
+
+class WidthAwareLines implements Component {
+  constructor(private readonly buildLines: (width: number) => string[]) {}
+  render(width: number): string[] {
+    const available = Number.isFinite(width) && width > 0 ? Math.floor(width) : FALLBACK_RENDER_WIDTH;
+    return this.buildLines(available);
+  }
+  invalidate(): void {}
+}
+
+function taskList(params: TakomiSubagentToolParams): Array<{ agent: string; task: string }> {
+  if (params.chain?.length) return params.chain;
+  if (params.tasks?.length) return params.tasks;
+  if (params.agent || params.task) return [{ agent: params.agent ?? "...", task: params.task ?? "..." }];
+  return [];
+}
+
+export function renderTakomiSubagentCall(params: TakomiSubagentToolParams, theme: Theme) {
+  const safeParams = sanitizeUntrustedValue(params);
+  const tasks = taskList(safeParams);
+  const mode = safeParams.chain?.length ? "chain" : safeParams.tasks?.length ? "parallel" : "single";
+  if (tasks.length === 1) {
+    return new Text(`${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${theme.fg("accent", tasks[0]?.agent || "?")}`, 0, 0);
+  }
+  return new Text(`${theme.fg("toolTitle", theme.bold("takomi_subagent "))}${mode} (${tasks.length})`, 0, 0);
+}
+
+function resultText(result: ToolResult): string {
+  const text = typeof (result as any)?.content === "string"
+    ? (result as any).content
+    : Array.isArray((result as any)?.content)
+      ? (result as any).content.map((part: any) => part?.text ?? "").filter(Boolean).join("\n")
+      : JSON.stringify((result as any)?.details ?? {}, null, 2);
+  return sanitizeUntrustedText(text);
+}
+
+function extractPolicyNames(text: string): string[] {
+  const policyMatch = text.match(/Required policies:\n((?:- .+\n?)+)/);
+  return policyMatch?.[1]?.split("\n").map((line) => line.replace(/^[-\s]+/, "").trim()).filter(Boolean) ?? [];
+}
+
+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 safeText = sanitizeUntrustedText(text);
+  const policies = extractPolicyNames(safeText);
+  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. Ctrl+O shows the complete policy detail."),
+    ].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."),
+    "",
+    safeText,
+  ].join("\n");
+}
+
+function uxTasks(details: any): TakomiUxTask[] {
+  return Array.isArray(details?.takomiUx?.tasks) ? details.takomiUx.tasks : [];
+}
+
+function taskFor(tasks: TakomiUxTask[], row: any, index: number): TakomiUxTask {
+  return tasks[index] ?? { agent: row?.agent ?? `task ${index + 1}`, task: row?.task ?? "", checklist: [] };
+}
+
+function checklistFor(task: TakomiUxTask, row: any): ReturnType<typeof resolvedChecklist> {
+  const texts = explicitAssistantTexts(row);
+  if (typeof row?.finalOutput === "string") texts.push(row.finalOutput);
+  return resolvedChecklist(task.checklist, texts);
+}
+
+function normalizedLine(value: string): string {
+  return sanitizeUntrustedText(value).replace(/\s+/g, " ").trim();
+}
+
+function nativePreview(row: any): string {
+  const output = typeof row?.truncation?.text === "string" && row.truncation.text.trim()
+    ? row.truncation.text
+    : finalAnswer(row);
+  return output.split(/\r?\n/).find((line: string) => line.trim())?.trim() ?? "";
+}
+
+function compactNarratives(rows: any[], isPartial: boolean): string[] {
+  const narratives: string[] = [];
+  for (const row of rows) {
+    const source = isPartial ? explicitAssistantTexts(row).at(-1) ?? "" : finalAnswer(row);
+    const lines = source.split(/\r?\n/)
+      .filter((line) => !/^\s*[-*+]\s+\[[ xX]\]\s+/.test(line))
+      .map(normalizedLine)
+      .filter(Boolean);
+    // Native compact only previews successful single results. Acceptance rejection
+    // changes exitCode to non-zero, so keep the first final line in that case.
+    if (!isPartial && rows.length === 1 && row?.exitCode === 0 && lines.length && normalizedLine(nativePreview(row)) === lines[0]) lines.shift();
+    for (const line of lines) {
+      if (narratives.some((existing) => normalizedLine(existing) === line)) continue;
+      narratives.push(line);
+      if (narratives.length >= COMPACT_NARRATIVE_LINE_BUDGET) return narratives;
+    }
+  }
+  return narratives;
+}
+
+function checklistSummary(rows: any[], tasks: TakomiUxTask[]): { summary: string; expanded: string } | undefined {
+  const checklists = rows.map((row, index) => checklistFor(taskFor(tasks, row, index), row));
+  const items = checklists.flat();
+  if (!items.length) return undefined;
+  const done = items.filter((item) => item.done).length;
+  const reported = items.filter((item) => item.done && item.stateSource === "agent-reported").length;
+  const summary = `checklist ${done}/${items.length} complete${reported ? ` · ${reported} agent-reported` : ""}`;
+  if (rows.length !== 1) return { summary, expanded: `Checklist: ${done}/${items.length} complete${reported ? ` (${reported} agent-reported)` : ""}` };
+  const labels = items.map((item) => `[${item.done ? "x" : " "}] ${item.text}`);
+  return { summary, expanded: `Checklist: ${labels.join(" · ")}` };
+}
+
+function fallbackSummary(rows: any[]): string | undefined {
+  const states = rows.map((row) => row?.takomiDetachedOutput)
+    .filter((value) => value && value.fallbackState !== "not-needed");
+  if (!states.length) return undefined;
+  const first = states[0];
+  return `output ${first.source} fallback: ${first.fallbackState}`;
+}
+
+function compactAddition(details: any, isPartial: boolean, theme: Theme): Component | undefined {
+  const rows = Array.isArray(details?.results) ? details.results : [];
+  if (!rows.length) return undefined;
+  const tasks = uxTasks(details);
+  const narratives = compactNarratives(rows, isPartial);
+  const checklist = checklistSummary(rows, tasks);
+  const checklistProvenance = details?.takomiDetached?.checklistProvenance === "unavailable-after-restart"
+    ? "checklist provenance unavailable after restart"
+    : checklist?.summary;
+  const provenance = [checklistProvenance, fallbackSummary(rows)].filter((value): value is string => Boolean(value));
+  if (!narratives.length && !provenance.length) return undefined;
+
+  return new WidthAwareLines((width) => {
+    const lines: string[] = [];
+    const narrativeWidth = Math.max(1, width - NARRATIVE_PREFIX.length);
+    for (const narrative of narratives) {
+      const bounded = boundNarrative(narrative, { maxLines: 1, maxColumns: narrativeWidth, from: "start" });
+      if (bounded.lines[0]) lines.push(theme.fg("dim", `${NARRATIVE_PREFIX}${bounded.lines[0]}`));
+    }
+    for (const item of provenance) {
+      if (lines.length >= COMPACT_CUSTOM_LINE_BUDGET) break;
+      const bounded = boundNarrative(item, { maxLines: 1, maxColumns: Math.max(1, width - 2), from: "start" });
+      if (bounded.lines[0]) lines.push(theme.fg("muted", `  ${bounded.lines[0]}`));
+    }
+    return lines.slice(0, COMPACT_CUSTOM_LINE_BUDGET);
+  });
+}
+
+function expandedAddition(details: any, theme: Theme): Component | undefined {
+  const rows = Array.isArray(details?.results) ? details.results : [];
+  if (!rows.length) return undefined;
+  const checklist = checklistSummary(rows, uxTasks(details));
+  const checklistProvenance = details?.takomiDetached?.checklistProvenance === "unavailable-after-restart"
+    ? "Checklist provenance unavailable after restart"
+    : checklist ? checklist.summary.replace(/^checklist/, "Checklist provenance:") : undefined;
+  const provenance = [checklistProvenance, fallbackSummary(rows)]
+    .filter(Boolean)
+    .join("\n");
+  if (!provenance) return undefined;
+
+  return new WidthAwareLines((width) => boundNarrative(provenance, {
+    maxLines: EXPANDED_CUSTOM_LINE_BUDGET,
+    maxColumns: width,
+    from: "start",
+  }).lines.slice(0, EXPANDED_CUSTOM_LINE_BUDGET).map((line) => theme.fg("dim", line)));
+}
+
+function compose(
+  native: Component | undefined,
+  addition: Component | undefined,
+  fallback: Component,
+  errorNotice?: Component,
+): Component {
+  if (!native && !addition && !errorNotice) return fallback;
+  const container = new Container();
+  if (errorNotice) container.addChild(errorNotice);
+  if (errorNotice && (native || addition)) container.addChild(new Spacer(1));
+  if (native) container.addChild(native);
+  if (native && addition) container.addChild(new Spacer(1));
+  if (addition) container.addChild(addition);
+  return container;
+}
+
+export function renderTakomiSubagentResult(
+  result: ToolResult,
+  options: { expanded?: boolean; isPartial?: boolean },
+  theme: Theme,
+  context: TakomiSubagentRenderContext & { isError?: boolean },
+): any {
+  if (options.isPartial) ensureTakomiSubagentResultHeartbeat(context);
+  else clearTakomiSubagentResultHeartbeat(context);
+
+  const safeResult = sanitizeUntrustedValue(result);
+  const text = resultText(safeResult);
+  if (isPolicyGateBlock(text)) return new Text(renderPolicyGateBlock(text, options.expanded, theme), 0, 0);
+
+  const frame = getTakomiSubagentHeartbeatFrame(context);
+  const native = renderNativeSubagentResult(
+    safeResult,
+    { expanded: options.expanded === true, isPartial: options.isPartial === true },
+    theme,
+    frame,
+  ) as Component | undefined;
+  const details: any = (safeResult as any)?.details ?? {};
+  const addition = options.expanded
+    ? expandedAddition(details, theme)
+    : compactAddition(details, options.isPartial === true, theme);
+  const isError = Boolean((safeResult as any)?.isError || context?.isError);
+  const errorNotice = isError ? new Text(theme.fg("error", "takomi_subagent failed"), 0, 0) : undefined;
+  const fallback = new Text(`${isError ? `${theme.fg("error", "failed")}\n` : ""}${text || "No result content."}`, 0, 0);
+  return compose(native, addition, fallback, errorNotice);
+}