@d3ara1n/pi-subagent 0.10.3 → 1.0.0

package/src/output.ts

@@ -60,6 +60,13 @@ export async function compressOutput(
   }
 }
 
+/** First line of the output as a short summary, truncated to ~65 chars. */
+function firstLineSummary(outputText: string): string | undefined {
+  const firstLine = outputText.trim().split("\n")[0];
+  if (!firstLine) return undefined;
+  return firstLine.length <= 65 ? firstLine : firstLine.slice(0, 62) + "...";
+}
+
 export async function generateSummary(
   rolesApi: ModelRolesAPI,
   outputText: string,
@@ -68,11 +75,7 @@ export async function generateSummary(
   if (!summaryConfig.enabled || !outputText.trim()) return undefined;
 
   // Short outputs don't justify an extra API call — reuse the first line directly
-  const shortTrimmed = outputText.trim();
-  if (shortTrimmed.length <= 150) {
-    const firstLine = shortTrimmed.split("\n")[0];
-    return firstLine.length <= 65 ? firstLine : firstLine.slice(0, 62) + "...";
-  }
+  if (outputText.trim().length <= 150) return firstLineSummary(outputText);
 
   try {
     if (!rolesApi.resolveRole(summaryConfig.role).model) return undefined;
@@ -106,11 +109,7 @@ export async function generateSummary(
 
     return text || undefined;
   } catch {
-    // Fall back to manual truncation: use first line of output as summary
-    const trimmed = outputText.trim();
-    if (!trimmed) return undefined;
-    const firstLine = trimmed.split("\n")[0];
-    if (firstLine.length <= 65) return firstLine;
-    return firstLine.slice(0, 62) + "...";
+    // Fall back to the first-line summary
+    return firstLineSummary(outputText);
   }
 }

package/src/render-async.ts

@@ -0,0 +1,324 @@
+/**
+ * TUI rendering for background delegation: the background delegate input
+ * block, the wait live view, and the check snapshot view.
+ *
+ * This module is deliberately independent of ./render.ts (the foreground
+ * delegate family): the two presentation shapes evolve separately and share
+ * only the pure helpers from ./utils.ts (per-item formatters, icons, the
+ * result-line chain, and the elapsed-time timer).
+ *
+ * Layout contract (mirrors how foreground delegate rows decompose):
+ * - background delegate row = INPUT only (static — the run outlives the call)
+ * - wait row = per-run STATUS line + PROCESS stream + usage bar. When a run
+ *   finishes, its result line carries only the status ("finished" / stop
+ *   reason) — the conclusion itself is check's job, for the LLM and the user
+ * - check row = the same block shape, but the single-run snapshot whose result
+ *   line/expanded view DO show the actual output (check is the result-fetcher)
+ *
+ * Icon discipline (parity with the foreground row): the status line shows an
+ * icon only while queued/running; once terminal it goes bare and the result
+ * line takes over the icon — never both.
+ */
+
+import { getMarkdownTheme, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import type {
+  BackgroundDelegateDetails,
+  CheckDetails,
+  RunViewEntry,
+  SubagentResult,
+  WaitDetails,
+} from "./types.ts";
+import {
+  buildDisplayItems,
+  clearElapsedTimer,
+  contentText,
+  deriveRunState,
+  ensureElapsedTimer,
+  formatFallback,
+  formatThinking,
+  formatTimePart,
+  formatToolCall,
+  formatUsageStats,
+  renderDisplayItems,
+  runIcon,
+  statusStyle,
+  taskPreview,
+  terminalResultLine,
+} from "./utils.ts";
+
+// Contextual types derived from ToolDefinition so we don't depend on
+// non-root-exported render types (ToolRenderContext is internal).
+type RenderCallFn = NonNullable<ToolDefinition["renderCall"]>;
+type RenderResultFn = NonNullable<ToolDefinition["renderResult"]>;
+
+type Fg = (color: string, text: string) => string;
+
+// ── Small shared pieces (same presentation family) ─────────────
+
+/** Usage line: elapsed/budget(+grace) prefix + token/turn/cost stats. */
+function runUsageLine(r: SubagentResult): string | null {
+  const stats = formatUsageStats(r.usage, r.model);
+  return [formatTimePart(r), stats].filter(Boolean).join(" \u00b7 ") || null;
+}
+
+/** Full activity stream as container rows (shared by the expanded views). */
+function addActivityRows(container: Container, r: SubagentResult, fg: Fg): void {
+  const activity = buildDisplayItems(r.activityLog);
+  if (activity.length === 0) {
+    const state = deriveRunState(r);
+    const label =
+      state === "queued" ? "(queued — waiting for a concurrency slot...)" : "(no activity yet)";
+    container.addChild(new Text(fg("muted", label), 0, 0));
+    return;
+  }
+  for (const item of activity) {
+    if (item.type === "thinking") {
+      container.addChild(new Text(formatThinking(item.status, fg), 0, 0));
+    } else {
+      const { prefix, color } = statusStyle(item.status, fg);
+      container.addChild(new Text(prefix + formatToolCall(item.name, item.args, color), 0, 0));
+    }
+  }
+}
+
+/** Fallback trace line, shown while a retry is in flight and after it lands. */
+function addFallbackRow(container: Container, r: SubagentResult, fg: Fg): void {
+  if (r.fallbackFrom) {
+    container.addChild(new Text(fg("warning", `\u26a0 fallback: ${formatFallback(r.fallbackFrom)}`), 0, 0));
+  }
+}
+
+// ── wait entries: id'd status line, process stream, status-only result line ──
+
+/** wait status line: `<icon> <id> (running|queued) <preview>` live; bare `<id> <preview>` once terminal. */
+function waitStatusLine(entry: RunViewEntry, fg: Fg): string {
+  const r = entry.result;
+  const state = deriveRunState(r);
+  if (state === "queued" || state === "running") {
+    const label = state === "queued" ? "(queued)" : "(running)";
+    return `${runIcon(r, fg)} ${fg("accent", entry.id)} ${fg("dim", label)} ${fg("text", taskPreview(r.task))}`;
+  }
+  // Terminal: no icon — the result line takes over the status display.
+  return `${fg("accent", entry.id)} ${fg("text", taskPreview(r.task))}`;
+}
+
+function waitEntryCollapsedText(entry: RunViewEntry, fg: Fg): string {
+  const r = entry.result;
+  const state = deriveRunState(r);
+  let text = waitStatusLine(entry, fg);
+
+  if (state === "running") {
+    const activity = buildDisplayItems(r.activityLog);
+    if (activity.length === 0) {
+      text += `\n${fg("muted", "(running...)")}`;
+    } else {
+      const rendered = renderDisplayItems(activity, 5, fg);
+      if (rendered) text += `\n${rendered}`;
+    }
+  } else if (state !== "queued") {
+    // The process stream becomes the result line once the run finishes.
+    // "finished" — wait never shows output; the conclusion is check's job.
+    text += `\n${terminalResultLine(r, fg, "finished")}`;
+  }
+
+  const usage = runUsageLine(r);
+  if (usage) text += `\n${fg("dim", usage)}`;
+  return text;
+}
+
+function waitEntryExpandedContainer(entry: RunViewEntry, fg: Fg): Container {
+  const r = entry.result;
+  const state = deriveRunState(r);
+  const container = new Container();
+
+  container.addChild(new Text(waitStatusLine(entry, fg), 0, 0));
+  addFallbackRow(container, r, fg);
+  container.addChild(new Spacer(1));
+  if (state === "finished" || state === "failed") {
+    container.addChild(new Text(terminalResultLine(r, fg, "finished"), 0, 0));
+    container.addChild(new Spacer(1));
+  }
+  // Process stream in full — no output text here even when finished.
+  addActivityRows(container, r, fg);
+
+  const usage = runUsageLine(r);
+  if (usage) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(fg("dim", usage), 0, 0));
+  }
+  return container;
+}
+
+// ── check entry: no id (single run), result line + expanded view show output ──
+
+/** check status line: `<icon> (running|queued) <preview>` live; bare `<preview>` once terminal. No id — there is only one. */
+function checkStatusLine(r: SubagentResult, fg: Fg): string {
+  const state = deriveRunState(r);
+  if (state === "queued" || state === "running") {
+    const label = state === "queued" ? "(queued)" : "(running)";
+    return `${runIcon(r, fg)} ${fg("dim", label)} ${fg("text", taskPreview(r.task))}`;
+  }
+  // Terminal: no icon — the result line takes over the status display.
+  return fg("text", taskPreview(r.task));
+}
+
+function checkEntryCollapsedText(r: SubagentResult, fg: Fg): string {
+  const state = deriveRunState(r);
+  let text = checkStatusLine(r, fg);
+
+  if (state === "running") {
+    const activity = buildDisplayItems(r.activityLog);
+    if (activity.length === 0) {
+      text += `\n${fg("muted", "(running...)")}`;
+    } else {
+      const rendered = renderDisplayItems(activity, 5, fg);
+      if (rendered) text += `\n${rendered}`;
+    }
+  } else if (state !== "queued") {
+    // check is the result-fetcher: same chain as the foreground row.
+    text += `\n${terminalResultLine(r, fg)}`;
+  }
+
+  const usage = runUsageLine(r);
+  if (usage) text += `\n${fg("dim", usage)}`;
+  return text;
+}
+
+function checkEntryExpandedContainer(r: SubagentResult, fg: Fg): Container {
+  const state = deriveRunState(r);
+  const container = new Container();
+
+  container.addChild(new Text(checkStatusLine(r, fg), 0, 0));
+  addFallbackRow(container, r, fg);
+  container.addChild(new Spacer(1));
+
+  if (state === "finished" || state === "failed") {
+    container.addChild(new Text(terminalResultLine(r, fg), 0, 0));
+    // check is the result-fetcher: the full output lives here.
+    container.addChild(new Spacer(1));
+    if (r.output.trim()) {
+      container.addChild(new Markdown(r.output.trim(), 0, 0, getMarkdownTheme()));
+      if (r.outputMethod === "compressed") {
+        container.addChild(
+          new Text(fg("muted", "(output compressed by summary model \u2014 full text in history)"), 0, 0),
+        );
+      } else if (r.outputMethod === "truncated") {
+        container.addChild(new Text(fg("muted", "(output truncated \u2014 full text in history)"), 0, 0));
+      }
+    } else {
+      container.addChild(new Text(fg("muted", "(no output \u2014 the run produced no text)"), 0, 0));
+    }
+  } else {
+    addActivityRows(container, r, fg);
+  }
+
+  const usage = runUsageLine(r);
+  if (usage) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(fg("dim", usage), 0, 0));
+  }
+  return container;
+}
+
+// ── Background delegate: static input block ────────────────────
+
+export const renderBackgroundDelegateCall: RenderCallFn = (args, theme) => {
+  const roleName = (args as any).role || "...";
+  const text =
+    theme.fg("toolTitle", theme.bold("subagent_delegate ")) +
+    theme.fg("accent", roleName) +
+    theme.fg("dim", " (background)");
+  return new Text(text, 0, 0);
+};
+
+export const renderBackgroundDelegateResult: RenderResultFn = (result, { expanded }, theme) => {
+  const details = result.details as BackgroundDelegateDetails | undefined;
+  if (!details) return new Text(contentText(result), 0, 0);
+
+  const fg = theme.fg.bind(theme) as Fg;
+  // One-line anchor: marker + id + task preview. The run's live state is NOT
+  // shown here — the row is written the moment the tool returns and the run
+  // progresses invisibly until a wait/check row picks it up.
+  const summaryLine = `${fg("accent", "\u25B6")} ${fg("dim", details.id)} ${fg("text", taskPreview(details.task))}`;
+
+  if (!expanded) return new Text(summaryLine, 0, 0);
+
+  // Expanded: full input — reference files, context size, task text.
+  const container = new Container();
+  container.addChild(new Text(summaryLine, 0, 0));
+  container.addChild(new Spacer(1));
+  if (details.files) {
+    for (const f of details.files) {
+      container.addChild(new Text(fg("dim", `@${f}`), 0, 0));
+    }
+  }
+  if (details.context) {
+    container.addChild(new Text(fg("dim", `ctx ${details.context.length} chars`), 0, 0));
+  }
+  container.addChild(new Text(fg("dim", details.task), 0, 0));
+  return container;
+};
+
+// ── wait: live multi-run view ──────────────────────────────────
+
+export const renderWaitCall: RenderCallFn = (args, theme) => {
+  const ids = ((args as any).ids as string[] | undefined) ?? [];
+  const label = ids.length > 0 ? ids.join(", ") : "(all)";
+  const text = theme.fg("toolTitle", theme.bold("subagent_wait ")) + theme.fg("accent", label);
+  return new Text(text, 0, 0);
+};
+
+export const renderWaitResult: RenderResultFn = (result, { expanded }, theme, context) => {
+  const details = result.details as WaitDetails | undefined;
+  if (!details || details.entries.length === 0) {
+    return new Text(contentText(result), 0, 0);
+  }
+
+  // Tick while any watched run is still live. A timed-out wait freezes the
+  // view instead — the runs keep going, but this row is done.
+  const anyLive =
+    !details.timedOut &&
+    details.entries.some((e) => {
+      const s = deriveRunState(e.result);
+      return s === "queued" || s === "running";
+    });
+  if (anyLive) {
+    ensureElapsedTimer(context);
+  } else {
+    clearElapsedTimer(context);
+  }
+
+  const fg = theme.fg.bind(theme) as Fg;
+
+  if (expanded) {
+    const container = new Container();
+    details.entries.forEach((entry, i) => {
+      if (i > 0) container.addChild(new Spacer(1));
+      container.addChild(waitEntryExpandedContainer(entry, fg));
+    });
+    return container;
+  }
+
+  const text = details.entries.map((e) => waitEntryCollapsedText(e, fg)).join("\n\n");
+  return new Text(text, 0, 0);
+};
+
+// ── check: frozen single-run snapshot ──────────────────────────
+
+export const renderCheckCall: RenderCallFn = (args, theme) => {
+  const id = (args as any).id || "...";
+  const text = theme.fg("toolTitle", theme.bold("subagent_check ")) + theme.fg("accent", id);
+  return new Text(text, 0, 0);
+};
+
+export const renderCheckResult: RenderResultFn = (result, { expanded }, theme, _context) => {
+  const details = result.details as CheckDetails | undefined;
+  if (!details) return new Text(contentText(result), 0, 0);
+
+  const fg = theme.fg.bind(theme) as Fg;
+  // Static snapshot — never starts the animation timer (the execute layer
+  // freezes the frame before handing it over).
+  if (expanded) return checkEntryExpandedContainer(details.result, fg);
+  return new Text(checkEntryCollapsedText(details.result, fg), 0, 0);
+};

