@nghyane/arcane 0.1.13 → 0.1.14

package/src/task/render.ts

@@ -1,9 +1,19 @@
 import type { Component } from "@nghyane/arcane-tui";
-import { Text } from "@nghyane/arcane-tui";
+import { Markdown, Text } from "@nghyane/arcane-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
-import type { Theme, ThemeColor } from "../modes/theme/theme";
-import { formatBadge, formatDuration, formatStatusIcon, replaceTabs, truncateToWidth } from "../tools/render-utils";
-import { Ellipsis, Hasher, type RenderCache, renderStatusLine } from "../tui";
+import type { Theme, ThemeColor } from "../theme/theme";
+import { getMarkdownTheme } from "../theme/theme";
+import { Ellipsis, Hasher, type RenderCache } from "../tui";
+import {
+	formatBadge,
+	formatDuration,
+	formatStatusIcon,
+	PREVIEW_LIMITS,
+	replaceTabs,
+	type ToolUIColor,
+	TRUNCATE_LENGTHS,
+	truncateToWidth,
+} from "../ui/render-utils";
 import { subprocessToolRegistry } from "./subprocess-tool-registry";
 import type { AgentProgress, SingleResult, TaskParams, TaskToolDetails } from "./types";
 
@@ -26,19 +36,11 @@ function getStatusIcon(status: AgentProgress["status"], theme: Theme, spinnerFra
 	}
 }
 
-function formatTaskId(id: string): string {
-	const segments = id.split(".");
-	if (segments.length < 2) return id;
-	const parsed = segments.map(segment => segment.match(/^(\d+)-(.+)$/));
-	if (parsed.some(match => !match)) return id;
-	const indices = parsed.map(match => match![1]).join(".");
-	const labels = parsed.map(match => match![2]).join(">");
-	return `${indices} ${labels}`;
-}
-
 type ToolEntry = { tool: string; args: string; status: "success" | "error" | "running" };
 
