pi-prompt-template-model 0.6.6 → 0.6.8

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## [0.6.8] - 2026-03-28
+
+### Added
+- Delegated prompt results are now injected back into the parent conversation as a user message, triggering an agent turn so the parent agent can process and respond to the delegation outcome. Applies to single delegated runs, delegated loops, and delegated chain steps.
+
+## [0.6.7] - 2026-03-28
+
+### Changed
+- Delegation progress widget now shows a unified tool stream where completed tools scroll chronologically with the active tool highlighted at the bottom, replacing the old design where the active tool flashed at the top and disappeared on completion.
+- Delegation progress widget now renders the subagent's model name in the header (e.g., `delegate [fork] gpt-5.3-codex | 14 tools, 170k tok, 2m47s`).
+- Delegation progress widget no longer caps tool history or output lines. The box grows to show the full execution trace.
+- Delegation progress widget now refreshes every second during idle periods (model thinking) so the elapsed timer ticks smoothly instead of freezing between progress updates.
+- Enriched the delegation bridge protocol to pass through full `recentOutputLines`, `recentTools` history, and `model` from pi-subagents progress data, replacing the old single-line `recentOutput` and missing tool/model fields.
+- Removed `lastTool`/`lastToolArgs` tracking from live state (dead code after the unified tool stream redesign).
+
 ## [0.6.6] - 2026-03-28
 
 ### Added

package/index.ts

@@ -45,6 +45,7 @@ interface ExecutionErrorState {
 
 interface PromptStepResult {
 	changed: boolean;
+	text?: string;
 }
 
 export default function promptModelExtension(pi: ExtensionAPI) {
@@ -132,9 +133,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 
 		for (const command of pi.getCommands()) {
 			if (command.source !== "skill") continue;
-			if (!command.sourceInfo.path) continue;
+			const sourceInfo = "sourceInfo" in command
+				? (command as { sourceInfo?: { path?: string } }).sourceInfo
+				: undefined;
+			if (!sourceInfo?.path) continue;
 			if (!candidates.has(command.name)) continue;
-			return command.sourceInfo.path;
+			return sourceInfo.path;
 		}
 
 		return undefined;
@@ -215,7 +219,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					notify(ctx, `Prompt \`${prompt.name}\` is not configured for delegated execution.`, "error");
 					return "aborted";
 				}
-				return { changed: delegated.changed };
+				return { changed: delegated.changed, text: delegated.text };
 			} catch (error) {
 				notify(ctx, error instanceof Error ? error.message : String(error), "error");
 				return { changed: false };
@@ -418,6 +422,8 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		let completedIterations = 0;
 		let converged = false;
 		let loopErrorState: ExecutionErrorState = { hasError: false, error: undefined };
+		let lastDelegatedText: string | undefined;
+		let loopAborted = false;
 
 		try {
 			for (let i = 0; i < effectiveMax; i++) {
@@ -428,6 +434,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 				const prompt = prompts.get(name);
 				if (!prompt) {
 					notify(ctx, `Prompt "${name}" no longer exists`, "error");
+					loopAborted = true;
 					break;
 				}
 				const effectivePrompt = { ...prompt, ...(cwdOverride ? { cwd: cwdOverride } : {}), ...promptOverrides };
@@ -465,13 +472,20 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					undefined,
 					loopContext,
 				);
-				if (stepResult === "aborted") break;
+				if (stepResult === "aborted") {
+					loopAborted = true;
+					break;
+				}
+				const delegatedStep = shouldDelegatePrompt(iterationPrompt, subagentOverride);
+				if (delegatedStep) {
+					lastDelegatedText = stepResult.text;
+				}
 
 				currentModel = getCurrentModel(ctx);
 				currentThinking = pi.getThinkingLevel();
 				completedIterations++;
 
-				const iterationChanged = shouldDelegatePrompt(iterationPrompt, subagentOverride)
+				const iterationChanged = delegatedStep
 					? stepResult.changed
 					: didIterationMakeChanges(getIterationEntries(ctx, iterationStartId));
 				if (useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
@@ -484,6 +498,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					const result = await ctx.navigateTree(anchorId, { summarize: true });
 					freshCollapse = null;
 					if (result.cancelled) {
+						loopAborted = true;
 						notify(ctx, "Loop cancelled", "warning");
 						break;
 					}
@@ -514,6 +529,15 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			}
 		}
 
+		if (lastDelegatedText && !loopErrorState.hasError && !loopAborted) {
+			const label = converged
+				? `Delegated loop converged after ${completedIterations} iteration(s): ${name}`
+				: `Delegated loop completed ${completedIterations} iteration(s): ${name}`;
+			pi.sendUserMessage(`[${label}]\n\n${lastDelegatedText}`);
+			await waitForTurnStart(ctx);
+			await ctx.waitForIdle();
+		}
+
 		if (loopErrorState.hasError) {
 			throw loopErrorState.error;
 		}
@@ -607,6 +631,8 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 		let completedIterations = 0;
 		let converged = false;
 		let chainErrorState: ExecutionErrorState = { hasError: false, error: undefined };
+		let lastDelegatedText: string | undefined;
+		let chainAborted = false;
 		if (effectiveMax > 1) {
 			loopState = { currentIteration: 1, totalIterations };
 			accumulatedSummaries = [];
@@ -619,7 +645,10 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					loopState!.currentIteration = iteration + 1;
 					updateLoopStatus(ctx);
 					refreshPrompts(ctx.cwd, ctx);
-					if (!validateChainSteps()) break;
+					if (!validateChainSteps()) {
+						chainAborted = true;
+						break;
+					}
 				}
 
 				const templates = steps.map((step) =>
@@ -697,6 +726,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 							aborted = true;
 							break;
 						}
+						lastDelegatedText = delegated.text;
 
 						currentModel = getCurrentModel(ctx);
 						currentThinking = pi.getThinkingLevel();
@@ -761,9 +791,13 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 								stepLoopContext,
 							);
 							if (stepResult === "aborted") {
+								chainAborted = true;
 								aborted = true;
 								break;
 							}
