@pi-spice/minimal-subagents 0.1.0

package/README.md

@@ -0,0 +1,39 @@
+# @pi-spice/minimal-subagents
+
+One tool, `spawn_agents`: describe sub-agents inline, run them in parallel, block until every one finishes. No predefined agent files, no orchestration, no nesting. Each sub-agent is an isolated `pi` process with its own context window; the child-process machinery is adapted from pi's official subagent example.
+
+## Install
+
+```bash
+pi install npm:@pi-spice/minimal-subagents
+```
+
+Quick test from this repo: `pi -e ./extensions/minimal-subagents`
+
+## How it works
+
+`spawn_agents({ agents: [spec...] })` — a single task is an array of one; up to 8 per call, 4 running at a time.
+
+| Field | Required | Default |
+|---|---|---|
+| `task` | ✓ | — |
+| `systemPrompt` | — | child default; role/constraints go here, not the assignment |
+| `model` | — | inherit the parent session's model |
+| `thinking` | — | inherit the parent session's thinking level (`off`…`max`) |
+| `tools` | — | child default tools; e.g. `["read","grep","find","ls"]` for read-only scouts |
+| `name` | — | `agent-<index>` |
+
+- **Failures don't cancel siblings** — every agent runs to completion; each result is a `### [name] completed/failed` section with the agent's final output (50 KB cap; full transcripts stay in the tool details). `isError` only when all fail.
+- **Live progress** — a one-line-per-agent scoreboard in the transcript (status, turns, latest activity); `alt+a` for the live detail panel, `Ctrl+O` after completion for the full archive.
+- **Abort** returns partial results — finished agents keep their output, the rest are marked `aborted`; the whole child process group is killed (`SIGTERM`, then `SIGKILL` after 5 s).
+
+## Details panel (`alt+a`)
+
+- One tab per sub-agent (`←`/`→` or `1`-`8`; the tab bar compacts automatically on narrow panels), labeled with name and live status (⏳/✓/✗).
+- Each tab is the agent's full timeline: task, tool calls, tool-result previews (first 10 lines), assistant output rendered as markdown, usage. Thinking is not shown.
+- Terminal-style scrolling: `↑/↓`, `PgUp/PgDn`, `Home`/`g`, `End`/`G`, mouse wheel — pinned to the bottom while following new output, scrolling up pauses, `End` resumes. `Esc` closes.
+- Shows the latest call only. Two platform limits: it is an overlay (the transcript is covered, not reflowed), and mouse wheel works only under `--tui-mode fullscreen` — the only mode where pi enables terminal mouse reporting.
+
+## No nesting
+
+Children run with `PI_SUBAGENTS_CHILD=1` (the extension skips tool registration when it sees it) and are launched with `--exclude-tools spawn_agents` as a backstop. This is a guard, not a sandbox: a sub-agent with `bash` can still start arbitrary processes and work around both layers (e.g. `env -u PI_SUBAGENTS_CHILD pi ...`) — use `tools` restrictions or a container for hard isolation. Side effect: exporting `PI_SUBAGENTS_CHILD=1` in your own shell hides `spawn_agents` from your sessions.

package/index.ts

