oira666_pi-subagent 0.1.0 → 0.1.2

package/README.md

@@ -19,13 +19,13 @@ There are many subagent extensions for pi, this one is mine.
 ### Option 1: Install from npm (recommended)
 
 ```bash
-pi install npm:@mjakl/pi-subagent
+pi install npm:oira666_pi-subagent
 ```
 
 ### Option 2: Install via git
 
 ```bash
-pi install git:github.com/mjakl/pi-subagent
+pi install git:github.com/gee666/pi-subagent.git
 ```
 
 ### Option 3: Manual Installation
@@ -34,7 +34,7 @@ Clone this repository to your Pi extensions directory:
 
 ```bash
 cd ~/.pi/agent/extensions
-git clone https://github.com/mjakl/pi-subagent.git
+git clone https://github.com/gee666/pi-subagent.git
 cd pi-subagent
 npm install
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-subagent",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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("; ")}`;
+}