oira666_pi-subagent 0.2.22 → 0.2.24

package/index.ts

@@ -632,6 +632,73 @@ export default function (pi: ExtensionAPI) {
   };
   let nextActiveSubagentId = 1;
 
+  /**
+   * Build a lightweight version of SubagentDetails for live progress bubbling.
+   *
+   * Full message histories can be very large in long agent trees. For live TUI
+   * rendering we only need subagent tool-call structure, nested subagent
+   * results, live logs, metadata, and usage counters. Text conversations are
+   * intentionally omitted; final durable results still arrive via normal
+   * tool_result_end messages.
+   */
+  function slimDetailsForProgress(details: SubagentDetails): SubagentDetails {
+    const slimResult = (result: SingleResult): SingleResult => {
+      const slimMessages = result.messages
+        .map((message: any) => {
+          if (message?.role === "assistant" && Array.isArray(message.content)) {
+            const subagentCalls = message.content.filter(
+              (part: any) => part?.type === "toolCall" && part?.name === "subagent",
+            );
+            return subagentCalls.length > 0
+              ? { ...message, content: subagentCalls }
+              : null;
+          }
+          if (message?.role === "toolResult" && message.toolName === "subagent") {
+            return isSubagentDetails(message.details)
+              ? { ...message, details: slimDetailsForProgress(message.details) }
+              : message;
+          }
+          return null;
+        })
+        .filter(Boolean) as SingleResult["messages"];
+
+      const liveNestedSubagents = result.liveNestedSubagents
+        ? Object.fromEntries(
+            Object.entries(result.liveNestedSubagents).map(([nestedToolCallId, nested]) => [
+              nestedToolCallId,
+              slimDetailsForProgress(nested),
+            ]),
+          )
+        : undefined;
+
+      return {
+        ...result,
+        messages: slimMessages,
+        stderr: result.stderr ? result.stderr.slice(-1000) : "",
+        liveLog: [...(result.liveLog ?? [])],
+        liveNestedSubagents,
+      };
+    };
+
+    return {
+      ...details,
+      results: details.results.map(slimResult),
+    };
+  }
+
+  function emitNestedProgressToParent(toolCallId: string, details: SubagentDetails): void {
+    if (currentDepth <= 0) return;
+    try {
+      process.stdout.write(`${JSON.stringify({
+        type: "subagent_progress",
+        toolCallId,
+        details: slimDetailsForProgress(details),
+      })}\n`);
+    } catch {
+      // Best-effort only. Normal final tool_result_end still carries the durable result.
+    }
+  }
+
   const BROADCAST_STEER_PREFIX = "__PI_SUBAGENT_BROADCAST_STEER__";
 
   interface BroadcastTarget {
@@ -1157,7 +1224,10 @@ calls one after another. Do NOT put dependent tasks in the same array.
 
           const executionMode = tasks.length === 1 ? "single" : "parallel";
           const trackedOnUpdate = (partial: any) => {
-            if (isSubagentDetails(partial?.details)) updateLatestBroadcastTargets(partial.details);
+            if (isSubagentDetails(partial?.details)) {
+              updateLatestBroadcastTargets(partial.details);
+              emitNestedProgressToParent(toolCallId, partial.details);
+            }
             onUpdate?.(partial);
           };
 

package/package.json

@@ -1,74 +1,75 @@
-{
-  "name": "oira666_pi-subagent",
-  "version": "0.2.22",
-  "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
-  "type": "module",
-  "main": "index.ts",
-  "files": [
-    "index.ts",
-    "agents.ts",
-    "runner.ts",
-    "resume.ts",
-    "shared.ts",
-    "render.ts",
-    "types.ts",
-    "agents/*.md",
-    "README.md",
-    "LICENSE"
-  ],
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "keywords": [
-    "pi",
-    "subagent",
-    "delegation",
-    "pi-package"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gee666/pi-subagent.git"
-  },
-  "bugs": {
-    "url": "https://github.com/gee666/pi-subagent/issues"
-  },
-  "homepage": "https://github.com/gee666/pi-subagent#readme",
-  "publishConfig": {
-    "access": "public"
-  },
-  "license": "MIT",
-  "scripts": {
-    "test": "node --import tsx/esm --test tests/*.test.ts test/*.test.ts"
-  },
-  "devDependencies": {
-    "@types/node": "^25.2.3",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
-  },
-  "peerDependencies": {
-    "@mariozechner/pi-agent-core": ">=0.37.0",
-    "@mariozechner/pi-ai": ">=0.37.0",
-    "@mariozechner/pi-coding-agent": ">=0.37.0",
-    "@mariozechner/pi-tui": ">=0.37.0",
-    "@sinclair/typebox": ">=0.34.0"
-  },
-  "peerDependenciesMeta": {
-    "@mariozechner/pi-agent-core": {
-      "optional": true
-    },
-    "@mariozechner/pi-coding-agent": {
-      "optional": true
-    },
-    "@mariozechner/pi-tui": {
-      "optional": true
-    },
-    "@mariozechner/pi-ai": {
-      "optional": true
-    },
-    "@sinclair/typebox": {
-      "optional": true
-    }
-  }
-}
+{
+  "name": "oira666_pi-subagent",
+  "version": "0.2.24",
+  "description": "Subagent extension for Pi coding agent. Delegate tasks to specialized agents.",
+  "type": "module",
+  "main": "index.ts",
+  "files": [
+    "index.ts",
+    "agents.ts",
+    "runner.ts",
+    "resume.ts",
+    "shared.ts",
+    "render.ts",
+    "tree.ts",
+    "types.ts",
+    "agents/*.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "keywords": [
+    "pi",
+    "subagent",
+    "delegation",
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gee666/pi-subagent.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gee666/pi-subagent/issues"
+  },
+  "homepage": "https://github.com/gee666/pi-subagent#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "scripts": {
+    "test": "node --import tsx/esm --test tests/*.test.ts test/*.test.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^25.2.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-agent-core": ">=0.37.0",
+    "@mariozechner/pi-ai": ">=0.37.0",
+    "@mariozechner/pi-coding-agent": ">=0.37.0",
+    "@mariozechner/pi-tui": ">=0.37.0",
+    "@sinclair/typebox": ">=0.34.0"
+  },
+  "peerDependenciesMeta": {
+    "@mariozechner/pi-agent-core": {
+      "optional": true
+    },
+    "@mariozechner/pi-coding-agent": {
+      "optional": true
+    },
+    "@mariozechner/pi-tui": {
+      "optional": true
+    },
+    "@mariozechner/pi-ai": {
+      "optional": true
+    },
+    "@sinclair/typebox": {
+      "optional": true
+    }
+  }
+}

