oira666_pi-subagent 0.1.1 → 0.1.3

package/README.md

@@ -1,326 +1,124 @@
 # Pi Subagent
 
-**Delegate tasks to specialized subagents with configurable context modes (`spawn` / `fork`).**
-
-There are many subagent extensions for pi, this one is mine.
-
-## Why Pi Subagent
-
-**Specialization** — Use tailored agents for specific tasks like refactoring, documentation, or research.
-
-**Context Control** — Choose `spawn` (fresh context) or `fork` (inherit current session context), depending on the task.
-
-**Parallel Execution** — Run multiple agents at once.
-
-**A Simpler Fork** — This extension intentionally keeps the surface area small and predictable compared to heavier implementations. It supports nested delegation with depth/cycle guards, but avoids broader scope-selection complexity. If you want the minimal, “just delegate” experience, this is it.
+Delegate tasks to specialized subagents with configurable context modes (`spawn` / `fork`).
 
 ## Install
 
-### Option 1: Install from npm (recommended)
-
 ```bash
 pi install npm:oira666_pi-subagent
 ```
 
-### Option 2: Install via git
+Or via git:
 
 ```bash
 pi install git:github.com/gee666/pi-subagent.git
 ```
 
-### Option 3: Manual Installation
-
-Clone this repository to your Pi extensions directory:
-
-```bash
-cd ~/.pi/agent/extensions
-git clone https://github.com/gee666/pi-subagent.git
-cd pi-subagent
-npm install
-```
-
-## Configuration
-
-### Delegation Guards (Depth + Cycle Prevention)
-
-By default, this extension enforces two runtime guards:
-
-1. **Depth guard** (`--subagent-max-depth`, default `3`)
-   - Main agent starts at depth `0`
-   - Delegation is allowed while `currentDepth < maxDepth`
-   - With default depth `3`: depth `0`, `1`, and `2` can delegate; depth `3` cannot
-2. **Cycle guard** (`--subagent-prevent-cycles`, default `true`)
-   - Blocks delegating to any agent name already present in the current delegation stack
-   - Prevents self-recursion (`writer -> writer`) and loops (`planner -> reviewer -> planner`)
-
-You can configure depth with either:
-
-- CLI flag: `--subagent-max-depth <n>`
-- Environment variable: `PI_SUBAGENT_MAX_DEPTH=<n>`
-
-`n` must be a non-negative integer.
-
-You can configure cycle prevention with either:
-
-- CLI flag: `--subagent-prevent-cycles` / `--no-subagent-prevent-cycles`
-- Environment variable: `PI_SUBAGENT_PREVENT_CYCLES=true|false`
-
-Internal env vars managed by the extension and propagated to child processes:
-
-- `PI_SUBAGENT_DEPTH`
-- `PI_SUBAGENT_MAX_DEPTH`
-- `PI_SUBAGENT_STACK` (JSON array of ancestor agent names, e.g. `["scout","planner"]`)
-- `PI_SUBAGENT_PREVENT_CYCLES`
-
-Examples:
+## Remove
 
 ```bash
-# Default behavior: depth 3 + cycle prevention enabled
-pi
-
-# Restrict to one nested level (main -> child -> grandchild)
-pi --subagent-max-depth 2
-
-# Disable subagent delegation entirely
-pi --subagent-max-depth 0
-
-# Allow depth 3 but disable cycle prevention (not recommended)
-pi --subagent-max-depth 3 --no-subagent-prevent-cycles
+pi remove npm:oira666_pi-subagent
 ```
 
-### Tool Call Shape
+## How It Works
 
-`subagent` always accepts a top-level `tasks` array:
+Each subagent runs as a **separate `pi` process** — isolated memory, its own model/tool loop.
 
-- One task = single-agent delegation
-- Multiple tasks = parallel delegation
+**`spawn` (default)** — Child receives only the task string. Best for isolated work, lower cost.
+**`fork`** — Child receives a snapshot of the current session context + task. Best for follow-up work.
 
-Single-task example:
+The main agent receives only the **final text output** from subagents (no tool calls, no reasoning).
 
-```json
-{ "tasks": [{ "agent": "code-writer", "task": "Implement the API change" }], "mode": "spawn" }
-```
-
-Multi-task example:
+## Tool Call Shape
 
 ```json
-{ "tasks": [{ "agent": "code-writer", "task": "Draft the implementation" }, { "agent": "code-reviwer", "task": "Review the plan" }], "mode": "fork" }
+{ "tasks": [{ "agent": "code-writer", "task": "Implement the API" }], "mode": "spawn" }
 ```
 
-Each task item supports:
-
-- `agent` — subagent name
-- `task` — delegated task text
-- `cwd` — optional working directory override for that task
-
-### Parallel Execution Limits
-
-For multi-task calls, two environment variables control fan-out:
-
-- `PI_SUBAGENT_MAX_PARALLEL_TASKS` — maximum number of tasks allowed in one call (default: `16`)
-- `PI_SUBAGENT_MAX_CONCURRENCY` — maximum number of subagents running at the same time inside that call (default: `8`)
-
-`PI_SUBAGENT_MAX_CONCURRENCY` is effectively clamped to at least `1`.
-
-### Project-local Agent Confirmation
-
-Project-local agents from `.pi/agents/*.md` can be gated by `PI_SUBAGENT_CONFIRM_PROJECT_AGENTS`:
-
-- `true`, `ask`, or `once` (default) — prompt with **Yes once**, **Yes for this session**, or **No**
-- `false` or `never` — skip the prompt and allow project-local agents immediately
-- `session` — allow project-local agents for the rest of the current session without prompting
-
-If you choose **Yes for this session** in the UI, the choice is remembered and you will not be asked again in that session. In non-UI mode, `ask` blocks execution because the extension cannot prompt.
-
-### Context Mode (`spawn` vs `fork`)
-
-`subagent` supports a top-level `mode` switch:
-
-- `spawn` (default) — Child receives only the task string (`Task: ...`). Best for isolated, reproducible work; typically lower token/cost and less context leakage.
-- `fork` — Child receives a forked snapshot of the current session context **plus** the task string. Best for follow-up work that depends on prior context; typically higher token/cost and may include sensitive context.
-
-Quick rule of thumb:
-
-- Start with `spawn` for one-off tasks.
-- Use `fork` when the delegated task depends on the current session's prior discussion, reads, or decisions.
-
-Examples:
+Multiple tasks run in parallel:
 
 ```json
-{ "tasks": [{ "agent": "code-writer", "task": "Implement the migration" }], "mode": "spawn" }
+{
+  "tasks": [
+    { "agent": "code-writer", "task": "Draft the implementation" },
+    { "agent": "code-reviwer", "task": "Review the plan" }
+  ],
+  "mode": "fork"
+}
 ```
 
