pi-fast-subagent 0.8.0 → 0.9.1

package/loader-pool.ts

@@ -0,0 +1,175 @@
+/**
+ * Pooled ResourceLoader for subagent sessions.
+ *
+ * Loading the full extension/resource graph is expensive, so each unique
+ * (cwd, agentDir, noExtensions) tuple is warmed once and the underlying
+ * loader is reused across subagent runs. The pool is intentionally simple:
+ * one-loader-per-tuple with a FIFO idle queue.
+ */
+
+import { DefaultResourceLoader } from "@mariozechner/pi-coding-agent";
+import type { ResourceLoader } from "@mariozechner/pi-coding-agent";
+
+type DefaultResourceLoaderOptions = ConstructorParameters<typeof DefaultResourceLoader>[0];
+
+/** Minimum surface the pool needs from a loader. */
+export interface PoolableLoader extends ResourceLoader {
+  reload(): Promise<void>;
+}
+
+export type LoaderFactory = (options: DefaultResourceLoaderOptions) => PoolableLoader;
+
+interface LoaderPoolEntry {
+  idle: PoolableLoader[];
+  active: Set<PoolableLoader>;
+  warming: Set<Promise<void>>;
+}
+
+export interface LoaderLease {
+  loader: ResourceLoader;
+  release: () => void;
+}
+
+export class AgentPromptResourceLoader implements ResourceLoader {
+  constructor(
+    private readonly base: ResourceLoader,
+    private readonly systemPromptOverride: string | undefined,
+  ) {}
+
+  getExtensions() { return this.base.getExtensions(); }
+  getSkills() { return this.base.getSkills(); }
+  getPrompts() { return this.base.getPrompts(); }
+  getThemes() { return this.base.getThemes(); }
+  getAgentsFiles() { return this.base.getAgentsFiles(); }
+  getSystemPrompt() { return this.systemPromptOverride ?? this.base.getSystemPrompt(); }
+  getAppendSystemPrompt() { return this.base.getAppendSystemPrompt(); }
+  extendResources(paths: Parameters<ResourceLoader["extendResources"]>[0]): void {
+    this.base.extendResources(paths);
+  }
+  reload(): Promise<void> { return this.base.reload(); }
+}
+
+export function makeLoaderOptions(
+  cwd: string,
+  agentDir: string,
+  noExtensions: boolean,
+): DefaultResourceLoaderOptions {
+  return {
+    cwd,
+    agentDir,
+    noExtensions,
+    noContextFiles: true,
+    noSkills: true,
+  };
+}
+
+export class LoaderPool {
+  private entries = new Map<string, LoaderPoolEntry>();
+
+  constructor(
+    private readonly factory: LoaderFactory = (opts) => new DefaultResourceLoader(opts) as PoolableLoader,
+  ) {}
+
+  private key(cwd: string, agentDir: string, noExtensions: boolean): string {
+    return `${cwd}\0${agentDir}\0${noExtensions ? "noext" : "ext"}`;
+  }
+
+  private getEntry(cwd: string, agentDir: string, noExtensions: boolean): LoaderPoolEntry {
+    const k = this.key(cwd, agentDir, noExtensions);
+    let entry = this.entries.get(k);
+    if (!entry) {
+      entry = { idle: [], active: new Set(), warming: new Set() };
+      this.entries.set(k, entry);
+    }
+    return entry;
+  }
+
+  isWarm(cwd: string, agentDir: string, noExtensions: boolean): boolean {
+    const entry = this.entries.get(this.key(cwd, agentDir, noExtensions));
+    return !!entry && entry.idle.length > 0;
+  }
+
+  async acquire(
+    cwd: string,
+    agentDir: string,
+    noExtensions: boolean,
+    systemPromptOverride: string | undefined,
+  ): Promise<LoaderLease> {
+    const entry = this.getEntry(cwd, agentDir, noExtensions);
+
+    while (true) {
+      const cached = entry.idle.pop();
+      if (cached) {
+        entry.active.add(cached);
+        let released = false;
+        return {
+          loader: new AgentPromptResourceLoader(cached, systemPromptOverride),
+          release: () => {
+            if (released) return;
+            released = true;
+            entry.active.delete(cached);
+            entry.idle.push(cached);
+          },
+        };
+      }
+
+      const warming = entry.warming.values().next().value as Promise<void> | undefined;
+      if (warming) {
+        await warming;
+        continue;
+      }
+
+      const loader = this.factory(makeLoaderOptions(cwd, agentDir, noExtensions));
+      const warmPromise = loader
+        .reload()
+        .then(() => {
+          entry.idle.push(loader);
+        })
+        .finally(() => {
+          entry.warming.delete(warmPromise);
+        });
+      entry.warming.add(warmPromise);
+      await warmPromise;
+    }
+  }
+
+  warm(cwd: string, agentDir: string, noExtensions: boolean): void {
+    const entry = this.getEntry(cwd, agentDir, noExtensions);
+    if (entry.idle.length > 0 || entry.active.size > 0 || entry.warming.size > 0) return;
+    const loader = this.factory(makeLoaderOptions(cwd, agentDir, noExtensions));
+    const warmPromise = loader
+      .reload()
+      .then(() => {
+        entry.idle.push(loader);
+      })
+      .catch(() => {
+        /* ignore warm failures; foreground call reports real error */
+      })
+      .finally(() => {
+        entry.warming.delete(warmPromise);
+      });
+    entry.warming.add(warmPromise);
+  }
+
+  clear(): void {
+    this.entries.clear();
+  }
+
+  /** Test-only inspection helpers. */
+  _sizes(cwd: string, agentDir: string, noExtensions: boolean): { idle: number; active: number; warming: number } {
+    const entry = this.entries.get(this.key(cwd, agentDir, noExtensions));
+    if (!entry) return { idle: 0, active: 0, warming: 0 };
+    return { idle: entry.idle.length, active: entry.active.size, warming: entry.warming.size };
+  }
+}
+
+/** Default singleton used by the extension at runtime. */
+export const defaultLoaderPool = new LoaderPool();
+
+export async function allowUiPaint(coldLoader: boolean): Promise<void> {
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  if (!coldLoader) return;
+  // Give pi's TUI render timer a real timers-phase turn before CPU-heavy extension loading.
+  await new Promise<void>((resolve) => setTimeout(resolve, 50));
+  await new Promise<void>((resolve) => setImmediate(resolve));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fast-subagent",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "In-process subagent delegation for pi with single, parallel, and background modes",
   "type": "module",
   "keywords": [
@@ -36,9 +36,19 @@
     "agents.ts",
     "background-job-manager.ts",
     "background-types.ts",
+    "format.ts",
+    "loader-pool.ts",
+    "render.ts",
+    "runner.ts",
+    "schemas.ts",
+    "types.ts",
     "agents/*.md",
     "README.md"
   ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/*.test.ts"
+  },
   "pi": {
     "extensions": [
       "./index.ts"

package/render.ts

@@ -0,0 +1,459 @@
+/**
+ * Render function for the `subagent` tool's result panel.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getAgentDir, Theme, truncateToVisualLines, keyHint } from "@mariozechner/pi-coding-agent";
+import type { AgentToolResult, ToolRenderResultOptions } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
+import type { Component } from "@mariozechner/pi-tui";
+
+import { formatDuration, formatUsage } from "./format.js";
+import type { SubagentDetails, ToolCallEntry } from "./types.js";
+
+import type { ExecutionEvent } from "./types.js";
+
+const DEFAULT_PREVIEW_LINES = 12;
+const DEFAULT_PROMPT_PREVIEW_LINES = 12;
+
+/**
+ * From an ordered event log, find tool calls that ran AFTER the last text_delta.
+ * Returns { trailingToolIds, hasAnyText }. When no text has been emitted yet,
+ * hasAnyText is false and callers should show all tool calls instead.
+ */
+export function findTrailingTools(events: ExecutionEvent[]): {
+  trailingToolIds: string[];
+  hasAnyText: boolean;
+} {
+  if (events.length === 0) return { trailingToolIds: [], hasAnyText: false };
+  let lastTextIdx = -1;
+  let hasAnyText = false;
+  for (let i = events.length - 1; i >= 0; i--) {
+    if (events[i]!.type === "text_delta") { lastTextIdx = i; hasAnyText = true; break; }
+  }
+  const seen = new Set<string>();
+  const trailingToolIds: string[] = [];
+  for (let i = lastTextIdx + 1; i < events.length; i++) {
+    const evt = events[i]!;
+    if (evt.type === "tool_start" && !seen.has(evt.toolCallId)) {
+      seen.add(evt.toolCallId);
+      trailingToolIds.push(evt.toolCallId);
+    }
+  }
+  return { trailingToolIds, hasAnyText };
+}
+
+let _settingsCache: { previewLines: number; promptPreviewLines: number; readAt: number } | null = null;
+const SETTINGS_TTL_MS = 2000;
+
+function readPreviewSettings(): { previewLines: number; promptPreviewLines: number } {
+  const now = Date.now();
+  if (_settingsCache && now - _settingsCache.readAt < SETTINGS_TTL_MS) return _settingsCache;
+  let previewLines = DEFAULT_PREVIEW_LINES;
+  let promptPreviewLines = DEFAULT_PROMPT_PREVIEW_LINES;
+  try {
+    const path = join(getAgentDir(), "settings.json");
+    if (existsSync(path)) {
+      const settings = JSON.parse(readFileSync(path, "utf-8")) as {
+        fastSubagent?: { previewLines?: number; promptPreviewLines?: number };
+      };
+      const fs = settings.fastSubagent;
+      if (fs && typeof fs.previewLines === "number" && fs.previewLines > 0) {
+        previewLines = Math.floor(fs.previewLines);
+      }
+      if (fs && typeof fs.promptPreviewLines === "number" && fs.promptPreviewLines > 0) {
+        promptPreviewLines = Math.floor(fs.promptPreviewLines);
+      }
+    }
+  } catch {
+    // fall through to defaults
+  }
+  _settingsCache = { previewLines, promptPreviewLines, readAt: now };
+  return _settingsCache;
+}
+
+interface SubagentCallArgs {
+  agent?: unknown;
+  task?: unknown;
+  tasks?: unknown;
+  action?: unknown;
+  background?: unknown;
+}
+
+interface SubagentRenderCallContext {
+  state: Record<string, unknown>;
+  executionStarted: boolean;
+  argsComplete: boolean;
+}
+
+function asString(v: unknown): string | undefined {
+  return typeof v === "string" ? v : undefined;
+}
+
+function taskPreviewLines(task: string, width: number, maxLines: number): { lines: string[]; skipped: number } {
+  const innerWidth = Math.max(1, width - 2);
+  const visual: string[] = [];
+  for (const raw of task.split("\n")) {
+    try {
+      for (const w of wrapTextWithAnsi(raw, innerWidth)) visual.push(w);
+    } catch {
+      visual.push(truncateToWidth(raw, innerWidth, "..."));
+    }
+  }
+  const lines = visual.slice(0, maxLines).map((line) => truncateToWidth(`  ${line}`, width, "..."));
+  return { lines, skipped: Math.max(0, visual.length - lines.length) };
+}
+
+/**
+ * Render tool-call args while provider is still streaming them. This makes long
+ * subagent prompt generation visible before execute() can start.
+ */
+export function renderSubagentCall(
+  args: SubagentCallArgs,
+  theme: Theme,
+  context: SubagentRenderCallContext,
+): Component {
+  const cache = context.state as {
+    callWidth?: number;
+    callLines?: string[];
+    callKey?: string;
+  };
+
+  return {
+    invalidate() {
+      cache.callWidth = undefined;
+      cache.callLines = undefined;
+      cache.callKey = undefined;
+    },
+    render(width: number): string[] {
+      const key = JSON.stringify({ args, executionStarted: context.executionStarted, argsComplete: context.argsComplete, width });
+      if (cache.callWidth === width && cache.callKey === key && cache.callLines) return cache.callLines;
+
+      const out: string[] = [];
+      const agent = asString(args.agent);
+      const action = asString(args.action);
+      const task = asString(args.task);
+      const tasks = Array.isArray(args.tasks) ? args.tasks as Array<Record<string, unknown>> : undefined;
+      const isParallel = !!tasks?.length;
+      const status = context.executionStarted
+        ? "running"
+        : context.argsComplete
+          ? "starting"
+          : task || isParallel
+            ? "writing prompt"
+            : "waiting for prompt";
+      const mode = isParallel ? `Parallel (${tasks!.length})` : "Subagent";
+      const bg = args.background === true ? " · background" : "";
+      const target = agent ? ` ${agent}` : action ? ` ${action}` : "";
+      out.push(truncateToWidth(`${theme.fg("toolTitle", mode)}${target}${bg} · ${theme.fg("dim", status)}`, width, "..."));
+
+      // Once execution starts, result renderer owns prompt display. Keep call row compact.
+      if (context.executionStarted) {
+        cache.callWidth = width;
+        cache.callKey = key;
+        cache.callLines = out;
+        return out;
+      }
+
+      const maxLines = readPreviewSettings().promptPreviewLines;
+      if (task) {
+        out.push(truncateToWidth("Prompt:", width, "..."));
+        const preview = taskPreviewLines(task, width, maxLines);
+        out.push(...preview.lines);
+        if (preview.skipped > 0) out.push(truncateToWidth(theme.fg("muted", `  … (${preview.skipped} more lines)`), width, "..."));
+      } else if (tasks?.length) {
+        const maxRows = Math.max(1, Math.min(maxLines, tasks.length));
+        for (let i = 0; i < maxRows; i++) {
+          const t = tasks[i]!;
+          const rowAgent = asString(t.agent) ?? "?";
+          const rowTask = asString(t.task) ?? "";
+          out.push(truncateToWidth(`  [${rowAgent}] ${rowTask || theme.fg("dim", "writing prompt...")}`, width, "..."));
+        }
+        if (tasks.length > maxRows) out.push(truncateToWidth(theme.fg("muted", `  … (${tasks.length - maxRows} more task${tasks.length - maxRows === 1 ? "" : "s"})`), width, "..."));
+      } else {
+        out.push(truncateToWidth(theme.fg("dim", "  waiting for streamed tool arguments..."), width, "..."));
+      }
+
+      cache.callWidth = width;
+      cache.callKey = key;
+      cache.callLines = out;
+      return out;
+    },
+  };
+}
+
+export function renderSubagentResult(
+  result: AgentToolResult<unknown>,
+  { isPartial, expanded }: ToolRenderResultOptions,
+  theme: Theme,
+) {
+  const agentText = result.content?.[0]?.type === "text" ? (result.content[0] as any).text as string : "";
+  const details = (result.details ?? {}) as SubagentDetails;
+  const toolCalls = details.toolCalls ?? [];
+
+  // ── Parallel mode render ──────────────────────────────────────
+  if (details.mode === "parallel" && details.parallelAgents) {
+    const agents = details.parallelAgents;
+    const doneCount = agents.filter((a) => a.status === "done" || a.status === "error").length;
+
+    function agentToolRow(t: ToolCallEntry): string {
+      const arg = t.argSummary || "";
+      const call = `${t.name}(${arg})`;
+      if (t.result === undefined) return theme.fg("dim", call);
+      const dur = t.durMs != null ? (t.durMs < 1000 ? ` ${t.durMs}ms` : ` ${(t.durMs / 1000).toFixed(1)}s`) : "";
+      return `${call}${t.isError ? " ✗" : ` ✓${dur}`}`;
+    }
+
+    function wrapL(text: string, w: number): string[] {
+      try { return wrapTextWithAnsi(text, w); } catch { return [truncateToWidth(text, w, "...")]; }
+    }
+
+    const cache: { width?: number } = {};
+    return {
+      invalidate() { cache.width = undefined; },
+      render(width: number): string[] {
+        const out: string[] = [];
+        const header = details.running
+          ? `Parallel (${doneCount}/${agents.length} done)`
+          : `Parallel: ${agents.filter((a) => a.status === "done").length}/${agents.length} succeeded`;
+        out.push(truncateToWidth(header, width, "..."));
+
+        for (const a of agents) {
+          const dur = a.durMs != null ? (a.durMs < 1000 ? ` ${a.durMs}ms` : ` ${(a.durMs / 1000).toFixed(1)}s`) : "";
+          const mark = a.status === "pending" ? theme.fg("dim", "⋅")
+            : a.status === "running" ? theme.fg("dim", "→")
+            : a.status === "done" ? `✓${dur}` : `✗${dur}`;
+
+          if (expanded) {
+            out.push("");
+            out.push(truncateToWidth(`[${a.name}] ${mark}`, width, "..."));
+            out.push(truncateToWidth(`Prompt:`, width, "..."));
+            out.push(truncateToWidth(`  ${a.taskSummary}`, width, "..."));
+            for (const t of a.toolCalls ?? []) {
+              out.push(truncateToWidth(agentToolRow(t), width, "..."));
+            }
+            if (a.responseText) {
+              out.push("Response:");
+              const preview = truncateToVisualLines(a.responseText, 6, width - 2);
+              for (const l of preview.visualLines) out.push(truncateToWidth("  " + l, width, "..."));
+              if (preview.skippedCount > 0) out.push(truncateToWidth(theme.fg("dim", `  … ${preview.skippedCount} more lines`), width, "..."));
+            } else if (a.status === "running") {
+              out.push(theme.fg("dim", "  running..."));
+            }
+          } else {
+            const row = `  [${a.name}] ${mark}  ${a.taskSummary}`;
+            out.push(truncateToWidth(row, width, "..."));
+            for (const t of a.toolCalls ?? []) {
+              out.push(truncateToWidth(`    ${agentToolRow(t)}`, width, "..."));
+            }
+            if (a.responseText && (a.status === "done" || a.status === "error")) {
+              const preview = truncateToVisualLines(a.responseText, 2, width - 4);
+              for (const l of preview.visualLines) out.push(truncateToWidth("    " + l, width, "..."));
+            }
+          }
+        }
+
+        out.push("");
+        const status = details.running
+          ? ["running", details.usage?.turns ? `${details.usage.turns} turn${details.usage.turns > 1 ? "s" : ""}` : ""].filter(Boolean).join(" · ")
+          : formatUsage(details.usage ?? { input: 0, output: 0, cost: 0, turns: 0 }, details.model);
+        const expandHint = !expanded ? keyHint("app.tools.expand", "expand for full output") : "";
+        out.push(truncateToWidth([status, expandHint].filter(Boolean).join("  "), width, "..."));
+        // Suppress unused warning
+        void wrapL;
+        return out;
+      },
+    };
+  }
+
+  // ── Single mode render ────────────────────────────────────────
+
+  function statusLine(): string {
+    if (details.backgroundJobId) return `moved to background · ${details.backgroundJobId}`;
+    if (details.running) {
+      const parts: string[] = ["running"];
+      if (details.usage?.turns) parts.push(`${details.usage.turns} turn${details.usage.turns > 1 ? "s" : ""}`);
+      if (details.elapsedMs != null) parts.push(formatDuration(details.elapsedMs));
+      if (details.model) parts.push(details.model);
+      return parts.join(" · ");
+    }
+    return formatUsage(details.usage ?? { input: 0, output: 0, cost: 0, turns: 0 }, details.model);
+  }
+
+  function toolRow(t: ToolCallEntry): string {
+    const arg = t.argSummary ? t.argSummary : "";
+    const call = `${t.name}(${arg})`;
+    if (t.result === undefined) return theme.fg("dim", call);
+    const dur = t.durMs != null
+      ? t.durMs < 1000 ? ` ${t.durMs}ms` : ` ${(t.durMs / 1000).toFixed(1)}s`
+      : "";
+    return `${call}${t.isError ? " ✗" : ` ✓${dur}`}`;
+  }
+
+  function wrapLine(text: string, w: number): string[] {
+    try { return wrapTextWithAnsi(text, w); } catch { return [truncateToWidth(text, w, "...")]; }
+  }
+
+  const cache: {
+    width?: number;
+    promptLines?: string[];
+    promptSkipped?: number;
+    responseLines?: string[];
+    skipped?: number;
+  } = {};
+
+  function renderExpandedChronological(width: number): string[] {
+    const out: string[] = [];
+    const indent = "  ";
+    const events = details.executionEvents || [];
+    const toolLineMap = new Map<string, number>(); // toolCallId → line index where tool_start was rendered
+
+    if (details.task) {
+      out.push("Prompt:");
+      for (const line of details.task.split("\n")) {
+        for (const w of wrapLine(indent + line, width)) out.push(w);
+      }
+    }
+
+    if (events.length === 0) {
+      // Fallback: no events, render tool calls then response
+      for (const t of toolCalls) {
+        out.push(truncateToWidth(toolRow(t), width, "..."));
+        if (t.result !== undefined) {
+          for (const line of t.result.split("\n")) {
+            for (const w of wrapLine(theme.fg("dim", indent + line), width)) out.push(w);
+          }
+        }
+      }
+      const responseText = agentText || "";
+      if (responseText) {
+        for (const line of responseText.split("\n")) {
+          for (const w of wrapLine(indent + line, width)) out.push(w);
+        }
+      }
+    } else {
+      // Render events chronologically
+      let lastWasText = false;
+      const agentLabel = `${details.agentName ?? "Agent"}:`;
+      for (const evt of events) {
+        if (evt.type === "tool_start") {
+          lastWasText = false;
+          const call = `${evt.toolName}(${evt.argSummary})`;
+          toolLineMap.set(evt.toolCallId, out.length);
+          out.push(truncateToWidth(call, width, "..."));
+        } else if (evt.type === "text_delta") {
+          if (!lastWasText) {
+            out.push(truncateToWidth(theme.fg("toolTitle", agentLabel), width, "..."));
+            lastWasText = true;
+          }
+          for (const line of evt.text.split("\n")) {
+            for (const w of wrapLine(indent + line, width)) out.push(w);
+          }
+        } else if (evt.type === "tool_end") {
+          lastWasText = false;
+          const toolLineIdx = toolLineMap.get(evt.toolCallId);
+          const dur = evt.durMs != null
+            ? evt.durMs < 1000 ? ` ${evt.durMs}ms` : ` ${(evt.durMs / 1000).toFixed(1)}s`
+            : "";
+          const statusMark = evt.isError ? " ✗" : ` ✓${dur}`;
+          if (toolLineIdx != null) {
+            out[toolLineIdx] = truncateToWidth((out[toolLineIdx] ?? "") + statusMark, width, "...");
+          }
+          if (evt.result) {
+            for (const line of evt.result.split("\n")) {
+              for (const w of wrapLine(theme.fg("dim", indent + line), width)) out.push(w);
+            }
+          }
+        }
+      }
+    }
+
+    return out;
+  }
+
+  return {
+    invalidate() { cache.width = undefined; },
+    render(width: number): string[] {
+      const out: string[] = [];
+      const indent = "  ";
+      const ellipsisLine = (count: number) =>
+        theme.fg("muted", `${indent}… (${count} more line${count === 1 ? "" : "s"})`);
+
+      if (expanded) {
+        // Expanded: render chronologically from events
+        const expandedOut = renderExpandedChronological(width);
+        expandedOut.push("");
+        const status = statusLine();
+        if (status) expandedOut.push(truncateToWidth(status, width, "..."));
+        if (details.running && !details.backgroundJobId) {
+          expandedOut.push(truncateToWidth(theme.fg("dim", "Ctrl+Shift+B: move to background"), width, "..."));
+        }
+        return expandedOut;
+      }
+
+      // Collapsed view
+      if (details.task) {
+        out.push("Prompt:");
+        const PROMPT_PREVIEW_LINES = readPreviewSettings().promptPreviewLines;
+        if (cache.width !== width || cache.promptLines === undefined) {
+          const innerWidth = Math.max(1, width - indent.length);
+          const allVisual: string[] = [];
+          for (const raw of details.task.split("\n")) {
+            for (const w of wrapLine(raw, innerWidth)) allVisual.push(w);
+          }
+          const head = allVisual.slice(0, PROMPT_PREVIEW_LINES);
+          cache.promptLines = head.map((l) => truncateToWidth(indent + l, width, "..."));
+          cache.promptSkipped = Math.max(0, allVisual.length - head.length);
+        }
+        out.push(...cache.promptLines);
+        if ((cache.promptSkipped ?? 0) > 0) {
+          out.push(truncateToWidth(ellipsisLine(cache.promptSkipped!), width, "..."));
+        }
+      }
+
+      // Find trailing tool calls (those that ran AFTER the last text_delta)
+      const { trailingToolIds, hasAnyText } = findTrailingTools(details.executionEvents || []);
+
+      const responseText = agentText || (isPartial ? "" : "");
+      if (responseText || isPartial) {
+        const agentLabel = `${details.agentName ?? "Agent"}:`;
+        out.push(truncateToWidth(theme.fg("toolTitle", agentLabel), width, "..."));
+        const PREVIEW_LINES = readPreviewSettings().previewLines;
+        if (cache.width !== width) {
+          const preview = truncateToVisualLines(responseText, PREVIEW_LINES, width - indent.length);
+          cache.responseLines = preview.visualLines.map((l) => truncateToWidth(indent + l, width, "..."));
+          cache.skipped = preview.skippedCount;
+          cache.width = width;
+        }
+        out.push(...(cache.responseLines ?? []));
+        if ((cache.skipped ?? 0) > 0) {
+          out.push(truncateToWidth(ellipsisLine(cache.skipped!), width, "..."));
+        }
+      }
+
+      // Show trailing tool calls (those that ran after the last text block)
+      // If no text yet, show all tools to indicate progress.
+      const toolsToShow = hasAnyText
+        ? toolCalls.filter((t) => trailingToolIds.includes(t.id))
+        : toolCalls;
+      for (let i = 0; i < toolsToShow.length; i++) {
+        const t = toolsToShow[i]!;
+        const isLast = i === toolsToShow.length - 1;
+        const connector = theme.fg("muted", isLast ? "└─ " : "├─ ");
+        out.push(truncateToWidth(indent + connector + toolRow(t), width, "..."));
+      }
+
+      const status = statusLine();
+      const totalSkipped = (cache.skipped ?? 0) + (cache.promptSkipped ?? 0);
+      const expandHint = !expanded ? keyHint("app.tools.expand", "verbose") : "";
+      const statusWithHint = [status, expandHint].filter(Boolean).join("  ");
+      if (statusWithHint) out.push(truncateToWidth(statusWithHint, width, "..."));
+      if (details.running && !details.backgroundJobId)
+        out.push(truncateToWidth(theme.fg("dim", "Ctrl+Shift+B: move to background"), width, "..."));
+
+      return out;
+    },
+  };
+}