+							if (shouldDelegatePrompt(singleStep.prompt, subagentOverride)) {
+								lastDelegatedText = stepResult.text;
+							}
 
 							currentModel = getCurrentModel(ctx);
 							currentThinking = pi.getThinkingLevel();
@@ -787,7 +821,10 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					chainStepSummaries.push(generateChainStepSummary(stepEntries, singleStep.prompt.name, stepNumber));
 				}
 
-				if (aborted) break;
+				if (aborted) {
+					chainAborted = true;
+					break;
+				}
 				completedIterations++;
 
 				if (useConverge && (isUnlimited || effectiveMax > 1) && !iterationChanged) {
@@ -800,6 +837,7 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 					const result = await ctx.navigateTree(anchorId, { summarize: true });
 					freshCollapse = null;
 					if (result.cancelled) {
+						chainAborted = true;
 						notify(ctx, "Loop cancelled", "warning");
 						break;
 					}
@@ -835,6 +873,12 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			}
 		}
 
+		if (lastDelegatedText && !chainErrorState.hasError && !chainAborted) {
+			pi.sendUserMessage(`[Delegated chain complete: ${chainStepNames}]\n\n${lastDelegatedText}`);
+			await waitForTurnStart(ctx);
+			await ctx.waitForIdle();
+		}
+
 		if (chainErrorState.hasError) {
 			throw chainErrorState.error;
 		}
@@ -934,6 +978,11 @@ export default function promptModelExtension(pi: ExtensionAPI) {
 			subagent.override,
 		);
 		if (stepResult === "aborted") return;