-```json
-{ "tasks": [{ "agent": "code-reviwer", "task": "Double-check this migration" }], "mode": "fork" }
-```
-
-If omitted, mode defaults to `spawn`.
-
-### Subagent Definitions
-
-Subagents are defined as Markdown files with YAML frontmatter.
-
-**User Agents:** `~/.pi/agent/agents/*.md`
-**Project Agents:** `.pi/agents/*.md`
-**Bundled Fallback Agents:** `agents/code-writer.md`, `agents/code-reviwer.md`, `agents/code-architect.md`
+Each task supports `agent`, `task`, and optional `cwd`.
 
-The extension always loads user and project agents first. If a project agent shares a name with a user agent, the project agent wins. The bundled fallback agents are only discovered when no user or project agents are found at all. If you have any user or project agents configured, the bundled defaults are hidden and not discoverable. When project agents are requested, Pi can prompt for confirmation before running them, depending on `PI_SUBAGENT_CONFIRM_PROJECT_AGENTS`.
+## Bundled Agents
 
-If nothing is configured yet, these fallback agents are available by default:
+Three fallback agents ship with the extension (used when no user/project agents are configured):
 
 - `code-writer` — implementation and refactoring
 - `code-reviwer` — code review and risk finding
 - `code-architect` — technical design and approach selection
 
-Example agent (`~/.pi/agent/agents/writer.md`):
+## Defining Agents
+
+Create Markdown files with YAML frontmatter:
+
+- **User agents:** `~/.pi/agent/agents/*.md`
+- **Project agents:** `.pi/agents/*.md` *(may prompt for confirmation — see `PI_SUBAGENT_CONFIRM_PROJECT_AGENTS`)*
 
 ```markdown
 ---
 name: writer
-description: Expert technical writer and editor
+description: Expert technical writer
 model: anthropic/claude-3-5-sonnet
-tools: read, write
+thinking: low
+tools: read,write
 ---
 
-You are an expert technical writer. Your task is to improve the clarity and conciseness of the provided text.
+You are an expert technical writer focused on clarity and conciseness.
 ```
 
-Note: this repository includes bundled fallback agents in `agents/code-writer.md`, `agents/code-reviwer.md`, and `agents/code-architect.md`.
-
 ### Frontmatter Fields
 
-| Field         | Required | Default                          | Description                                                                                                                                                                |
-| ------------- | -------- | -------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `name`        | Yes      | —                                | Agent identifier used in tool calls (must match exactly)                                                                                                                   |
-| `description` | Yes      | —                                | What the agent does (shown to the main agent)                                                                                                                              |
-| `model`       | No       | Uses the default pi model        | Overrides the model for this agent. You can include a provider prefix (e.g. `anthropic/claude-3-5-sonnet` or `openrouter/claude-3.5-sonnet`) to force a specific provider. |
-| `thinking`    | No       | Uses Pi's default thinking level | Sets the thinking level (`off`, `minimal`, `low`, `medium`, `high`, `xhigh`). Equivalent to `--thinking`.                                                                  |
-| `tools`       | No       | `read,bash,edit,write`           | Comma-separated list of **built-in** tools to enable for this agent. If omitted, defaults apply.                                                                           |
-
-Notes:
-
-- `model` accepts `provider/model` syntax — this is a Pi feature. Use it when multiple providers offer the same model ID.
-- `thinking` uses the same values as Pi's `--thinking` flag; it's recommended to set it explicitly since thinking support varies by model.
-- `tools` only controls built-in tools. Extension tools remain available unless extensions are disabled.
-- The Markdown body below the frontmatter becomes the agent's system prompt and is **appended** to Pi's default system prompt (it does **not** replace it).
-
-### Writing a Good Agent File
-
-- **Description matters** — the main agent uses the `description` to decide which subagent to call, so be specific about what the agent is good at.
-- **Tool scope is optional but helpful** — reducing tools can keep the agent focused, but you can leave defaults if unsure.
-- **Model + thinking is the power combo** — selecting the right model and thinking level is often the biggest quality boost.
-
-### Available Built-in Tools
-
-Available Tools (default: `read`, `bash`, `edit`, `write`):
-
-- `read` — Read file contents
-- `bash` — Execute bash commands
-- `edit` — Edit files with find/replace
-- `write` — Write files (creates/overwrites)
-- `grep` — Search file contents (read-only, off by default)
-- `find` — Find files by glob pattern (read-only, off by default)
-- `ls` — List directory contents (read-only, off by default)
-
-Tip: for a read-only tool selection, use `read,find,ls,grep`. As soon as you include `edit`, `write`, or `bash`, the agent can practically go wild.
-
-## How Communication Works
-
-### The Isolation Model
-
-Each subagent always runs in a **separate `pi` process**:
-
-- ❌ No shared memory/state with the parent process
-- ❌ No visibility into sibling subagents
-- ✅ Its own model/tool/runtime loop
-- ✅ Started with `PI_OFFLINE=1` to skip startup network operations and reduce spawn latency
-
-What it can see depends on `mode`:
+| Field         | Required | Default              | Description                                              |
+| ------------- | -------- | -------------------- | -------------------------------------------------------- |
+| `name`        | Yes      | —                    | Agent identifier used in tool calls                      |
+| `description` | Yes      | —                    | What the agent does (shown to the main agent)            |
+| `model`       | No       | Pi default           | Override model, e.g. `anthropic/claude-3-5-sonnet`       |
+| `thinking`    | No       | Pi default           | `off`, `minimal`, `low`, `medium`, `high`, `xhigh`       |
+| `tools`       | No       | `read,bash,edit,write` | Comma-separated built-in tools                         |
 
-- `spawn` (default)
-  - ✅ Receives: subagent system prompt + `Task: ...`
-  - ❌ Does **not** receive parent session history
-- `fork`
-  - ✅ Receives: forked snapshot of current parent session context + `Task: ...`
+Available tools: `read`, `bash`, `edit`, `write`.
 
-### What Gets Sent to Subagents
+The Markdown body becomes the agent's system prompt (appended to Pi's default, not replacing it).
 
-#### `spawn` mode (default)
+## Delegation Guards
 