@@ -0,0 +1,208 @@
+/**
+ * minimal-subagents — spawn dynamically created sub-agents, in parallel
+ *
+ * Fork of the official pi example extension `examples/extensions/subagent`
+ * (pi v0.84.4, MIT License, https://github.com/earendil-works/pi), reshaped:
+ * agents are defined inline per invocation (no predefined .md files), there is
+ * a single `{ agents: [spec...] }` mode (no chain/orchestration), and nesting
+ * is prevented via an environment sentinel. The parent blocks until every
+ * sub-agent finished; each spec can pick its own model, thinking level and
+ * tool allowlist, inheriting the parent session's model/thinking by default.
+ *
+ * Process spawning lives in spawn.ts, TUI rendering in render.ts.
+ *
+ * Install: pi install npm:@pi-spice/minimal-subagents
+ * Quick test: pi -e ./extensions/minimal-subagents
+ */
+
+import { StringEnum } from "@earendil-works/pi-ai";
+import { type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import {
+	getResultOutput,
+	isFailedResult,
+	mapWithConcurrencyLimit,
+	runSpec,
+	truncateParallelOutput,
+	type SingleResult,
+	type SubagentDetails,
+} from "./spawn.ts";
+import { renderSpawnCall, renderSpawnResult } from "./render.ts";
+import { openAgentPanel, setPanelDetails } from "./panel.ts";
+
+const MAX_AGENTS = 8;
+const MAX_CONCURRENCY = 4;
+
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+const AgentSpecSchema = Type.Object({
+	name: Type.Optional(
+		Type.String({
+			description:
+				'Heading for this agent result section ("### [name]"). Prefer a short role name like "scout" over agent-1.',
+		}),
+	),
+	systemPrompt: Type.Optional(
+		Type.String({
+			description:
+				"Role, constraints and output-format rules for this agent (appended to the child's system prompt). Put standing instructions here, not the assignment.",
+		}),
+	),
+	task: Type.String({ minLength: 1, description: "The concrete assignment this agent must complete" }),
+	model: Type.Optional(
+		Type.String({ description: 'Model for this agent, e.g. "anthropic/claude-haiku-4-5". Default: inherit parent session model' }),
+	),
+	thinking: Type.Optional(
+		StringEnum(THINKING_LEVELS, {
+			description: "Reasoning effort for this agent. Default: inherit parent session thinking level",
+		}),
+	),
+	tools: Type.Optional(
+		Type.Array(Type.String(), {
+			description: 'Tool allowlist for this agent, e.g. ["read","grep","find","ls"]. Default: child default tools',
+		}),
+	),
+});
+
+const SpawnAgentsParams = Type.Object({
+	agents: Type.Array(AgentSpecSchema, {
+		minItems: 1,
+		maxItems: MAX_AGENTS,
+		description: `Agents to create and run (1-${MAX_AGENTS}; at most ${MAX_CONCURRENCY} run at a time). A single task is an array of one. Blocks until every agent finishes.`,
+	}),
+});
+
+export default function (pi: ExtensionAPI) {
+	// Nesting guard: sub-agent processes run with PI_SUBAGENTS_CHILD=1 (set in
+	// runSpec's spawn env). Refuse to register the tool there, so sub-agents
+	// cannot spawn their own sub-agents — while keeping every other extension
+	// available to them.
+	if (process.env.PI_SUBAGENTS_CHILD) return;
+
+	pi.registerTool({
+		name: "spawn_agents",
+		label: "Spawn agents",
+		description: [
+			"Create sub-agents dynamically and run them in parallel, each in an isolated pi process.",
+			"Each agent is defined inline: systemPrompt (role/constraints) + task (assignment), with optional model, thinking level and tool allowlist; unset fields inherit the parent session.",
+			"Blocks until all agents finish, then returns each agent's final output under ### [name] headings.",
+			"The parent's working directory and project context (AGENTS.md) are shared; agents cannot spawn further sub-agents.",
+		].join(" "),
+		promptGuidelines: [
+			"spawn_agents returns only each agent's final text under ### [name] headings; agents' intermediate steps stay hidden, so ask agents to put key findings in their final answer.",
+			"spawn_agents agents run isolated from each other; one failing does not stop the others, and the tool result reports every agent's status.",
+		],
+		parameters: SpawnAgentsParams,
+
+		async execute(_toolCallId, params, signal, onUpdate, ctx) {
+			if (params.agents.length > MAX_AGENTS) {
+				return {
+					content: [{ type: "text", text: `Too many agents (${params.agents.length}). Max is ${MAX_AGENTS}.` }],
+					details: { results: [] },
+				};
+			}
+
+			const dispatchDefaults = {
+				model: ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : undefined,
+				thinkingLevel: ctx.thinkingLevel,
+			};
+
+			const makeDetails = (results: SingleResult[]): SubagentDetails => ({ results });
+
+			// Track all results for streaming updates
+			const allResults: SingleResult[] = new Array(params.agents.length);
+
+			// Initialize placeholder results
+			for (let i = 0; i < params.agents.length; i++) {
+				allResults[i] = {
+					name: params.agents[i].name ?? `agent-${i + 1}`,
+					task: params.agents[i].task,
+					exitCode: -1, // -1 = still running
+					messages: [],
+					stderr: "",
+					usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+				};
+			}
+
+			const emitParallelUpdate = () => {
+				setPanelDetails(makeDetails([...allResults]));
+				if (onUpdate) {
+					const running = allResults.filter((r) => r.exitCode === -1).length;
+					const done = allResults.filter((r) => r.exitCode !== -1).length;
+					onUpdate({
+						content: [
+							{ type: "text", text: `Running: ${done}/${allResults.length} done, ${running} running...` },
+						],
+						details: makeDetails([...allResults]),
+					});
+				}
+			};
+
+			const results = await mapWithConcurrencyLimit(params.agents, MAX_CONCURRENCY, async (spec, index) => {
+				// On abort, return what exists instead of throwing finished work away.
+				const abortPlaceholder = (): SingleResult => {
+					const partial = allResults[index];
+					partial.exitCode = 1;
+					partial.stopReason = "aborted";
+					return partial;
+				};
+				if (signal?.aborted) return abortPlaceholder();
+				try {
+					const result = await runSpec(
+						ctx.cwd,
+						dispatchDefaults,
+						spec,
+						allResults[index].name,
+						signal,
+						(partial) => {
+							if (partial.details?.results[0]) {
+								allResults[index] = partial.details.results[0];
+								emitParallelUpdate();
+							}
+						},
+						makeDetails,
+					);
+					allResults[index] = result;
+					emitParallelUpdate();
+					return result;
+				} catch (err) {
+					if (signal?.aborted) return abortPlaceholder();
+					throw err;
+				}
+			});
+
+			const successCount = results.filter((r) => !isFailedResult(r)).length;
+			const aborted = signal?.aborted === true;
+			setPanelDetails(makeDetails(results));
+			const summaries = results.map((r) => {
+				const output = truncateParallelOutput(getResultOutput(r));
+				const status = isFailedResult(r)
+					? `failed${r.stopReason && r.stopReason !== "end" ? ` (${r.stopReason})` : ""}`
+					: "completed";
+				const usage =
+					r.usage.turns > 0 || r.usage.cost > 0
+						? `\n\n(${r.usage.turns} turns, $${r.usage.cost.toFixed(4)})`
+						: "";
+				return `### [${r.name}] ${status}\n\n${output}${usage}`;
+			});
+			return {
+				content: [
+					{
+						type: "text",
+						text: `${successCount}/${results.length} succeeded${aborted ? " before abort" : ""}\n\n${summaries.join("\n\n---\n\n")}`,
+					},
+				],
+				details: makeDetails(results),
+				isError: successCount === 0,
+			};
+		},
+
+		renderCall: renderSpawnCall,
+		renderResult: renderSpawnResult,
+	});
+
+	pi.registerShortcut("alt+a", {
+		description: "Open the sub-agent details panel (tabs per agent, full timeline)",
+		handler: (ctx) => openAgentPanel(ctx),
+	});
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@pi-spice/minimal-subagents",
+  "version": "0.1.0",
+  "description": "Create sub-agents dynamically and run them in parallel; single blocking tool, no orchestration, nesting prevented",
+  "keywords": ["pi-package"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0x2E/pi-spice.git",
+    "directory": "extensions/minimal-subagents"
+  },
+  "pi": {
+    "extensions": ["./index.ts"]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/panel.ts

@@ -0,0 +1,338 @@
+/**
+ * panel.ts — sub-agent details panel (overlay) for minimal-subagents
+ *
+ * Opened with alt+a (registered in index.ts). Shows the latest spawn_agents
+ * call: one tab per sub-agent, a full scrollable timeline per tab (task,
+ * tool calls, tool-result previews, assistant output rendered as markdown,
+ * usage), live-updating while agents run.
+ *
+ * Rendering is line-based: the timeline is flattened into styled lines and
+ * windowed by a hand-rolled viewport (offset math) — the overlay contract is
+ * `render(width) => string[]`, so we control exactly which slice is visible.
+ * Mouse wheel is parsed directly from SGR sequences reaching handleInput
+ * while the overlay is focused.
+ */
+
+import { Markdown, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { type Message } from "@earendil-works/pi-ai";
+import { formatToolCall, formatUsageStats, type RenderTheme } from "./render.ts";
+import { isFailedResult, type SingleResult, type SubagentDetails } from "./spawn.ts";
+
+// ---------------------------------------------------------------------------
+// Module state: the latest spawn_agents details, updated by index.ts
+// ---------------------------------------------------------------------------
+
+let currentDetails: SubagentDetails | null = null;
+const listeners = new Set<() => void>();
+
+/** Publish the latest (possibly still running) details; live panels re-render. */
+export function setPanelDetails(details: SubagentDetails): void {
+	currentDetails = details;
+	for (const listener of listeners) listener();
+}
+
+// ---------------------------------------------------------------------------
+// Panel opening
+// ---------------------------------------------------------------------------
+
+let opening: Promise<unknown> | null = null;
+
+export function openAgentPanel(ctx: { ui: any; hasUI?: boolean }): void {
+	if (opening) return; // already open; Esc closes
+	if (ctx.hasUI === false) return;
+	opening = ctx.ui
+		.custom(
+			(tui: any, theme: RenderTheme & { fg(c: string, t: string): string }, keybindings: any, done: () => void) =>
+				new AgentPanel(tui, theme, keybindings, done),
+			{
+				overlay: true,
+				overlayOptions: {
+				// Full-height right column: anchor top-right, zero margin, and
+				// render() always returns exactly `rows` lines (overlay height is
+				// content-driven, capped by maxHeight).
+				anchor: "top-right",
+				width: "50%",
+				minWidth: 50,
+				maxHeight: "100%",
+				margin: 0,
+			},
+			},
+		)
+		.finally(() => {
+			opening = null;
+		});
+}
+
+// ---------------------------------------------------------------------------
+// Timeline construction
+// ---------------------------------------------------------------------------
+
+const TOOL_RESULT_PREVIEW_LINES = 10;
+const WHEEL_LINES = 3;
+
+function isAgentRunning(result: SingleResult): boolean {
+	return result.exitCode === -1;
+}
+
+function statusIcon(result: SingleResult, theme: RenderTheme): string {
+	if (isAgentRunning(result)) return theme.fg("warning", "⏳");
+	return isFailedResult(result) ? theme.fg("error", "✗") : theme.fg("success", "✓");
+}
+
+/** Flatten one agent's messages into styled lines (unwindowed). */
+function buildTimeline(result: SingleResult, theme: RenderTheme, width: number): string[] {
+	const lines: string[] = [];
+	const push = (line: string) => {
+		if (line.length === 0) lines.push("");
+		else lines.push(...wrapTextWithAnsi(line, width));
+	};
+
+	const status =
+		isAgentRunning(result)
+			? theme.fg("warning", "running")
+			: isFailedResult(result)
+				? theme.fg("error", `failed${result.stopReason && result.stopReason !== "end" ? ` (${result.stopReason})` : ""}`)
+				: theme.fg("success", "completed");
+
+	push(`${theme.fg("toolTitle", theme.bold(result.name))} ${status}${result.model ? theme.fg("dim", ` · ${result.model}`) : ""}`);
+	push(theme.fg("dim", `Task: ${result.task}`));
+	lines.push("");
+
+	const mdTheme = getMarkdownTheme();
+
+	for (const msg of result.messages as Message[]) {
+		if (msg.role === "user") continue; // the "Task: ..." prompt is already shown
+
+		if (msg.role === "toolResult") {
+			const text = (msg.content || [])
+				.filter((p: any) => p.type === "text")
+				.map((p: any) => p.text)
+				.join("\n");
+			if (!text.trim()) continue;
+			const all = text.split("\n");
+			const shown = all.slice(0, TOOL_RESULT_PREVIEW_LINES);
+			for (const l of shown) push(theme.fg("muted", `  ${l}`));
+			if (all.length > TOOL_RESULT_PREVIEW_LINES)
+				push(theme.fg("dim", `  [+${all.length - TOOL_RESULT_PREVIEW_LINES} more lines]`));
+			continue;
+		}
+
+		if (msg.role === "assistant") {
+			for (const part of msg.content as any[]) {
+				if (part.type === "thinking") continue;
+				if (part.type === "toolCall") {
+					push(`${theme.fg("muted", "→ ")}${formatToolCall(part.name, part.arguments, theme.fg.bind(theme))}`);
+				} else if (part.type === "text" && part.text.trim()) {
+					lines.push(...new Markdown(part.text.trim(), 0, 0, mdTheme).render(width));
+					lines.push("");
+				}
+			}
+		}
+	}
+
+	const usage = formatUsageStats(result.usage, result.model);
+	if (usage) push(theme.fg("dim", usage));
+	if (result.errorMessage) push(theme.fg("error", `Error: ${result.errorMessage}`));
+	return lines;
+}
+
+// ---------------------------------------------------------------------------
+// The panel component
+// ---------------------------------------------------------------------------
+
+class AgentPanel {
+	private tui: any;
+	private theme: RenderTheme;
+	private keybindings: any;
+	private close: () => void;
+
+	private activeTab = 0;
+	private offset = 0;
+	private follow = true;
+	private bodyHeight = 10;
+	private lineCount = 0;
+	private renderWidth = 60;
+
+	private notify: () => void;
+
+	constructor(tui: any, theme: RenderTheme, keybindings: any, done: (value: null) => void) {
+		this.tui = tui;
+		this.theme = theme;
+		this.keybindings = keybindings;
+		this.close = () => {
+			listeners.delete(this.notify);
+			done(null);
+		};
+		this.notify = () => this.tui.requestRender();
+		listeners.add(this.notify);
+	}
+
+	render(width: number): string[] {
+		try {
+			return this.renderInner(width);
+		} catch (err) {
+			// A panel bug must never crash the host TUI.
+			return [this.theme.fg("error", `panel render failed: ${err instanceof Error ? err.message : String(err)}`)];
+		}
+	}
+
+	private renderInner(width: number): string[] {
+		const theme = this.theme;
+		const details = currentDetails;
+		if (!details || details.results.length === 0)
+			return [theme.fg("muted", "(no agent data yet — run spawn_agents first)")];
+
+		this.renderWidth = width;
+		// A newer spawn_agents call may have fewer agents — clamp the tab.
+		this.activeTab = Math.min(this.activeTab, details.results.length - 1);
+
+		// --- header: tab bar ------------------------------------------------
+		// Full labels (index + name + status) when they fit the panel width;
+		// otherwise degrade to compact slots (index + status) which always fit
+		// for up to MAX_AGENTS=8 tabs — the active agent's full identity stays
+		// visible as the timeline's first line either way.
+		const sep = theme.fg("muted", "│");
+		const renderSlots = (labels: string[]) =>
+			labels.map((label, i) => (i === this.activeTab ? theme.fg("accent", theme.bold(`[${label}]`)) : theme.fg("dim", ` ${label} `))).join(sep);
+		const fullLabels = details.results.map((r, i) => {
+			const name = r.name.length > 12 ? `${r.name.slice(0, 11)}…` : r.name;
+			return `${i + 1} ${name} ${statusIcon(r, theme)}`;
+		});
+		const fullFits =
+			7 + fullLabels.reduce((sum, l) => sum + visibleWidth(l) + 2, 0) + (fullLabels.length - 1) <= width;
+		const tabs = fullFits
+			? renderSlots(fullLabels)
+			: renderSlots(details.results.map((r, i) => `${i + 1}${statusIcon(r, theme)}`));
+		const header = [theme.fg("toolTitle", theme.bold("agents ")) + tabs, theme.fg("muted", "─".repeat(width))];
+
+		// --- body: windowed timeline ----------------------------------------
+		const rows = this.tui?.terminal?.rows ?? process.stdout.rows ?? 24;
+		const headerH = header.length; // tab bar + rule
+		const footerH = 2; // rule + status line
+		this.bodyHeight = Math.max(4, rows - headerH - footerH);
+
+		const lines = buildTimeline(details.results[this.activeTab], theme, width);
+		this.lineCount = lines.length;
+
+		const maxOffset = Math.max(0, this.lineCount - this.bodyHeight);
+		if (this.follow) this.offset = maxOffset;
+		this.offset = Math.min(Math.max(0, this.offset), maxOffset);
+		const body = lines.slice(this.offset, this.offset + this.bodyHeight);
+		while (body.length < this.bodyHeight) body.push(""); // stable panel height
+
+		// --- footer: scroll position + hints ---------------------------------
+		const pos = this.lineCount > 0 ? `${this.offset + 1}-${Math.min(this.offset + this.bodyHeight, this.lineCount)}/${this.lineCount}` : "0";
+		const mode = this.follow ? "following" : "paused";
+		const footer =
+			theme.fg("dim", `${pos} ${mode}`) +
+			theme.fg("muted", " · ←/→ tab · ↑/↓ wheel scroll · End follow · Esc close");
+
+		return [...header, ...body, theme.fg("muted", "─".repeat(width)), footer];
+	}
+
+	handleInput(data: string): void {
+		try {
+			this.handleInputInner(data);
+		} catch (err) {
+			// A panel bug must never crash the host TUI.
+			this.tui.requestRender();
+		}
+	}
+
+	private handleInputInner(data: string): void {
+		const details = currentDetails;
+		if (!details || details.results.length === 0) {
+			if (data === "\x1b") this.close();
+			return;
+		}
+		const tabCount = details.results.length;
+
+		// SGR mouse wheel: \x1B[<64;col;rowM (up) / 65 (down)
+		if (data.startsWith("\x1b[<") && data.endsWith("M")) {
+			const b = Number.parseInt(data.slice(3, data.indexOf(";")), 10);
+			if (b === 64) this.scroll(-WHEEL_LINES);
+			else if (b === 65) this.scroll(WHEEL_LINES);
+			return;
+		}
+
+		switch (data) {
+			case "\x1b": // Esc alone
+				this.close();
+				return;
+			case "\x1b[D": // left
+			case "\x1b[1;5D": // ctrl+left
+				this.switchTab((this.activeTab - 1 + tabCount) % tabCount);
+				return;
+			case "\x1b[C": // right
+			case "\x1b[1;5C": // ctrl+right
+				this.switchTab((this.activeTab + 1) % tabCount);
+				return;
+			case "\x1b[A":
+				this.scroll(-1);
+				return;
+			case "\x1b[B":
+				this.scroll(1);
+				return;
+			case "\x1b[H":
+			case "g":
+				this.offset = 0;
+				this.follow = false;
+				this.tui.requestRender();
+				return;
+			case "\x1b[F":
+			case "G":
+				this.follow = true;
+				this.tui.requestRender();
+				return;
+		}
+
+		// Number keys 1..8 jump to a tab
+		if (/^[1-9]$/.test(data)) {
+			const idx = Number(data) - 1;
+			if (idx < tabCount) this.switchTab(idx);
+			return;
+		}
+
+		// Paging respects user keybindings (tui.altScreen.* ids)
+		const kb = this.keybindings;
+		if (kb?.matches) {
+			if (kb.matches(data, "tui.altScreen.pageUp")) {
+				this.scroll(-this.bodyHeight);
+				return;
+			}
+			if (kb.matches(data, "tui.altScreen.pageDown")) {
+				this.scroll(this.bodyHeight);
+				return;
+			}
+			if (kb.matches(data, "tui.altScreen.halfPageUp")) {
+				this.scroll(-Math.ceil(this.bodyHeight / 2));
+				return;
+			}
+			if (kb.matches(data, "tui.altScreen.halfPageDown")) {
+				this.scroll(Math.ceil(this.bodyHeight / 2));
+				return;
+			}
+		}
+	}
+
+	private switchTab(idx: number): void {
+		this.activeTab = idx;
+		this.offset = 0;
+		this.follow = true;
+		this.tui.requestRender();
+	}
+
+	private scroll(delta: number): void {
+		const maxOffset = Math.max(0, this.lineCount - this.bodyHeight);
+		this.offset = Math.min(Math.max(0, this.offset + delta), maxOffset);
+		this.follow = this.offset >= maxOffset && delta > 0;
+		this.tui.requestRender();
+	}
+
+	invalidate(): void {
+		// nothing cached across renders; theme changes are picked up next render
+	}
+}
+
+

package/render.ts

@@ -0,0 +1,339 @@
+/**
+ * render.ts — TUI presentation for minimal-subagents
+ *
+ * All rendering for the spawn_agents tool call and its (possibly still
+ * streaming) result: collapsed/expanded views per agent, tool-call lines
+ * mimicking pi's built-in tool formatting, usage stats, and markdown final
+ * output. Pure presentation — no spawning logic here.
+ */
+
+import * as os from "node:os";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Message } from "@earendil-works/pi-ai";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+import { Container, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
+import {
+	getFinalOutput,
+	isFailedResult,
+	type AgentSpec,
+	type SingleResult,
+	type SubagentDetails,
+} from "./spawn.ts";
+
+/** Structural view of the tool's args — avoids a type-only import cycle with index.ts. */
+export type SpawnAgentsArgs = { agents?: AgentSpec[] };
+
+/** Structural slice of pi's theme object — keeps this file decoupled from theme internals. */
+export interface RenderTheme {
+	fg(color: string, text: string): string;
+	bold(text: string): string;
+}
+
+function formatTokens(count: number): string {
+	if (count < 1000) return count.toString();
+	if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
+	if (count < 1000000) return `${Math.round(count / 1000)}k`;
+	return `${(count / 1000000).toFixed(1)}M`;
+}
+
+export function formatUsageStats(
+	usage: {
+		input: number;
+		output: number;
+		cacheRead: number;
+		cacheWrite: number;
+		cost: number;
+		contextTokens?: number;
+		turns?: number;
+	},
+	model?: string,
+): string {
+	const parts: string[] = [];
+	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
+	if (usage.input) parts.push(`↑${formatTokens(usage.input)}`);
+	if (usage.output) parts.push(`↓${formatTokens(usage.output)}`);
+	if (usage.cacheRead) parts.push(`R${formatTokens(usage.cacheRead)}`);
+	if (usage.cacheWrite) parts.push(`W${formatTokens(usage.cacheWrite)}`);
+	if (usage.cost) parts.push(`$${usage.cost.toFixed(4)}`);
+	if (usage.contextTokens && usage.contextTokens > 0) {
+		parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
+	}
+	if (model) parts.push(model);
+	return parts.join(" ");
+}
+
+export function formatToolCall(
+	toolName: string,
+	args: Record<string, unknown>,
+	themeFg: (color: any, text: string) => string,
+): string {
+	const shortenPath = (p: string) => {
+		const home = os.homedir();
+		return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+	};
+
+	switch (toolName) {
+		case "bash": {
+			const command = (args.command as string) || "...";
+			const preview = command.length > 60 ? `${command.slice(0, 60)}...` : command;
+			return themeFg("muted", "$ ") + themeFg("toolOutput", preview);
+		}
+		case "read": {
+			const rawPath = (args.file_path || args.path || "...") as string;
+			const filePath = shortenPath(rawPath);
+			const offset = args.offset as number | undefined;
+			const limit = args.limit as number | undefined;
+			let text = themeFg("accent", filePath);
+			if (offset !== undefined || limit !== undefined) {
+				const startLine = offset ?? 1;
+				const endLine = limit !== undefined ? startLine + limit - 1 : "";
+				text += themeFg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+			}
+			return themeFg("muted", "read ") + text;
+		}
+		case "write": {
+			const rawPath = (args.file_path || args.path || "...") as string;
+			const filePath = shortenPath(rawPath);
+			const content = (args.content || "") as string;
+			const lines = content.split("\n").length;
+			let text = themeFg("muted", "write ") + themeFg("accent", filePath);
+			if (lines > 1) text += themeFg("dim", ` (${lines} lines)`);
+			return text;
+		}
+		case "edit": {
+			const rawPath = (args.file_path || args.path || "...") as string;
+			return themeFg("muted", "edit ") + themeFg("accent", shortenPath(rawPath));
+		}
+		case "ls": {
+			const rawPath = (args.path || ".") as string;
+			return themeFg("muted", "ls ") + themeFg("accent", shortenPath(rawPath));
+		}
+		case "find": {
+			const pattern = (args.pattern || "*") as string;
+			const rawPath = (args.path || ".") as string;
+			return themeFg("muted", "find ") + themeFg("accent", pattern) + themeFg("dim", ` in ${shortenPath(rawPath)}`);
+		}
+		case "grep": {
+			const pattern = (args.pattern || "") as string;
+			const rawPath = (args.path || ".") as string;
+			return (
+				themeFg("muted", "grep ") +
+				themeFg("accent", `/${pattern}/`) +
+				themeFg("dim", ` in ${shortenPath(rawPath)}`)
+			);
+		}
+		default: {
+			const argsStr = JSON.stringify(args);
+			const preview = argsStr.length > 50 ? `${argsStr.slice(0, 50)}...` : argsStr;
+			return themeFg("accent", toolName) + themeFg("dim", ` ${preview}`);
+		}
+	}
+}
+
+type DisplayItem = { type: "text"; text: string } | { type: "toolCall"; name: string; args: Record<string, any> };
+
+function getDisplayItems(messages: Message[]): DisplayItem[] {
+	const items: DisplayItem[] = [];
+	for (const msg of messages) {
+		if (msg.role === "assistant") {
+			for (const part of msg.content) {
+				if (part.type === "text") items.push({ type: "text", text: part.text });
+				else if (part.type === "toolCall") items.push({ type: "toolCall", name: part.name, args: part.arguments });
+			}
+		}
+	}
+	return items;
+}
+
+export function renderSpawnCall(args: SpawnAgentsArgs, theme: RenderTheme): Text {
+	if (args.agents?.length) {
+		let text =
+			theme.fg("toolTitle", theme.bold("spawn_agents ")) +
+			theme.fg("accent", `(${args.agents.length} agent${args.agents.length > 1 ? "s" : ""})`);
+		for (const a of args.agents.slice(0, 3)) {
+			const preview = a.task.length > 40 ? `${a.task.slice(0, 40)}...` : a.task;
+			const model = a.model ? theme.fg("dim", ` [${a.model}]`) : "";
+			text += `\n  ${theme.fg("accent", a.name || "agent")}${model}${theme.fg("dim", ` ${preview}`)}`;
+		}
+		if (args.agents.length > 3) text += `\n  ${theme.fg("muted", `... +${args.agents.length - 3} more`)}`;
+		return new Text(text, 0, 0);
+	}
+	return new Text(theme.fg("toolTitle", theme.bold("spawn_agents")), 0, 0);
+}
+
+function truncatePlain(text: string, max: number): string {
+	return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+function isAgentRunning(details: SubagentDetails): boolean {
+	return details.results.some((r) => r.exitCode === -1);
+}
+
+/** One glanceable scoreboard line: icon, name, turns, latest activity. */
+function scoreboardLine(r: SingleResult, theme: RenderTheme): string {
+	const icon =
+		r.exitCode === -1 && r.messages.length === 0
+			? theme.fg("muted", "▢")
+			: r.exitCode === -1
+				? theme.fg("warning", "⏳")
+				: isFailedResult(r)
+					? theme.fg("error", "✗")
+					: theme.fg("success", "✓");
+
+	let activity: string;
+	if (r.exitCode === -1 && r.messages.length === 0) {
+		activity = theme.fg("muted", "queued");
+	} else if (isFailedResult(r)) {
+		const reason = (r.errorMessage || r.stderr || r.stopReason || "error").split("\n")[0];
+		activity = theme.fg("error", truncatePlain(reason, 60));
+	} else {
+		const items = getDisplayItems(r.messages);
+		const last = items[items.length - 1];
+		if (!last) activity = theme.fg("muted", r.exitCode === -1 ? "starting…" : "(no output)");
+		else if (last.type === "toolCall") activity = formatToolCall(last.name, last.args, theme.fg.bind(theme));
+		else activity = theme.fg("toolOutput", truncatePlain(last.text.split("\n")[0], 60));
+	}
+
+	const turns = r.usage.turns > 0 ? theme.fg("dim", ` ${r.usage.turns}t`) : "";
+	return `  ${icon} ${theme.fg("accent", r.name)}${turns}  ${activity}`;
+}
+
+export function renderSpawnResult(
+	result: AgentToolResult<SubagentDetails>,
+	{ expanded }: { expanded: boolean },
+	theme: RenderTheme,
+): Text | Container {
+	const details = result.details as SubagentDetails | undefined;
+	if (!details || details.results.length === 0) {
+		const text = result.content[0];
+		return new Text(text?.type === "text" ? text.text : "(no output)", 0, 0);
+	}
+
+	const mdTheme = getMarkdownTheme();
+
+	if (expanded && !isAgentRunning(details) && details.results.length === 1) {
+		const r = details.results[0];
+		const isError = isFailedResult(r);
+		const icon = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
+		const displayItems = getDisplayItems(r.messages);
+		const finalOutput = getFinalOutput(r.messages);
+
+		const container = new Container();
+		let header = `${icon} ${theme.fg("toolTitle", theme.bold(r.name))}`;
+		if (isError && r.stopReason) header += ` ${theme.fg("error", `[${r.stopReason}]`)}`;
+		container.addChild(new Text(header, 0, 0));
+		if (isError && r.errorMessage)
+			container.addChild(new Text(theme.fg("error", `Error: ${r.errorMessage}`), 0, 0));
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(theme.fg("muted", "─── Task ───"), 0, 0));
+		container.addChild(new Text(theme.fg("dim", r.task), 0, 0));
+		container.addChild(new Spacer(1));
+		container.addChild(new Text(theme.fg("muted", "─── Output ───"), 0, 0));
+		if (displayItems.length === 0 && !finalOutput) {
+			container.addChild(new Text(theme.fg("muted", "(no output)"), 0, 0));
+		} else {
+			for (const item of displayItems) {
+				if (item.type === "toolCall")
+					container.addChild(
+						new Text(
+							theme.fg("muted", "→ ") + formatToolCall(item.name, item.args, theme.fg.bind(theme)),
+							0, 0,
+						),
+					);
+			}
+			if (finalOutput) {
+				container.addChild(new Spacer(1));
+				container.addChild(new Markdown(finalOutput.trim(), 0, 0, mdTheme));
+			}
+		}
+		const usageStr = formatUsageStats(r.usage, r.model);
+		if (usageStr) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("dim", usageStr), 0, 0));
+		}
+		return container;
+	}
+
+	const aggregateUsage = (results: SingleResult[]) => {
+		const total = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, turns: 0 };
+		for (const r of results) {
+			total.input += r.usage.input;
+			total.output += r.usage.output;
+			total.cacheRead += r.usage.cacheRead;
+			total.cacheWrite += r.usage.cacheWrite;
+			total.cost += r.usage.cost;
+			total.turns += r.usage.turns;
+		}
+		return total;
+	};
+
+	const running = details.results.filter((r) => r.exitCode === -1).length;
+	const successCount = details.results.filter((r) => r.exitCode !== -1 && !isFailedResult(r)).length;
+	const failCount = details.results.filter((r) => r.exitCode !== -1 && isFailedResult(r)).length;
+	const isRunning = running > 0;
+	const icon = isRunning
+		? theme.fg("warning", "⏳")
+		: failCount > 0
+			? theme.fg("warning", "◐")
+			: theme.fg("success", "✓");
+	const status = isRunning
+		? `${successCount + failCount}/${details.results.length} done, ${running} running`
+		: `${successCount}/${details.results.length} succeeded${failCount > 0 ? `, ${failCount} failed` : ""}`;
+
+	if (expanded && !isRunning) {
+		const container = new Container();
+		container.addChild(
+			new Text(`${icon} ${theme.fg("toolTitle", theme.bold("spawn_agents "))}${theme.fg("accent", status)}`, 0, 0),
+		);
+
+		for (const r of details.results) {
+			const rIcon = isFailedResult(r) ? theme.fg("error", "✗") : theme.fg("success", "✓");
+			const displayItems = getDisplayItems(r.messages);
+			const finalOutput = getFinalOutput(r.messages);
+
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(`${theme.fg("muted", "─── ") + theme.fg("accent", r.name)} ${rIcon}`, 0, 0));
+			container.addChild(new Text(theme.fg("muted", "Task: ") + theme.fg("dim", r.task), 0, 0));
+
+			// Show tool calls
+			for (const item of displayItems) {
+				if (item.type === "toolCall") {
+					container.addChild(
+						new Text(theme.fg("muted", "→ ") + formatToolCall(item.name, item.args, theme.fg.bind(theme)), 0, 0),
+					);
+				}
+			}
+
+			// Show final output as markdown
+			if (finalOutput) {
+				container.addChild(new Spacer(1));
+				container.addChild(new Markdown(finalOutput.trim(), 0, 0, mdTheme));
+			}
+
+			const taskUsage = formatUsageStats(r.usage, r.model);
+			if (taskUsage) container.addChild(new Text(theme.fg("dim", taskUsage), 0, 0));
+		}
+
+		const usageStr = formatUsageStats(aggregateUsage(details.results));
+		if (usageStr) {
+			container.addChild(new Spacer(1));
+			container.addChild(new Text(theme.fg("dim", `Total: ${usageStr}`), 0, 0));
+		}
+		return container;
+	}
+
+	// --- scoreboard: one glanceable line per agent -----------------------
+	// The panel (alt+a) is the live view; the collapsed transcript block is a
+	// summary, not a competing log. Expanded (Ctrl+O, after completion) is the
+	// archive.
+	let text = `${icon} ${theme.fg("toolTitle", theme.bold("spawn_agents "))}${theme.fg("accent", status)}`;
+	for (const r of details.results) text += `\n${scoreboardLine(r, theme)}`;
+	if (!isRunning) {
+		const usageStr = formatUsageStats(aggregateUsage(details.results));
+		if (usageStr) text += `\n${theme.fg("dim", `Total: ${usageStr}`)}`;
+		text += `\n${theme.fg("muted", "(alt+a · Ctrl+O)")}`;
+	} else {
+		text += `\n${theme.fg("muted", "(alt+a · live details)")}`;
+	}
+	return new Text(text, 0, 0);
+}

