little-coder 1.8.4 → 1.9.0

package/.pi/extensions/prompt-history/index.ts

@@ -0,0 +1,154 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { CustomEditor } from "@earendil-works/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// Up-arrow prompt history, persisted across sessions.
+//
+// pi's default editor exposes an `addToHistory` hook (which pi calls on every
+// submit) but ships no actual navigation, so up-arrow does nothing. We provide a
+// custom editor — a subclass of pi's own CustomEditor, so pi copies all the
+// app keybindings, autocomplete, and submit wiring onto it (see
+// interactive-mode.setCustomEditorComponent) — that implements `addToHistory`
+// and recalls history on ↑ / ↓.
+//
+// Why a custom editor and not raw onTerminalInput key-matching: pi runs the
+// Kitty keyboard protocol (flags=7), so arrows arrive as CSI-u sequences with
+// press/repeat/release events. The editor path (a) only sees press/repeat —
+// the TUI filters releases before handleInput — and (b) lets us detect ↑/↓ via
+// keybindings.matches(), which already understands every encoding. Both are
+// brittle to reproduce from raw bytes.
+//
+// History is stored in <agentDir>/little-coder-prompt-history.json so a brand
+// new session (even one with no messages) can recall prompts from earlier runs.
+
+const MAX = 100;
+
+function agentDir(): string {
+  const env = process.env.PI_CODING_AGENT_DIR;
+  if (env && env.trim().length > 0) {
+    if (env === "~") return homedir();
+    if (env.startsWith("~/")) return homedir() + env.slice(1);
+    return env;
+  }
+  return join(homedir(), ".pi", "agent");
+}
+
+function historyFile(): string {
+  return join(agentDir(), "little-coder-prompt-history.json");
+}
+
+export function loadHistory(): string[] {
+  try {
+    const raw = JSON.parse(readFileSync(historyFile(), "utf-8"));
+    if (Array.isArray(raw)) return raw.filter((x) => typeof x === "string").slice(-MAX);
+  } catch {
+    // missing / unreadable / corrupt — start empty
+  }
+  return [];
+}
+
+function saveHistory(items: string[]): void {
+  try {
+    const dir = dirname(historyFile());
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(historyFile(), JSON.stringify(items.slice(-MAX)));
+  } catch {
+    // best-effort; recall still works in-process this session
+  }
+}
+
+/**
+ * Pure history store. `recall("up"|"down", currentText)` returns the text to
+ * place in the editor, or null to let the editor handle the key normally.
+ * Navigation only STARTS from an empty prompt (so it never clobbers a draft or
+ * fights multi-line cursor movement); once navigating, ↑/↓ walk the list.
+ */
+export function makeHistory(initial: string[] = [], persist: (items: string[]) => void = () => {}) {
+  const items = initial.slice(-MAX);
+  let nav = -1;
+
+  return {
+    items,
+    add(text: string) {
+      const t = (text ?? "").trim();
+      if (!t) return;
+      if (items[items.length - 1] !== text) {
+        items.push(text);
+        while (items.length > MAX) items.shift();
+        persist(items);
+      }
+      nav = -1;
+    },
+    reset() {
+      nav = -1;
+    },
+    recall(dir: "up" | "down", current: string): string | null {
+      if (dir === "up") {
+        if (nav === -1) {
+          if (current !== "" || items.length === 0) return null; // only from empty
+          nav = items.length - 1;
+        } else if (nav > 0) {
+          nav -= 1;
+        }
+        return items[nav];
+      }
+      // down
+      if (nav === -1) return null;
+      if (nav < items.length - 1) {
+        nav += 1;
+        return items[nav];
+      }
+      nav = -1;
+      return ""; // past the newest → empty prompt
+    },
+  };
+}
+
+export default function (pi: ExtensionAPI) {
+  const store = makeHistory(loadHistory(), saveHistory);
+
+  // A CustomEditor that adds history recall. pi copies app keybindings,
+  // autocomplete, and submit/change wiring onto it after construction.
+  class HistoryEditor extends CustomEditor {
+    private kb: any;
+    private tuiRef: any;
+    constructor(tui: any, theme: any, keybindings: any, options?: any) {
+      super(tui, theme, keybindings, options);
+      this.kb = keybindings;
+      this.tuiRef = tui;
+    }
+
+    // pi calls this on every submit — our hook to record + persist the prompt.
+    addToHistory(text: string): void {
+      store.add(text);
+    }
+
+    handleInput(data: string): void {
+      const up = this.kb?.matches?.(data, "tui.editor.cursorUp");
+      const down = this.kb?.matches?.(data, "tui.editor.cursorDown");
+      // Don't hijack ↑/↓ while the autocomplete dropdown is open — it owns them.
+      const autocompleting = (this as any).isShowingAutocomplete?.() === true;
+      if ((up || down) && !autocompleting) {
+        const next = store.recall(up ? "up" : "down", this.getText());
+        if (next !== null) {
+          this.setText(next);
+          this.tuiRef?.requestRender?.();
+          return;
+        }
+      }
+      // Any non-navigation key ends the current recall walk.
+      if (!up && !down) store.reset();
+      super.handleInput(data);
+    }
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI || typeof (ctx.ui as any).setEditorComponent !== "function") return;
+    store.reset();
+    (ctx.ui as any).setEditorComponent(
+      (tui: any, theme: any, keybindings: any) => new HistoryEditor(tui, theme, keybindings),
+    );
+  });
+}