-`subagent({ tasks: [{ agent: "writer", task: "Document the API" }] })` sends:
+Depth and cycle guards prevent runaway recursive delegation.
 
-```
-[System Prompt from ~/.pi/agent/agents/writer.md]
-
-User: Task: Document the API
-```
-
-No parent conversation history is included. In `spawn`, include all required context in `task`.
-
-#### `fork` mode
-
-`subagent({ tasks: [{ agent: "writer", task: "Document the API" }], mode: "fork" })` sends:
-
-```
-[Forked snapshot of current session context]
-[System Prompt from ~/.pi/agent/agents/writer.md]
-
-User: Task: Document the API
-```
-
-Note: `fork` copies session context, not transient runtime-only prompt mutations from the parent process.
+| Config                         | Default | Description                                      |
+| ------------------------------ | ------- | ------------------------------------------------ |
+| `--subagent-max-depth` / `PI_SUBAGENT_MAX_DEPTH` | `3` | Max delegation depth (0 disables delegation) |
+| `--subagent-prevent-cycles` / `PI_SUBAGENT_PREVENT_CYCLES` | `true` | Block same agent in delegation chain |
 
-### What Comes Back to the Main Agent
-
-| Data                        | Main Agent Sees          | TUI Shows              |
-| --------------------------- | ------------------------ | ---------------------- |
-| Final text output           | ✅ Yes — full, unbounded | ✅ Yes                 |
-| Tool calls made by subagent | ❌ No                    | ✅ Yes (expanded view) |
-| Token usage / cost          | ❌ No                    | ✅ Yes                 |
-| Reasoning/thinking steps    | ❌ No                    | ❌ No                  |
-| Error messages              | ✅ Yes (on failure)      | ✅ Yes                 |
-
-**Key point:** The main agent receives **only the final assistant text** from each subagent. Not the tool calls, not the reasoning, not the intermediate steps. This prevents context pollution while still giving you the results.
-
-### Parallel Mode Behavior
-
-When running multiple agents in parallel:
-
-- Subagents run concurrently up to `PI_SUBAGENT_MAX_CONCURRENCY` (default `8`)
-- The top-level `mode` applies to all tasks in that call
-- Main agent receives a combined result after all finish:
-
-```
-Parallel: 3/3 succeeded
-
-[writer] completed: Full output text here...
-[tester] completed: Full output text here...
-[reviewer] completed: Full output text here...
+```bash
+pi --subagent-max-depth 2         # one nested level
+pi --subagent-max-depth 0         # disable delegation entirely
+pi --no-subagent-prevent-cycles   # allow cycles (not recommended)
 ```
 
-## Features
+## Parallel Limits
 
-- **Auto-Discovery** — Agents are found at startup and their descriptions are injected into the main agent's system prompt.
-- **Context Mode Switch** — `spawn` (fresh context) and `fork` (session snapshot + task) per call.
-- **Depth + Cycle Guards** — Depth limiting and ancestry-cycle checks prevent runaway recursive delegation by default.
-- **Streaming Updates** — Watch subagent progress in real-time as tool calls and outputs stream in.
-- **Nested Delegation** — Subagents can call `subagent` again, subject to depth and cycle guards.
-- **Rich TUI Rendering** — Collapsed/expanded views with usage stats, nested delegation trees, tool call previews, and markdown output.
-- **Security Confirmation** — Project-local agents can require explicit user approval, with one-time and session-wide approval options.
+| Env Var                          | Default | Description                              |
+| -------------------------------- | ------- | ---------------------------------------- |
+| `PI_SUBAGENT_MAX_PARALLEL_TASKS` | `16`    | Max tasks per single call                |
+| `PI_SUBAGENT_MAX_CONCURRENCY`    | `8`     | Max subagents running simultaneously     |
 
-## Project Structure
+## create-subagent Skill
 
-```
-index.ts    — Extension entry point: lifecycle hooks, tool registration, mode orchestration
-agents.ts   — Agent discovery: reads and parses .md files from user/project directories
-runner.ts   — Process runner: starts `pi` subprocesses in spawn/fork context modes and streams JSON events
-render.ts   — TUI rendering: renderCall and renderResult for the subagent tool
-types.ts    — Shared types and pure helper functions
-```
+If you want the agent to **create new subagent definition files** for itself, install the [`create-subagent` skill](https://github.com/gee666/pi-subagent/tree/main/create-subagent). Once installed, the agent will know how to scaffold new `.md` agent files in the right location with correct frontmatter.
 
 ## Attribution
 
-Inspired by implementations from [vaayne/agent-kit](https://github.com/vaayne/agent-kit) and [mariozechner/pi-mono](https://github.com/badlogic/pi-mono).
+Inspired by [vaayne/agent-kit](https://github.com/vaayne/agent-kit) and [mariozechner/pi-mono](https://github.com/badlogic/pi-mono).
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
   "type": "module",
   "main": "index.ts",

package/render.ts

@@ -2,12 +2,9 @@
  * TUI rendering for subagent tool calls and results.
  */
 
-import * as os from "node:os";
-import { getMarkdownTheme } from "@mariozechner/pi-coding-agent";
-import { Container, Markdown, Spacer, Text } from "@mariozechner/pi-tui";
+import { Container, Spacer, Text } from "@mariozechner/pi-tui";
 import {
 	type DelegationMode,
-	type DisplayItem,
 	type NestedSubagentResult,
 	type SingleResult,
 	type SubagentDetails,
@@ -18,11 +15,36 @@ import {
 	getFinalOutput,
 	getNestedSubagentResults,
 	isResultError,
+	isSubagentDetails,
 } from "./types.js";
 
-const COLLAPSED_LINE_COUNT = 10;
-const COLLAPSED_PARALLEL_LINE_COUNT = 5;
-const NESTED_PREVIEW_LINE_COUNT = 6;
+const OUTPUT_PREVIEW_LINE_COUNT = 6;
+
+type ThemeFg = (color: string, text: string) => string;
+type NodeStatus = "running" | "success" | "error";
+
+interface TreeNode {
+	label: string;
+	status: NodeStatus;
+	meta?: string;
+	task?: string;
+	outputPreview?: string[];
+	children: TreeNode[];
+}
+
+interface TreeCounts {
+	total: number;
+	running: number;
+	success: number;
+	error: number;
+	finished: number;
+}
+
+interface PendingSubagentCall {
+	toolCallId: string;
+	mode: DelegationMode;
+	tasks: Array<{ agent: string; task?: string }>;
+}
 
 // ---------------------------------------------------------------------------
 // Formatting helpers
@@ -43,243 +65,221 @@ function formatUsage(usage: Partial<UsageStats>, model?: string): string {
 		(usage.cacheRead || 0) +
 		(usage.cacheWrite || 0);
 	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	if (totalTokens > 0) parts.push(`tokens:${formatTokens(totalTokens)}`);
+	if (totalTokens > 0) parts.push(`tok:${formatTokens(totalTokens)}`);
 	if (usage.input) parts.push(`in:${formatTokens(usage.input)}`);
 	if (usage.output) parts.push(`out:${formatTokens(usage.output)}`);
 	if (usage.cacheRead) parts.push(`cacheR:${formatTokens(usage.cacheRead)}`);
 	if (usage.cacheWrite) parts.push(`cacheW:${formatTokens(usage.cacheWrite)}`);
-	if (usage.cost) parts.push(`cost:$${usage.cost.toFixed(4)}`);
+	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(" ");
+	return parts.join(" • ");
 }
 
 function truncate(text: string, maxLen: number): string {
 	return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
 }
 
-function shortenPath(p: string): string {
-	const home = os.homedir();
-	return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
-}
-
 function normalizeDelegationMode(raw: unknown): DelegationMode {
 	return raw === "fork" ? "fork" : DEFAULT_DELEGATION_MODE;
 }
 
-type ThemeFg = (color: string, text: string) => string;
+function splitOutputLines(text: string): string[] {
+	const lines = text.replace(/\r\n?/g, "\n").split("\n");
+	if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
 
-function firstNonEmptyLine(text: string): string {
-	for (const line of splitOutputLines(text)) {
-		if (line.trim()) return line.trim();
-	}
-	return "";
+function lastNonEmptyLines(text: string, limit: number): string[] {
+	return splitOutputLines(text)
+		.map((line) => line.trimEnd())
+		.filter((line) => line.trim().length > 0)
+		.slice(-limit);
 }
 
-function formatToolCall(toolName: string, args: Record<string, unknown>, fg: ThemeFg): string {
-	const pathArg = (args.file_path || args.path || "...") as string;
-
-	switch (toolName) {
-		case "subagent": {
-			const mode = normalizeDelegationMode(args.mode);
-			const tasks = Array.isArray(args.tasks) ? args.tasks : [];
-			if (tasks.length > 1) {
-				const agents = tasks
-					.slice(0, 3)
-					.map((task) => typeof task?.agent === "string" ? task.agent : "...")
-					.join(", ");
-				const extra = tasks.length > 3 ? ` +${tasks.length - 3}` : "";
-				return fg("toolTitle", "subagent ") + fg("accent", `parallel (${tasks.length})`) + fg("muted", ` [${mode}]`) + fg("dim", agents ? ` ${agents}${extra}` : "");
-			}
-			const task = tasks[0] as { agent?: string; task?: string } | undefined;
-			return fg("toolTitle", "subagent ") + fg("accent", task?.agent || "...") + fg("muted", ` [${mode}]`) + fg("dim", task?.task ? ` ${truncate(task.task, 48)}` : "");
-		}
-		case "bash": {
-			const cmd = (args.command as string) || "...";
-			return fg("muted", "$ ") + fg("toolOutput", truncate(cmd, 60));
-		}
-		case "read": {
-			let text = fg("accent", shortenPath(pathArg));
-			const offset = args.offset as number | undefined;
-			const limit = args.limit as number | undefined;
-			if (offset !== undefined || limit !== undefined) {
-				const start = offset ?? 1;
-				const end = limit !== undefined ? start + limit - 1 : "";
-				text += fg("warning", `:${start}${end ? `-${end}` : ""}`);
-			}
-			return fg("muted", "read ") + text;
-		}
-		case "write": {
-			const lines = ((args.content || "") as string).split("\n").length;
-			let text = fg("muted", "write ") + fg("accent", shortenPath(pathArg));
-			if (lines > 1) text += fg("dim", ` (${lines} lines)`);
-			return text;
-		}
-		case "edit":
-			return fg("muted", "edit ") + fg("accent", shortenPath(pathArg));
-		case "ls":
-			return fg("muted", "ls ") + fg("accent", shortenPath((args.path || ".") as string));
-		case "find":
-			return fg("muted", "find ") + fg("accent", (args.pattern || "*") as string) + fg("dim", ` in ${shortenPath((args.path || ".") as string)}`);
-		case "grep":
-			return fg("muted", "grep ") + fg("accent", `/${(args.pattern || "") as string}/`) + fg("dim", ` in ${shortenPath((args.path || ".") as string)}`);
+function statusEmoji(status: NodeStatus, theme: { fg: ThemeFg }): string {
+	switch (status) {
+		case "running":
+			return theme.fg("warning", "⏳");
+		case "error":
+			return theme.fg("error", "❌");
 		default:
-			return fg("accent", toolName) + fg("dim", ` ${truncate(JSON.stringify(args), 50)}`);
+			return theme.fg("success", "✅");
 	}
 }
 
-// ---------------------------------------------------------------------------
-// Shared rendering building blocks
-// ---------------------------------------------------------------------------
+function statusFromResult(result: SingleResult): NodeStatus {
+	if (result.exitCode === -1) return "running";
+	return isResultError(result) ? "error" : "success";
+}
 
-function splitOutputLines(text: string): string[] {
-	const lines = text.replace(/\r\n?/g, "\n").split("\n");
-	if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
-	return lines;
+function countNodes(nodes: TreeNode[]): TreeCounts {
+	const counts: TreeCounts = {
+		total: 0,
+		running: 0,
+		success: 0,
+		error: 0,
+		finished: 0,
+	};
+
+	const visit = (node: TreeNode) => {
+		counts.total++;
+		if (node.status === "running") counts.running++;
+		if (node.status === "success") counts.success++;
+		if (node.status === "error") counts.error++;
+		if (node.status !== "running") counts.finished++;
+		for (const child of node.children) visit(child);
+	};
+
+	for (const node of nodes) visit(node);
+	return counts;
 }
 
-function countDisplayLines(items: DisplayItem[]): number {
-	let count = 0;
-	for (const item of items) {
-		count += item.type === "text" ? splitOutputLines(item.text).length : 1;
-	}
-	return count;
+function hasNestedChildren(nodes: TreeNode[]): boolean {
+	return nodes.some((node) => node.children.length > 0 || hasNestedChildren(node.children));
 }
 
-function renderDisplayItems(
-	items: DisplayItem[],
-	expanded: boolean,
-	theme: { fg: ThemeFg },
-	limit?: number,
-): string {
-	const lines: string[] = [];
-	for (const item of items) {
-		if (item.type === "text") {
-			for (const line of splitOutputLines(item.text)) {
-				lines.push(theme.fg("toolOutput", line));
-			}
-		} else {
-			lines.push(theme.fg("muted", "→ ") + formatToolCall(item.name, item.args, theme.fg.bind(theme)));
+function extractPendingSubagentCalls(messages: SingleResult["messages"]): PendingSubagentCall[] {
+	const calls: PendingSubagentCall[] = [];
+	for (let messageIndex = 0; messageIndex < messages.length; messageIndex++) {
+		const message = messages[messageIndex] as any;
+		if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+		for (let partIndex = 0; partIndex < message.content.length; partIndex++) {
+			const part = message.content[partIndex] as any;
+			if (part?.type !== "toolCall" || part?.name !== "subagent") continue;
+			const args = part.arguments && typeof part.arguments === "object" ? part.arguments : {};
+			const tasks = Array.isArray((args as any).tasks)
+				? (args as any).tasks
+						.filter((task: any) => task && typeof task.agent === "string")
+						.map((task: any) => ({
+							agent: task.agent,
+							task: typeof task.task === "string" ? task.task : undefined,
+						}))
+				: [];
+			calls.push({
+				toolCallId:
+					typeof part.toolCallId === "string"
+						? part.toolCallId
+						: typeof part.id === "string"
+							? part.id
+							: `${messageIndex}:${partIndex}`,
+				mode: normalizeDelegationMode((args as any).mode),
+				tasks,
+			});
 		}
 	}
+	return calls;
+}
 
-	const shouldTail = !expanded && typeof limit === "number";
-	const toShow = shouldTail ? lines.slice(-limit) : lines;
-	const skipped = shouldTail && lines.length > limit ? lines.length - limit : 0;
-
-	let text = "";
-	if (skipped > 0) text += theme.fg("muted", `... ${skipped} earlier lines\n`);
-	text += toShow.join("\n");
-	return text.trimEnd();
+function buildPendingNodes(call: PendingSubagentCall): TreeNode[] {
+	return call.tasks.map((task) => ({
+		label: task.agent,
+		status: "running",
+		meta: call.mode === "fork" ? "fork" : "spawn",
+		task: task.task,
+		children: [],
+	}));
 }
 
-function statusIcon(r: SingleResult, theme: { fg: ThemeFg }): string {
-	if (r.exitCode === -1) return theme.fg("warning", "⏳");
-	return isResultError(r) ? theme.fg("error", "✗") : theme.fg("success", "✓");
+function buildNodesFromNestedResult(nested: NestedSubagentResult): TreeNode[] {
+	return nested.details.results.map((result) => buildResultNode(result, nested.details.delegationMode));
 }
 
-function parallelStatus(details: SubagentDetails): {
-	icon: string;
-	status: string;
-	isRunning: boolean;
-} {
-	const running = details.results.filter((r) => r.exitCode === -1).length;
-	const successCount = details.results.filter((r) => r.exitCode === 0).length;
-	const failCount = details.results.filter((r) => r.exitCode > 0).length;
-	const isRunning = running > 0;
-	const icon = isRunning ? "⏳" : failCount > 0 ? "◐" : "✓";
-	const status = isRunning
-		? `${successCount + failCount}/${details.results.length} done, ${running} running`
-		: `${successCount}/${details.results.length} tasks`;
-	return { icon, status, isRunning };
+function buildNestedChildren(result: SingleResult): TreeNode[] {
+	const completedByToolCallId = new Map<string, NestedSubagentResult>();
+	for (const nested of getNestedSubagentResults(result.messages)) {
+		completedByToolCallId.set(nested.toolCallId, nested);
+	}
+
+	const nodes: TreeNode[] = [];
+	for (const call of extractPendingSubagentCalls(result.messages)) {
+		const completed = completedByToolCallId.get(call.toolCallId);
+		if (completed && isSubagentDetails(completed.details)) {
+			nodes.push(...buildNodesFromNestedResult(completed));
+			continue;
+		}
+		nodes.push(...buildPendingNodes(call));
+	}
+	return nodes;
 }
 
-function renderNestedDelegationLines(
-	items: NestedSubagentResult[],
-	theme: { fg: ThemeFg },
-	expanded: boolean,
-	depth = 0,
-): string[] {
+function buildLeafPreview(result: SingleResult): string[] | undefined {
+	const items = getDisplayItems(result.messages);
 	const lines: string[] = [];
 	for (const item of items) {
-		lines.push(...renderNestedDetailsLines(item.details, theme, expanded, depth));
+		if (item.type === "text") {
+			lines.push(...lastNonEmptyLines(item.text, OUTPUT_PREVIEW_LINE_COUNT));
+		}
 	}
-	return lines;
+	const finalOutput = getFinalOutput(result.messages);
+	if (finalOutput) lines.push(...lastNonEmptyLines(finalOutput, OUTPUT_PREVIEW_LINE_COUNT));
+	const unique = lines.filter((line, index) => line && lines.indexOf(line) === index);
+	return unique.length > 0 ? unique.slice(-OUTPUT_PREVIEW_LINE_COUNT) : undefined;
 }
 
-function renderNestedDetailsLines(
-	details: SubagentDetails,
+function buildResultNode(result: SingleResult, delegationMode: DelegationMode): TreeNode {
+	const status = statusFromResult(result);
+	const usage = formatUsage(result.usage, result.model);
+	const metaParts: string[] = [result.agentSource, delegationMode];
+	if (usage) metaParts.push(usage);
+	if (status === "error") {
+		const errorText = result.errorMessage || result.stderr || result.stopReason;
+		if (errorText) metaParts.push(truncate(errorText.replace(/\s+/g, " "), 120));
+	}
+
+	const children = buildNestedChildren(result);
+	return {
+		label: result.agent,
+		status,
+		meta: metaParts.join(" • "),
+		task: result.task,
+		outputPreview: children.length === 0 ? buildLeafPreview(result) : undefined,
+		children,
+	};
+}
+
+function buildTopLevelNodes(details: SubagentDetails): TreeNode[] {
+	return details.results.map((result) => buildResultNode(result, details.delegationMode));
+}
+
+function renderTreeLines(
+	nodes: TreeNode[],
 	theme: { fg: ThemeFg },
-	expanded: boolean,
+	showOutputPreview: boolean,
 	depth = 0,
 ): string[] {
-	const indent = "  ".repeat(depth);
-	if (details.mode === "single") {
-		const result = details.results[0];
-		if (!result) return [];
-
-		const lines: string[] = [];
-		let header = `${indent}${theme.fg("muted", "↳ ")}${theme.fg("toolTitle", "subagent ")}${theme.fg("accent", result.agent)} ${statusIcon(result, theme)}${theme.fg("muted", ` [${details.delegationMode}]`)}`;
-		const usage = formatUsage(result.usage, result.model);
-		if (usage) header += ` ${theme.fg("dim", usage)}`;
-		lines.push(header);
-
-		if (!expanded) return lines;
-
-		lines.push(`${indent}  ${theme.fg("muted", "task: ")}${theme.fg("dim", truncate(result.task, 96))}`);
-		const nested = getNestedSubagentResults(result.messages);
-		if (nested.length > 0) {
-			lines.push(...renderNestedDelegationLines(nested, theme, true, depth + 1));
-		}
-		const finalLine = firstNonEmptyLine(getFinalOutput(result.messages));
-		if (finalLine) {
-			lines.push(`${indent}  ${theme.fg("muted", "final: ")}${theme.fg("toolOutput", truncate(finalLine, 96))}`);
-		}
-		return lines;
-	}
-
-	const { icon, status } = parallelStatus(details);
 	const lines: string[] = [];
-	let header = `${indent}${theme.fg("muted", "↳ ")}${theme.fg("toolTitle", "parallel delegation ")}${theme.fg("accent", status)} ${theme.fg("muted", `[${details.delegationMode}]`)} ${theme.fg(icon === "✓" ? "success" : icon === "⏳" ? "warning" : "warning", icon)}`;
-	const totalUsage = formatUsage(aggregateUsage(details.results));
-	if (totalUsage) header += ` ${theme.fg("dim", totalUsage)}`;
-	lines.push(header);
 
-	for (const result of details.results) {
-		let line = `${indent}  ${statusIcon(result, theme)} ${theme.fg("accent", result.agent)}`;
-		const usage = formatUsage(result.usage, result.model);
-		if (usage) line += ` ${theme.fg("dim", usage)}`;
+	for (const node of nodes) {
+		const indent = "  ".repeat(depth);
+		let line = `${indent}${statusEmoji(node.status, theme)} ${theme.fg("accent", node.label)}`;
+		if (node.meta) line += ` ${theme.fg("dim", node.meta)}`;
 		lines.push(line);
-		if (expanded) {
-			lines.push(`${indent}    ${theme.fg("muted", "task: ")}${theme.fg("dim", truncate(result.task, 88))}`);
-			const nested = getNestedSubagentResults(result.messages);
-			if (nested.length > 0) {
-				lines.push(...renderNestedDelegationLines(nested, theme, true, depth + 2));
-			}
-			const finalLine = firstNonEmptyLine(getFinalOutput(result.messages));
-			if (finalLine) {
-				lines.push(`${indent}    ${theme.fg("muted", "final: ")}${theme.fg("toolOutput", truncate(finalLine, 88))}`);
+
+		if (showOutputPreview && node.outputPreview && node.outputPreview.length > 0) {
+			for (const outputLine of node.outputPreview) {
+				lines.push(`${indent}  ${theme.fg("toolOutput", outputLine)}`);
 			}
 		}
+
+		if (node.children.length > 0) {
+			lines.push(...renderTreeLines(node.children, theme, false, depth + 1));
+		}
 	}
 
 	return lines;
 }
 
-function nestedDelegationText(
-	messages: SingleResult["messages"],
-	theme: { fg: ThemeFg },
-	expanded: boolean,
-): string {
-	const nested = getNestedSubagentResults(messages);
-	if (nested.length === 0) return "";
-	const lines = renderNestedDelegationLines(nested, theme, expanded);
-	if (expanded) return lines.join("\n");
-	if (lines.length <= NESTED_PREVIEW_LINE_COUNT) return lines.join("\n");
-	return [
-		...lines.slice(0, NESTED_PREVIEW_LINE_COUNT),
-		theme.fg("muted", `... ${lines.length - NESTED_PREVIEW_LINE_COUNT} more delegation lines`),
-	].join("\n");
+function topLevelSummary(details: SubagentDetails, counts: TreeCounts): string {
+	const totalUsage = formatUsage(aggregateUsage(details.results));
+	const parts = [
+		`${counts.running} running`,
+		`${counts.finished}/${counts.total} finished`,
+		`${counts.success} ok`,
+		`${counts.error} error`,
+	];
+	if (totalUsage) parts.push(totalUsage);
+	return parts.join(" • ");
 }
 
 // ---------------------------------------------------------------------------
@@ -288,39 +288,25 @@ function nestedDelegationText(
 
 export function renderCall(args: Record<string, any>, theme: { fg: ThemeFg; bold: (s: string) => string }): Text {
 	const delegationMode = normalizeDelegationMode(args.mode);
-	const modeBadge = theme.fg("muted", ` [${delegationMode}]`);
 	const tasks = Array.isArray(args.tasks) ? args.tasks : [];
-
-	if (tasks.length > 1) {
-		let text =
-			theme.fg("toolTitle", theme.bold("subagent ")) +
-			theme.fg("accent", `parallel (${tasks.length} tasks)`) +
-			modeBadge;
-		for (const t of tasks.slice(0, 3)) {
-			text += `\n  ${theme.fg("accent", t.agent)}${theme.fg("dim", ` ${truncate(t.task, 40)}`)}`;
-		}
-		if (tasks.length > 3) text += `\n  ${theme.fg("muted", `... +${tasks.length - 3} more`)}`;
-		return new Text(text, 0, 0);
+	const count = tasks.length;
+	let text = `${theme.fg("toolTitle", theme.bold("subagent "))}${theme.fg("muted", `[${delegationMode}]`)} ${theme.fg("accent", `${count} task${count === 1 ? "" : "s"}`)}`;
+	for (const task of tasks.slice(0, 6)) {
+		const agent = typeof task?.agent === "string" ? task.agent : "...";
+		const preview = typeof task?.task === "string" ? ` ${truncate(task.task, 56)}` : "";
+		text += `\n  ${theme.fg("warning", "⏳")} ${theme.fg("accent", agent)}${theme.fg("dim", preview)}`;
 	}
-
-	const singleTask = tasks[0];
-	const agentName = singleTask?.agent || args.agent || "...";
-	const preview = singleTask?.task ? truncate(singleTask.task, 60) : args.task ? truncate(args.task, 60) : "...";
-	let text =
-		theme.fg("toolTitle", theme.bold("subagent ")) +
-		theme.fg("accent", agentName) +
-		modeBadge;
-	text += `\n  ${theme.fg("dim", preview)}`;
+	if (tasks.length > 6) text += `\n  ${theme.fg("muted", `... +${tasks.length - 6} more`)}`;
 	return new Text(text, 0, 0);
 }
 
 // ---------------------------------------------------------------------------
-// renderResult — shown after the tool completes
+// renderResult — shown after the tool completes / streams updates
 // ---------------------------------------------------------------------------
 
 export function renderResult(
 	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
-	expanded: boolean,
+	_expanded: boolean,
 	theme: { fg: ThemeFg; bold: (s: string) => string },
 ): Container | Text {
 	const details = result.details as SubagentDetails | undefined;
@@ -329,267 +315,26 @@ export function renderResult(
 		return new Text(first?.type === "text" && first.text ? first.text : "(no output)", 0, 0);
 	}
 
-	const delegationMode = normalizeDelegationMode(
-		(details as Partial<SubagentDetails>).delegationMode,
-	);
-	if (details.mode === "single") {
-		return renderSingleResult(details.results[0], delegationMode, expanded, theme);
-	}
-	return renderParallelResult(details, delegationMode, expanded, theme);
-}
-
-// ---------------------------------------------------------------------------
-// Single-mode result
-// ---------------------------------------------------------------------------
-
-function renderSingleResult(
-	r: SingleResult,
-	delegationMode: DelegationMode,
-	expanded: boolean,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Container | Text {
-	const error = isResultError(r);
-	const icon = statusIcon(r, theme);
-	const displayItems = getDisplayItems(r.messages);
-	const finalOutput = getFinalOutput(r.messages);
-	const nestedDelegations = nestedDelegationText(r.messages, theme, expanded);
-
-	if (expanded) {
-		return renderSingleExpanded(
-			r,
-			delegationMode,
-			icon,
-			error,
-			displayItems,
-			finalOutput,
-			nestedDelegations,
-			theme,
-		);
-	}
-	return renderSingleCollapsed(r, delegationMode, icon, error, displayItems, nestedDelegations, theme);
-}
-
-function renderSingleExpanded(
-	r: SingleResult,
-	delegationMode: DelegationMode,
-	icon: string,
-	error: boolean,
-	displayItems: DisplayItem[],
-	finalOutput: string,
-	nestedDelegations: string,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Container {
-	const mdTheme = getMarkdownTheme();
-	const container = new Container();
-
-	// Header
-	let header = `${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${theme.fg("muted", ` (${r.agentSource}, ${delegationMode})`)}`;
-	if (error && r.stopReason) header += ` ${theme.fg("error", `[${r.stopReason}]`)}`;
-	container.addChild(new Text(header, 0, 0));
-	if (error && r.errorMessage) {
-		container.addChild(new Text(theme.fg("error", `Error: ${r.errorMessage}`), 0, 0));
-	}
-
-	// Task
-	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));
-
-	if (nestedDelegations) {
-		container.addChild(new Spacer(1));
-		container.addChild(new Text(theme.fg("muted", "─── Delegation tree ───"), 0, 0));
-		container.addChild(new Text(nestedDelegations, 0, 0));
-	}
-
-	// Output
-	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));
-		}
-	}
-
-	// Usage
-	const usageStr = formatUsage(r.usage, r.model);
-	if (usageStr) {
-		container.addChild(new Spacer(1));
-		container.addChild(new Text(theme.fg("dim", usageStr), 0, 0));
-	}
-
-	return container;
-}
-
-function renderSingleCollapsed(
-	r: SingleResult,
-	delegationMode: DelegationMode,
-	icon: string,
-	error: boolean,
-	displayItems: DisplayItem[],
-	nestedDelegations: string,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Text {
-	let text = `${icon} ${theme.fg("toolTitle", theme.bold(r.agent))}${theme.fg("muted", ` (${r.agentSource}, ${delegationMode})`)}`;
-	if (error && r.stopReason) text += ` ${theme.fg("error", `[${r.stopReason}]`)}`;
-
-	if (error && r.errorMessage) {
-		text += `\n${theme.fg("error", `Error: ${r.errorMessage}`)}`;
-	} else if (displayItems.length === 0) {
-		text += `\n${theme.fg("muted", "(no output)")}`;
-	} else {
-		text += `\n${renderDisplayItems(displayItems, false, theme, COLLAPSED_LINE_COUNT)}`;
-		if (countDisplayLines(displayItems) > COLLAPSED_LINE_COUNT) {
-			text += `\n${theme.fg("muted", "(Ctrl+O to expand)")}`;
-		}
-	}
-
-	if (nestedDelegations) {
-		text += `\n\n${theme.fg("muted", "Delegation tree:")}`;
-		text += `\n${nestedDelegations}`;
-	}
-
-	const usageStr = formatUsage(r.usage, r.model);
-	if (usageStr) text += `\n${theme.fg("dim", usageStr)}`;
-	return new Text(text, 0, 0);
-}
-
-// ---------------------------------------------------------------------------
-// Parallel-mode result
-// ---------------------------------------------------------------------------
-
-function renderParallelResult(
-	details: SubagentDetails,
-	delegationMode: DelegationMode,
-	expanded: boolean,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Container | Text {
-	const running = details.results.filter((r) => r.exitCode === -1).length;
-	const successCount = details.results.filter((r) => r.exitCode === 0).length;
-	const failCount = details.results.filter((r) => r.exitCode > 0).length;
-	const isRunning = running > 0;
-
-	const icon = isRunning
+	const nodes = buildTopLevelNodes(details);
+	const counts = countNodes(nodes);
+	const showOutputPreview = !hasNestedChildren(nodes);
+	const icon = counts.running > 0
 		? 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} tasks`;
-
-	if (expanded && !isRunning) {
-		return renderParallelExpanded(details, delegationMode, icon, status, theme);
-	}
-	return renderParallelCollapsed(
-		details,
-		delegationMode,
-		icon,
-		status,
-		isRunning,
-		expanded,
-		theme,
-	);
-}
+		: counts.error > 0
+			? theme.fg("error", "❌")
+			: theme.fg("success", "✅");
 