+		if (shouldDelegatePrompt(effectivePrompt, subagent.override) && stepResult.text) {
+			pi.sendUserMessage(`[Delegated result: ${name}]\n\n${stepResult.text}`);
+			await waitForTurnStart(ctx);
+			await ctx.waitForIdle();
+		}
 
 		if (!shouldDelegatePrompt(effectivePrompt, subagent.override) && prompt.restore) {
 			const currentModel = getCurrentModel(ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-prompt-template-model",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "type": "module",
   "description": "Prompt template model selector extension for pi coding agent",
   "author": "Nico Bailon",

package/subagent-runtime.ts

@@ -52,6 +52,9 @@ export interface DelegatedSubagentUpdate {
 	currentTool?: string;
 	currentToolArgs?: string;
 	recentOutput?: string;
+	recentOutputLines?: string[];
+	recentTools?: Array<{ tool: string; args: string }>;
+	model?: string;
 	toolCount?: number;
 	durationMs?: number;
 	tokens?: number;
@@ -65,6 +68,9 @@ export interface DelegatedSubagentTaskProgress {
 	currentTool?: string;
 	currentToolArgs?: string;
 	recentOutput?: string;
+	recentOutputLines?: string[];
+	recentTools?: Array<{ tool: string; args: string }>;
+	model?: string;
 	toolCount?: number;
 	durationMs?: number;
 	tokens?: number;
@@ -74,9 +80,9 @@ export interface DelegatedSubagentLiveState {
 	status?: string;
 	currentTool?: string;
 	currentToolArgs?: string;
-	lastTool?: string;
-	lastToolArgs?: string;
 	recentOutput: string[];
+	recentTools: Array<{ tool: string; args: string }>;
+	model?: string;
 	toolCount: number;
 	durationMs: number;
 	tokens: number;
@@ -151,6 +157,7 @@ export function updateDelegatedLiveState(requestId: string, update: Partial<Dele
 	const now = Date.now();
 	const existing = delegatedLiveState.get(requestId) ?? {
 		recentOutput: [],
+		recentTools: [],
 		toolCount: 0,
 		durationMs: 0,
 		tokens: 0,
@@ -158,21 +165,16 @@ export function updateDelegatedLiveState(requestId: string, update: Partial<Dele
 		startedAt: now,
 		updatedAt: now,
 	};
-	// When a tool finishes (currentTool goes undefined), preserve it as lastTool
-	const toolJustCleared = update.currentTool === undefined && existing.currentTool !== undefined;
-	const lastTool = toolJustCleared ? existing.currentTool : (update.currentTool ?? existing.lastTool);
-	const lastToolArgs = toolJustCleared ? existing.currentToolArgs : (update.currentToolArgs ?? existing.lastToolArgs);
-
 	const next: DelegatedSubagentLiveState = {
 		...existing,
 		...update,
 		recentOutput: update.recentOutput ?? existing.recentOutput,
+		recentTools: update.recentTools ?? existing.recentTools,
+		model: update.model ?? existing.model,
 		toolCount: update.toolCount ?? existing.toolCount,
 		durationMs: update.durationMs ?? (now - existing.startedAt),
 		tokens: update.tokens ?? existing.tokens,
 		taskProgress: update.taskProgress ?? existing.taskProgress,
-		lastTool,
-		lastToolArgs,
 		startedAt: existing.startedAt,
 		updatedAt: now,
 	};
@@ -184,6 +186,7 @@ export function appendDelegatedLiveOutput(requestId: string, line?: string): voi
 	const fallbackNow = Date.now();
 	const existing = delegatedLiveState.get(requestId) ?? {
 		recentOutput: [],
+		recentTools: [],
 		toolCount: 0,
 		durationMs: 0,
 		tokens: 0,
@@ -191,7 +194,7 @@ export function appendDelegatedLiveOutput(requestId: string, line?: string): voi
 		startedAt: fallbackNow,
 		updatedAt: fallbackNow,
 	};
-	const recentOutput = [...existing.recentOutput, line].slice(-12);
+	const recentOutput = [...existing.recentOutput, line];
 	delegatedLiveState.set(requestId, {
 		...existing,
 		recentOutput,

package/subagent-step.ts

@@ -204,6 +204,9 @@ function formatProgressStatus(update: DelegatedSubagentUpdate): string | undefin
 	if (update.currentTool) {
 		return `running ${update.currentTool}${update.currentToolArgs ? ` ${update.currentToolArgs}` : ""}`;
 	}
+	if (update.taskProgress?.some((task) => task.status === "running")) {
+		return "running";
+	}
 	if (update.toolCount && update.toolCount > 0) {
 		return `completed ${update.toolCount} tool${update.toolCount === 1 ? "" : "s"}`;
 	}
@@ -216,6 +219,38 @@ function formatParallelProgressStatus(update: DelegatedSubagentUpdate): string |
 	return `parallel ${completed}/${update.taskProgress.length} running`;
 }
 
+function hasOwn<T extends object>(value: T, key: PropertyKey): boolean {
+	return Object.prototype.hasOwnProperty.call(value, key);
+}
+
+function sanitizeOutputLines(lines: string[] | undefined): string[] {
+	if (!lines || lines.length === 0) return [];
+	return lines.filter((line): line is string => typeof line === "string" && line.trim() && line.trim() !== "(running...)");
+}
+
+function collectNewOutputLines(previous: string[] | undefined, next: string[] | undefined): string[] {
+	const previousLines = sanitizeOutputLines(previous);
+	const nextLines = sanitizeOutputLines(next);
+	if (nextLines.length === 0) return [];
+	if (previousLines.length === 0) return nextLines;
+
+	const overlapLimit = Math.min(previousLines.length, nextLines.length);
+	for (let overlap = overlapLimit; overlap > 0; overlap--) {
+		let matches = true;
+		for (let index = 0; index < overlap; index++) {
+			if (previousLines[previousLines.length - overlap + index] !== nextLines[index]) {
+				matches = false;
+				break;
+			}
+		}
+		if (matches) {
+			return nextLines.slice(overlap);
+		}
+	}
+
+	return nextLines;
+}
+
 function mergeTaskProgress(
 	requestTasks: DelegatedSubagentTask[] | undefined,
 	existingProgress: DelegatedSubagentTaskProgress[] | undefined,
@@ -235,6 +270,9 @@ function mergeTaskProgress(
 			currentTool: existing?.currentTool,
 			currentToolArgs: existing?.currentToolArgs,
 			recentOutput: existing?.recentOutput,
+			recentOutputLines: existing?.recentOutputLines,
+			recentTools: existing?.recentTools,
+			model: existing?.model ?? task.model,
 			toolCount: existing?.toolCount,
 			durationMs: existing?.durationMs,
 			tokens: existing?.tokens,
@@ -255,11 +293,20 @@ function mergeTaskProgress(
 		}
 		if (targetIndex < 0) continue;
 		consumed.add(targetIndex);
+		const current = merged[targetIndex]!;
 		merged[targetIndex] = {
-			...merged[targetIndex],
-			...entry,
 			index: targetIndex,
-			agent: merged[targetIndex]!.agent,
+			agent: current.agent,
+			status: entry.status ?? current.status,
+			currentTool: hasOwn(entry, "currentTool") ? entry.currentTool : current.currentTool,
+			currentToolArgs: hasOwn(entry, "currentToolArgs") ? entry.currentToolArgs : current.currentToolArgs,
+			recentOutput: entry.recentOutput ?? current.recentOutput,
+			recentOutputLines: entry.recentOutputLines ?? current.recentOutputLines,
+			recentTools: entry.recentTools ?? current.recentTools,
+			model: entry.model ?? current.model,
+			toolCount: entry.toolCount ?? current.toolCount,
+			durationMs: entry.durationMs ?? current.durationMs,
+			tokens: entry.tokens ?? current.tokens,
 		};
 	}
 
@@ -316,18 +363,29 @@ async function requestDelegatedRun(
 
 		let lastProgressStatus = "";
 		let widgetSet = false;
+		let refreshTimer: ReturnType<typeof setInterval> | null = null;
 
 		const showWidget = () => {
 			if (!ctx.hasUI || widgetSet) return;
 			widgetSet = true;
 			ctx.ui.setWidget(
 				DELEGATED_WIDGET_KEY,
-				(_tui, theme) => createDelegatedProgressWidget(request.requestId, request.agent, request.context, request.task, request.tasks, theme),
+				(_tui, theme) => createDelegatedProgressWidget(request.requestId, request.agent, request.context, request.task, request.tasks, theme, request.model),
 				{ placement: "aboveEditor" },
 			);
+			// Force TUI repaints every second so the elapsed timer ticks during idle periods
+			refreshTimer = setInterval(() => {
+				if (done) return;
+				const statusLine = lastProgressStatus || "running...";
+				ctx.ui.setStatus("prompt-subagent", `delegating to ${requestLabel} · ${statusLine}`);
+			}, 1000);
 		};
 
 		const clearWidget = () => {
+			if (refreshTimer) {
+				clearInterval(refreshTimer);
+				refreshTimer = null;
+			}
 			if (ctx.hasUI && widgetSet) {
 				ctx.ui.setWidget(DELEGATED_WIDGET_KEY, undefined);
 				widgetSet = false;
@@ -338,9 +396,11 @@ async function requestDelegatedRun(
 			if (done || !data || typeof data !== "object") return;
 			const update = data as DelegatedSubagentUpdate;
 			if (update.requestId !== request.requestId) return;
+
+			const previousTaskProgress = getDelegatedLiveState(request.requestId)?.taskProgress;
 			const mergedTaskProgress = mergeTaskProgress(
 				request.tasks,
-				getDelegatedLiveState(request.requestId)?.taskProgress,
+				previousTaskProgress,
 				update.taskProgress,
 			);
 			const isParallel = (request.tasks?.length ?? 0) > 0;
@@ -353,18 +413,46 @@ async function requestDelegatedRun(
 			if (progressStatus) {
 				lastProgressStatus = progressStatus;
 			}
+
 			updateDelegatedLiveState(request.requestId, {
 				status: progressStatus ?? (lastProgressStatus || "running..."),
 				currentTool: update.currentTool,
 				currentToolArgs: update.currentToolArgs,
+				recentTools: update.recentTools,
+				model: update.model,
 				toolCount: update.toolCount,
 				durationMs: update.durationMs,
 				tokens: update.tokens,
 				taskProgress: mergedTaskProgress,
 			});
-			appendDelegatedLiveOutput(request.requestId, update.recentOutput);
-			if (mergedTaskProgress) {
+
+			if (!isParallel) {
+				if (update.recentOutputLines && update.recentOutputLines.length > 0) {
+					updateDelegatedLiveState(request.requestId, {
+						recentOutput: sanitizeOutputLines(update.recentOutputLines),
+					});
+				} else {
+					appendDelegatedLiveOutput(request.requestId, update.recentOutput);
+				}
+			}
+
+			if (isParallel && mergedTaskProgress) {
 				for (const task of mergedTaskProgress) {
+					const previousTask =
+						previousTaskProgress?.find((entry) => entry.index === task.index) ??
+						previousTaskProgress?.find((entry) => entry.agent === task.agent);
+
+					const newOutputLines = collectNewOutputLines(previousTask?.recentOutputLines, task.recentOutputLines);
+					if (newOutputLines.length > 0) {
+						for (const line of newOutputLines) {
+							appendDelegatedLiveOutput(request.requestId, line);
+						}
+						continue;
+					}
+
+					if (!task.recentOutput || task.recentOutput === previousTask?.recentOutput) {
+						continue;
+					}
 					appendDelegatedLiveOutput(request.requestId, task.recentOutput);
 				}
 			}
@@ -567,11 +655,12 @@ export async function executeSubagentPromptStep(options: DelegatedPromptOptions)
 			agent: preparedTasks[0]!.agent,
 		};
 	} catch (error) {
-		const responseText = error instanceof Error ? error.message : String(error);
+		const cause = error instanceof Error ? error : new Error(String(error));
+		const responseText = cause.message;
 		if (isParallelRequest) {
-			throw new Error(`Parallel delegated prompts (${promptLabel}) failed: ${responseText}`);
+			throw new Error(`Parallel delegated prompts (${promptLabel}) failed: ${responseText}`, { cause });
 		}
-		throw new Error(`Prompt \`${preparedTasks[0]!.promptName}\` delegated subagent \`${preparedTasks[0]!.agent}\` failed: ${responseText}`);
+		throw new Error(`Prompt \`${preparedTasks[0]!.promptName}\` delegated subagent \`${preparedTasks[0]!.agent}\` failed: ${responseText}`, { cause });
 	} finally {
 		clearDelegatedLiveState(request.requestId);
 		if (ctx.hasUI) {

package/subagent-widget.ts

@@ -18,6 +18,28 @@ function formatTokens(n: number | undefined): string {
 	return String(n);
 }
 
+function normalizeModelLabel(model: string | undefined): string | undefined {
+	if (!model) return undefined;
+	return model.includes("/") ? model.split("/").pop() : model;
+}
+
+function formatToolCall(tool: string, args: string): string {
+	const safeArgs = args ?? "";
+	switch (tool) {
+		case "bash": {
+			const cmd = safeArgs.replace(/[\n\t]/g, " ").trim();
+			return `$ ${cmd.length > 80 ? cmd.slice(0, 80) + "..." : cmd}`;
+		}
+		case "read": return `[read: ${safeArgs}]`;
+		case "write": return `[write: ${safeArgs}]`;
+		case "edit": return `[edit: ${safeArgs}]`;
+		default: {
+			const short = safeArgs.length > 60 ? safeArgs.slice(0, 60) + "..." : safeArgs;
+			return `[${tool}: ${short}]`;
+		}
+	}
+}
+
 export function createDelegatedProgressWidget(
 	requestId: string,
 	agent: string,
@@ -25,11 +47,18 @@ export function createDelegatedProgressWidget(
 	task: string,
 	tasks: DelegatedSubagentTask[] | undefined,
 	theme: Theme,
+	model?: string,
 ): Container & { dispose?(): void } {
 	const contextSuffix = context === "fork" ? theme.fg("warning", " [fork]") : "";
-	const taskPreview = task.length > 120 ? `${task.slice(0, 120)}...` : task;
+	const taskPreview = task.length > 200 ? `${task.slice(0, 200)}...` : task;
 	const parallelTasks = tasks ?? [];
 	const isParallel = parallelTasks.length > 0;
+	const parallelModels = [...new Set(parallelTasks
+		.map((task) => normalizeModelLabel(task.model))
+		.filter((entry): entry is string => !!entry))];
+	const requestModel = isParallel
+		? (parallelModels.length === 1 ? parallelModels[0] : undefined)
+		: normalizeModelLabel(model);
 
 	const container = new Container();
 	container.addChild(new Spacer(1));
@@ -44,7 +73,7 @@ export function createDelegatedProgressWidget(
 		const key = stateKey(state, elapsed);
 		if (key !== lastKey) {
 			lastKey = key;
-			rebuildBox(box, agent, contextSuffix, taskPreview, parallelTasks, isParallel, state, elapsed, theme);
+			rebuildBox(box, agent, contextSuffix, taskPreview, parallelTasks, isParallel, state, elapsed, theme, requestModel);
 		}
 		return Container.prototype.render.call(container, width);
 	};
@@ -55,11 +84,16 @@ export function createDelegatedProgressWidget(
 function stateKey(state: DelegatedSubagentLiveState | undefined, elapsed: number): string {
 	if (!state) return "none";
 	const elapsedBucket = Math.floor(elapsed / 1000);
-	const tool = state.currentTool ?? state.lastTool ?? "";
+	const tool = state.currentTool ?? "";
+	const outputLen = state.recentOutput.length;
+	const outputTail = state.recentOutput.length > 0
+		? state.recentOutput[state.recentOutput.length - 1]?.slice(0, 80) ?? ""
+		: "";
+	const toolsLen = state.recentTools.length;
 	const taskProgressKey = state.taskProgress
 		.map((entry) => `${entry.index ?? ""}:${entry.agent}:${entry.status ?? ""}:${entry.currentTool ?? ""}:${entry.toolCount ?? 0}`)
 		.join("|");
-	return `${state.status}|${tool}|${state.toolCount}|${state.tokens}|${state.recentOutput.length}|${taskProgressKey}|${elapsedBucket}`;
+	return `${state.status}|${tool}|${state.toolCount}|${state.tokens}|${outputLen}:${outputTail}|${toolsLen}|${state.model ?? ""}|${taskProgressKey}|${elapsedBucket}`;
 }
 
 function rebuildBox(
@@ -72,34 +106,49 @@ function rebuildBox(
 	state: DelegatedSubagentLiveState | undefined,
 	elapsed: number,
 	theme: Theme,
+	requestModel?: string,
 ): void {
 	box.clear();
 
-	const toolCount = state?.toolCount ?? 0;
-	const tokens = formatTokens(state?.tokens);
+	const taskProgress = state?.taskProgress ?? [];
+	const baseToolCount = state?.toolCount ?? 0;
+	const baseTokens = state?.tokens ?? 0;
+	const parallelToolCount = taskProgress.reduce((sum, entry) => sum + (entry.toolCount ?? 0), 0);
+	const parallelTokens = taskProgress.reduce((sum, entry) => sum + (entry.tokens ?? 0), 0);
+	const toolCount = isParallel && parallelToolCount > 0 ? parallelToolCount : baseToolCount;
+	const tokens = isParallel && parallelTokens > 0 ? parallelTokens : baseTokens;
+	const tokensLabel = formatTokens(tokens);
 	const duration = formatDuration(elapsed);
-	const isThinking = toolCount === 0 && (state?.tokens ?? 0) === 0;
+	const isThinking = toolCount === 0 && tokens === 0;
 	const icon = theme.fg("warning", "...");
+	const modelLabel = isParallel
+		? requestModel
+		: normalizeModelLabel(state?.model ?? requestModel);
+	const modelSuffix = modelLabel ? ` ${theme.fg("dim", modelLabel)}` : "";
 	const stats = isThinking
 		? `thinking, ${duration}`
-		: `${toolCount} tool${toolCount === 1 ? "" : "s"}, ${tokens} tok, ${duration}`;
-	const taskProgress = state?.taskProgress ?? [];
+		: `${toolCount} tool${toolCount === 1 ? "" : "s"}, ${tokensLabel} tok, ${duration}`;
 
+	// Header
 	if (isParallel) {
 		const completedCount = taskProgress.filter((entry) => entry.status === "completed").length;
 		const runningLabel = `parallel ${completedCount}/${parallelTasks.length} running`;
-		box.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(runningLabel))}${contextSuffix} | ${stats}`, 0, 0));
+		box.addChild(new Text(`${icon} ${theme.fg("toolTitle", theme.bold(runningLabel))}${contextSuffix}${modelSuffix} | ${stats}`, 0, 0));
 	} else {
 		box.addChild(new Text(
-			`${icon} ${theme.fg("toolTitle", theme.bold(agent))}${contextSuffix} | ${stats}`,
+			`${icon} ${theme.fg("toolTitle", theme.bold(agent))}${contextSuffix}${modelSuffix} | ${stats}`,
 			0, 0,
 		));
 	}
 	box.addChild(new Spacer(1));
+
+	// Task preview
 	if (!isParallel) {
 		box.addChild(new Text(theme.fg("dim", `Task: ${taskPreview}`), 0, 0));
+		box.addChild(new Spacer(1));
 	}
 
+	// Parallel task list
 	if (isParallel) {
 		for (let index = 0; index < parallelTasks.length; index++) {
 			const task = parallelTasks[index]!;
@@ -111,35 +160,38 @@ function rebuildBox(
 			if (taskStatus === "running") {
 				const runningTool = progress.currentTool ? ` ${progress.currentTool}...` : "";
 				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: running${runningTool}`), 0, 0));
-				continue;
-			}
-			if (taskStatus === "completed") {
+			} else if (taskStatus === "completed") {
 				const toolSuffix =
 					progress?.toolCount !== undefined
 						? ` (${progress.toolCount} tool${progress.toolCount === 1 ? "" : "s"})`
 						: "";
 				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: completed${toolSuffix}`), 0, 0));
-				continue;
-			}
-			if (taskStatus === "failed") {
+			} else if (taskStatus === "failed") {
 				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: failed`), 0, 0));
-				continue;
+			} else {
+				box.addChild(new Text(theme.fg("dim", `  ${task.agent}: pending`), 0, 0));
 			}
-			box.addChild(new Text(theme.fg("dim", `  ${task.agent}: pending`), 0, 0));
 		}
 		return;
 	}
 
-	const activeTool = state?.currentTool;
-	const displayTool = activeTool ?? state?.lastTool;
-	if (displayTool) {
-		const toolArgs = activeTool ? state?.currentToolArgs : state?.lastToolArgs;
-		const toolLine = `${displayTool}${toolArgs ? ` ${toolArgs}` : ""}`;
-		box.addChild(new Text(theme.fg("dim", toolLine), 0, 0));
+	// Unified tool stream: completed tools (dim) then active tool (warning) at bottom.
+	// When a tool finishes it moves from active → completed in place — no visual jump.
+	const recentTools = state?.recentTools ?? [];
+	for (const tool of recentTools) {
+		box.addChild(new Text(theme.fg("dim", formatToolCall(tool.tool, tool.args)), 0, 0));
+	}
+	if (state?.currentTool) {
+		const active = formatToolCall(state.currentTool, state.currentToolArgs ?? "");
+		box.addChild(new Text(theme.fg("warning", `> ${active}`), 0, 0));
 	}
 
+	// Recent output
 	if (state && state.recentOutput.length > 0) {
-		for (const line of state.recentOutput.slice(-4)) {
+		if (recentTools.length > 0 || state.currentTool) {
+			box.addChild(new Spacer(1));
+		}
+		for (const line of state.recentOutput) {
 			box.addChild(new Text(theme.fg("dim", `  ${line}`), 0, 0));
 		}
 	}