package/.pi/extensions/prompt-history/prompt-history.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest";
+import { makeHistory } from "./index.ts";
+
+describe("prompt history recall", () => {
+  it("records prompts, skipping blanks and consecutive duplicates", () => {
+    const h = makeHistory();
+    h.add("first");
+    h.add("  "); // blank
+    h.add("second");
+    h.add("second"); // dup
+    expect(h.items).toEqual(["first", "second"]);
+  });
+
+  it("persists on add via the provided callback", () => {
+    const saved: string[][] = [];
+    const h = makeHistory([], (items) => saved.push([...items]));
+    h.add("one");
+    h.add("two");
+    expect(saved).toEqual([["one"], ["one", "two"]]);
+  });
+
+  it("seeds from initial (cross-session) history", () => {
+    const h = makeHistory(["older", "newer"]);
+    expect(h.recall("up", "")).toBe("newer");
+    expect(h.recall("up", "newer")).toBe("older");
+  });
+
+  it("up from an empty prompt recalls most-recent-first and clamps", () => {
+    const h = makeHistory(["a", "b", "c"]);
+    expect(h.recall("up", "")).toBe("c");
+    expect(h.recall("up", "c")).toBe("b");
+    expect(h.recall("up", "b")).toBe("a");
+    expect(h.recall("up", "a")).toBe("a"); // clamps at oldest
+  });
+
+  it("down walks forward and clears past the newest", () => {
+    const h = makeHistory(["a", "b"]);
+    h.recall("up", ""); // → b
+    h.recall("up", "b"); // → a
+    expect(h.recall("down", "a")).toBe("b");
+    expect(h.recall("down", "b")).toBe(""); // past newest → empty
+  });
+
+  it("does NOT hijack up when the prompt is non-empty (editor handles it)", () => {
+    const h = makeHistory(["a"]);
+    expect(h.recall("up", "draft text")).toBeNull();
+  });
+
+  it("does nothing on up when there is no history", () => {
+    const h = makeHistory([]);
+    expect(h.recall("up", "")).toBeNull();
+  });
+
+  it("down with no active navigation is a no-op (editor handles it)", () => {
+    const h = makeHistory(["a"]);
+    expect(h.recall("down", "")).toBeNull();
+  });
+
+  it("reset() ends navigation so the next up starts fresh", () => {
+    const h = makeHistory(["a", "b"]);
+    h.recall("up", ""); // → b (navigating)
+    h.reset();
+    expect(h.recall("up", "b")).toBeNull(); // non-empty + not navigating → editor handles
+  });
+
+  it("caps stored history at the maximum", () => {
+    const many = Array.from({ length: 150 }, (_, i) => `p${i}`);
+    const h = makeHistory(many);
+    expect(h.items.length).toBe(100);
+    expect(h.items[0]).toBe("p50"); // kept the newest 100
+  });
+});

package/.pi/extensions/read-guard-edit/index.ts

