pi-subagents 0.14.0 → 0.14.1

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [0.14.1] - 2026-04-14
+
+### Fixed
+- Completed foreground subagent results now return compact payloads instead of inlining full raw message histories and per-result progress objects, preventing long tool-heavy sync runs from overwhelming the parent agent return path.
+- Prompt-template delegation now rebuilds minimal assistant messages from compact foreground results when raw message arrays are intentionally omitted.
+- UI/status wording now uses plain text labels instead of glyph-heavy markers across foreground rendering, parallel summaries, save-result receipts, installer output, agent manager views, clarify screens, and the corresponding README/CHANGELOG examples.
+- Added a realistic foreground integration repro for issue `#80` and cleaned up the touched tests to remove the remaining blunt `as any` fixture casts.
+
 ## [0.14.0] - 2026-04-14
 
 ### Added
@@ -496,7 +504,7 @@
   - Pre-selects current thinking level if already set
 - **Model selector in chain TUI** - Press `[m]` to select a different model for any step
   - Fuzzy search through all available models
-  - Shows current model with ✓ indicator
+  - Shows the current model with a `current` badge
   - Provider/model format (e.g., `anthropic/claude-haiku-4-5`)
   - Override indicator (✎) when model differs from agent default
 - **Model visibility in chain execution** - Shows which model each step is using
@@ -534,8 +542,8 @@
 
 ### Improved
 - **Per-step progress indicators** - When progress is enabled, each step shows its role:
-  - Step 1: `● creates & updates progress.md`
-  - Step 2+: `↔ reads & updates progress.md`
+  - Step 1: `writes progress.md`
+  - Step 2+: `reads progress.md`
   - Clear visualization of progress.md data flow through the chain
 - **Comprehensive tool descriptions** - Better documentation of chain variables:
   - Tool description now explains `{task}`, `{previous}`, `{chain_dir}` in detail
@@ -591,7 +599,7 @@
 ### Improved
 - **Tool description now explicitly shows the three modes** (SINGLE, CHAIN, PARALLEL) with syntax - helps agents pick the right mode when user says "scout → planner"
 - **Chain execution observability** - Now shows:
-  - Chain visualization with status icons: `✓scout → ●planner` (✓=done, ●=running, ○=pending, ✗=failed) - sequential chains only
+  - Chain visualization with status labels: `done scout → running planner` (`done`, `running`, `pending`, `failed`) - sequential chains only
   - Accurate step counter: "step 1/2" instead of misleading "1/1"
   - Current tool and recent output for running step
 

package/README.md

@@ -921,8 +921,8 @@ Requirements:
 During sync execution, the collapsed view shows real-time progress for single, chain, and parallel modes.
 
 **Chains:**
-- Header: `... chain 1/2 | 8 tools, 1.4k tok, 38s`
-- Chain visualization with status: `✓scout → ●planner` (✓=done, ●=running, ○=pending, ✗=failed)
+- Header: `running chain 1/2 | 8 tools, 1.4k tok, 38s`
+- Chain visualization with status: `done scout → running planner` (`done`, `running`, `pending`, `failed`)
 - Current tool: `> read: packages/tui/src/...`
 - Recent output lines (last 2-3 lines)
 
@@ -933,7 +933,7 @@ During sync execution, the collapsed view shows real-time progress for single, c
 
 Press **Ctrl+O** to expand the full streaming view with complete output per step.
 
-> **Note:** Chain visualization (the `✓scout → ●planner` line) is only shown for sequential chains. Chains with parallel steps show per-step cards instead.
+> **Note:** Chain visualization (the `done scout → running planner` line) is only shown for sequential chains. Chains with parallel steps show per-step cards instead.
 
 ## Nested subagent recursion guard
 

package/agent-manager-detail.ts