-function renderParallelExpanded(
-	details: SubagentDetails,
-	delegationMode: DelegationMode,
-	icon: string,
-	status: string,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Container {
-	const mdTheme = getMarkdownTheme();
 	const container = new Container();
 	container.addChild(
 		new Text(
-			`${icon} ${theme.fg("toolTitle", theme.bold("parallel "))}${theme.fg("accent", status)}${theme.fg("muted", ` [${delegationMode}]`)}`,
+			`${icon} ${theme.fg("toolTitle", theme.bold("subagent tree "))}${theme.fg("muted", `[${details.delegationMode}]`)} ${theme.fg("dim", topLevelSummary(details, counts))}`,
 			0,
 			0,
 		),
 	);
 
-	for (const r of details.results) {
-		const rIcon = statusIcon(r, theme);
-		const displayItems = getDisplayItems(r.messages);
-		const finalOutput = getFinalOutput(r.messages);
-		const nestedDelegations = nestedDelegationText(r.messages, theme, true);
-
-		container.addChild(new Spacer(1));
-		container.addChild(new Text(`${theme.fg("muted", "─── ")}${theme.fg("accent", r.agent)} ${rIcon}`, 0, 0));
-		container.addChild(new Text(theme.fg("muted", "Task: ") + theme.fg("dim", r.task), 0, 0));
-
-		if (nestedDelegations) {
-			container.addChild(new Text(theme.fg("muted", "Delegation tree:"), 0, 0));
-			container.addChild(new Text(nestedDelegations, 0, 0));
-		}
-
-		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 taskUsage = formatUsage(r.usage, r.model);
-		if (taskUsage) container.addChild(new Text(theme.fg("dim", taskUsage), 0, 0));
-	}
-
-	const totalUsage = formatUsage(aggregateUsage(details.results));
-	if (totalUsage) {
-		container.addChild(new Spacer(1));
-		container.addChild(new Text(theme.fg("dim", `Total: ${totalUsage}`), 0, 0));
-	}
+	container.addChild(new Spacer(1));
+	container.addChild(new Text(renderTreeLines(nodes, theme, showOutputPreview).join("\n"), 0, 0));
 
 	return container;
 }
-
-function renderParallelCollapsed(
-	details: SubagentDetails,
-	delegationMode: DelegationMode,
-	icon: string,
-	status: string,
-	isRunning: boolean,
-	expanded: boolean,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Text {
-	let text = `${icon} ${theme.fg("toolTitle", theme.bold("parallel "))}${theme.fg("accent", status)}${theme.fg("muted", ` [${delegationMode}]`)}`;
-
-	for (const r of details.results) {
-		const rIcon = statusIcon(r, theme);
-		const displayItems = getDisplayItems(r.messages);
-		const nestedDelegations = nestedDelegationText(r.messages, theme, false);
-		text += `\n\n${theme.fg("muted", "─── ")}${theme.fg("accent", r.agent)} ${rIcon}`;
-		if (displayItems.length === 0) {
-			text += `\n${theme.fg("muted", r.exitCode === -1 ? "(running...)" : "(no output)")}`;
-		} else {
-			text += `\n${renderDisplayItems(displayItems, false, theme, COLLAPSED_PARALLEL_LINE_COUNT)}`;
-		}
-		if (nestedDelegations) {
-			text += `\n${theme.fg("muted", "Delegation tree:")}`;
-			text += `\n${nestedDelegations}`;
-		}
-		const taskUsage = formatUsage(r.usage, r.model);
-		if (taskUsage) text += `\n${theme.fg("dim", taskUsage)}`;
-	}
-
-	if (!isRunning) {
-		const totalUsage = formatUsage(aggregateUsage(details.results));
-		if (totalUsage) text += `\n\n${theme.fg("dim", `Total: ${totalUsage}`)}`;
-	}
-	if (!expanded) text += `\n${theme.fg("muted", "(Ctrl+O to expand)")}`;
-
-	return new Text(text, 0, 0);
-}

package/runner.ts

@@ -17,6 +17,7 @@ import {
   type SubagentDetails,
   emptyUsage,
   getFinalOutput,
+  getNestedSubagentErrorSummary,
 } from "./types.js";
 
 const SIGKILL_TIMEOUT_MS = 5000;
@@ -291,6 +292,8 @@ export async function runAgent(opts: RunAgentOptions): Promise<SingleResult> {
     });
   };
 