package/src/render.ts

@@ -1,76 +1,40 @@
 /**
- * TUI rendering for the delegate tool: the call row (`delegate <role>`) and the
- * result view (collapsed and expanded), plus the render-side elapsed-time timer.
+ * TUI rendering for the delegate tool: the call row (`subagent_delegate <role>`)
+ * and the result view (collapsed and expanded). Shared composition helpers
+ * (icons, result lines, timers) live in ./utils.ts and are used by
+ * ./render-async.ts too, so every view renders an outcome the same way.
  */
 
-import {
-  getMarkdownTheme,
-  type ThemeColor,
-  type ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
+import { getMarkdownTheme, type ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 import type { SubagentDetails } from "./types.ts";
-
-// Contextual types derived from ToolDefinition so we don't depend on
-// non-root-exported render types (ToolRenderContext is internal).
-type RenderCallFn = NonNullable<ToolDefinition["renderCall"]>;
-type RenderResultFn = NonNullable<ToolDefinition["renderResult"]>;
 import {
   buildDisplayItems,
-  formatUsageStats,
-  elapsedSeconds,
-  formatToolCall,
-  statusStyle,
+  clearElapsedTimer,
+  contentText,
+  ensureElapsedTimer,
+  formatFallback,
   formatThinking,
+  formatTimePart,
+  formatToolCall,
+  formatUsageStats,
   renderDisplayItems,
-  isFailedResult,
+  runIcon,
+  statusStyle,
+  taskPreview,
+  terminalResultLine,
 } from "./utils.ts";
 
-// ── Elapsed-time animation (render-side timer) ───────────────
-
-/**
- * Per-row render state slot holding the elapsed-time animation timer.
- * The handle lives in context.state so it is scoped to one tool row.
- */
-interface DelegateRenderState {
-  elapsedTimer?: ReturnType<typeof setInterval>;
-}
-
-/**
- * While a delegate is running, force a TUI repaint every second so the
- * elapsed time ticks up even when the child process is idle. Uses
- * context.invalidate() (pi's official re-render hook) rather than pushing
- * data via onUpdate — the render recomputes elapsed time fresh from Date.now().
- */
-function ensureElapsedTimer(context: {
-  state: Record<string, unknown>;
-  invalidate?: () => void;
-}): void {
-  const state = context.state as DelegateRenderState;
-  if (state.elapsedTimer) return;
-  if (typeof context.invalidate !== "function") return;
-  state.elapsedTimer = setInterval(() => {
-    try {
-      context.invalidate?.();
-    } catch {
-      /* ignore — invalidate must never break rendering */
-    }
-  }, 1000);
-}
-
-/** Stop the elapsed-time animation once the run reaches a terminal state. */
-function clearElapsedTimer(context: { state: Record<string, unknown> }): void {
-  const state = context.state as DelegateRenderState;
-  if (!state.elapsedTimer) return;
-  clearInterval(state.elapsedTimer);
-  state.elapsedTimer = undefined;
-}
+// Contextual types derived from ToolDefinition so we don't depend on
+// non-root-exported render types (ToolRenderContext is internal).
+type RenderCallFn = NonNullable<ToolDefinition["renderCall"]>;
+type RenderResultFn = NonNullable<ToolDefinition["renderResult"]>;
 
 // ── renderCall: what the user sees when the tool is invoked ─────
 
 export const renderDelegateCall: RenderCallFn = (args, theme, _context) => {
   const roleName = (args as any).role || "...";
-  const text = theme.fg("toolTitle", theme.bold("delegate ")) + theme.fg("accent", roleName);
+  const text = theme.fg("toolTitle", theme.bold("subagent_delegate ")) + theme.fg("accent", roleName);
   return new Text(text, 0, 0);
 };
 
@@ -93,91 +57,51 @@ export const renderDelegateResult: RenderResultFn = (result, { expanded }, theme
   }
 
   if (!details || details.results.length === 0) {
-    const text = result.content[0];
-    return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+    return new Text(contentText(result), 0, 0);
   }
 
   const r = details.results[0];
-  const isError = !isRunning && isFailedResult(r);
-  const isTimeout = !isRunning && r.stopReason === "timeout";
-  const isBudget = !isRunning && r.stopReason === "budget_exceeded";
-  const isFailedState = isError || isTimeout || isBudget;
-
-  // Status icon. ⏳ running / ⏸ queued (pause) / ⏱ timeout / ⏲ budget / ✗ error / ✓ ok
-  let icon: string;
-  if (isRunning) {
-    icon = r.queued ? theme.fg("warning", "\u23F8") : theme.fg("warning", "\u23F3");
-  } else if (isTimeout) {
-    icon = theme.fg("warning", "\u23F1");
-  } else if (isBudget) {
-    icon = theme.fg("warning", "\u23F2");
-  } else if (isError) {
-    icon = theme.fg("error", "\u2717");
-  } else {
-    icon = theme.fg("success", "\u2713");
-  }
-
+  const fg = theme.fg.bind(theme) as (color: string, text: string) => string;
+  const icon = runIcon(r, fg);
   const displayItems = buildDisplayItems(r.activityLog);
   const mdTheme = getMarkdownTheme();
-  const fg = theme.fg.bind(theme) as (color: string, text: string) => string;
 
-  // Task preview: first line, truncated to one row (always-visible anchor).
-  const firstLine = r.task.split("\n")[0];
-  const taskPreview = firstLine.length > 70 ? `${firstLine.slice(0, 70)}...` : firstLine;
   // taskline: indicator prefix while running/queued; bare text once finished.
+  const preview = taskPreview(r.task);
   let taskline: string;
   if (isRunning) {
     const label = r.queued ? "(queued)" : "(running)";
-    taskline = `${icon} ${theme.fg("dim", label)} ${theme.fg("text", taskPreview)}`;
+    taskline = `${icon} ${theme.fg("dim", label)} ${theme.fg("text", preview)}`;
   } else {
-    taskline = theme.fg("text", taskPreview);
+    taskline = theme.fg("text", preview);
   }
 
-  // usage line: elapsed/budget(+grace) prefix + existing stats.
-  const secs = elapsedSeconds(r);
+  // usage line: elapsed/budget(+grace) prefix + stats.
   const stats = formatUsageStats(r.usage, r.model);
-  const budgetSec = r.budgetMs ? Math.round(r.budgetMs / 1000) : 0;
-  const liveGraceMs = (r.graceMs ?? 0) + (r.pauseStart ? Date.now() - r.pauseStart : 0);
-  const graceSec = Math.round(liveGraceMs / 1000);
-  let timePart: string | null = null;
-  if (secs != null) {
-    timePart =
-      budgetSec > 0
-        ? graceSec > 0
-          ? `${secs}s/${budgetSec}s(+${graceSec}s)`
-          : `${secs}s/${budgetSec}s`
-        : `${secs}s`;
-  }
-  const usageLine = [timePart, stats].filter(Boolean).join(" \u00b7 ");
+  const usageLine = [formatTimePart(r), stats].filter(Boolean).join(" \u00b7 ");
 
-  // resultline: fixed line on terminal frames — `<icon> <content>` colored by outcome.
-  // success → AI summary, else first line of output (truncated), else a placeholder — never blank.
-  // error/timeout/budget → errorMessage (or a default label).
-  let resultline: string | undefined;
-  if (!isRunning) {
-    if (isFailedState) {
-      const content =
-        r.errorMessage || (isTimeout ? "Timed out" : isBudget ? "Budget exceeded" : "failed");
-      const col: ThemeColor = isTimeout || isBudget ? "warning" : "error";
-      resultline = `${icon} ${theme.fg(col, content)}`;
-    } else {
-      // success fallback chain: summary → output first line → placeholder.
-      const firstLine = r.output.trim().split("\n")[0] ?? "";
-      const preview = firstLine.length > 70 ? `${firstLine.slice(0, 70)}...` : firstLine;
-      const content = r.summary || preview;
-      const col: ThemeColor = content ? "text" : "muted";
-      resultline = `${icon} ${theme.fg(col, content || "(no output)")}`;
-    }
-  }
+  // resultline: fixed line on terminal frames — the shared chain (failure or
+  // budget reason on stops, summary → first output line → placeholder on success).
+  const resultline = isRunning ? undefined : terminalResultLine(r, fg);
+
+  // Fallback trace: the role's primary model hit a provider error and the run is
+  // being / was retried on the fallback role — warn, don't error (the retry may
+  // still succeed). Also shown while the retry is running.
+  const fallbackLine = r.fallbackFrom
+    ? theme.fg("warning", `\u26a0 fallback: ${formatFallback(r.fallbackFrom)}`)
+    : undefined;
 
   if (expanded) {
     const container = new Container();
 
-    // Header: taskline + resultline (summary on success, error message on failure).
+    // Header: taskline + resultline (summary on success, reason on failure).
     container.addChild(new Text(taskline, 0, 0));
     if (resultline) {
       container.addChild(new Text(resultline, 0, 0));
     }
+    if (fallbackLine) {
+      container.addChild(new Text(fallbackLine, 0, 0));
+    }
 
     // Input block: reference files + context char count + task full text,
     // grouped without inner spacing (they are all subagent input).
@@ -194,10 +118,7 @@ export const renderDelegateResult: RenderResultFn = (result, { expanded }, theme
 
     // Activity stream (shown while running and after completion).
     container.addChild(new Spacer(1));
-    const activity = displayItems.filter(
-      (item) => item.type === "toolCall" || item.type === "thinking",
-    );
-    if (activity.length === 0) {
+    if (displayItems.length === 0) {
       const runningLabel = isRunning
         ? r.queued
           ? "(queued \u2014 waiting for a concurrency slot...)"
@@ -205,7 +126,7 @@ export const renderDelegateResult: RenderResultFn = (result, { expanded }, theme
         : "(none)";
       container.addChild(new Text(theme.fg("muted", runningLabel), 0, 0));
     } else {
-      for (const item of activity) {
+      for (const item of displayItems) {
         if (item.type === "thinking") {
           container.addChild(new Text(formatThinking(item.status, fg), 0, 0));
         } else {
@@ -258,20 +179,18 @@ export const renderDelegateResult: RenderResultFn = (result, { expanded }, theme
   // Collapsed view.
   let text = taskline;
   if (!isRunning) {
-    // resultline (shared computation above).
+    // Terminal: taskline + resultline + usage — no activity replay.
     if (resultline) text += `\n${resultline}`;
   } else if (!r.queued) {
     // Running (not queued): show recent activity only.
-    const activity = displayItems.filter(
-      (item) => item.type === "toolCall" || item.type === "thinking",
-    );
-    if (activity.length === 0) {
+    if (displayItems.length === 0) {
       text += `\n${theme.fg("muted", "(running...)")}`;
     } else {
-      const rendered = renderDisplayItems(activity, 5, fg);
+      const rendered = renderDisplayItems(displayItems, 5, fg);
       if (rendered) text += `\n${rendered}`;
     }
   }
+  if (fallbackLine) text += `\n${fallbackLine}`;
   if (usageLine) text += `\n${theme.fg("dim", usageLine)}`;
   return new Text(text, 0, 0);
 };

package/src/roles.ts

@@ -56,10 +56,10 @@ export const BUILTIN_ROLES: Record<string, SubagentRole> = {
     role: "default",
     timeout: 2400,
     description:
-      "the ONLY role that can MODIFY files — edit, write, refactor, fix, implement. Tools: read, bash, edit, write, grep, find, delegate. Can delegate to explorer/researcher.",
+      "the ONLY role that can MODIFY files — edit, write, refactor, fix, implement. Tools: read, bash, edit, write, grep, find, subagent_delegate. Can delegate to explorer/researcher.",
     examples: ["Rename all snake_case fields to camelCase", "Add input validation to POST /login"],
     decisionTrigger: "Task modifies files?",
-    tools: ["read", "bash", "edit", "write", "grep", "find", "delegate"],
+    tools: ["read", "bash", "edit", "write", "grep", "find", "subagent_delegate"],
     subagentRoles: ["explorer", "researcher"],
     systemPrompt: [
       "Implementation worker. Work autonomously — all context is in the task description.",
@@ -67,9 +67,9 @@ export const BUILTIN_ROLES: Record<string, SubagentRole> = {
       "After each change, validate: run tests, check syntax, verify behavior.",
       "",
       "## Protecting your context",
-      "You have a `delegate` tool. Use it to offload exploration and research:",
-      "- delegate(role=explorer) when you need to map unfamiliar code before editing",
-      "- delegate(role=researcher) when you need external docs or library references",
+      "You have a `subagent_delegate` tool. Use it to offload exploration and research:",
+      "- subagent_delegate(role=explorer) when you need to map unfamiliar code before editing",
+      "- subagent_delegate(role=researcher) when you need external docs or library references",
       "Don't delegate tasks you can do with a single read or grep.",
       "",
       "Output format (be brief — summarize, don't paste full diffs):",
@@ -82,10 +82,10 @@ export const BUILTIN_ROLES: Record<string, SubagentRole> = {
     fallbackRole: "default",
     timeout: 2400,
     description:
-      "the ONLY role with WEB ACCESS — search docs, fetch pages, analyze GitHub repos. Tools: web_search, fetch_content, read, bash, delegate. Can clone repos & delegate to explorer.",
+      "the ONLY role with WEB ACCESS — search docs, fetch pages, analyze GitHub repos. Tools: web_search, fetch_content, read, bash, subagent_delegate. Can clone repos & delegate to explorer.",
     examples: ["Find the React 19 migration guide", "Check GitHub issue #1234 for context"],
     decisionTrigger: "Task searches web or GitHub?",
-    tools: ["web_search", "fetch_content", "read", "bash", "delegate"],
+    tools: ["web_search", "fetch_content", "read", "bash", "subagent_delegate"],
     subagentRoles: ["explorer"],
     systemPrompt: [
       "Web researcher. Search with varied angles, prefer official docs over blogs.",
@@ -94,7 +94,7 @@ export const BUILTIN_ROLES: Record<string, SubagentRole> = {
       "## GitHub repo analysis",
       "When the task requires analyzing a GitHub repo:",
       "1. git clone the repo into PI_SUBAGENT_TMPDIR (must exist)",
-      "2. Use `delegate` with role=explorer to investigate the cloned codebase — pass the repo path and the research question",
+      "2. Use `subagent_delegate` with role=explorer to investigate the cloned codebase — pass the repo path and the research question",
       "3. Combine explorer findings with any web search results",
       "",
       "bash is for git clone and read-only commands only. Never modify files.",