@@ -106,7 +106,7 @@ function buildDetailLines(
 
 	for (const run of recentRuns) {
 		const when = pad(formatRelativeTime(run.ts), 8);
-		const status = run.status === "ok" ? "✓" : "✗";
+		const status = run.status;
 		const task = truncateToWidth(`"${run.task}"`, 34);
 		const tail = run.status === "ok" ? formatDuration(run.duration) : `exit ${run.exit ?? 1}`;
 		lines.push(truncateToWidth(`  ${when} ${status} ${task} ${tail}`, contentWidth));

package/agent-manager-list.ts

@@ -200,9 +200,9 @@ export function renderList(
 			const count = selectionCount(state.selected, agent.id);
 			const isShadowed = agent.kind === "agent" && agent.source === "project" && userNames.has(agent.name);
 
-			const cursorChar = isCursor ? theme.fg("accent", "▸") : " ";
-			const selectBadge = count > 1 ? theme.fg("accent", `×${count}`.padStart(2)) : count === 1 ? theme.fg("accent", " ✓") : "  ";
-			const shadowMarker = isShadowed ? theme.fg("warning", "●") : " ";
+			const cursorChar = isCursor ? theme.fg("accent", ">") : " ";
+			const selectBadge = count > 0 ? theme.fg("accent", String(count).padStart(2)) : "  ";
+			const shadowMarker = isShadowed ? theme.fg("warning", "!") : " ";
 			const prefix = `${cursorChar}${selectBadge}${shadowMarker} `;
 
 			const modelRaw = agent.kind === "chain" ? `${agent.stepCount ?? 0} steps` : (agent.model ?? "default");

package/chain-clarify.ts

@@ -987,7 +987,7 @@ export class ChainClarifyComponent implements Component {
 				const prefix = isSelected ? th.fg("accent", "→ ") : "  ";
 				const modelText = isSelected ? th.fg("accent", model.id) : model.id;
 				const providerBadge = th.fg("dim", ` [${model.provider}]`);
-				const currentBadge = isCurrent ? th.fg("success", " ✓") : "";
+				const currentBadge = isCurrent ? th.fg("success", " current") : "";
 
 				lines.push(this.row(` ${prefix}${modelText}${providerBadge}${currentBadge}`));
 			}
@@ -1269,7 +1269,7 @@ export class ChainClarifyComponent implements Component {
 		lines.push(this.row(` Chain Dir: ${th.fg("dim", chainDirPreview)}`));
 
 		const progressEnabled = this.agentConfigs.some((_, i) => this.getEffectiveBehavior(i).progress);
-		const progressValue = progressEnabled ? th.fg("success", "✓ enabled") : th.fg("dim", "✗ disabled");
+		const progressValue = progressEnabled ? th.fg("success", "enabled") : th.fg("dim", "disabled");
 		lines.push(this.row(` Progress: ${progressValue} ${th.fg("dim", "(press [p] to toggle)")}`));
 		lines.push(this.row(""));
 
@@ -1331,8 +1331,8 @@ export class ChainClarifyComponent implements Component {
 			if (progressEnabled) {
 				const isFirstStep = i === 0;
 				const progressAction = isFirstStep 
-					? th.fg("success", "●") + th.fg("dim", " creates & updates progress.md")
-					: th.fg("accent", "↔") + th.fg("dim", " reads & updates progress.md");
+					? th.fg("success", "writes progress.md")
+					: th.fg("accent", "reads progress.md");
 				const progressLabel = th.fg("dim", "progress: ");
 				lines.push(this.row(`     ${progressLabel}${progressAction}`));
 			}

package/chain-execution.ts

@@ -28,7 +28,7 @@ import {
 import { discoverAvailableSkills, normalizeSkillInput } from "./skills.ts";
 import { runSync } from "./execution.ts";
 import { buildChainSummary } from "./formatters.ts";
-import { getSingleResultOutput, mapConcurrent } from "./utils.ts";
+import { compactForegroundDetails, getSingleResultOutput, mapConcurrent } from "./utils.ts";
 import { recordRun } from "./run-history.ts";
 import {
 	cleanupWorktrees,
@@ -91,7 +91,7 @@ interface ParallelChainRunInput {
 }
 
 function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details {
-	return {
+	return compactForegroundDetails({
 		mode: "chain",
 		results: input.results,
 		progress: input.includeProgress ? input.allProgress : undefined,
@@ -99,7 +99,7 @@ function buildChainExecutionDetails(input: ChainExecutionDetailsInput): Details
 		chainAgents: input.chainAgents,
 		totalSteps: input.totalSteps,
 		currentStepIndex: input.currentStepIndex,
-	};
+	});
 }
 
 function buildChainExecutionErrorResult(message: string, input: ChainExecutionDetailsInput): ChainExecutionResult {
@@ -670,15 +670,16 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				});
 				return {
 					content: [{ type: "text", text: summary }],
-					details: {
-						mode: "chain",
+					details: buildChainExecutionDetails({
 						results,
-						progress: includeProgress ? allProgress : undefined,
-						artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
+						includeProgress,
+						allProgress,
+						allArtifactPaths,
+						artifactsDir,
 						chainAgents,
 						totalSteps,
 						currentStepIndex: stepIndex,
-					},
+					}),
 					isError: true,
 				};
 			}
@@ -691,13 +692,14 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 
 	return {
 		content: [{ type: "text", text: summary }],
-		details: {
-			mode: "chain",
+		details: buildChainExecutionDetails({
 			results,
-			progress: includeProgress ? allProgress : undefined,
-			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
+			includeProgress,
+			allProgress,
+			allArtifactPaths,
+			artifactsDir,
 			chainAgents,
 			totalSteps,
-		},
+		}),
 	};
 }

package/install.mjs

@@ -38,7 +38,7 @@ if (isRemove) {
 	if (fs.existsSync(EXTENSION_DIR)) {
 		console.log(`Removing ${EXTENSION_DIR}...`);
 		fs.rmSync(EXTENSION_DIR, { recursive: true });
-		console.log("✓ pi-subagents removed");
+		console.log("pi-subagents removed");
 	} else {
 		console.log("pi-subagents is not installed");
 	}
@@ -61,7 +61,7 @@ if (fs.existsSync(EXTENSION_DIR)) {
 		console.log("Updating existing installation...");
 		try {
 			execSync("git pull", { cwd: EXTENSION_DIR, stdio: "inherit" });
-			console.log("\n✓ pi-subagents updated");
+			console.log("\npi-subagents updated");
 		} catch (err) {
 			console.error("Failed to update. Try removing and reinstalling:");
 			console.error("  npx pi-subagents --remove && npx pi-subagents");
@@ -77,7 +77,7 @@ if (fs.existsSync(EXTENSION_DIR)) {
 	console.log(`Cloning to ${EXTENSION_DIR}...`);
 	try {
 		execSync(`git clone ${REPO_URL} "${EXTENSION_DIR}"`, { stdio: "inherit" });
-		console.log("\n✓ pi-subagents installed");
+		console.log("\npi-subagents installed");
 	} catch (err) {
 		console.error("Failed to clone repository");
 		process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",

package/parallel-utils.ts

@@ -102,15 +102,15 @@ export function aggregateParallelOutputs(
 			const hasOutput = Boolean(r.output?.trim());
 			const status =
 				r.exitCode === -1
-					? "⏭️ SKIPPED"
+					? "SKIPPED"
 					: r.exitCode !== 0 && r.exitCode !== null
-						? `⚠️ FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
+						? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}`
 						: r.error
-							? `⚠️ WARNING: ${r.error}`
+							? `WARNING: ${r.error}`
 							: !hasOutput && r.outputTargetPath && r.outputTargetExists === false
-								? `⚠️ EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
+								? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
 								: !hasOutput && !r.outputTargetPath
-									? "⚠️ EMPTY OUTPUT (no textual response returned)"
+									? "EMPTY OUTPUT (no textual response returned)"
 							: "";
 			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
 			return `${header}\n${body}`;

package/prompt-template-bridge.ts

@@ -78,6 +78,7 @@ interface PromptTemplateBridgeResult {
 		results?: Array<{
 			agent?: string;
 			messages?: unknown[];
+			finalOutput?: string;
 			exitCode?: number;
 			error?: string;
 			model?: string;
@@ -180,12 +181,13 @@ function sanitizeRecentTools(
 	tools: Array<{ tool?: string; args?: string }> | undefined,
 ): Array<{ tool: string; args: string }> | undefined {
 	if (!tools || tools.length === 0) return undefined;
-	const sanitized = tools
-		.filter((entry) => typeof entry.tool === "string" && entry.tool.trim().length > 0)
-		.map((entry) => ({
-			tool: entry.tool as string,
+	const sanitized = tools.flatMap((entry) => {
+		if (typeof entry.tool !== "string" || entry.tool.trim().length === 0) return [];
+		return [{
+			tool: entry.tool,
 			args: typeof entry.args === "string" ? entry.args : String(entry.args ?? ""),
-		}));
+		}];
+	});
 	return sanitized.length > 0 ? sanitized : undefined;
 }
 
@@ -207,6 +209,15 @@ function resolveProgressModel(
 	return firstWithModel?.model;
 }
 
+function buildDelegationMessages(result: { messages?: unknown[]; finalOutput?: string }, fallbackText?: string): unknown[] {
+	if (Array.isArray(result.messages) && result.messages.length > 0) return result.messages;
+	const text = typeof result.finalOutput === "string" && result.finalOutput.trim().length > 0
+		? result.finalOutput.trim()
+		: fallbackText;
+	if (!text) return [];
+	return [{ role: "assistant", content: [{ type: "text", text }] }];
+}
+
 function toDelegationUpdate(requestId: string, update: PromptTemplateBridgeResult): PromptTemplateDelegationUpdate | undefined {
 	const progress = update.details?.progress?.[0];
 	const taskProgress = update.details?.progress?.map((entry) => {
@@ -324,7 +335,8 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
 				},
 			);
-			const messages = result.details?.results?.[0]?.messages ?? [];
+			const contentText = firstTextContent(result.content);
+			const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
 			const parallelResults = request.tasks
 				? request.tasks.map<PromptTemplateDelegationParallelResult>((task, index) => {
 					const step = result.details?.results?.[index];
@@ -340,13 +352,12 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 					const errorText = step.error;
 					return {
 						agent: step.agent ?? task.agent,
-						messages: step.messages ?? [],
+						messages: buildDelegationMessages(step),
 						isError: (exitCode !== undefined && exitCode !== 0) || !!errorText,
 						errorText: errorText || undefined,
 					};
 				})
 				: undefined;
-			const contentText = firstTextContent(result.content);
 			const response: PromptTemplateDelegationResponse = {
 				...request,
 				messages,

package/render.ts

@@ -20,7 +20,6 @@ function getTermWidth(): number {
 	return process.stdout.columns || 120;
 }
 
-// Grapheme segmenter for proper Unicode handling (shared instance)
 const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 
 /**
@@ -35,42 +34,38 @@ const segmenter = new Intl.Segmenter(undefined, { granularity: "grapheme" });
 function truncLine(text: string, maxWidth: number): string {
 	if (visibleWidth(text) <= maxWidth) return text;
 
-	const targetWidth = maxWidth - 1; // Room for single ellipsis character
+	const targetWidth = maxWidth - 1;
 	let result = "";
 	let currentWidth = 0;
-	let activeStyles: string[] = []; // Track ALL active styles (not just last)
+	let activeStyles: string[] = [];
 	let i = 0;
 
 	while (i < text.length) {
-		// Check for ANSI escape code
 		const ansiMatch = text.slice(i).match(/^\x1b\[[0-9;]*m/);
 		if (ansiMatch) {
 			const code = ansiMatch[0];
 			result += code;
 
 			if (code === "\x1b[0m" || code === "\x1b[m") {
-				activeStyles = []; // Reset clears all styles
+				activeStyles = [];
 			} else {
-				activeStyles.push(code); // Stack styles (bold + color, etc.)
+				activeStyles.push(code);
 			}
 			i += code.length;
 			continue;
 		}
 
-		// Find end of non-ANSI text segment
 		let end = i;
 		while (end < text.length && !text.slice(end).match(/^\x1b\[[0-9;]*m/)) {
 			end++;
 		}
 
-		// Segment into graphemes for proper Unicode handling
 		const textPortion = text.slice(i, end);
 		for (const seg of segmenter.segment(textPortion)) {
 			const grapheme = seg.segment;
 			const graphemeWidth = visibleWidth(grapheme);
 
 			if (currentWidth + graphemeWidth > targetWidth) {
-				// Re-apply all active styles before ellipsis to preserve background/colors
 				return result + activeStyles.join("") + "…";
 			}
 
@@ -80,16 +75,11 @@ function truncLine(text: string, maxWidth: number): string {
 		i = end;
 	}
 
-	// Reached end without exceeding width (shouldn't happen given initial check)
 	return result + activeStyles.join("") + "…";
 }
 
-// Track last rendered widget state to avoid no-op re-renders
 let lastWidgetHash = "";
 
-/**
- * Compute a simple hash of job states for change detection
- */
 function computeWidgetHash(jobs: AsyncJobState[]): string {
 	return jobs.slice(0, MAX_WIDGET_JOBS).map(job =>
 		`${job.asyncId}:${job.status}:${job.currentStep}:${job.updatedAt}:${job.totalTokens?.total ?? 0}`
@@ -124,13 +114,11 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 		return;
 	}
 
-	// Check if anything changed since last render
-	// Always re-render if any displayed job is running (output tail updates constantly)
 	const displayedJobs = jobs.slice(0, MAX_WIDGET_JOBS);
 	const hasRunningJobs = displayedJobs.some(job => job.status === "running");
 	const newHash = computeWidgetHash(jobs);
 	if (!hasRunningJobs && newHash === lastWidgetHash) {
-		return; // Skip re-render, nothing changed
+		return;
 	}
 	lastWidgetHash = newHash;
 
@@ -194,12 +182,12 @@ export function renderSubagentResult(
 		const r = d.results[0];
 		const isRunning = r.progress?.status === "running";
 		const icon = isRunning
-			? theme.fg("warning", "...")
+			? theme.fg("warning", "running")
 			: r.detached
-				? theme.fg("warning", "↗")
+				? theme.fg("warning", "detached")
 				: r.exitCode === 0
 					? theme.fg("success", "ok")
-					: theme.fg("error", "X");
+					: theme.fg("error", "failed");
 		const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
 		const output = r.truncation?.text || getSingleResultOutput(r);
 
@@ -265,7 +253,7 @@ export function renderSubagentResult(
 			c.addChild(new Text(truncLine(theme.fg("dim", `Skills: ${r.skills.join(", ")}`), w), 0, 0));
 		}
 		if (r.skillsWarning) {
-			c.addChild(new Text(truncLine(theme.fg("warning", `⚠️ ${r.skillsWarning}`), w), 0, 0));
+			c.addChild(new Text(truncLine(theme.fg("warning", `Warning: ${r.skillsWarning}`), w), 0, 0));
 		}
 		if (r.attemptedModels && r.attemptedModels.length > 1) {
 			c.addChild(new Text(truncLine(theme.fg("dim", `Fallbacks: ${r.attemptedModels.join(" → ")}`), w), 0, 0));
@@ -291,12 +279,12 @@ export function renderSubagentResult(
 		&& hasEmptyTextOutputWithoutOutputTarget(r.task, getSingleResultOutput(r)),
 	);
 	const icon = hasRunning
-		? theme.fg("warning", "...")
+		? theme.fg("warning", "running")
 		: hasEmptyWithoutTarget
-			? theme.fg("warning", "⚠")
+			? theme.fg("warning", "warning")
 			: ok === d.results.length
 				? theme.fg("success", "ok")
-				: theme.fg("error", "X");
+				: theme.fg("error", "failed");
 
 	const totalSummary =
 		d.progressSummary ||
@@ -323,17 +311,11 @@ export function renderSubagentResult(
 
 	const modeLabel = d.mode;
 	const contextBadge = d.context === "fork" ? theme.fg("warning", " [fork]") : "";
-	// For parallel-in-chain, show task count (results) for consistency with step display
-	// For sequential chains, show logical step count
 	const hasParallelInChain = d.chainAgents?.some((a) => a.startsWith("["));
 	const totalCount = hasParallelInChain ? d.results.length : (d.totalSteps ?? d.results.length);
 	const currentStep = d.currentStepIndex !== undefined ? d.currentStepIndex + 1 : ok + 1;
 	const stepInfo = hasRunning ? ` ${currentStep}/${totalCount}` : ` ${ok}/${totalCount}`;
 	
-	// Build chain visualization: "scout → planner" with status icons
-	// Note: Only works correctly for sequential chains. Chains with parallel steps
-	// (indicated by "[agent1+agent2]" format) have multiple results per step,
-	// breaking the 1:1 mapping between chainAgents and results.
 	const chainVis = d.chainAgents?.length && !hasParallelInChain
 		? d.chainAgents
 				.map((agent, i) => {
@@ -345,14 +327,14 @@ export function renderSubagentResult(
 						&& hasEmptyTextOutputWithoutOutputTarget(result.task, getSingleResultOutput(result));
 					const isCurrent = i === (d.currentStepIndex ?? d.results.length);
 					const stepIcon = isFailed
-						? theme.fg("error", "✗")
+						? theme.fg("error", "failed")
 						: isEmptyWithoutTarget
-							? theme.fg("warning", "⚠")
+							? theme.fg("warning", "warning")
 							: isComplete
-								? theme.fg("success", "✓")
+								? theme.fg("success", "done")
 								: isCurrent && hasRunning
-									? theme.fg("warning", "●")
-									: theme.fg("dim", "○");
+									? theme.fg("warning", "running")
+									: theme.fg("dim", "pending");
 					return `${stepIcon} ${agent}`;
 				})
 				.join(theme.fg("dim", " → "))
@@ -367,15 +349,10 @@ export function renderSubagentResult(
 			0,
 		),
 	);
-	// Show chain visualization
 	if (chainVis) {
 		c.addChild(new Text(truncLine(`  ${chainVis}`, w), 0, 0));
 	}
 
-	// === STATIC STEP LAYOUT (like clarification UI) ===
-	// Each step gets a fixed section with task/output/status
-	// Note: For chains with parallel steps, chainAgents indices don't map 1:1 to results
-	// (parallel steps produce multiple results). Fall back to result-based iteration.
 	const useResultsDirectly = hasParallelInChain || !d.chainAgents?.length;
 	const stepsToShow = useResultsDirectly ? d.results.length : d.chainAgents!.length;
 
@@ -388,9 +365,8 @@ export function renderSubagentResult(
 			: (d.chainAgents![i] || r?.agent || `step-${i + 1}`);
 
 		if (!r) {
-			// Pending step
 			c.addChild(new Text(truncLine(theme.fg("dim", `  Step ${i + 1}: ${agentName}`), w), 0, 0));
-			c.addChild(new Text(theme.fg("dim", `    status: ○ pending`), 0, 0));
+			c.addChild(new Text(theme.fg("dim", `    status: pending`), 0, 0));
 			c.addChild(new Spacer(1));
 			continue;
 		}
@@ -402,12 +378,12 @@ export function renderSubagentResult(
 
 		const resultOutput = getSingleResultOutput(r);
 		const statusIcon = rRunning
-			? theme.fg("warning", "●")
+			? theme.fg("warning", "running")
 			: r.exitCode !== 0
-				? theme.fg("error", "✗")
+				? theme.fg("error", "failed")
 				: hasEmptyTextOutputWithoutOutputTarget(r.task, resultOutput)
-					? theme.fg("warning", "⚠")
-					: theme.fg("success", "✓");
+					? theme.fg("warning", "warning")
+					: theme.fg("success", "done");
 		const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(rProg.durationMs)}` : "";
 		const modelDisplay = r.model ? theme.fg("dim", ` (${r.model})`) : "";
 		const stepHeader = rRunning
@@ -430,7 +406,7 @@ export function renderSubagentResult(
 			c.addChild(new Text(truncLine(theme.fg("dim", `    skills: ${r.skills.join(", ")}`), w), 0, 0));
 		}
 		if (r.skillsWarning) {
-			c.addChild(new Text(truncLine(theme.fg("warning", `    ⚠️ ${r.skillsWarning}`), w), 0, 0));
+			c.addChild(new Text(truncLine(theme.fg("warning", `    Warning: ${r.skillsWarning}`), w), 0, 0));
 		}
 		if (r.attemptedModels && r.attemptedModels.length > 1) {
 			c.addChild(new Text(truncLine(theme.fg("dim", `    fallbacks: ${r.attemptedModels.join(" → ")}`), w), 0, 0));
@@ -440,7 +416,6 @@ export function renderSubagentResult(
 			if (rProg.skills?.length) {
 				c.addChild(new Text(truncLine(theme.fg("accent", `    skills: ${rProg.skills.join(", ")}`), w), 0, 0));
 			}
-			// Current tool for running step
 			if (rProg.currentTool) {
 				const maxToolArgsLen = Math.max(50, w - 20);
 				const toolArgsPreview = rProg.currentToolArgs
@@ -453,7 +428,6 @@ export function renderSubagentResult(
 					: rProg.currentTool;
 				c.addChild(new Text(truncLine(theme.fg("warning", `    > ${toolLine}`), w), 0, 0));
 			}
-			// Recent tools
 			if (rProg.recentTools?.length) {
 				for (const t of rProg.recentTools.slice(-3)) {
 					const maxArgsLen = Math.max(40, w - 30);
@@ -463,7 +437,6 @@ export function renderSubagentResult(
 					c.addChild(new Text(truncLine(theme.fg("dim", `      ${t.tool}: ${argsPreview}`), w), 0, 0));
 				}
 			}
-			// Recent output - let truncLine handle truncation entirely
 			const recentLines = (rProg.recentOutput ?? []).slice(-5);
 			for (const line of recentLines) {
 				c.addChild(new Text(truncLine(theme.fg("dim", `      ${line}`), w), 0, 0));

package/single-output.ts

@@ -84,11 +84,11 @@ export function finalizeSingleOutput(params: {
 }): { displayOutput: string; savedPath?: string; saveError?: string } {
 	let displayOutput = params.truncatedOutput || params.fullOutput;
 	if (params.exitCode === 0 && params.savedPath) {
-		displayOutput += `\n\n📄 Output saved to: ${params.savedPath}`;
+		displayOutput += `\n\nOutput saved to: ${params.savedPath}`;
 		return { displayOutput, savedPath: params.savedPath };
 	}
 	if (params.exitCode === 0 && params.saveError && params.outputPath) {
-		displayOutput += `\n\n⚠️ Failed to save output to: ${params.outputPath}\n${params.saveError}`;
+		displayOutput += `\n\nFailed to save output to: ${params.outputPath}\n${params.saveError}`;
 		return { displayOutput, saveError: params.saveError };
 	}
 	return { displayOutput };

package/subagent-executor.ts

@@ -25,7 +25,7 @@ import { executeAsyncChain, executeAsyncSingle, isAsyncAvailable } from "./async
 import { createForkContextResolver } from "./fork-context.ts";
 import { applyIntercomBridgeToAgent, resolveIntercomBridge, resolveIntercomSessionTarget } from "./intercom-bridge.ts";
 import { finalizeSingleOutput, injectSingleOutputInstruction, resolveSingleOutputPath } from "./single-output.ts";
-import { getSingleResultOutput, mapConcurrent } from "./utils.ts";
+import { compactForegroundDetails, getSingleResultOutput, mapConcurrent } from "./utils.ts";
 import {
 	cleanupWorktrees,
 	createWorktrees,
@@ -885,12 +885,12 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 
 		return {
 			content: [{ type: "text", text: fullContent }],
-			details: {
+			details: compactForegroundDetails({
 				mode: "parallel",
 				results,
 				progress: params.includeProgress ? allProgress : undefined,
 				artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
-			},
+			}),
 		};
 	} finally {
 		if (worktreeSetup) cleanupWorktrees(worktreeSetup);
@@ -1063,37 +1063,37 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 	if (r.detached) {
 		return {
 			content: [{ type: "text", text: `Detached for intercom coordination: ${params.agent}` }],
-			details: {
+			details: compactForegroundDetails({
 				mode: "single",
 				results: [r],
 				progress: params.includeProgress ? allProgress : undefined,
 				artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 				truncation: r.truncation,
-			},
+			}),
 		};
 	}
 
 	if (r.exitCode !== 0)
 		return {
 			content: [{ type: "text", text: r.error || "Failed" }],
-			details: {
+			details: compactForegroundDetails({
 				mode: "single",
 				results: [r],
 				progress: params.includeProgress ? allProgress : undefined,
 				artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 				truncation: r.truncation,
-			},
+			}),
 			isError: true,
 		};
 	return {
 		content: [{ type: "text", text: finalizedOutput.displayOutput || "(no output)" }],
-		details: {
+		details: compactForegroundDetails({
 			mode: "single",
 			results: [r],
 			progress: params.includeProgress ? allProgress : undefined,
 			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 			truncation: r.truncation,
-		},
+		}),
 	};
 }
 

package/subagent-runner.ts

@@ -555,12 +555,12 @@ async function runSingleStep(
 	}
 	if (resolvedOutput.savedPath) {
 		outputForSummary = outputForSummary
-			? `${outputForSummary}\n\n📄 Output saved to: ${resolvedOutput.savedPath}`
-			: `📄 Output saved to: ${resolvedOutput.savedPath}`;
+			? `${outputForSummary}\n\nOutput saved to: ${resolvedOutput.savedPath}`
+			: `Output saved to: ${resolvedOutput.savedPath}`;
 	} else if (resolvedOutput.saveError && step.outputPath && finalResult?.exitCode === 0) {
 		outputForSummary = outputForSummary
-			? `${outputForSummary}\n\n⚠️ Failed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`
-			: `⚠️ Failed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`;
+			? `${outputForSummary}\n\nFailed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`
+			: `Failed to save output to: ${step.outputPath}\n${resolvedOutput.saveError}`;
 	}
 
 	if (artifactPaths && ctx.artifactConfig?.enabled !== false) {

package/types.ts

@@ -85,7 +85,7 @@ export interface SingleResult {
 	exitCode: number;
 	detached?: boolean;
 	detachedReason?: string;
-	messages: Message[];
+	messages?: Message[];
 	usage: Usage;
 	model?: string;
 	attemptedModels?: string[];

package/utils.ts

@@ -6,13 +6,12 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import type { Message } from "@mariozechner/pi-ai";
-import type { AsyncStatus, DisplayItem, ErrorInfo, SingleResult } from "./types.ts";
+import type { AgentProgress, AsyncStatus, Details, DisplayItem, ErrorInfo, SingleResult } from "./types.ts";
 
 // ============================================================================
 // File System Utilities
 // ============================================================================
 
-// Cache for status file reads - avoid re-reading unchanged files
 const statusCache = new Map<string, { mtime: number; status: AsyncStatus }>();
 
 function getErrorMessage(error: unknown): string {
@@ -74,7 +73,6 @@ export function readStatus(asyncDir: string): AsyncStatus | null {
 	return status;
 }
 
-// Cache for output tail reads - avoid re-reading unchanged files
 const outputTailCache = new Map<string, { mtime: number; size: number; lines: string[] }>();
 
 /**
@@ -87,7 +85,6 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 		const stat = fs.statSync(outputFile);
 		if (stat.size === 0) return [];
 
-		// Check cache using both mtime and size (size changes more frequently during writes)
 		const cached = outputTailCache.get(outputFile);
 		if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
 			return cached.lines;
@@ -102,9 +99,7 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 		const allLines = content.split("\n").filter((l) => l.trim());
 		const lines = allLines.slice(-maxLines).map((l) => l.slice(0, 120) + (l.length > 120 ? "..." : ""));
 
-		// Cache the result
 		outputTailCache.set(outputFile, { mtime: stat.mtimeMs, size: stat.size, lines });
-		// Limit cache size
 		if (outputTailCache.size > 20) {
 			const firstKey = outputTailCache.keys().next().value;
 			if (firstKey) outputTailCache.delete(firstKey);
@@ -112,12 +107,15 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 
 		return lines;
 	} catch {
+		// Output tails are UI-only hints; unreadable or missing files should render as no tail.
 		return [];
 	} finally {
 		if (fd !== null) {
 			try {
 				fs.closeSync(fd);
-			} catch {}
+			} catch {
+				// Closing the best-effort tail file handle should not surface over the main status view.
+			}
 		}
 	}
 }
@@ -125,16 +123,16 @@ export function getOutputTail(outputFile: string | undefined, maxLines: number =
 /**
  * Get human-readable last activity time for a file
  */
-export function getLastActivity(outputFile: string | undefined): string {
+	export function getLastActivity(outputFile: string | undefined): string {
 	if (!outputFile) return "";
 	try {
-		// Single stat call - throws if file doesn't exist
 		const stat = fs.statSync(outputFile);
 		const ago = Date.now() - stat.mtimeMs;
 		if (ago < 1000) return "active now";
 		if (ago < 60000) return `active ${Math.floor(ago / 1000)}s ago`;
 		return `active ${Math.floor(ago / 60000)}m ago`;
 	} catch {
+		// Last-activity text is best effort; missing files should simply omit the hint.
 		return "";
 	}
 }
@@ -201,13 +199,14 @@ export function getFinalOutput(messages: Message[]): string {
 }
 
 export function getSingleResultOutput(result: Pick<SingleResult, "finalOutput" | "messages">): string {
-	return result.finalOutput ?? getFinalOutput(result.messages);
+	return result.finalOutput ?? getFinalOutput(result.messages ?? []);
 }
 
 /**
  * Extract display items (text and tool calls) from messages
  */
-export function getDisplayItems(messages: Message[]): DisplayItem[] {
+export function getDisplayItems(messages: Message[] | undefined): DisplayItem[] {
+	if (!messages || messages.length === 0) return [];
 	const items: DisplayItem[] = [];
 	for (const msg of messages) {
 		if (msg.role === "assistant") {
@@ -220,6 +219,43 @@ export function getDisplayItems(messages: Message[]): DisplayItem[] {
 	return items;
 }
 
+function compactCompletedProgress(progress: AgentProgress): AgentProgress {
+	if (progress.status === "running") return progress;
+	return {
+		index: progress.index,
+		agent: progress.agent,
+		status: progress.status,
+		task: progress.task,
+		skills: progress.skills,
+		toolCount: progress.toolCount,
+		tokens: progress.tokens,
+		durationMs: progress.durationMs,
+		error: progress.error,
+		failedTool: progress.failedTool,
+		recentTools: [],
+		recentOutput: [],
+	};
+}
+
+export function compactForegroundResult(result: SingleResult): SingleResult {
+	if (result.progress?.status === "running") return result;
+	return {
+		...result,
+		messages: undefined,
+		progress: undefined,
+	};
+}
+
+export function compactForegroundDetails(details: Details): Details {
+	return {
+		...details,
+		results: details.results.map(compactForegroundResult),
+		progress: details.progress
+			? details.progress.map(compactCompletedProgress)
+			: undefined,
+	};
+}
+
 /**
  * Detect errors in subagent execution from messages (only errors with no subsequent success)
  */