+  emitUpdate();
+
   // Write system prompt to temp file if needed
   let promptTmpDir: string | null = null;
   let promptTmpPath: string | null = null;
@@ -382,6 +385,17 @@ export async function runAgent(opts: RunAgentOptions): Promise<SingleResult> {
       result.errorMessage = "Subagent was aborted.";
       if (!result.stderr.trim()) result.stderr = "Subagent was aborted.";
     }
+
+    if (result.exitCode === 0) {
+      const nestedErrorSummary = getNestedSubagentErrorSummary(result.messages);
+      if (nestedErrorSummary) {
+        result.exitCode = 1;
+        result.stopReason = "error";
+        result.errorMessage = nestedErrorSummary;
+        if (!result.stderr.trim()) result.stderr = nestedErrorSummary;
+      }
+    }
+
     return result;
   } finally {
     cleanupTempDir(promptTmpDir);

package/types.ts

@@ -133,3 +133,37 @@ export function getNestedSubagentResults(messages: Message[]): NestedSubagentRes
 	}
 	return results;
 }
+
+function collectSubagentErrorLinesFromDetails(
+	details: SubagentDetails,
+	lines: string[],
+	prefix = "",
+): void {
+	for (const result of details.results) {
+		if (isResultError(result)) {
+			const reason = result.errorMessage || result.stderr || result.stopReason || "failed";
+			lines.push(`${prefix}${result.agent}: ${reason}`);
+		}
+		const nested = getNestedSubagentResults(result.messages);
+		for (const child of nested) {
+			if (child.isError) {
+				collectSubagentErrorLinesFromDetails(
+					child.details,
+					lines,
+					`${prefix}${result.agent} -> `,
+				);
+			}
+		}
+	}
+}
+
+/** Summarize nested subagent failures captured in a message history. */
+export function getNestedSubagentErrorSummary(messages: Message[]): string | null {
+	const lines: string[] = [];
+	for (const nested of getNestedSubagentResults(messages)) {
+		if (!nested.isError) continue;
+		collectSubagentErrorLinesFromDetails(nested.details, lines);
+	}
+	if (lines.length === 0) return null;
+	return `Nested subagent failure: ${lines.join("; ")}`;
+}