-function renderToolLine(entry: ToolEntry, continuePrefix: string, theme: Theme): string {
+const INDENT = "   ";
+
+function renderToolLine(entry: ToolEntry, theme: Theme): string {
 	const icon =
 		entry.status === "running"
 			? theme.fg("accent", theme.status.running)
@@ -46,234 +48,243 @@ function renderToolLine(entry: ToolEntry, continuePrefix: string, theme: Theme):
 				? theme.fg("error", theme.status.error)
 				: theme.fg("dim", theme.status.success);
 	const toolName = entry.status === "running" ? theme.fg("muted", entry.tool) : theme.fg("dim", entry.tool);
-	const args = entry.args ? `  ${theme.fg("dim", truncateToWidth(replaceTabs(entry.args), 50))}` : "";
-	return `${continuePrefix}${icon} ${toolName}${args}`;
+	const args = entry.args
+		? `  ${theme.fg("dim", truncateToWidth(replaceTabs(entry.args), TRUNCATE_LENGTHS.TOOL_ARGS))}`
+		: "";
+	return `${INDENT}${icon} ${toolName}${args}`;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// renderCall
+// Unified subagent header
 // ═══════════════════════════════════════════════════════════════════════════
 
-export function renderCall(args: TaskParams, _options: RenderResultOptions, theme: Theme): Component {
-	const lines: string[] = [];
-	lines.push(renderStatusLine({ icon: "pending", title: "Task", description: args.id }, theme));
-
-	const context = (args.context ?? "").trim();
-	if (context) {
-		const branch = theme.fg("dim", theme.tree.branch);
-		const vertical = theme.fg("dim", theme.tree.vertical);
-		const last = theme.fg("dim", theme.tree.last);
-		lines.push(` ${branch} ${theme.fg("dim", "Context")}`);
-		for (const line of context.split("\n")) {
-			lines.push(` ${vertical}  ${line ? theme.fg("muted", replaceTabs(line)) : ""}`);
+/** Config for rendering any subagent (task, explore, oracle, etc.) */
+export interface SubagentRenderConfig {
+	label: string;
+	getDescription: (args: Record<string, unknown>) => string;
+	getContextLine?: (args: Record<string, unknown>) => string | null;
+}
+
+/** Cheap fingerprint of tool state for cache invalidation. */
+function toolStateFingerprint(details: TaskToolDetails): number {
+	let fp = 0;
+	if (details.progress) {
+		for (const p of details.progress) {
+			fp = (fp * 31 + p.toolHistory.length) | 0;
+			const last = p.toolHistory[p.toolHistory.length - 1];
+			if (last) fp = (fp * 31 + (last.status === "running" ? 1 : 2)) | 0;
 		}
-		const assignmentPreview = truncateToWidth(replaceTabs(args.assignment.split("\n")[0] ?? ""), 60);
-		lines.push(` ${last} ${theme.fg("dim", "Assignment")}: ${theme.fg("muted", assignmentPreview)}`);
-		return new Text(lines.join("\n"), 0, 0);
 	}
-
-	const assignmentPreview = truncateToWidth(replaceTabs(args.assignment.split("\n")[0] ?? ""), 60);
-	lines.push(` ${theme.fg("dim", "Assignment")}: ${theme.fg("muted", assignmentPreview)}`);
-	return new Text(lines.join("\n"), 0, 0);
+	if (details.results) fp = (fp * 31 + details.results.length) | 0;
+	return fp >>> 0;
 }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// renderAgentProgress (streaming)
-// ═══════════════════════════════════════════════════════════════════════════
-
-/** Max tool history entries to show during streaming */
-const STREAMING_TOOL_LIMIT = 4;
-
-function renderAgentProgress(
-	progress: AgentProgress,
-	isLast: boolean,
-	expanded: boolean,
+/**
+ * Render the stable header block for any subagent.
+ * Returns [headerLine, contextLine?] — structure never changes across states.
+ */
+function renderSubagentHeader(
+	config: SubagentRenderConfig,
+	args: Record<string, unknown>,
+	state: { icon: string; duration?: number; badge?: { text: string; color: ToolUIColor } },
 	theme: Theme,
-	spinnerFrame?: number,
 ): string[] {
-	const lines: string[] = [];
-	const prefix = isLast ? theme.fg("dim", theme.tree.last) : theme.fg("dim", theme.tree.branch);
-	const continuePrefix = isLast ? "   " : `${theme.fg("dim", theme.tree.vertical)}  `;
-
-	const icon = getStatusIcon(progress.status, theme, spinnerFrame);
-	const iconColor: ThemeColor =
-		progress.status === "completed"
-			? "success"
-			: progress.status === "failed" || progress.status === "aborted"
-				? "error"
-				: "accent";
-
-	// Main status line
-	const description = progress.description?.trim();
-	const displayId = formatTaskId(progress.id);
-	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)}`;
-
-	if (progress.status === "failed" || progress.status === "aborted") {
-		statusLine += ` ${formatBadge(progress.status, iconColor, theme)}`;
+	const desc = truncateToWidth(replaceTabs(config.getDescription(args)), TRUNCATE_LENGTHS.CONTENT);
+	let header = `${state.icon} ${theme.fg("accent", theme.bold(config.label))}  ${theme.fg("muted", desc)}`;
+	if (state.duration && state.duration > 0) {
+		header += `${theme.sep.dot}${theme.fg("dim", formatDuration(state.duration))}`;
 	}
-
-	if (progress.durationMs > 0) {
-		statusLine += `${theme.sep.dot}${theme.fg("dim", formatDuration(progress.durationMs))}`;
+	if (state.badge) {
+		header += ` ${formatBadge(state.badge.text, state.badge.color, theme)}`;
 	}
 
-	lines.push(statusLine);
-
-	// Tool history — show last N completed + current running
-	if (progress.status === "running" || progress.status === "completed" || progress.status === "failed") {
-		const history = progress.toolHistory;
-		const completed = history.filter(t => t.status !== "running");
-		const running = history.filter(t => t.status === "running");
+	const lines = [header];
 
-		// Show recent completed (last N)
-		const showCompleted = expanded ? completed : completed.slice(-STREAMING_TOOL_LIMIT);
-		const skipped = completed.length - showCompleted.length;
-		if (skipped > 0) {
-			lines.push(`${continuePrefix}${theme.fg("dim", `… ${skipped} more`)}`);
-		}
-		for (const entry of showCompleted) {
-			lines.push(renderToolLine(entry, continuePrefix, theme));
-		}
-		// Show currently running tool
-		for (const entry of running) {
-			lines.push(renderToolLine(entry, continuePrefix, theme));
-		}
+	const contextLine = config.getContextLine?.(args);
+	if (contextLine) {
+		lines.push(`${INDENT}${theme.fg("dim", "↳")} ${theme.fg("dim", contextLine)}`);
 	}
 
 	return lines;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// renderAgentResult (final)
+// Tool history rendering
 // ═══════════════════════════════════════════════════════════════════════════
 
-/** Max tool history entries when collapsed */
-const COLLAPSED_TOOL_LIMIT = 3;
+const STREAMING_TOOL_LIMIT = PREVIEW_LIMITS.SUBAGENT_STREAMING_TOOLS;
+const COLLAPSED_TOOL_LIMIT = PREVIEW_LIMITS.SUBAGENT_COLLAPSED_TOOLS;
+const COLLAPSED_CONCLUSION_LINES = PREVIEW_LIMITS.SUBAGENT_CONCLUSION;
+
+/** Render conclusion text as markdown, returning indented lines with collapsed/expanded limit. */
+function renderConclusionMarkdown(text: string, width: number, expanded: boolean, theme: Theme): string[] {
+	const md = new Markdown(text.trim(), INDENT.length, 0, getMarkdownTheme());
+	const mdLines = md.render(width);
+	if (mdLines.length === 0) return [];
+
+	const maxLines = expanded ? mdLines.length : COLLAPSED_CONCLUSION_LINES;
+	const show = mdLines.slice(0, maxLines);
+	const remaining = mdLines.length - maxLines;
+	const lines = ["", ...show];
+	if (remaining > 0) {
+		lines.push(`${INDENT}${theme.fg("dim", `… ${remaining} more lines`)}`);
+	}
+	return lines;
+}
 
-function renderAgentResult(result: SingleResult, isLast: boolean, expanded: boolean, theme: Theme): string[] {
+function renderToolHistory(history: ToolEntry[], expanded: boolean, limit: number, theme: Theme): string[] {
 	const lines: string[] = [];
-	const prefix = isLast ? theme.fg("dim", theme.tree.last) : theme.fg("dim", theme.tree.branch);
-	const continuePrefix = isLast ? "   " : `${theme.fg("dim", theme.tree.vertical)}  `;
+	const completed = history.filter(t => t.status !== "running");
+	const running = history.filter(t => t.status === "running");
 
-	const aborted = result.aborted ?? false;
-	const success = !aborted && result.exitCode === 0;
-	const icon = aborted ? theme.status.aborted : success ? theme.status.success : theme.status.error;
-	const iconColor: ThemeColor = success ? "success" : "error";
-	const statusText = aborted ? "aborted" : success ? "done" : "failed";
-
-	// Main status line
-	const description = result.description?.trim();
-	const displayId = formatTaskId(result.id);
-	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
-	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)} ${formatBadge(statusText, iconColor, theme)}`;
-	statusLine += `${theme.sep.dot}${theme.fg("dim", formatDuration(result.durationMs))}`;
-
-	if (result.truncated) {
-		statusLine += ` ${theme.fg("warning", "[truncated]")}`;
+	const showCompleted = expanded ? completed : completed.slice(-limit);
+	const skipped = completed.length - showCompleted.length;
+	if (skipped > 0) {
+		lines.push(`${INDENT}${theme.fg("dim", `… ${skipped} more`)}`);
 	}
-
-	lines.push(statusLine);
-
-	// Tool history
-	const history = result.toolHistory ?? [];
-	if (history.length > 0) {
-		const show = expanded ? history : history.slice(-COLLAPSED_TOOL_LIMIT);
-		const skipped = history.length - show.length;
-		if (skipped > 0) {
-			lines.push(`${continuePrefix}${theme.fg("dim", `… ${skipped} more`)}`);
-		}
-		for (const entry of show) {
-			lines.push(renderToolLine(entry, continuePrefix, theme));
-		}
+	for (const entry of showCompleted) {
+		lines.push(renderToolLine(entry, theme));
 	}
-
-	// Error message for failed tasks
-	if (result.error && !success) {
-		lines.push(`${continuePrefix}${theme.fg("error", truncateToWidth(result.error, 70))}`);
+	if (running.length > 0) {
+		for (const entry of running) {
+			lines.push(renderToolLine(entry, theme));
+		}
+	} else if (completed.length > 0) {
+		// Between tool calls — reserve empty line to prevent layout shift
+		lines.push(INDENT);
 	}
-
 	return lines;
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-// renderResult (main entry point)
+// Task tool renderCall / renderResult
 // ═══════════════════════════════════════════════════════════════════════════
 
+const taskRenderConfig: SubagentRenderConfig = {
+	label: "Task",
+	getDescription: args => String(args.description ?? ""),
+	getContextLine: args => {
+		const prompt = String(args.prompt ?? "").trim();
+		if (!prompt) return null;
+		return `Prompt: ${truncateToWidth(replaceTabs(prompt.split("\n")[0] ?? ""), TRUNCATE_LENGTHS.SUBAGENT_ERROR)}`;
+	},
+};
+
+export function renderCall(args: TaskParams, options: RenderResultOptions, theme: Theme): Component {
+	const params = args as Record<string, unknown>;
+	let cached: RenderCache | undefined;
+	return {
+		render() {
+			const frame = options.spinnerFrame ?? 0;
+			const key = new Hasher().u32(frame).digest();
+			if (cached?.key === key) return cached.lines;
+			const icon = formatStatusIcon("running", theme, frame);
+			const lines = renderSubagentHeader(taskRenderConfig, params, { icon }, theme);
+			cached = { key, lines };
+			return lines;
+		},
+		invalidate() {
+			cached = undefined;
+		},
+	};
+}
+
 export function renderResult(
 	result: { content: Array<{ type: string; text?: string }>; details?: TaskToolDetails },
 	options: RenderResultOptions,
 	theme: Theme,
 ): Component {
-	const fallbackText = result.content.find(c => c.type === "text")?.text ?? "";
-	const details = result.details;
-
-	if (!details) {
+	if (!result.details) {
 		const text = result.content.find(c => c.type === "text")?.text || "";
-		return new Text(theme.fg("dim", truncateToWidth(text, 100)), 0, 0);
+		return new Text(theme.fg("dim", truncateToWidth(text, TRUNCATE_LENGTHS.LONG)), 0, 0);
 	}
 
 	let cached: RenderCache | undefined;
 
 	return {
 		render(width) {
+			// Read from result ref each render to pick up mutable updates
+			const details = result.details!;
+			const fallbackText = result.content.find(c => c.type === "text")?.text ?? "";
 			const { expanded, isPartial, spinnerFrame } = options;
 			const key = new Hasher()
 				.bool(expanded)
 				.bool(isPartial)
 				.u32(spinnerFrame ?? 0)
 				.u32(width)
+				.u32(toolStateFingerprint(details))
 				.digest();
 			if (cached?.key === key) return cached.lines;
 
 			const lines: string[] = [];
+			const args = {} as Record<string, unknown>;
+
+			if (isPartial && details.progress?.length) {
+				const p = details.progress[0];
+				const icon = getStatusIcon(p.status, theme, spinnerFrame);
+				const duration = p.durationMs > 0 ? p.durationMs : undefined;
+				const errorColor = "error" as const;
+				const badge =
+					p.status === "failed" || p.status === "aborted" ? { text: p.status, color: errorColor } : undefined;
+				// Use description from progress for header
+				const headerArgs = { description: p.description ?? p.id, prompt: p.task };
+				lines.push(
+					...renderSubagentHeader(
+						taskRenderConfig,
+						headerArgs as Record<string, unknown>,
+						{ icon, duration, badge },
+						theme,
+					),
+				);
+				lines.push(...renderToolHistory(p.toolHistory, expanded, STREAMING_TOOL_LIMIT, theme));
+			} else if (details.results?.length) {
+				const r = details.results[0];
+				const aborted = r.aborted ?? false;
+				const success = !aborted && r.exitCode === 0;
+				const statusText = aborted ? "aborted" : success ? "done" : "failed";
+				const iconColor: ToolUIColor = success ? "success" : "error";
+				const icon = formatStatusIcon(success ? "success" : "error", theme);
+				const headerArgs = { description: r.description ?? r.id, prompt: r.task };
+				lines.push(
+					...renderSubagentHeader(
+						taskRenderConfig,
+						headerArgs as Record<string, unknown>,
+						{ icon, duration: r.durationMs, badge: { text: statusText, color: iconColor } },
+						theme,
+					),
+				);
+
+				// Tool history
+				const history = r.toolHistory ?? [];
+				if (history.length > 0) {
+					const show = expanded ? history : history.slice(-COLLAPSED_TOOL_LIMIT);
+					const skipped = history.length - show.length;
+					if (skipped > 0) {
+						lines.push(`${INDENT}${theme.fg("dim", `… ${skipped} more`)}`);
+					}
+					for (const entry of show) {
+						lines.push(renderToolLine(entry, theme));
+					}
+				}
 
-			if (isPartial && details.progress) {
-				details.progress.forEach((progress, i) => {
-					const isLast = i === details.progress!.length - 1;
-					lines.push(...renderAgentProgress(progress, isLast, expanded, theme, spinnerFrame));
-				});
-			} else if (details.results && details.results.length > 0) {
-				details.results.forEach((res, i) => {
-					const isLast = i === details.results.length - 1;
-					lines.push(...renderAgentResult(res, isLast, expanded, theme));
-				});
-
-				// Summary line
-				const abortedCount = details.results.filter(r => r.aborted).length;
-				const successCount = details.results.filter(r => !r.aborted && r.exitCode === 0).length;
-				const failCount = details.results.length - successCount - abortedCount;
-				const parts: string[] = [];
-				if (successCount > 0) parts.push(theme.fg("success", `${successCount} succeeded`));
-				if (failCount > 0) parts.push(theme.fg("error", `${failCount} failed`));
-				if (abortedCount > 0) parts.push(theme.fg("error", `${abortedCount} aborted`));
-				parts.push(theme.fg("dim", formatDuration(details.totalDurationMs)));
-				lines.push(parts.join(theme.sep.dot));
+				if (r.error && !success) {
+					lines.push(`${INDENT}${theme.fg("error", truncateToWidth(r.error, TRUNCATE_LENGTHS.SUBAGENT_ERROR))}`);
+				}
+				if (success && fallbackText.trim()) {
+					lines.push(...renderConclusionMarkdown(fallbackText, width, expanded, theme));
+				}
+			} else {
+				const icon = formatStatusIcon("pending", theme);
+				lines.push(...renderSubagentHeader(taskRenderConfig, args, { icon }, theme));
 			}
 
 			if (lines.length === 0) {
-				const text = fallbackText.trim() ? fallbackText : "No results";
-				const result = [theme.fg("dim", truncateToWidth(text, width))];
+				const result = [truncateToWidth(fallbackText.trim() || theme.fg("dim", "No results"), width)];
 				cached = { key, lines: result };
 				return result;
 			}
 
-			// Check for system notifications in fallback text
-			if (fallbackText.trim()) {
-				const summaryLines = fallbackText.split("\n");
-				const markerIndex = summaryLines.findIndex(
-					line => line.includes("<system-notification>") || line.startsWith("Applied patches:"),
-				);
-				if (markerIndex >= 0) {
-					for (const line of summaryLines.slice(markerIndex)) {
-						if (!line.trim()) continue;
-						lines.push(theme.fg("dim", line));
-					}
-				}
-			}
-
-			const indented = lines.map(line =>
-				line.length > 0 ? truncateToWidth(`   ${line}`, width, Ellipsis.Omit) : "",
-			);
+			const indented = lines.map(line => (line.length > 0 ? truncateToWidth(line, width, Ellipsis.Omit) : ""));
 			cached = { key, lines: indented };
 			return indented;
 		},
@@ -283,10 +294,189 @@ export function renderResult(
 	};
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Unified subagent renderer factory
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Create a renderer for any subagent tool (explore, oracle, librarian, code_review).
+ *
+ * Renders call and result with unified header + tool history + conclusion.
+ */
+export function createUnifiedSubagentRenderer(config: SubagentRenderConfig): {
+	renderCall: (args: unknown, options: RenderResultOptions, theme: Theme) => Component;
+	renderResult: (
+		result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
+		options: RenderResultOptions,
+		theme: Theme,
+		args?: unknown,
+	) => Component;
+} {
+	return {
+		renderCall(args: unknown, options: RenderResultOptions, theme: Theme): Component {
+			const params = (args ?? {}) as Record<string, unknown>;
+			let cached: RenderCache | undefined;
+			return {
+				render() {
+					const frame = options.spinnerFrame ?? 0;
+					const key = new Hasher().u32(frame).digest();
+					if (cached?.key === key) return cached.lines;
+					const icon = formatStatusIcon("running", theme, frame);
+					const lines = renderSubagentHeader(config, params, { icon }, theme);
+					cached = { key, lines };
+					return lines;
+				},
+				invalidate() {
+					cached = undefined;
+				},
+			};
+		},
+
+		renderResult(
+			result: { content: Array<{ type: string; text?: string }>; details?: unknown; isError?: boolean },
+			options: RenderResultOptions,
+			theme: Theme,
+			args?: unknown,
+		): Component {
+			const params = (args ?? {}) as Record<string, unknown>;
+
+			if (!result.details) {
+				const text = result.content.find(c => c.type === "text")?.text || "No results";
+				return new Text(theme.fg("dim", truncateToWidth(text, TRUNCATE_LENGTHS.LONG)), 0, 0);
+			}
+
+			let cached: RenderCache | undefined;
+
+			return {
+				render(width) {
+					// Read from result ref each render to pick up mutable updates
+					const details = result.details as TaskToolDetails;
+					const fallbackText = result.content.find(c => c.type === "text")?.text ?? "";
+					const { expanded, isPartial, spinnerFrame } = options;
+					const key = new Hasher()
+						.bool(expanded)
+						.bool(isPartial)
+						.u32(spinnerFrame ?? 0)
+						.u32(width)
+						.u32(toolStateFingerprint(details))
+						.digest();
+					if (cached?.key === key) return cached.lines;
+
+					const lines: string[] = [];
+
+					// Stable header — same structure as renderCall
+					if (isPartial && details.progress?.length) {
+						const p = details.progress[0];
+						const icon = getStatusIcon(p.status, theme, spinnerFrame);
+						const duration = p.durationMs > 0 ? p.durationMs : undefined;
+						const errorColor = "error" as const;
+						const badge =
+							p.status === "failed" || p.status === "aborted"
+								? { text: p.status, color: errorColor }
+								: undefined;
+						lines.push(...renderSubagentHeader(config, params, { icon, duration, badge }, theme));
+						lines.push(...renderToolHistory(p.toolHistory, expanded, STREAMING_TOOL_LIMIT, theme));
+					} else if (details.results?.length) {
+						const r = details.results[0];
+						const aborted = r.aborted ?? false;
+						const success = !aborted && r.exitCode === 0;
+						const statusText = aborted ? "aborted" : success ? "done" : "failed";
+						const iconColor: ToolUIColor = success ? "success" : "error";
+						const icon = formatStatusIcon(success ? "success" : "error", theme);
+						lines.push(
+							...renderSubagentHeader(
+								config,
+								params,
+								{
+									icon,
+									duration: r.durationMs,
+									badge: { text: statusText, color: iconColor },
+								},
+								theme,
+							),
+						);
+
+						const history = r.toolHistory ?? [];
+						if (history.length > 0) {
+							const show = expanded ? history : history.slice(-COLLAPSED_TOOL_LIMIT);
+							const skipped = history.length - show.length;
+							if (skipped > 0) {
+								lines.push(`${INDENT}${theme.fg("dim", `… ${skipped} more`)}`);
+							}
+							for (const entry of show) {
+								lines.push(renderToolLine(entry, theme));
+							}
+						}
+
+						if (r.error && !success) {
+							lines.push(
+								`${INDENT}${theme.fg("error", truncateToWidth(r.error, TRUNCATE_LENGTHS.SUBAGENT_ERROR))}`,
+							);
+						}
+						if (success && fallbackText.trim()) {
+							lines.push(...renderConclusionMarkdown(fallbackText, width, expanded, theme));
+						}
+					} else {
+						const icon = formatStatusIcon("pending", theme);
+						lines.push(...renderSubagentHeader(config, params, { icon }, theme));
+					}
+
+					if (lines.length === 0) {
+						const text = fallbackText.trim() ? fallbackText : "No results";
+						const result = [theme.fg("dim", truncateToWidth(text, width))];
+						cached = { key, lines: result };
+						return result;
+					}
+
+					const indented = lines.map(line => (line.length > 0 ? truncateToWidth(line, width, Ellipsis.Omit) : ""));
+					cached = { key, lines: indented };
+					return indented;
+				},
+				invalidate() {
+					cached = undefined;
+				},
+			};
+		},
+	};
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Subprocess tool registry
 // ═══════════════════════════════════════════════════════════════════════════
 
+function renderAgentResult(result: SingleResult, expanded: boolean, theme: Theme): string[] {
+	const lines: string[] = [];
+	const aborted = result.aborted ?? false;
+	const success = !aborted && result.exitCode === 0;
+	const icon = aborted ? theme.status.aborted : success ? theme.status.success : theme.status.error;
+	const iconColor: ThemeColor = success ? "success" : "error";
+	const statusText = aborted ? "aborted" : success ? "done" : "failed";
+
+	const description = result.description?.trim();
+	const titlePart = description || result.id;
+	let statusLine = `${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)} ${formatBadge(statusText, iconColor, theme)}`;
+	statusLine += `${theme.sep.dot}${theme.fg("dim", formatDuration(result.durationMs))}`;
+	lines.push(statusLine);
+
+	const history = result.toolHistory ?? [];
+	if (history.length > 0) {
+		const show = expanded ? history : history.slice(-COLLAPSED_TOOL_LIMIT);
+		const skipped = history.length - show.length;
+		if (skipped > 0) {
+			lines.push(`${INDENT}${theme.fg("dim", `… ${skipped} more`)}`);
+		}
+		for (const entry of show) {
+			lines.push(renderToolLine(entry, theme));
+		}
+	}
+
+	if (result.error && !success) {
+		lines.push(`${INDENT}${theme.fg("error", truncateToWidth(result.error, TRUNCATE_LENGTHS.SUBAGENT_ERROR))}`);
+	}
+
+	return lines;
+}
+
 function isTaskToolDetails(value: unknown): value is TaskToolDetails {
 	return (
 		Boolean(value) &&
@@ -305,10 +495,9 @@ const taskSubprocessHandler = {
 		const lines: string[] = [];
 		for (const details of allData) {
 			if (!details.results || details.results.length === 0) continue;
-			details.results.forEach((result, index) => {
-				const isLast = index === details.results.length - 1;
-				lines.push(...renderAgentResult(result, isLast, expanded, theme));
-			});
+			for (const result of details.results) {
+				lines.push(...renderAgentResult(result, expanded, theme));
+			}
 		}
 		return new Text(lines.join("\n"), 0, 0);
 	},
@@ -319,8 +508,3 @@ subprocessToolRegistry.register<TaskToolDetails>("explore", taskSubprocessHandle
 subprocessToolRegistry.register<TaskToolDetails>("librarian", taskSubprocessHandler);
 subprocessToolRegistry.register<TaskToolDetails>("oracle", taskSubprocessHandler);
 subprocessToolRegistry.register<TaskToolDetails>("code_review", taskSubprocessHandler);
-
-export const taskToolRenderer = {
-	renderCall,
-	renderResult,
-};