package/render.ts

@@ -1,471 +1,87 @@
-/**
- * TUI rendering for subagent tool calls and results.
- */
-
-import * as os from "node:os";
-import { Container, Spacer, Text } from "@mariozechner/pi-tui";
-import {
-	type LiveLogEntry,
-	type NestedSubagentResult,
-	type SingleResult,
-	type SubagentDetails,
-	type UsageStats,
-	aggregateUsage,
-	getDisplayItems,
-	getFinalOutput,
-	getNestedSubagentResults,
-	isResultError,
-	isSubagentDetails,
-} from "./types.js";
-
-const OUTPUT_PREVIEW_LINE_COUNT = 6;
-
-let broadcastNumberingActive = false;
-
-export function setBroadcastNumberingActive(active: boolean): void {
-	broadcastNumberingActive = active;
-}
-
-type ThemeFg = (color: string, text: string) => string;
-type NodeStatus = "running" | "success" | "error";
-
-interface TreeNode {
-	label: string;
-	status: NodeStatus;
-	meta?: string;
-	task?: string;
-	outputPreview?: string[];
-	liveActivity?: LiveLogEntry[];
-	children: TreeNode[];
-}
-
-
-interface TreeCounts {
-	total: number;
-	running: number;
-	success: number;
-	error: number;
-	finished: number;
-}
-
-interface PendingSubagentCall {
-	toolCallId: string;
-	tasks: Array<{ agent: string; task?: string }>;
-}
-
-// ---------------------------------------------------------------------------
-// Formatting helpers
-// ---------------------------------------------------------------------------
-
-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`;
-}
-
-function formatUsage(usage: Partial<UsageStats>, model?: string): string {
-	const parts: string[] = [];
-	const totalTokens =
-		(usage.input || 0) +
-		(usage.output || 0) +
-		(usage.cacheRead || 0) +
-		(usage.cacheWrite || 0);
-	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
-	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(`$${usage.cost.toFixed(4)}`);
-	if (usage.contextTokens && usage.contextTokens > 0) parts.push(`ctx:${formatTokens(usage.contextTokens)}`);
-	if (model) parts.push(model);
-	return parts.join(" • ");
-}
-
-function truncate(text: string, maxLen: number): string {
-	return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
-}
-
-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 lastNonEmptyLines(text: string, limit: number): string[] {
-	return splitOutputLines(text)
-		.map((line) => line.trimEnd())
-		.filter((line) => line.trim().length > 0)
-		.slice(-limit);
-}
-
-function statusEmoji(status: NodeStatus, theme: { fg: ThemeFg }): string {
-	switch (status) {
-		case "running":
-			return theme.fg("warning", "⏳");
-		case "error":
-			return theme.fg("error", "❌");
-		default:
-			return theme.fg("success", "✅");
-	}
-}
-
-function statusFromResult(result: SingleResult): NodeStatus {
-	if (result.exitCode === -1) return "running";
-	return isResultError(result) ? "error" : "success";
-}
-
-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 hasNestedChildren(nodes: TreeNode[]): boolean {
-	return nodes.some((node) => node.children.length > 0 || hasNestedChildren(node.children));
-}
-
-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}`,
-				tasks,
-			});
-		}
-	}
-	return calls;
-}
-
-function buildPendingNodes(call: PendingSubagentCall): TreeNode[] {
-	return call.tasks.map((task) => ({
-		label: task.agent,
-		status: "running",
-		task: task.task,
-		children: [],
-	}));
-}
-
-function buildNodesFromNestedResult(nested: NestedSubagentResult): TreeNode[] {
-	return nested.details.results.map((result) => buildResultNode(result));
-}
-
-function subagentCallSignature(call: PendingSubagentCall): string {
-	return JSON.stringify(call.tasks.map((task) => ({ agent: task.agent, task: task.task ?? "" })));
-}
-
-function nestedResultIsHealthy(nested: NestedSubagentResult | undefined): boolean {
-	if (!nested || nested.isError) return false;
-	return nested.details.results.every((result) => !isResultError(result));
-}
-
-function buildNestedChildren(result: SingleResult): TreeNode[] {
-	const parentIsRunning = result.exitCode === -1;
-	const completedByToolCallId = new Map<string, NestedSubagentResult>();
-	for (const nested of getNestedSubagentResults(result.messages)) {
-		completedByToolCallId.set(nested.toolCallId, nested);
-	}
-
-	const calls = extractPendingSubagentCalls(result.messages);
-	const laterResumeBySignature = new Map<string, number>();
-	calls.forEach((call, index) => {
-		const completed = completedByToolCallId.get(call.toolCallId);
-		// A resumed call has the same task signature as the interrupted call but a
-		// newer toolCallId. Prefer that newer running/successful tree over the old
-		// synthetic/aborted result so resumed nested subagents render in-place.
-		if (!completed || nestedResultIsHealthy(completed)) {
-			laterResumeBySignature.set(subagentCallSignature(call), index);
-		}
-	});
-
-	const nodes: TreeNode[] = [];
-	calls.forEach((call, index) => {
-		const completed = completedByToolCallId.get(call.toolCallId);
-		const newerEquivalent = laterResumeBySignature.get(subagentCallSignature(call));
-		if (
-			newerEquivalent !== undefined &&
-			newerEquivalent > index &&
-			(!completed || completed.isError || !nestedResultIsHealthy(completed))
-		) {
-			return;
-		}
-
-		if (completed && isSubagentDetails(completed.details)) {
-			nodes.push(...buildNodesFromNestedResult(completed));
-			return;
-		}
-		// Unmatched subagent tool calls are useful while the parent is still
-		// running (they show live pending children). Once the parent finished,
-		// unmatched calls are stale history from an interrupted/resumed session and
-		// must not keep the whole tree in a perpetual "running" state.
-		if (parentIsRunning) nodes.push(...buildPendingNodes(call));
-	});
-	return nodes;
-}
-
-function formatToolArgPreview(toolName: string, args: Record<string, unknown>): string {
-	const shorten = (p: string) => {
-		const home = os.homedir();
-		return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
-	};
-	const truncateTo = (s: string, n: number) =>
-		s.length > n ? s.slice(0, n) + "\u2026" : s;
-
-	switch (toolName) {
-		case "bash": {
-			const cmd = (args.command as string) || "";
-			return truncateTo(cmd.replace(/\s+/g, " "), 52);
-		}
-		case "read":
-		case "write":
-		case "edit":
-			return shorten(truncateTo((args.path ?? args.file_path ?? "") as string, 52));
-		case "grep":
-			return truncateTo(`/${args.pattern}/`, 30) +
-				   (args.path ? ` in ${shorten(args.path as string)}` : "");
-		case "find":
-			return truncateTo((args.pattern ?? "*") as string, 30) +
-				   (args.path ? ` in ${shorten(args.path as string)}` : "");
-		case "subagent": {
-			const tasks = (args.tasks as any[]) ?? [];
-			return tasks.map((t: any) => t.agent).join(", ");
-		}
-		default:
-			return "";
-	}
-}
-
-function formatLiveLogEntry(
-	entry: LiveLogEntry,
-	theme: { fg: ThemeFg },
-): string {
-	switch (entry.kind) {
-		case "turn_start":
-			return theme.fg("muted", "\u27f3") + " " + theme.fg("dim", "thinking\u2026");
-
-		case "turn_end": {
-			const tokens = entry.inputTokens || entry.outputTokens
-				? " " + theme.fg("dim",
-					`\u2191${formatTokens(entry.inputTokens)} \u2193${formatTokens(entry.outputTokens)}`)
-				: "";
-			return (
-				theme.fg("success", "\u2713") +
-				" " +
-				theme.fg("muted", `turn ${entry.turn}`) +
-				tokens
-			);
-		}
-
-		case "tool_start": {
-			const argPreview = formatToolArgPreview(entry.toolName, entry.args);
-			return (
-				theme.fg("muted", "\u2192") +
-				" " +
-				theme.fg("accent", entry.toolName) +
-				(argPreview ? "  " + theme.fg("dim", argPreview) : "")
-			);
-		}
-
-		case "tool_end":
-			return (
-				theme.fg("success", "\u2713") +
-				" " +
-				theme.fg("accent", entry.toolName)
-			);
-	}
-}
-
-function buildLeafPreview(result: SingleResult): string[] | undefined {
-	const items = getDisplayItems(result.messages);
-	const lines: string[] = [];
-	for (const item of items) {
-		if (item.type === "text") {
-			lines.push(...lastNonEmptyLines(item.text, OUTPUT_PREVIEW_LINE_COUNT));
-		}
-	}
-	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 buildResultNode(result: SingleResult): TreeNode {
-	const status = statusFromResult(result);
-	const usage = formatUsage(result.usage, result.model);
-	const metaParts: string[] = [result.agentSource];
-	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);
-	const isRunning = status === "running";
-	return {
-		label: result.agent,
-		status,
-		meta: metaParts.join(" • "),
-		task: result.task,
-		liveActivity: isRunning && result.liveLog?.length > 0 ? result.liveLog : undefined,
-		outputPreview: !isRunning && children.length === 0 ? buildLeafPreview(result) : undefined,
-		children,
-	};
-}
-
-function buildTopLevelNodes(details: SubagentDetails): TreeNode[] {
-	return details.results.map((result) => buildResultNode(result));
-}
-
-function renderTreeLines(
-	nodes: TreeNode[],
-	theme: { fg: ThemeFg },
-	showOutputPreview: boolean,
-	depth = 0,
-	prefix = "",
-): string[] {
-	const lines: string[] = [];
-
-	nodes.forEach((node, index) => {
-		const indent = "  ".repeat(depth);
-		const number = prefix ? `${prefix}.${index + 1}` : `${index + 1}`;
-		const numberPrefix = broadcastNumberingActive ? `${number}. ` : "";
-		let line = `${indent}${numberPrefix}${statusEmoji(node.status, theme)} ${theme.fg("accent", node.label)}`;
-		if (node.meta) line += ` ${theme.fg("dim", node.meta)}`;
-		lines.push(line);
-
-		if (showOutputPreview && node.outputPreview && node.outputPreview.length > 0) {
-			for (const outputLine of node.outputPreview) {
-				lines.push(`${indent}  ${theme.fg("toolOutput", outputLine)}`);
-			}
-		}
-
-		if (showOutputPreview && node.liveActivity && node.liveActivity.length > 0) {
-			for (const entry of node.liveActivity) {
-				lines.push(`${indent}  ${formatLiveLogEntry(entry, theme)}`);
-			}
-		}
-
-		if (node.children.length > 0) {
-			lines.push(...renderTreeLines(node.children, theme, false, depth + 1, number));
-		}
-	});
-
-	return lines;
-}
-
-function topLevelSummary(details: SubagentDetails, counts: TreeCounts): string {
-	// aggregatedUsage includes own agents + all their nested descendants;
-	// fall back to summing only direct results for old serialised data lacking the field.
-	const totalUsage = formatUsage(
-		details.aggregatedUsage ?? 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(" • ");
-}
-
-// ---------------------------------------------------------------------------
-// renderCall — shown while the tool is being invoked
-// ---------------------------------------------------------------------------
-
-export function renderCall(
-	args: Record<string, any>,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-	context?: { isPartial?: boolean; isError?: boolean },
-): Text {
-	const tasks = Array.isArray(args.tasks) ? args.tasks : [];
-	const count = tasks.length;
-	const icon = context?.isPartial === false
-		? context.isError
-			? theme.fg("error", "❌")
-			: theme.fg("success", "✅")
-		: theme.fg("warning", "⏳");
-	let text = `${theme.fg("toolTitle", theme.bold("subagent "))}${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  ${icon} ${theme.fg("accent", agent)}${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 / streams updates
-// ---------------------------------------------------------------------------
-
-export function renderResult(
-	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
-	_expanded: boolean,
-	theme: { fg: ThemeFg; bold: (s: string) => string },
-): Container | Text {
-	const details = result.details as SubagentDetails | undefined;
-	if (!details || details.results.length === 0) {
-		const first = result.content[0];
-		return new Text(first?.type === "text" && first.text ? first.text : "(no output)", 0, 0);
-	}
-
-	const nodes = buildTopLevelNodes(details);
-	const counts = countNodes(nodes);
-	const showOutputPreview = !hasNestedChildren(nodes);
-	const icon = counts.running > 0
-		? theme.fg("warning", "⏳")
-		: counts.error > 0
-			? theme.fg("error", "❌")
-			: theme.fg("success", "✅");
-
-	const container = new Container();
-	container.addChild(
-		new Text(
-			`${icon} ${theme.fg("toolTitle", theme.bold("subagent tree "))}${theme.fg("dim", topLevelSummary(details, counts))}`,
-			0,
-			0,
-		),
-	);
-
-	container.addChild(new Spacer(1));
-	container.addChild(new Text(renderTreeLines(nodes, theme, showOutputPreview).join("\n"), 0, 0));
-
-	return container;
-}
+/**
+ * TUI rendering for subagent tool calls and results.
+ *
+ * The pure tree-building and line-rendering logic lives in `tree.ts` (no
+ * pi-tui dependency, unit-tested). This module only wraps those lines in
+ * pi-tui Containers/Text widgets.
+ */
+
+import { Container, Spacer, Text } from "@mariozechner/pi-tui";
+import type { SubagentDetails } from "./types.js";
+import {
+	type ThemeFg,
+	buildTopLevelNodes,
+	countNodes,
+	hasNestedChildren,
+	renderTreeLines,
+	setBroadcastNumberingActive,
+	topLevelSummary,
+	truncate,
+} from "./tree.js";
+
+export { setBroadcastNumberingActive };
+
+// ---------------------------------------------------------------------------
+// renderCall — shown while the tool is being invoked
+// ---------------------------------------------------------------------------
+
+export function renderCall(
+	args: Record<string, any>,
+	theme: { fg: ThemeFg; bold: (s: string) => string },
+	context?: { isPartial?: boolean; isError?: boolean },
+): Text {
+	const tasks = Array.isArray(args.tasks) ? args.tasks : [];
+	const count = tasks.length;
+	const icon = context?.isPartial === false
+		? context.isError
+			? theme.fg("error", "❌")
+			: theme.fg("success", "✅")
+		: theme.fg("warning", "⏳");
+	let text = `${theme.fg("toolTitle", theme.bold("subagent "))}${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  ${icon} ${theme.fg("accent", agent)}${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 / streams updates
+// ---------------------------------------------------------------------------
+
+export function renderResult(
+	result: { content: Array<{ type: string; text?: string }>; details?: unknown },
+	_expanded: boolean,
+	theme: { fg: ThemeFg; bold: (s: string) => string },
+): Container | Text {
+	const details = result.details as SubagentDetails | undefined;
+	if (!details || details.results.length === 0) {
+		const first = result.content[0];
+		return new Text(first?.type === "text" && first.text ? first.text : "(no output)", 0, 0);
+	}
+
+	const nodes = buildTopLevelNodes(details);
+	const counts = countNodes(nodes);
+	const showOutputPreview = !hasNestedChildren(nodes);
+	const icon = counts.running > 0
+		? theme.fg("warning", "⏳")
+		: counts.error > 0
+			? theme.fg("error", "❌")
+			: theme.fg("success", "✅");
+
+	const container = new Container();
+	container.addChild(
+		new Text(
+			`${icon} ${theme.fg("toolTitle", theme.bold("subagent tree "))}${theme.fg("dim", topLevelSummary(details, counts))}`,
+			0,
+			0,
+		),
+	);
+
+	container.addChild(new Spacer(1));
+	container.addChild(new Text(renderTreeLines(nodes, theme, showOutputPreview).join("\n"), 0, 0));
+
+	return container;
+}

package/runner.ts

@@ -20,6 +20,7 @@ import {
   extractToolCalls,
   getFinalOutput,
   getNestedSubagentErrorSummary,
+  isSubagentDetails,
 } from "./types.js";
 import { SUBAGENT_SESSION_ROOT_ENV } from "./resume.js";
 import {
@@ -414,9 +415,22 @@ export function processJsonLine(line: string, result: SingleResult): boolean {
   if (event.type === "tool_result_end" && event.message) {
     const msg = event.message as Message;
     if (!hasMessage(result, msg)) result.messages.push(msg);
+    if ((msg as any).toolName === "subagent" && typeof (msg as any).toolCallId === "string") {
+      delete result.liveNestedSubagents?.[(msg as any).toolCallId];
+    }
     return true;
   }
 
+  if (event.type === "subagent_progress") {
+    const toolCallId = typeof event.toolCallId === "string" ? event.toolCallId : undefined;
+    if (toolCallId && isSubagentDetails(event.details)) {
+      result.liveNestedSubagents ??= {};
+      result.liveNestedSubagents[toolCallId] = event.details;
+      return true;
+    }
+    return false;
+  }
+
   if (event.type === "turn_start") {
     result.turnInProgress = true;
     pushLiveLog(result, { kind: "turn_start" });
@@ -620,6 +634,7 @@ export async function runAgentSubprocess(opts: RunAgentOptions): Promise<SingleR
     turnInProgress: false,
     liveToolExecutions: initialResult?.liveToolExecutions,
     liveLog: initialResult?.liveLog ? [...initialResult.liveLog] : [],
+    liveNestedSubagents: initialResult?.liveNestedSubagents ? { ...initialResult.liveNestedSubagents } : undefined,
     sessionDir,
   };
 

package/tree.ts

@@ -0,0 +1,475 @@
+/**
+ * Pure tree-building and line-rendering logic for the subagent TUI.
+ *
+ * This module deliberately has NO dependency on `@mariozechner/pi-tui` so it
+ * can be unit-tested without the (peer) TUI package installed. `render.ts`
+ * imports from here and wraps the produced lines in pi-tui Containers/Text.
+ */
+
+import * as os from "node:os";
+import {
+	type LiveLogEntry,
+	type NestedSubagentResult,
+	type SingleResult,
+	type SubagentDetails,
+	type UsageStats,
+	aggregateUsage,
+	getDisplayItems,
+	getFinalOutput,
+	getNestedSubagentResults,
+	isResultError,
+	isSubagentDetails,
+} from "./types.js";
+
+export const OUTPUT_PREVIEW_LINE_COUNT = 6;
+
+let broadcastNumberingActive = false;
+
+export function setBroadcastNumberingActive(active: boolean): void {
+	broadcastNumberingActive = active;
+}
+
+export type ThemeFg = (color: string, text: string) => string;
+export type NodeStatus = "running" | "success" | "error";
+
+export interface TreeNode {
+	label: string;
+	status: NodeStatus;
+	meta?: string;
+	task?: string;
+	outputPreview?: string[];
+	liveActivity?: LiveLogEntry[];
+	children: TreeNode[];
+}
+
+export interface TreeCounts {
+	total: number;
+	running: number;
+	success: number;
+	error: number;
+	finished: number;
+}
+
+interface PendingSubagentCall {
+	toolCallId: string;
+	tasks: Array<{ agent: string; task?: string }>;
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+export 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 formatUsage(usage: Partial<UsageStats>, model?: string): string {
+	const parts: string[] = [];
+	const totalTokens =
+		(usage.input || 0) +
+		(usage.output || 0) +
+		(usage.cacheRead || 0) +
+		(usage.cacheWrite || 0);
+	if (usage.turns) parts.push(`${usage.turns} turn${usage.turns > 1 ? "s" : ""}`);
+	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(`$${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 truncate(text: string, maxLen: number): string {
+	return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
+}
+
+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 lastNonEmptyLines(text: string, limit: number): string[] {
+	return splitOutputLines(text)
+		.map((line) => line.trimEnd())
+		.filter((line) => line.trim().length > 0)
+		.slice(-limit);
+}
+
+export function statusEmoji(status: NodeStatus, theme: { fg: ThemeFg }): string {
+	switch (status) {
+		case "running":
+			return theme.fg("warning", "⏳");
+		case "error":
+			return theme.fg("error", "❌");
+		default:
+			return theme.fg("success", "✅");
+	}
+}
+
+function statusFromResult(result: SingleResult): NodeStatus {
+	if (result.exitCode === -1) return "running";
+	return isResultError(result) ? "error" : "success";
+}
+
+export 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;
+}
+
+export function hasNestedChildren(nodes: TreeNode[]): boolean {
+	return nodes.some((node) => node.children.length > 0 || hasNestedChildren(node.children));
+}
+
+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}`,
+				tasks,
+			});
+		}
+	}
+	return calls;
+}
+
+function buildPendingNodes(call: PendingSubagentCall): TreeNode[] {
+	return call.tasks.map((task) => ({
+		label: task.agent,
+		status: "running",
+		task: task.task,
+		children: [],
+	}));
+}
+
+function buildNodesFromDetails(details: SubagentDetails): TreeNode[] {
+	return details.results.map((result) => buildResultNode(result));
+}
+
+function buildNodesFromNestedResult(nested: NestedSubagentResult): TreeNode[] {
+	return buildNodesFromDetails(nested.details);
+}
+
+function subagentCallSignature(call: PendingSubagentCall): string {
+	return JSON.stringify(call.tasks.map((task) => ({ agent: task.agent, task: task.task ?? "" })));
+}
+
+function nestedResultIsHealthy(nested: NestedSubagentResult | undefined): boolean {
+	if (!nested || nested.isError) return false;
+	return nested.details.results.every((result) => !isResultError(result));
+}
+
+function buildLiveDetailsSignature(details: SubagentDetails): string {
+	return JSON.stringify(details.results.map((result) => ({ agent: result.agent, task: result.task ?? "" })));
+}
+
+function findLiveNestedDetailsForCall(
+	result: SingleResult,
+	call: PendingSubagentCall,
+	usedLiveKeys: Set<string>,
+): SubagentDetails | undefined {
+	const live = result.liveNestedSubagents;
+	if (!live) return undefined;
+
+	const byId = live[call.toolCallId];
+	if (isSubagentDetails(byId)) {
+		usedLiveKeys.add(call.toolCallId);
+		return byId;
+	}
+
+	// Some pi versions pass a different internal id to Tool.execute than the id
+	// stored on the assistant toolCall part. Final toolResult messages still line
+	// up by id, but live `subagent_progress` events can be keyed differently. In
+	// that case match the running nested tree by the requested agent/task
+	// signature so grandchildren render live instead of falling back to static
+	// pending placeholders.
+	const signature = subagentCallSignature(call);
+	for (const [key, details] of Object.entries(live)) {
+		if (usedLiveKeys.has(key) || !isSubagentDetails(details)) continue;
+		if (buildLiveDetailsSignature(details) !== signature) continue;
+		usedLiveKeys.add(key);
+		return details;
+	}
+
+	// Fallback for cases where task text differs slightly by the time the child
+	// details are emitted. Still require the same agent sequence; count-only
+	// matching can attach progress to the wrong repeated/concurrent call.
+	const agentSignature = JSON.stringify(call.tasks.map((task) => task.agent));
+	for (const [key, details] of Object.entries(live)) {
+		if (usedLiveKeys.has(key) || !isSubagentDetails(details)) continue;
+		const liveAgentSignature = JSON.stringify(details.results.map((nestedResult) => nestedResult.agent));
+		if (liveAgentSignature !== agentSignature) continue;
+		usedLiveKeys.add(key);
+		return details;
+	}
+
+	return undefined;
+}
+
+function buildNestedChildren(result: SingleResult): TreeNode[] {
+	const parentIsRunning = result.exitCode === -1;
+	const completedByToolCallId = new Map<string, NestedSubagentResult>();
+	for (const nested of getNestedSubagentResults(result.messages)) {
+		completedByToolCallId.set(nested.toolCallId, nested);
+	}
+	const usedLiveKeys = new Set<string>();
+
+	const calls = extractPendingSubagentCalls(result.messages);
+	const laterResumeBySignature = new Map<string, number>();
+	calls.forEach((call, index) => {
+		const completed = completedByToolCallId.get(call.toolCallId);
+		// A resumed call has the same task signature as the interrupted call but a
+		// newer toolCallId. Prefer that newer running/successful tree over the old
+		// synthetic/aborted result so resumed nested subagents render in-place.
+		if (!completed || nestedResultIsHealthy(completed)) {
+			laterResumeBySignature.set(subagentCallSignature(call), index);
+		}
+	});
+
+	const nodes: TreeNode[] = [];
+	calls.forEach((call, index) => {
+		const completed = completedByToolCallId.get(call.toolCallId);
+		const newerEquivalent = laterResumeBySignature.get(subagentCallSignature(call));
+		if (
+			newerEquivalent !== undefined &&
+			newerEquivalent > index &&
+			(!completed || completed.isError || !nestedResultIsHealthy(completed))
+		) {
+			return;
+		}
+
+		if (completed && isSubagentDetails(completed.details)) {
+			nodes.push(...buildNodesFromNestedResult(completed));
+			return;
+		}
+
+		const liveDetails = parentIsRunning
+			? findLiveNestedDetailsForCall(result, call, usedLiveKeys)
+			: undefined;
+		if (liveDetails) {
+			nodes.push(...buildNodesFromDetails(liveDetails));
+			return;
+		}
+
+		// Unmatched subagent tool calls are useful while the parent is still
+		// running (they show live pending children). Once the parent finished,
+		// unmatched calls are stale history from an interrupted/resumed session and
+		// must not keep the whole tree in a perpetual "running" state.
+		if (parentIsRunning) nodes.push(...buildPendingNodes(call));
+	});
+	return nodes;
+}
+
+function formatToolArgPreview(toolName: string, args: Record<string, unknown>): string {
+	const shorten = (p: string) => {
+		const home = os.homedir();
+		return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+	};
+	const truncateTo = (s: string, n: number) =>
+		s.length > n ? s.slice(0, n) + "\u2026" : s;
+
+	switch (toolName) {
+		case "bash": {
+			const cmd = (args.command as string) || "";
+			return truncateTo(cmd.replace(/\s+/g, " "), 52);
+		}
+		case "read":
+		case "write":
+		case "edit":
+			return shorten(truncateTo((args.path ?? args.file_path ?? "") as string, 52));
+		case "grep":
+			return truncateTo(`/${args.pattern}/`, 30) +
+				   (args.path ? ` in ${shorten(args.path as string)}` : "");
+		case "find":
+			return truncateTo((args.pattern ?? "*") as string, 30) +
+				   (args.path ? ` in ${shorten(args.path as string)}` : "");
+		case "subagent": {
+			const tasks = (args.tasks as any[]) ?? [];
+			return tasks.map((t: any) => t.agent).join(", ");
+		}
+		default:
+			return "";
+	}
+}
+
+export function formatLiveLogEntry(
+	entry: LiveLogEntry,
+	theme: { fg: ThemeFg },
+): string {
+	switch (entry.kind) {
+		case "turn_start":
+			return theme.fg("muted", "\u27f3") + " " + theme.fg("dim", "thinking\u2026");
+
+		case "turn_end": {
+			const tokens = entry.inputTokens || entry.outputTokens
+				? " " + theme.fg("dim",
+					`\u2191${formatTokens(entry.inputTokens)} \u2193${formatTokens(entry.outputTokens)}`)
+				: "";
+			return (
+				theme.fg("success", "\u2713") +
+				" " +
+				theme.fg("muted", `turn ${entry.turn}`) +
+				tokens
+			);
+		}
+
+		case "tool_start": {
+			const argPreview = formatToolArgPreview(entry.toolName, entry.args);
+			return (
+				theme.fg("muted", "\u2192") +
+				" " +
+				theme.fg("accent", entry.toolName) +
+				(argPreview ? "  " + theme.fg("dim", argPreview) : "")
+			);
+		}
+
+		case "tool_end":
+			return (
+				theme.fg("success", "\u2713") +
+				" " +
+				theme.fg("accent", entry.toolName)
+			);
+	}
+}
+
+function buildLeafPreview(result: SingleResult): string[] | undefined {
+	const items = getDisplayItems(result.messages);
+	const lines: string[] = [];
+	for (const item of items) {
+		if (item.type === "text") {
+			lines.push(...lastNonEmptyLines(item.text, OUTPUT_PREVIEW_LINE_COUNT));
+		}
+	}
+	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 buildResultNode(result: SingleResult): TreeNode {
+	const status = statusFromResult(result);
+	const usage = formatUsage(result.usage, result.model);
+	const metaParts: string[] = [result.agentSource];
+	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);
+	const isRunning = status === "running";
+	return {
+		label: result.agent,
+		status,
+		meta: metaParts.join(" • "),
+		task: result.task,
+		liveActivity: isRunning && result.liveLog?.length > 0 ? result.liveLog : undefined,
+		outputPreview: !isRunning && children.length === 0 ? buildLeafPreview(result) : undefined,
+		children,
+	};
+}
+
+export function buildTopLevelNodes(details: SubagentDetails): TreeNode[] {
+	return details.results.map((result) => buildResultNode(result));
+}
+
+export function renderTreeLines(
+	nodes: TreeNode[],
+	theme: { fg: ThemeFg },
+	showOutputPreview: boolean,
+	depth = 0,
+	prefix = "",
+): string[] {
+	const lines: string[] = [];
+
+	nodes.forEach((node, index) => {
+		const indent = "  ".repeat(depth);
+		const number = prefix ? `${prefix}.${index + 1}` : `${index + 1}`;
+		const numberPrefix = broadcastNumberingActive ? `${number}. ` : "";
+		let line = `${indent}${numberPrefix}${statusEmoji(node.status, theme)} ${theme.fg("accent", node.label)}`;
+		if (node.meta) line += ` ${theme.fg("dim", node.meta)}`;
+		lines.push(line);
+
+		if (showOutputPreview && node.outputPreview && node.outputPreview.length > 0) {
+			for (const outputLine of node.outputPreview) {
+				lines.push(`${indent}  ${theme.fg("toolOutput", outputLine)}`);
+			}
+		}
+
+		// Live activity (thinking / tool calls of a *running* agent) is always
+		// shown, at any depth and regardless of `showOutputPreview`. Previously it
+		// was gated behind `showOutputPreview`, which is disabled for the whole
+		// tree as soon as any nesting exists — so teamlead/nested runs showed only
+		// static status lines and looked frozen. liveActivity is only attached to
+		// running nodes (see buildResultNode), so completed nodes stay quiet.
+		if (node.liveActivity && node.liveActivity.length > 0) {
+			for (const entry of node.liveActivity) {
+				lines.push(`${indent}  ${formatLiveLogEntry(entry, theme)}`);
+			}
+		}
+
+		if (node.children.length > 0) {
+			lines.push(...renderTreeLines(node.children, theme, showOutputPreview, depth + 1, number));
+		}
+	});
+
+	return lines;
+}
+
+export function topLevelSummary(details: SubagentDetails, counts: TreeCounts): string {
+	// aggregatedUsage includes own agents + all their nested descendants;
+	// fall back to summing only direct results for old serialised data lacking the field.
+	const totalUsage = formatUsage(
+		details.aggregatedUsage ?? 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(" • ");
+}

package/types.ts

@@ -62,6 +62,13 @@ export interface SingleResult {
 	 * Populated while the agent is running; each entry is one display line.
 	 */
 	liveLog: LiveLogEntry[];
+	/**
+	 * Transient, streaming progress for nested subagent calls made by this agent,
+	 * keyed by the nested subagent toolCallId. This is intentionally not part of
+	 * the durable conversation history; final nested results still live in
+	 * messages as toolResult entries.
+	 */
+	liveNestedSubagents?: Record<string, SubagentDetails>;
 }
 
 /** A node in the per-subagent usage tree (own stats + recursive children) */