@@ -0,0 +1,89 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { normalizeWritePath } from "../write-guard/index.ts";
+import { harnessIntervention } from "../_shared/intervention.ts";
+
+// Read-before-edit guard.
+//
+// Small models routinely fire `edit` with an `oldText` they never actually saw
+// — guessing at the current file contents — which either fails the exact-match
+// requirement (wasting a turn) or, worse, matches the wrong span. Editors the
+// user is used to (Claude Code et al.) enforce a simple invariant: a file must
+// be Read before it can be Edited. We reproduce that here.
+//
+// Mechanism mirrors write-guard: we don't own pi's built-in `read`/`edit`
+// tools, so we enforce at the event layer. We remember every file that was
+// successfully `read` this session (`tool_result`, !isError), and block any
+// `edit` whose target hasn't been read, redirecting the model to Read first.
+//
+// Why a separate extension from `read-guard`: read-guard trims an oversized
+// read so it can't overflow a small context window — a different concern from
+// the read-before-edit invariant. Keeping them apart keeps each single-purpose.
+//
+// A successful `edit` or `write` also marks the path as known: an edit only
+// succeeds when the file was already read (we'd have blocked it otherwise), and
+// a write means the model authored the file's contents, so a follow-up edit to
+// either is legitimate without a re-read.
+
+// Files read (or authored) in the current session. Module-scoped: one pi
+// process drives one session at a time, and we clear on session_start.
+export const readFiles = new Set<string>();
+
+// pi's built-in tools use `path`; some prompts/older builds use `file_path`.
+// Accept both so the guard is independent of which key the model emits.
+export function resolveToolPath(
+  input: Record<string, unknown>,
+  cwd: string,
+): string | undefined {
+  const raw =
+    typeof input.path === "string"
+      ? input.path
+      : typeof input.file_path === "string"
+        ? input.file_path
+        : undefined;
+  if (!raw) return undefined;
+  return normalizeWritePath(raw, cwd).path;
+}
+
+export function editBeforeReadReason(resolved: string): string {
+  return (
+    `File must be read first before edit — ${resolved} has not been read in ` +
+    `this session.\n` +
+    `\n` +
+    `Read ${resolved} first to get the exact current text for oldText ` +
+    `(whitespace and indentation must match exactly), then issue the Edit. ` +
+    `Reading also lets you include enough surrounding context (2-3 lines) to ` +
+    `make oldText unique in the file. Do NOT guess the file's contents.`
+  );
+}
+
+export default function (pi: ExtensionAPI) {
+  // New session (startup, /clear, /resume, reload) is a clean slate — what was
+  // read in a previous session says nothing about the current one.
+  pi.on("session_start", async () => {
+    readFiles.clear();
+  });
+
+  // Record successful reads (and authored files) as "known".
+  pi.on("tool_result", async (event, ctx) => {
+    const name = String((event as any).toolName ?? "").toLowerCase();
+    if (name !== "read" && name !== "edit" && name !== "write") return;
+    if ((event as any).isError) return;
+    const p = resolveToolPath(((event as any).input ?? {}) as Record<string, unknown>, ctx.cwd);
+    if (p) readFiles.add(p);
+  });
+
+  // Block edits to files that were never read.
+  pi.on("tool_call", async (event, ctx) => {
+    if (String((event as any).toolName ?? "").toLowerCase() !== "edit") return;
+    const input = ((event as any).input ?? {}) as Record<string, unknown>;
+    const p = resolveToolPath(input, ctx.cwd);
+    if (!p) return; // no resolvable path — let the edit tool surface its own error
+    if (readFiles.has(p)) return; // already read this session — allow
+
+    harnessIntervention(
+      ctx,
+      "the model tried to edit a file it hadn't read — redirected it to Read first.",
+    );
+    return { block: true, reason: editBeforeReadReason(p) };
+  });
+}