package/spawn.ts

@@ -0,0 +1,286 @@
+/**
+ * spawn.ts — process-spawning core for minimal-subagents
+ *
+ * Runs one dynamically defined agent spec as an isolated `pi -p --no-session`
+ * child process in NDJSON mode: builds the CLI invocation (model / thinking /
+ * tools / appended system prompt), parses the event stream into messages and
+ * usage stats, and honors abort by killing the child.
+ */
+
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { Message } from "@earendil-works/pi-ai";
+
+const PER_TASK_OUTPUT_CAP = 50 * 1024;
+
+export interface UsageStats {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+	contextTokens: number;
+	turns: number;
+}
+
+export interface SingleResult {
+	name: string;
+	task: string;
+	/** -1 while the agent is still running */
+	exitCode: number;
+	messages: Message[];
+	stderr: string;
+	usage: UsageStats;
+	model?: string;
+	stopReason?: string;
+	errorMessage?: string;
+}
+
+export interface SubagentDetails {
+	results: SingleResult[];
+}
+
+export interface AgentSpec {
+	name?: string;
+	systemPrompt?: string;
+	task: string;
+	model?: string;
+	thinking?: string;
+	tools?: string[];
+}
+
+export interface DispatchDefaults {
+	model?: string;
+	thinkingLevel?: string;
+}
+
+type OnUpdateCallback = (partial: AgentToolResult<SubagentDetails>) => void;
+
+export function getFinalOutput(messages: Message[]): string {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "assistant") {
+			for (const part of msg.content) {
+				if (part.type === "text") return part.text;
+			}
+		}
+	}
+	return "";
+}
+
+export function isFailedResult(result: SingleResult): boolean {
+	// exitCode -1 means still running; a real non-zero exit (or an error/abort
+	// stop reason) is the failure signal.
+	return result.exitCode > 0 || result.stopReason === "error" || result.stopReason === "aborted";
+}
+
+export function getResultOutput(result: SingleResult): string {
+	if (isFailedResult(result)) {
+		return result.errorMessage || result.stderr || getFinalOutput(result.messages) || "(no output)";
+	}
+	return getFinalOutput(result.messages) || "(no output)";
+}
+
+export function truncateParallelOutput(output: string): string {
+	const byteLength = Buffer.byteLength(output, "utf8");
+	if (byteLength <= PER_TASK_OUTPUT_CAP) return output;
+
+	let truncated = output.slice(0, PER_TASK_OUTPUT_CAP);
+	while (Buffer.byteLength(truncated, "utf8") > PER_TASK_OUTPUT_CAP) {
+		truncated = truncated.slice(0, -1);
+	}
+	return `${truncated}\n\n[Output truncated at 50 KB]`;
+}
+
+export async function mapWithConcurrencyLimit<TIn, TOut>(
+	items: TIn[],
+	concurrency: number,
+	fn: (item: TIn, index: number) => Promise<TOut>,
+): Promise<TOut[]> {
+	if (items.length === 0) return [];
+	const limit = Math.max(1, Math.min(concurrency, items.length));
+	const results: TOut[] = new Array(items.length);
+	let nextIndex = 0;
+	const workers = new Array(limit).fill(null).map(async () => {
+		while (true) {
+			const current = nextIndex++;
+			if (current >= items.length) return;
+			results[current] = await fn(items[current], current);
+		}
+	});
+	await Promise.all(workers);
+	return results;
+}
+
+/**
+ * Re-invoke the pi binary that is running us. Prefers the exact interpreter +
+ * script pair (works for bundled binaries and npm installs); falls back to
+ * `pi` on PATH when running under a generic node/bun runtime we cannot pin.
+ */
+function getPiInvocation(args: string[]): { command: string; args: string[] } {
+	const currentScript = process.argv[1];
+	const isBunVirtualScript = currentScript?.startsWith("/$bunfs/root/");
+	if (currentScript && !isBunVirtualScript && fs.existsSync(currentScript)) {
+		return { command: process.execPath, args: [currentScript, ...args] };
+	}
+
+	const execName = path.basename(process.execPath).toLowerCase();
+	const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
+	if (!isGenericRuntime) {
+		return { command: process.execPath, args };
+	}
+
+	return { command: "pi", args };
+}
+
+export async function runSpec(
+	defaultCwd: string,
+	dispatchDefaults: DispatchDefaults,
+	spec: AgentSpec,
+	displayName: string,
+	signal: AbortSignal | undefined,
+	onUpdate: OnUpdateCallback | undefined,
+	makeDetails: (results: SingleResult[]) => SubagentDetails,
+): Promise<SingleResult> {
+	const args: string[] = ["--mode", "json", "-p", "--no-session"];
+	// Belt-and-braces: even if the env sentinel were scrubbed, the child's
+	// pi never sees the spawn_agents tool.
+	args.push("--exclude-tools", "spawn_agents");
+	const model = spec.model ?? dispatchDefaults.model;
+	if (model) args.push("--model", model);
+	const thinking = spec.thinking ?? dispatchDefaults.thinkingLevel;
+	if (thinking) args.push("--thinking", thinking);
+	if (spec.tools && spec.tools.length > 0) args.push("--tools", spec.tools.join(","));
+	if (spec.systemPrompt?.trim()) {
+		// Leading "\n" guarantees pi treats this as literal text, never a file path.
+		args.push("--append-system-prompt", `\n${spec.systemPrompt}`);
+	}
+
+	const currentResult: SingleResult = {
+		name: displayName,
+		task: spec.task,
+		exitCode: -1, // -1 = still running; real exit code set on close
+		messages: [],
+		stderr: "",
+		usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+		model,
+	};
+
+	const emitUpdate = () => {
+		if (onUpdate) {
+			onUpdate({
+				content: [{ type: "text", text: getFinalOutput(currentResult.messages) || "(running...)" }],
+				details: makeDetails([currentResult]),
+			});
+		}
+	};
+
+	args.push(`Task: ${spec.task}`);
+	let wasAborted = false;
+	let closed = false;
+	let hardKillTimer: ReturnType<typeof setTimeout> | undefined;
+
+	const exitCode = await new Promise<number>((resolve) => {
+		const invocation = getPiInvocation(args);
+		const proc = spawn(invocation.command, invocation.args, {
+			cwd: defaultCwd,
+			env: { ...process.env, PI_SUBAGENTS_CHILD: "1" },
+			shell: false,
+			stdio: ["ignore", "pipe", "pipe"],
+			// Own process group on POSIX so abort can kill the whole tree
+			// (the child spawns grandchildren like bash).
+			detached: process.platform !== "win32",
+		});
+		let buffer = "";
+
+		const processLine = (line: string) => {
+			if (!line.trim()) return;
+			let event: any;
+			try {
+				event = JSON.parse(line);
+			} catch {
+				return;
+			}
+
+			if (event.type === "message_end" && event.message) {
+				const msg = event.message as Message;
+				currentResult.messages.push(msg);
+
+				if (msg.role === "assistant") {
+					currentResult.usage.turns++;
+					const usage = msg.usage;
+					if (usage) {
+						currentResult.usage.input += usage.input || 0;
+						currentResult.usage.output += usage.output || 0;
+						currentResult.usage.cacheRead += usage.cacheRead || 0;
+						currentResult.usage.cacheWrite += usage.cacheWrite || 0;
+						currentResult.usage.cost += usage.cost?.total || 0;
+						currentResult.usage.contextTokens = usage.totalTokens || 0;
+					}
+					if (!currentResult.model && msg.model) currentResult.model = msg.model;
+					if (msg.stopReason) currentResult.stopReason = msg.stopReason;
+					if (msg.errorMessage) currentResult.errorMessage = msg.errorMessage;
+				}
+				emitUpdate();
+			}
+
+			if (event.type === "tool_result_end" && event.message) {
+				currentResult.messages.push(event.message as Message);
+				emitUpdate();
+			}
+		};
+
+		proc.stdout.on("data", (data) => {
+			buffer += data.toString();
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) processLine(line);
+		});
+
+		proc.stderr.on("data", (data) => {
+			currentResult.stderr += data.toString();
+		});
+
+		proc.on("close", (code) => {
+			closed = true;
+			if (hardKillTimer) clearTimeout(hardKillTimer);
+			if (buffer.trim()) processLine(buffer);
+			// A null code means death by signal — count it as failure unless we
+			// aborted on purpose (the abort path throws below instead).
+			resolve(code ?? 1);
+		});
+
+		proc.on("error", (err) => {
+			currentResult.errorMessage = err instanceof Error ? err.message : String(err);
+			resolve(1);
+		});
+
+		if (signal) {
+			const killTree = (sig: NodeJS.Signals) => {
+				try {
+					if (process.platform === "win32" || proc.pid === undefined) proc.kill(sig);
+					else process.kill(-proc.pid, sig); // negative pid = process group
+				} catch {
+					/* already gone */
+				}
+			};
+			const killProc = () => {
+				wasAborted = true;
+				killTree("SIGTERM");
+				// NOTE: proc.killed flips true once the signal is *sent*, so it
+				// cannot gate the SIGKILL fallback — track `closed` instead.
+				hardKillTimer = setTimeout(() => {
+					if (!closed) killTree("SIGKILL");
+				}, 5000);
+			};
+			if (signal.aborted) killProc();
+			else signal.addEventListener("abort", killProc, { once: true });
+		}
+	});
+
+	currentResult.exitCode = exitCode;
+	if (wasAborted) throw new Error("Subagent was aborted");
+	return currentResult;
+}