package/.pi/extensions/read-guard-edit/read-guard-edit.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import setupReadGuardEdit, { readFiles, resolveToolPath } from "./index.ts";
+
+describe("resolveToolPath", () => {
+  const cwd = "/home/me/proj";
+  it("resolves relative paths against cwd", () => {
+    expect(resolveToolPath({ path: "src/a.ts" }, cwd)).toBe("/home/me/proj/src/a.ts");
+  });
+  it("honors the file_path key", () => {
+    expect(resolveToolPath({ file_path: "b.ts" }, cwd)).toBe("/home/me/proj/b.ts");
+  });
+  it("returns undefined with no path", () => {
+    expect(resolveToolPath({ content: "x" }, cwd)).toBeUndefined();
+  });
+});
+
+// Wire up the extension against a fake pi, capturing each registered handler.
+function setup() {
+  const handlers: Record<string, (...args: any[]) => any> = {};
+  const pi = {
+    on(name: string, h: (...args: any[]) => any) {
+      handlers[name] = h;
+    },
+  };
+  setupReadGuardEdit(pi as any);
+  return handlers;
+}
+
+function makeCtx(cwd: string) {
+  const notifies: string[] = [];
+  return { cwd, notifies, ui: { notify: (m: string) => notifies.push(m) } };
+}
+
+describe("read-before-edit guard", () => {
+  const cwd = "/home/me/proj";
+  beforeEach(() => readFiles.clear());
+
+  it("blocks an edit to a file that was never read", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts", edits: [] } }, ctx);
+    expect(result?.block).toBe(true);
+    expect(result.reason).toContain("must be read first");
+    expect(result.reason).toContain("/home/me/proj/a.ts");
+    expect(ctx.notifies[0]).toMatch(/harness intervention:.*Read first/i);
+  });
+
+  it("allows an edit after the file was successfully read", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "read", isError: false, input: { path: "a.ts" } }, ctx);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts", edits: [] } }, ctx);
+    expect(result).toBeUndefined();
+    expect(ctx.notifies).toHaveLength(0);
+  });
+
+  it("does not count a failed read as having read the file", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "read", isError: true, input: { path: "a.ts" } }, ctx);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts" } }, ctx);
+    expect(result?.block).toBe(true);
+  });
+
+  it("treats a freshly written file as known (write then edit is allowed)", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "write", isError: false, input: { path: "new.ts" } }, ctx);
+    const result = await h.tool_call({ toolName: "edit", input: { path: "new.ts" } }, ctx);
+    expect(result).toBeUndefined();
+  });
+
+  it("clears known files on session_start", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    await h.tool_result({ toolName: "read", isError: false, input: { path: "a.ts" } }, ctx);
+    await h.session_start();
+    const result = await h.tool_call({ toolName: "edit", input: { path: "a.ts" } }, ctx);
+    expect(result?.block).toBe(true);
+  });
+
+  it("matches reads and edits that use different path spellings for the same file", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    // read with cwd-relative, edit with the absolute form of the same file
+    await h.tool_result({ toolName: "read", isError: false, input: { path: "src/a.ts" } }, ctx);
+    const result = await h.tool_call(
+      { toolName: "edit", input: { path: "/home/me/proj/src/a.ts" } },
+      ctx,
+    );
+    expect(result).toBeUndefined();
+  });
+
+  it("ignores non-edit tool calls", async () => {
+    const h = setup();
+    const ctx = makeCtx(cwd);
+    const result = await h.tool_call({ toolName: "grep", input: { pattern: "x" } }, ctx);
+    expect(result).toBeUndefined();
+  });
+});

package/.pi/extensions/skill-inject/index.ts

@@ -56,6 +56,9 @@ const INTENT_MAP: Record<string, string[]> = {
   browse: ["BrowserNavigate", "BrowserExtract"],
   page: ["BrowserExtract"],
   click: ["BrowserClick"],
+  // Sub-coder delegation
+  delegate: ["dispatch"], dispatch: ["dispatch"], subagent: ["dispatch"],
+  investigate: ["dispatch"], parallel: ["dispatch"],
 };
 
 function skillsDir(): string {

package/.pi/extensions/skill-inject/selector.test.ts

@@ -60,10 +60,10 @@ describe("skills directory loads from repo", () => {
   const here = dirname(fileURLToPath(import.meta.url));
   const toolsDir = join(here, "..", "..", "..", "skills", "tools");
 
-  it("exists and has 13 markdown files", () => {
+  it("exists and has 14 markdown files", () => {
     expect(existsSync(toolsDir)).toBe(true);
     const files = readdirSync(toolsDir).filter((f) => f.endsWith(".md"));
-    expect(files.length).toBe(13);
+    expect(files.length).toBe(14);
   });
 
   it("every tool skill has target_tool in frontmatter", () => {

package/.pi/extensions/subagent/index.ts

@@ -0,0 +1,201 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import {
+  runSubCoder,
+  runSubCodersConcurrent,
+  truncateReport,
+  type SubCoderItem,
+  type SubCoderResult,
+} from "./spawn.ts";
+import { SubCoderTracker } from "./tracker.ts";
+
+// The `dispatch` tool: the main little-coder spawns isolated child little-coder
+// sessions ("sub-coders") to research a focused question — they read the repo
+// and browse online, then return a CONCISE report. The full child transcript
+// lives in the tool's `details` (UI-only); only the short report enters the
+// parent model's context. A live panel above the input tracks them while they
+// run. See spawn.ts for the engine and the read-only constraints.
+
+const MAX_PARALLEL = 4;
+
+/** "provider/id" of the current model, so children run on the same backend. */
+export function currentModelId(ctx: any): string | undefined {
+  const m = ctx?.model;
+  if (!m || typeof m.id !== "string") return undefined;
+  return m.provider ? `${m.provider}/${m.id}` : m.id;
+}
+
+/** A short label for a single-mode task (first few words). */
+function shortLabel(task: string): string {
+  const words = task.trim().split(/\s+/).filter(Boolean).slice(0, 4).join(" ");
+  return words.length > 28 ? `${words.slice(0, 27)}…` : words || "sub-coder";
+}
+
+function buildContent(results: SubCoderResult[]): string {
+  if (results.length === 1) {
+    const r = results[0];
+    if (r.exitCode !== 0) return `Sub-coder "${r.label}" ${r.stopReason || "failed"}: ${r.errorMessage || "(no output)"}`;
+    return truncateReport(r.report) || "(no report)";
+  }
+  const ok = results.filter((r) => r.exitCode === 0).length;
+  const blocks = results.map((r) => {
+    const status = r.exitCode === 0 ? "" : ` [${r.stopReason || "failed"}]`;
+    const body = r.exitCode === 0 ? truncateReport(r.report) : r.errorMessage || "(no output)";
+    return `### ${r.label}${status}\n${body || "(no report)"}`;
+  });
+  return `${ok}/${results.length} sub-coders succeeded.\n\n${blocks.join("\n\n")}`;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "dispatch",
+    label: "Dispatch sub-coder",
+    description: [
+      "Dispatch one or more isolated sub-coders to research a focused question.",
+      "Each runs in its own context window, can read the repo and browse online",
+      "(read, grep, glob, webfetch, websearch, browser, read-only bash) but CANNOT",
+      "edit or write files. Each returns a concise report. Use this to gather",
+      "information without cluttering your own context.",
+      "Single: { task }. Parallel: { tasks: [{ label, task }] } (max 4).",
+    ].join(" "),
+    parameters: Type.Object({
+      task: Type.Optional(Type.String({ description: "A single research task (single mode)" })),
+      tasks: Type.Optional(
+        Type.Array(
+          Type.Object({
+            label: Type.String({ description: "Short name for this sub-coder (shown in the tracker)" }),
+            task: Type.String({ description: "The research task delegated to this sub-coder" }),
+          }),
+          { description: `Up to ${MAX_PARALLEL} tasks to run in parallel` },
+        ),
+      ),
+      cwd: Type.Optional(Type.String({ description: "Working directory for the sub-coders (default: current)" })),
+    }),
+
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const hasSingle = typeof params.task === "string" && params.task.trim().length > 0;
+      const hasTasks = Array.isArray(params.tasks) && params.tasks.length > 0;
+      if (hasSingle === hasTasks) {
+        return {
+          content: [{ type: "text", text: "Provide exactly one of `task` (single) or `tasks` (parallel)." }],
+          details: { results: [] },
+          isError: true,
+        };
+      }
+      if (hasTasks && params.tasks!.length > MAX_PARALLEL) {
+        return {
+          content: [{ type: "text", text: `Too many parallel tasks (${params.tasks!.length}). Max is ${MAX_PARALLEL}.` }],
+          details: { results: [] },
+          isError: true,
+        };
+      }
+
+      const cwd = params.cwd || ctx.cwd;
+      const items: SubCoderItem[] = hasSingle
+        ? [{ id: "1", label: shortLabel(params.task!), task: params.task!, cwd }]
+        : params.tasks!.map((t, i) => ({ id: String(i + 1), label: t.label, task: t.task, cwd }));
+
+      const model = currentModelId(ctx);
+      const tracker = new SubCoderTracker(ctx as any);
+      tracker.begin(items.map((it) => ({ id: it.id, label: it.label })));
+
+      const streamToToolCard = (results: SubCoderResult[]) => {
+        if (!onUpdate) return;
+        const done = results.filter((r) => r.exitCode !== -1).length;
+        onUpdate({
+          content: [{ type: "text", text: `${done}/${results.length} sub-coders done…` }],
+          details: { results },
+        });
+      };
+
+      let results: SubCoderResult[];
+      try {
+        if (hasSingle) {
+          const r = await runSubCoder({
+            ...items[0],
+            model,
+            signal,
+            onUpdate: (live) => {
+              tracker.update([live]);
+              streamToToolCard([live]);
+            },
+          });
+          results = [r];
+        } else {
+          results = await runSubCodersConcurrent(items, {
+            model,
+            signal,
+            onUpdate: (all) => {
+              tracker.update(all);
+              streamToToolCard(all);
+            },
+          });
+        }
+      } finally {
+        tracker.end();
+      }
+
+      const anyError = results.some((r) => r.exitCode !== 0);
+      const allError = results.every((r) => r.exitCode !== 0);
+      return {
+        content: [{ type: "text", text: buildContent(results) }],
+        details: { results },
+        isError: allError && anyError,
+      };
+    },
+
+    // Renderers return a duck-typed Component ({ render→lines, invalidate }).
+    // pi 0.79 stopped hoisting pi-tui, so we build colored lines via `theme`
+    // rather than importing pi-tui primitives (same approach as branding).
+    renderCall(args: any, theme: any) {
+      const lines: string[] = [];
+      const title = theme.fg("toolTitle", theme.bold("dispatch "));
+      if (Array.isArray(args.tasks) && args.tasks.length > 0) {
+        lines.push(title + theme.fg("accent", `${args.tasks.length} sub-coders`));
+        for (const t of args.tasks.slice(0, MAX_PARALLEL)) {
+          const preview = t.task.length > 48 ? `${t.task.slice(0, 48)}…` : t.task;
+          lines.push(`  ${theme.fg("accent", t.label)}${theme.fg("dim", ` — ${preview}`)}`);
+        }
+      } else {
+        const task = String(args.task ?? "…");
+        lines.push(title + theme.fg("dim", task.length > 64 ? `${task.slice(0, 64)}…` : task));
+      }
+      return makeComponent(lines);
+    },
+
+    renderResult(result: any, options: any, theme: any) {
+      const expanded = !!options?.expanded;
+      const results: SubCoderResult[] = result?.details?.results ?? [];
+      if (results.length === 0) {
+        const t = result?.content?.[0];
+        return makeComponent([t?.type === "text" ? t.text : "(no output)"]);
+      }
+      const ok = results.filter((r) => r.exitCode === 0).length;
+      const lines: string[] = [
+        theme.fg("toolTitle", theme.bold("dispatch ")) + theme.fg("accent", `${ok}/${results.length} sub-coders`),
+      ];
+      for (const r of results) {
+        const icon = r.exitCode === 0 ? theme.fg("success", "✓") : theme.fg("error", "✗");
+        lines.push("");
+        lines.push(`${icon} ${theme.fg("accent", r.label)}`);
+        const body = r.exitCode === 0 ? r.report : r.errorMessage || r.stderr || "(no output)";
+        const bodyLines = body.trim() ? body.trim().split("\n") : ["(no output)"];
+        const shown = expanded ? bodyLines : bodyLines.slice(0, 4);
+        for (const bl of shown) lines.push(theme.fg("toolOutput", bl));
+        if (!expanded && bodyLines.length > shown.length) lines.push(theme.fg("muted", "  …"));
+      }
+      if (!expanded) lines.push(theme.fg("muted", "(Ctrl+O to expand)"));
+      return makeComponent(lines);
+    },
+  });
+}
+
+/** A minimal pi-tui Component backed by precomputed lines. */
+function makeComponent(lines: string[]) {
+  return {
+    render(_width: number): string[] {
+      return lines;
+    },
+    invalidate() {},
+  };
+}