pi-subagents 0.59.0 → 0.60.0

package/src/tui/render.ts

@@ -31,11 +31,13 @@ import { flatToLogicalStepIndex } from "../runs/background/parallel-groups.ts";
 import { formatNestedAggregate } from "../runs/shared/nested-render.ts";
 import { aggregateStepStatus, formatActivityLabel, formatAgentRunningLabel, formatParallelOutcome } from "../shared/status-format.ts";
 import { contextModeBadge, contextModePrefix } from "../runs/shared/context-mode.ts";
+import { shouldSuppressSingleStep, stripRepeatedAgentPrefix, withDuplicateLabelDiscriminators } from "./render-helpers.ts";
 import { buildWorkflowChatProgressRows, type WorkflowChatProgressRow } from "../workflows/chat-progress.ts";
 import { formatWorkflowPreflight, formatWorkflowPreflightPlanSummary, formatWorkflowPreflightWarningSummary, formatWorkflowPreflightWarnings } from "../workflows/workflow-preflight.ts";
 import { encodeAsyncStatusSnapshotWidget } from "../runs/background/async-status-snapshot.ts";
 import { projectAsyncWorkflowRows, type AsyncStatusWorkflowRow } from "../runs/shared/async-status-projection.ts";
 import { hostStepReportName, hostStepVerdictLabel } from "../runs/shared/host-step-status.ts";
+import { workflowGraphStageNodes } from "../runs/shared/workflow-graph.ts";
 
 type Theme = ExtensionContext["ui"]["theme"];
 
@@ -192,7 +194,10 @@ function runningSeed(...values: Array<number | undefined>): number | undefined {
 
 function runningGlyph(seed?: number): string {
 	if (seed === undefined) return STATIC_RUNNING_GLYPH;
-	return RUNNING_FRAMES[Math.abs(seed) % RUNNING_FRAMES.length]!;
+	// Free-running wall-clock spinner: advance ~8 fps regardless of model
+	// activity; keep the seed so parallel rows stay phase-offset.
+	const clock = Math.floor(Date.now() / 125);
+	return RUNNING_FRAMES[Math.abs(seed + clock) % RUNNING_FRAMES.length]!;
 }
 
 function animatedSeed(seed: number | undefined, frame: number | undefined): number | undefined {
@@ -259,6 +264,7 @@ const noisyStatusPatterns = [
 	/^(?:checking|fetching|reading|inspecting|verifying|collecting|confirming|polling)\b/i,
 	/^(?:async\s+subagent\s+)?[\w.-]+\s*·\s*(?:step|agent)\s+\d+\/\d+\s*·/i,
 	/^(?:Step|Agent)\s+\d+\/\d+:\s+[\w.-]+\s*·\s*(?:running|queued|pending|complete|completed)\b/i,
+	/^(?:async\s+subagent\s+)?[\w.-]+(?:\s+\[(?:fresh|fork|mixed)\])?\s*·\s*(?:running|queued|pending|complete|completed|done)\b/i,
 	/^Press\s+\S+\s+for\s+live\s+detail$/i,
 	/^output:\s+.+\/async-subagent-runs\//i,
 ];
@@ -309,9 +315,129 @@ function boundedLaneValue(value: string | undefined, maxChars = LANE_VALUE_MAX_C
 	return previewDisplayText(oneLine(value), maxChars);
 }
 
+function workflowNodeStepStatus(status: WorkflowNodeStatus): AsyncJobStep["status"] {
+	switch (status) {
+		case "completed":
+			return "completed";
+		case "detached":
+			return "paused";
+		default:
+			return status;
+	}
+}
+
+function workflowNodeStatusLabel(status: WorkflowNodeStatus): string {
+	switch (status) {
+		case "completed":
+			return "complete";
+		case "detached":
+			return "paused";
+		default:
+			return status;
+	}
+}
+
+function workflowStepPriority(step: AsyncJobStep, currentNodeId?: string): number {
+	const isCurrent = step.workflowKey === currentNodeId;
+	if (step.status === "running" || (isCurrent && step.status !== "complete" && step.status !== "completed")) return 0;
+	const gate = laneGate(step);
+	if (
+		step.status === "failed"
+		|| step.status === "partial"
+		|| step.status === "paused"
+		|| step.status === "stopped"
+		|| step.status === "rejected"
+		|| step.toolBudgetBlocked === true
+		|| step.turnBudgetExceeded === true
+		|| step.activityState === "needs_attention"
+		|| step.watchdog?.phase === "stale"
+		|| gate !== undefined
+	) return 1;
+	if (step.status === "pending") return 2;
+	return 3;
+}
+
+/** Merge materialized child rows with the planned workflow stages for rendering. */
+function workflowWidgetSteps(job: AsyncJobState): AsyncJobStep[] {
+	const planned = job.mode === "workflow" ? workflowGraphStageNodes(job.workflowGraph) : [];
+	const loaded = job.steps ?? [];
+	if (planned.length === 0) return loaded;
+
+	const loadedIndexesByKey = new Map<string, number[]>();
+	for (const [index, step] of loaded.entries()) {
+		if (!step.workflowKey) continue;
+		const indexes = loadedIndexesByKey.get(step.workflowKey) ?? [];
+		indexes.push(index);
+		loadedIndexesByKey.set(step.workflowKey, indexes);
+	}
+	const consumed = new Set<number>();
+	const entries: Array<{ step: AsyncJobStep; order: number }> = [];
+	for (const [order, node] of planned.entries()) {
+		const loadedIndex = loadedIndexesByKey.get(node.id)?.find((index) => !consumed.has(index));
+		if (loadedIndex !== undefined) {
+			consumed.add(loadedIndex);
+			const loadedStep = loaded[loadedIndex]!;
+			entries.push({
+				step: {
+					...loadedStep,
+					index: node.flatIndex ?? loadedStep.index ?? order,
+					agent: loadedStep.agent || node.agent || job.agents?.[0] || "workflow",
+					phase: loadedStep.phase ?? node.phase,
+					label: loadedStep.label ?? node.label,
+					workflowKey: loadedStep.workflowKey ?? node.id,
+					...(loadedStep.outputName === undefined && node.outputName !== undefined ? { outputName: node.outputName } : {}),
+					...(loadedStep.structured === undefined && node.structured !== undefined ? { structured: node.structured } : {}),
+					...(loadedStep.error === undefined && node.error !== undefined ? { error: node.error } : {}),
+				},
+				order,
+			});
+			continue;
+		}
+		entries.push({
+			step: {
+				index: node.flatIndex ?? order,
+				agent: node.agent ?? job.agents?.[0] ?? "workflow",
+				status: workflowNodeStepStatus(node.status),
+				workflowKey: node.id,
+				label: node.label,
+				...(node.phase ? { phase: node.phase } : {}),
+				...(node.outputName ? { outputName: node.outputName } : {}),
+				...(node.structured !== undefined ? { structured: node.structured } : {}),
+				...(node.error ? { error: node.error } : {}),
+			},
+			order,
+		});
+	}
+	for (const [index, step] of loaded.entries()) {
+		if (!consumed.has(index)) entries.push({ step, order: planned.length + index });
+	}
+	entries.sort((left, right) => workflowStepPriority(left.step, job.workflowGraph?.currentNodeId) - workflowStepPriority(right.step, job.workflowGraph?.currentNodeId) || left.order - right.order);
+	return entries.map(({ step }) => step);
+}
+
+function workflowStageProgress(job: AsyncJobState): { total: number; current?: number } | undefined {
+	if (job.mode !== "workflow") return undefined;
+	const stages = workflowGraphStageNodes(job.workflowGraph);
+	if (stages.length === 0) return undefined;
+	const currentId = job.workflowGraph?.currentNodeId;
+	const currentIndex = currentId ? stages.findIndex((stage) => stage.id === currentId) : -1;
+	if (currentIndex >= 0 && stages[currentIndex]?.status !== "completed") return { total: stages.length, current: currentIndex };
+	const runningIndex = stages.findIndex((stage) => stage.status === "running");
+	if (runningIndex >= 0) return { total: stages.length, current: runningIndex };
+	const indexedStage = job.currentStep !== undefined && job.currentStep >= 0 ? stages[job.currentStep] : undefined;
+	if (indexedStage && indexedStage.status !== "completed") return { total: stages.length, current: job.currentStep };
+	if (stages.every((stage) => stage.status === "completed")) return { total: stages.length, current: stages.length - 1 };
+	return { total: stages.length };
+}
+
 function laneStepForJob(job: AsyncJobState): AsyncJobStep | undefined {
-	const steps = job.steps ?? [];
+	const steps = workflowWidgetSteps(job);
 	if (steps.length === 0) return undefined;
+	const graphCurrent = job.workflowGraph?.currentNodeId;
+	if (graphCurrent) {
+		const current = steps.find((step) => step.workflowKey === graphCurrent);
+		if (current) return current;
+	}
 	if (job.currentStep !== undefined) {
 		const current = steps[job.currentStep];
 		if (current && (current.index === undefined || current.index === job.currentStep)) return current;
@@ -454,7 +580,7 @@ function workflowPreflightLines(job: AsyncJobState, expanded = false): string[]
 }
 
 function workflowLabelForResult(details: Details, resultIndex: number): string | undefined {
-	const flatIndex = details.results[resultIndex]?.progress?.index ?? resultIndex;
+	const flatIndex = foregroundResultIndex(details, resultIndex);
 	const visit = (nodes: NonNullable<Details["workflowGraph"]>["nodes"]): string | undefined => {
 		for (const node of nodes) {
 			if (node.flatIndex === flatIndex && node.label.trim()) return node.label;
@@ -466,6 +592,52 @@ function workflowLabelForResult(details: Details, resultIndex: number): string |
 	return details.workflowGraph ? visit(details.workflowGraph.nodes) : undefined;
 }
 
+function foregroundProgressForResult(details: Details, resultIndex: number): AgentProgress | undefined {
+	const result = details.results[resultIndex];
+	if (result?.progress) return result.progress;
+	const index = result?.index ?? resultIndex;
+	const indexed = details.progress?.find((progress) => progress.index === index);
+	if (indexed) return indexed;
+	return result?.agent
+		? details.progress?.find((progress) => progress.agent === result.agent && progress.status === "running")
+		: undefined;
+}
+
+function foregroundResultIndex(details: Details, resultIndex: number): number {
+	const result = details.results[resultIndex];
+	if (typeof result?.index === "number") return result.index;
+	return foregroundProgressForResult(details, resultIndex)?.index ?? resultIndex;
+}
+
+function foregroundResultDisplayName(
+	details: Details,
+	resultIndex: number,
+	result: Details["results"][number] | undefined,
+	fallback: string,
+): string {
+	const progress = foregroundProgressForResult(details, resultIndex);
+	const agent = normalizedParallelDisplayText(result?.agent) ?? normalizedParallelDisplayText(progress?.agent);
+	const workflowLabel = normalizedParallelDisplayText(workflowLabelForResult(details, resultIndex));
+	if (workflowLabel) return compactTaskText(undefined, workflowLabel) ?? workflowLabel;
+
+	const sessionName = normalizedParallelDisplayText(result?.sessionName) ?? normalizedParallelDisplayText(progress?.sessionName);
+	if (sessionName) {
+		const sessionTask = stripRepeatedAgentPrefix(sessionName, agent);
+		if (sessionTask && sessionTask !== PROMPT_REDACTED && sessionTask.toLowerCase() !== agent?.toLowerCase()) {
+			return compactTaskText(sessionTask) ?? sessionTask;
+		}
+	}
+
+	return compactTaskText(result?.task) ?? compactTaskText(progress?.task) ?? agent ?? fallback;
+}
+
+function foregroundSingleDisplayName(result: Details["results"][number] | undefined): string {
+	return normalizedParallelDisplayText(result?.agent)
+		?? normalizedParallelDisplayText(result?.sessionName)
+		?? compactTaskText(result?.task)
+		?? "subagent";
+}
+
 function hasLiveOutputSignal(line: string): boolean {
 	const clean = oneLine(line);
 	return liveOutputWordSignalPattern.test(clean) || liveOutputCodeSignalPattern.test(clean);
@@ -779,6 +951,14 @@ function widgetStepRenderKey(step: AsyncJobStep, index: number, expanded = false
 		step.review?.status,
 		step.toolBudgetBlocked,
 		step.turnBudgetExceeded,
+		step.timedOut,
+		step.stopped,
+		step.execution?.status,
+		step.execution?.error,
+		step.execution?.timedOut,
+		step.execution?.interrupted,
+		step.execution?.stopped,
+		step.execution?.detached,
 		step.watchdog?.phase,
 		step.error,
 		expanded ? expandedStepActivityRenderKey(step) : undefined,
@@ -844,6 +1024,10 @@ export function widgetRenderKey(job: AsyncJobState, expanded = false): string {
 		chainStepCount: job.chainStepCount,
 		parallelGroups: job.parallelGroups,
 		workflowHostSteps: projectAsyncWorkflowRows([], job.hostSteps).map(hostStepRenderKey),
+		workflowGraph: job.mode === "workflow" && job.workflowGraph ? {
+			currentNodeId: job.workflowGraph.currentNodeId,
+			stages: workflowGraphStageNodes(job.workflowGraph).map((node) => [node.id, node.status, node.agent, node.phase, node.label, node.flatIndex, node.outputName, node.structured, node.error]),
+		} : undefined,
 		preflight: expanded ? job.preflight : job.preflight ? formatWorkflowPreflightPlanSummary(job.preflight) : undefined,
 		preflightWarnings: expanded ? job.workflow?.preflightWarnings : job.workflow?.preflightWarnings?.length || undefined,
 		steps: job.steps?.map((step, index) => widgetStepRenderKey(step, index, expanded)),
@@ -855,6 +1039,8 @@ export function widgetRenderKey(job: AsyncJobState, expanded = false): string {
 		activeParallelGroup: job.activeParallelGroup,
 		startedAt: job.startedAt,
 		updatedAt: job.updatedAt,
+		timedOut: job.timedOut,
+		stopped: job.stopped,
 		totalTokens: job.totalTokens,
 	});
 }
@@ -874,6 +1060,65 @@ function widgetJobName(job: AsyncJobState): string {
 	return job.mode ?? "subagent";
 }
 
+function isSingleChildAsyncJob(job: AsyncJobState): boolean {
+	return job.mode === "single"
+		&& job.steps?.length === 1
+		&& shouldSuppressSingleStep(job.chainStepCount, job.stepsTotal);
+}
+
+function isCompletedWidgetStepStatus(status: AsyncJobStep["status"]): boolean {
+	return status === "complete" || status === "completed";
+}
+
+function singleChildAgentName(job: AsyncJobState, step: AsyncJobStep): string {
+	return job.agents?.length === 1 ? job.agents[0]! : step.agent || widgetJobName(job);
+}
+
+function hasSingleChildDetailEvidence(job: AsyncJobState, step: AsyncJobStep): boolean {
+	return Boolean(
+		step.error?.trim()
+		|| step.execution?.error?.trim()
+		|| step.phase?.trim()
+		|| step.label?.trim()
+		|| step.workflowKey?.trim()
+		|| step.outputName?.trim()
+		|| step.lane
+		|| job.workflowKey?.trim()
+		|| job.lane
+		|| laneTraceForJob(job)?.phase?.trim()
+		|| laneTraceForJob(job)?.label?.trim()
+		|| step.timedOut
+		|| step.stopped
+		|| step.execution?.timedOut
+		|| step.execution?.interrupted
+		|| step.execution?.stopped
+		|| step.execution?.detached
+		|| job.timedOut
+		|| job.stopped
+		|| ["failed", "partial", "paused", "stopped", "detached"].includes(step.execution?.status ?? "")
+		|| step.acceptance?.status === "rejected"
+		|| step.acceptance?.reviewResult?.status === "blockers"
+		|| step.review?.status === "blockers",
+	);
+}
+
+function shouldCollapseSingleChildDetails(job: AsyncJobState, step: AsyncJobStep): boolean {
+	if (!isSingleChildAsyncJob(job) || hasSingleChildDetailEvidence(job, step)) return false;
+	if (job.status === "running") return step.status === "running";
+	if (job.status === "complete") return isCompletedWidgetStepStatus(step.status);
+	return false;
+}
+
+function singleChildTask(job: AsyncJobState, step: AsyncJobStep): string | undefined {
+	const task = compactTaskText(step.description, step.label);
+	if (task) return task;
+	const sessionName = step.sessionName?.trim();
+	if (!sessionName) return undefined;
+	const agentName = singleChildAgentName(job, step);
+	const sessionTask = stripRepeatedAgentPrefix(sessionName, agentName);
+	return sessionTask === agentName ? undefined : compactTaskText(sessionTask);
+}
+
 function widgetActivity(job: AsyncJobState): string {
 	const facts: string[] = [];
 	if (job.currentTool && job.currentToolStartedAt !== undefined && job.updatedAt !== undefined) facts.push(`${job.currentTool} ${formatDuration(Math.max(0, job.updatedAt - job.currentToolStartedAt))}`);
@@ -982,8 +1227,7 @@ function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded = false,
 	for (const span of buildAsyncChainStepSpans(total, job.steps.length, job.parallelGroups)) {
 		const steps = job.steps.slice(span.start, span.start + span.count);
 		if (span.isParallel) {
-			const status = aggregateStepStatus(steps);
-			lines.push(`  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(steps), frame)} Step ${span.stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(steps, span.count))}`);
+			lines.push(...parallelWidgetGroupDetails(job, theme, { steps, total: span.count, stepIndex: span.stepIndex, chainTotal: total }, expanded, width, frame, false));
 			continue;
 		}
 		const step = steps[0];
@@ -1000,6 +1244,8 @@ function widgetParallelAgentDetails(job: AsyncJobState, theme: Theme, expanded =
 	if (!job.steps?.length) return [];
 	if (job.mode !== "parallel" && job.mode !== "chain") return [];
 	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width, frame);
+	const group = activeParallelWidgetGroup(job);
+	if (group) return parallelWidgetGroupDetails(job, theme, group, expanded, width, frame, Boolean(job.activeParallelGroup));
 	const total = job.stepsTotal ?? job.steps.length;
 	const lines: string[] = [];
 	for (const [index, step] of job.steps.entries()) {
@@ -1090,6 +1336,127 @@ function buildAsyncChainStepSpans(total: number, stepCount: number, parallelGrou
 	return spans;
 }
 
+interface ParallelWidgetGroup {
+	steps: AsyncJobStep[];
+	total: number;
+	stepIndex?: number;
+	chainTotal?: number;
+}
+
+interface ParallelWidgetStepRow {
+	step: AsyncJobStep;
+	index: number;
+	rowLabel: string;
+}
+
+function normalizedParallelDisplayText(value: string | undefined): string | undefined {
+	if (!value?.trim()) return undefined;
+	const normalized = oneLine(value);
+	return normalized && normalized !== PROMPT_REDACTED ? normalized : undefined;
+}
+
+function parallelWidgetStepDisplayName(step: AsyncJobStep): string {
+	const agent = normalizedParallelDisplayText(step.agent);
+	const explicitLabel = normalizedParallelDisplayText(step.label);
+	if (explicitLabel) {
+		const label = compactTaskText(step.description, explicitLabel) ?? explicitLabel;
+		return agent ? `${label} (${agent})` : label;
+	}
+
+	const sessionName = normalizedParallelDisplayText(step.sessionName);
+	if (sessionName) {
+		const sessionTask = stripRepeatedAgentPrefix(sessionName, agent);
+		if (sessionTask && sessionTask !== PROMPT_REDACTED && sessionTask.toLowerCase() !== agent?.toLowerCase()) return sessionTask;
+	}
+
+	return compactTaskText(step.description) ?? agent ?? "subagent";
+}
+
+function parallelWidgetStepPriority(step: AsyncJobStep): number {
+	if (step.status === "running" || step.activityState === "needs_attention") return 0;
+	switch (step.status) {
+		case "failed":
+		case "rejected":
+		case "partial":
+		case "stopped":
+		case "paused":
+			return 1;
+		case "complete":
+		case "completed":
+			return 2;
+		default:
+			return 3;
+	}
+}
+
+function parallelWidgetStepRows(steps: AsyncJobStep[], total: number, prioritizeActive: boolean): ParallelWidgetStepRow[] {
+	const indexed = steps.map((step, index) => ({ step, index, displayName: parallelWidgetStepDisplayName(step) }));
+	if (prioritizeActive) indexed.sort((left, right) => parallelWidgetStepPriority(left.step) - parallelWidgetStepPriority(right.step) || left.index - right.index);
+	return withDuplicateLabelDiscriminators(indexed, total).map(({ displayName, ...row }) => row);
+}
+
+function activeParallelWidgetGroup(job: AsyncJobState): ParallelWidgetGroup | undefined {
+	const steps = job.steps ?? [];
+	if (!steps.length) return undefined;
+	if (job.mode === "parallel") return { steps, total: job.stepsTotal ?? steps.length };
+	if (job.mode !== "chain" || !job.activeParallelGroup) return undefined;
+
+	const chainTotal = job.chainStepCount ?? job.stepsTotal ?? steps.length;
+	const spans = buildAsyncChainStepSpans(chainTotal, steps.length, job.parallelGroups);
+	const currentStep = job.currentStep;
+	const activeSpan = currentStep === undefined
+		? spans.find((span) => span.isParallel)
+		: spans.find((span) => span.isParallel
+			&& currentStep >= span.start
+			&& currentStep < span.start + span.count);
+	return {
+		steps,
+		total: activeSpan?.count ?? job.stepsTotal ?? steps.length,
+		stepIndex: activeSpan?.stepIndex,
+		chainTotal,
+	};
+}
+
+function parallelWidgetGroupHeader(
+	group: ParallelWidgetGroup,
+	theme: Theme,
+	frame?: number,
+): string {
+	const status = aggregateStepStatus(group.steps);
+	const label = group.stepIndex !== undefined && group.chainTotal !== undefined
+		? `Step ${group.stepIndex + 1}/${group.chainTotal}: parallel group`
+		: "parallel group";
+	return `  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(group.steps), frame)} ${themeBold(theme, label)} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(group.steps, group.total))}`;
+}
+
+function parallelWidgetGroupDetails(
+	job: AsyncJobState,
+	theme: Theme,
+	group: ParallelWidgetGroup,
+	expanded: boolean,
+	width: number,
+	frame: number | undefined,
+	prioritizeActive: boolean,
+): string[] {
+	const lines = [parallelWidgetGroupHeader(group, theme, frame)];
+	const rows = parallelWidgetStepRows(group.steps, group.total, prioritizeActive);
+	for (const [rowIndex, row] of rows.entries()) {
+		const marker = rowIndex === rows.length - 1 && rows.length >= group.total ? "└─" : "├─";
+		lines.push(...foregroundStyleWidgetStepLines(job, theme, row.step, "Agent", row.index + 1, group.total, expanded, width, frame, {
+			rowLabel: row.rowLabel,
+			rowIndent: "    ",
+			detailIndent: "      ",
+			rowMarker: marker,
+			includeCurrentPath: true,
+		}));
+	}
+	for (let index = rows.length; index < group.total; index++) {
+		const marker = index === group.total - 1 ? "└─" : "├─";
+		lines.push(`    ${marker} ${theme.fg("muted", "◦")} ${theme.fg("dim", "pending")}`);
+	}
+	return lines;
+}
+
 function isDoneResult(result: Details["results"][number]): boolean {
 	const status = result.progress?.status;
 	if (status === "completed") return true;
@@ -1108,32 +1475,72 @@ interface ChainRenderResultEntry {
 	rowNumber: number;
 	rowLabel?: string;
 	agentName: string;
+	displayIndex: number;
+	isParallel?: boolean;
 }
 
-interface ChainRenderPlaceholderEntry {
-	kind: "placeholder";
-	rowNumber: number;
+interface ChainRenderGroupEntry {
+	kind: "group";
 	stepLabel: string;
-	agentName: string;
+	groupLabel?: string;
 	status: WorkflowNodeStatus;
 	error?: string;
 }
 
-type ChainRenderEntry = ChainRenderResultEntry | ChainRenderPlaceholderEntry;
+type ChainRenderEntry = ChainRenderResultEntry | ChainRenderGroupEntry;
+
+function chainSpanStatus(details: Details, span: ChainStepSpan): WorkflowNodeStatus {
+	if (span.status) return span.status;
+	const results = details.results.slice(span.start, span.start + span.count);
+	if (results.some((result) => isResultRunning(result))) return "running";
+	if (results.some((result) => !hasTerminalResultFlag(result) && (result.progress?.status === "failed" || result.exitCode !== 0) && !isResultRunning(result))) return "failed";
+	if (results.some((result) => result.stopped)) return "stopped";
+	if (results.some((result) => result.interrupted)) return "paused";
+	if (results.some((result) => result.detached || result.progress?.status === "detached")) return "detached";
+	if (results.length < span.count) return "pending";
+	if (results.length > 0 && results.every(isDoneResult)) return "completed";
+	return "pending";
+}
+
+function withDuplicateForegroundLabels(entries: ChainRenderResultEntry[], total: number): ChainRenderResultEntry[] {
+	return withDuplicateLabelDiscriminators(
+		entries.map((entry) => ({ ...entry, index: entry.displayIndex, displayName: entry.agentName })),
+		total,
+	).map(({ displayName, rowLabel, ...entry }) => ({
+		...entry,
+		rowLabel: rowLabel === displayName ? undefined : rowLabel.slice(0, -(displayName.length + 2)),
+	}));
+}
 
 function buildChainRenderEntries(details: Details, label: MultiProgressLabel): ChainRenderEntry[] | undefined {
 	if (details.mode !== "chain" || !label.hasParallelInChain || label.showActiveGroupOnly) return undefined;
 	const entries: ChainRenderEntry[] = [];
 	for (const span of buildChainStepSpans(details)) {
-		if (span.isParallel && span.count === 0) {
+		if (span.isParallel) {
 			entries.push({
-				kind: "placeholder",
-				rowNumber: span.stepIndex + 1,
-				stepLabel: `Step ${span.stepIndex + 1}`,
-				agentName: span.label ?? details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`,
-				status: span.status ?? "pending",
+				kind: "group",
+				stepLabel: `Step ${span.stepIndex + 1}/${label.logicalStepCount}: parallel group`,
+				groupLabel: span.label?.trim() || undefined,
+				status: chainSpanStatus(details, span),
 				error: span.error,
 			});
+			const groupEntries: ChainRenderResultEntry[] = [];
+			for (let index = span.start; index < span.start + span.count; index++) {
+				const result = details.results[index];
+				const localIndex = foregroundResultIndex(details, index);
+				const displayIndex = localIndex >= span.start && localIndex < span.start + span.count
+					? localIndex - span.start
+					: index - span.start;
+				groupEntries.push({
+					kind: "result",
+					resultIndex: index,
+					rowNumber: index - span.start + 1,
+					agentName: foregroundResultDisplayName(details, index, result, `agent-${displayIndex + 1}`),
+					displayIndex,
+					isParallel: true,
+				});
+			}
+			entries.push(...withDuplicateForegroundLabels(groupEntries, span.count));
 			continue;
 		}
 		for (let index = span.start; index < span.start + span.count; index++) {
@@ -1141,9 +1548,10 @@ function buildChainRenderEntries(details: Details, label: MultiProgressLabel): C
 			entries.push({
 				kind: "result",
 				resultIndex: index,
-				rowNumber: index + 1,
-				rowLabel: span.isParallel ? `Agent ${index - span.start + 1}/${span.count}` : `Step ${span.stepIndex + 1}`,
-				agentName: result?.sessionName?.trim() || result?.agent || details.chainAgents?.[span.stepIndex] || `step-${span.stepIndex + 1}`,
+				rowNumber: span.stepIndex + 1,
+				rowLabel: resultRowLabel(label, span.stepIndex + 1),
+				agentName: foregroundResultDisplayName(details, index, result, details.chainAgents?.[span.stepIndex] ?? `step-${span.stepIndex + 1}`),
+				displayIndex: foregroundResultIndex(details, index),
 			});
 		}
 	}
@@ -1159,6 +1567,7 @@ interface MultiProgressLabel {
 	groupStartIndex: number;
 	groupEndIndex: number;
 	showActiveGroupOnly: boolean;
+	logicalStepCount: number;
 }
 
 function buildMultiProgressLabel(details: Pick<Details, "mode" | "results" | "progress" | "totalSteps" | "currentStepIndex" | "chainAgents" | "workflowGraph">, hasRunning: boolean): MultiProgressLabel {
@@ -1194,7 +1603,7 @@ function buildMultiProgressLabel(details: Pick<Details, "mode" | "results" | "pr
 		const headerLabel = hasRunning
 			? `${formatAgentRunningLabel(running)} · ${done}/${totalCount} done`
 			: `${done}/${totalCount} done`;
-		return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: totalCount, showActiveGroupOnly: false };
+		return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: totalCount, showActiveGroupOnly: false, logicalStepCount: totalCount };
 	}
 
 	if (activeParallelGroup) {
@@ -1222,7 +1631,7 @@ function buildMultiProgressLabel(details: Pick<Details, "mode" | "results" | "pr
 		const headerLabel = hasRunning
 			? `step ${currentStepIndex + 1}/${totalSteps} · parallel group: ${formatAgentRunningLabel(running)} · ${done}/${groupSize} done`
 			: `step ${currentStepIndex + 1}/${totalSteps} · parallel group: ${done}/${groupSize} done`;
-		return { headerLabel, itemTitle, totalCount: groupSize, hasParallelInChain, activeParallelGroup, groupStartIndex: groupStart, groupEndIndex: groupEnd, showActiveGroupOnly: true };
+		return { headerLabel, itemTitle, totalCount: groupSize, hasParallelInChain, activeParallelGroup, groupStartIndex: groupStart, groupEndIndex: groupEnd, showActiveGroupOnly: true, logicalStepCount: totalSteps };
 	}
 
 	if (details.mode === "chain" && details.chainAgents?.length) {
@@ -1240,30 +1649,66 @@ function buildMultiProgressLabel(details: Pick<Details, "mode" | "results" | "pr
 		}).length;
 		const currentStep = details.currentStepIndex !== undefined ? details.currentStepIndex + 1 : Math.min(totalCount, doneLogical + (hasRunning ? 1 : 0));
 		const headerLabel = hasRunning ? `step ${currentStep}/${totalCount}` : `step ${doneLogical}/${totalCount}`;
-		return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false };
+		return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false, logicalStepCount: totalCount };
 	}
 
 	const totalCount = details.totalSteps ?? details.results.length;
 	const currentStep = details.currentStepIndex !== undefined ? details.currentStepIndex + 1 : Math.min(totalCount, details.results.filter(isDoneResult).length + (hasRunning ? 1 : 0));
 	const done = details.results.filter(isDoneResult).length;
 	const headerLabel = hasRunning ? `step ${currentStep}/${totalCount}` : `step ${done}/${totalCount}`;
-	return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false };
-}
-
-function resultRowLabel(label: MultiProgressLabel, resultIndex: number, stepNumber: number): string {
-	if (label.itemTitle === "Agent") {
-		const localStepNumber = label.activeParallelGroup
-			? resultIndex - label.groupStartIndex + 1
-			: stepNumber;
-		return `Agent ${localStepNumber}/${label.totalCount}`;
-	}
-	return `Step ${stepNumber}`;
+	return { headerLabel, itemTitle, totalCount, hasParallelInChain, activeParallelGroup, groupStartIndex: 0, groupEndIndex: details.results.length, showActiveGroupOnly: false, logicalStepCount: totalCount };
+}
+
+function resultRowLabel(label: MultiProgressLabel, stepNumber: number): string | undefined {
+	if (label.itemTitle === "Agent") return undefined;
+	if (shouldSuppressSingleStep(label.logicalStepCount)) return undefined;
+	return `Step ${stepNumber}/${label.logicalStepCount}`;
+}
+
+function buildForegroundResultEntries(
+	details: Details,
+	label: MultiProgressLabel,
+	displayStart: number,
+	displayEnd: number,
+	useResultsDirectly: boolean,
+): ChainRenderResultEntry[] {
+	const fallbackLabel = label.itemTitle.toLowerCase();
+	const entries = Array.from({ length: displayEnd - displayStart }, (_, offset): ChainRenderResultEntry => {
+		const index = displayStart + offset;
+		const result = details.results[index];
+		const stableIndex = foregroundResultIndex(details, index);
+		const rowNumber = label.showActiveGroupOnly ? index - label.groupStartIndex + 1 : stableIndex + 1;
+		const fallbackAgent = useResultsDirectly
+			? (result?.agent || `${fallbackLabel}-${rowNumber}`)
+			: (details.chainAgents![index] || result?.agent || `${fallbackLabel}-${rowNumber}`);
+		const displayIndex = label.activeParallelGroup && stableIndex >= label.groupStartIndex && stableIndex < label.groupEndIndex
+			? stableIndex - label.groupStartIndex
+			: label.activeParallelGroup ? index - label.groupStartIndex : stableIndex;
+		return {
+			kind: "result",
+			resultIndex: index,
+			rowNumber,
+			rowLabel: resultRowLabel(label, rowNumber),
+			agentName: foregroundResultDisplayName(details, index, result, fallbackAgent),
+			displayIndex,
+		};
+	});
+	return label.itemTitle === "Agent" ? withDuplicateForegroundLabels(entries, label.totalCount) : entries;
 }
 
 function widgetStats(job: AsyncJobState, theme: Theme): string {
 	const parts: string[] = [];
-	const stepsTotal = job.stepsTotal ?? (job.agents?.length ?? 1);
-	if (job.activeParallelGroup) {
+	const stageProgress = workflowStageProgress(job);
+	const stepsTotal = stageProgress?.total ?? job.stepsTotal ?? (job.agents?.length ?? 1);
+	const isSingleChild = isSingleChildAsyncJob(job);
+	if (stageProgress) {
+		const stages = workflowGraphStageNodes(job.workflowGraph);
+		const currentStage = stageProgress.current !== undefined ? stages[stageProgress.current] : undefined;
+		const focus = currentStage
+			? [compactTaskText(undefined, currentStage.label) ?? boundedLaneValue(currentStage.id), currentStage.agent ? boundedLaneValue(currentStage.agent) : "", workflowNodeStatusLabel(currentStage.status)].filter(Boolean)
+			: [];
+		parts.push(["staged lane", stageProgress.current !== undefined ? `stage ${stageProgress.current + 1}/${stageProgress.total}` : `${stageProgress.total} stages`, ...focus].join(" · "));
+	} else if (job.activeParallelGroup) {
 		const running = job.runningSteps ?? (job.status === "running" ? 1 : 0);
 		const done = job.completedSteps ?? (job.status === "complete" ? stepsTotal : 0);
 		if (job.mode === "parallel") {
@@ -1280,10 +1725,10 @@ function widgetStats(job: AsyncJobState, theme: Theme): string {
 			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupParts.join(" · ")}`);
 		}
 	} else if (job.currentStep !== undefined) {
-		if (job.mode === "chain" && job.parallelGroups?.length) {
+		if (job.mode === "chain") {
 			const total = job.chainStepCount ?? stepsTotal;
-			parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups) + 1}/${total}`);
-		} else {
+			parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups ?? []) + 1}/${total}`);
+		} else if (!isSingleChild) {
 			parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
 		}
 	} else if (stepsTotal > 1) {
@@ -1487,40 +1932,57 @@ function foregroundStyleWidgetStepLines(
 	job: AsyncJobState,
 	theme: Theme,
 	step: NonNullable<AsyncJobState["steps"]>[number],
-	itemTitle: "Agent" | "Step",
+	itemTitle: "Agent" | "Stage" | "Step",
 	index: number,
 	total: number,
 	expanded: boolean,
 	width: number,
 	frame?: number,
+	options?: { rowLabel?: string; rowIndent?: string; detailIndent?: string; rowMarker?: string; includeCurrentPath?: boolean },
 ): string[] {
+	const rowIndent = options?.rowIndent ?? "  ";
+	const detailIndent = options?.detailIndent ?? "    ";
 	const status = widgetStepStatus(step.status, theme);
 	const stats = widgetStepStats(theme, step);
 	const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking);
-	const lines = [`  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index - 1), frame)} ${itemTitle} ${index}/${total}: ${themeBold(theme, childDisplayName(step))}${contextModeBadge(theme, step.context)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
+	const collapseDetails = shouldCollapseSingleChildDetails(job, step);
+	const displayName = collapseDetails ? singleChildAgentName(job, step) : childDisplayName(step);
+	const stageName = itemTitle === "Stage"
+		? compactTaskText(undefined, step.label) ?? boundedLaneValue(step.workflowKey) ?? displayName
+		: undefined;
+	const stageIdentity = stageName && stageName !== displayName ? `${stageName} (${displayName})` : stageName ?? displayName;
+	const rowLabel = collapseDetails ? displayName : (options?.rowLabel ?? `${itemTitle} ${index}/${total}: ${itemTitle === "Stage" ? stageIdentity : displayName}`);
+	const rowMarker = options?.rowMarker ? `${options.rowMarker} ` : "";
+	const lines = [`${rowIndent}${rowMarker}${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index - 1), frame)} ${themeBold(theme, rowLabel)}${contextModeBadge(theme, step.context)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
 	const lane = projectAsyncLane(job, step);
-	if (lane) lines.push(...formatLaneProjectionLines(lane, theme, "    "));
-	const task = compactTaskText(step.description, step.label);
-	if (task) lines.push(`    ${theme.fg("dim", `task: ${task}`)}`);
+	if (lane) lines.push(...formatLaneProjectionLines(lane, theme, detailIndent));
+	const task = collapseDetails ? singleChildTask(job, step) : compactTaskText(step.description, step.label);
+	if (task) lines.push(`${detailIndent}${theme.fg("dim", `task: ${task}`)}`);
 	const activity = widgetStepActivityLine(step, width, expanded, job.updatedAt);
-	if (activity) lines.push(`    ${theme.fg("dim", `⎿  ${activity}`)}`);
+	const currentPath = options?.includeCurrentPath && step.currentPath ? shortenPath(step.currentPath) : undefined;
+	const activityWithPath = currentPath && activity && !activity.includes(currentPath)
+		? `${activity} · ${currentPath}`
+		: activity ?? currentPath;
+	if (activityWithPath) lines.push(`${detailIndent}${theme.fg("dim", `⎿  ${activityWithPath}`)}`);
 	for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, expanded ? 12 : 6)) {
-		lines.push(`    ${nestedLine}`);
+		lines.push(`${detailIndent}${nestedLine}`);
 	}
+	const error = step.error?.trim() || step.execution?.error?.trim();
+	if (error) lines.push(`${detailIndent}${theme.fg("error", `error: ${oneLine(error)}`)}`);
 	if (step.status === "running") {
-		if (!expanded) lines.push(`    ${theme.fg("accent", liveDetailHintText())}`);
+		if (!expanded) lines.push(`${detailIndent}${theme.fg("accent", liveDetailHintText())}`);
 		const output = widgetOutputPath(job, step);
-		if (output) lines.push(`    ${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
+		if (output) lines.push(`${detailIndent}${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
 		if (expanded) {
 			const liveStatus = buildLiveStatusLine(step, job.updatedAt);
-			if (liveStatus && liveStatus !== activity) lines.push(`    ${theme.fg("accent", liveStatus)}`);
+			if (liveStatus && liveStatus !== activity) lines.push(`${detailIndent}${theme.fg("accent", liveStatus)}`);
 			for (const tool of step.recentTools?.slice(-3) ?? []) {
 				const maxArgsLen = Math.max(40, width - 30);
 				const argsPreview = renderToolArgsPreview(tool.args, maxArgsLen, expanded);
-				lines.push(`      ${theme.fg("dim", `${tool.tool}${argsPreview ? `: ${argsPreview}` : ""}`)}`);
+				lines.push(`${detailIndent}  ${theme.fg("dim", `${tool.tool}${argsPreview ? `: ${argsPreview}` : ""}`)}`);
 			}
 			for (const line of compactRecentOutputLines(step.recentOutput)) {
-				lines.push(`      ${theme.fg("dim", line)}`);
+				lines.push(`${detailIndent}  ${theme.fg("dim", line)}`);
 			}
 		}
 	}
@@ -1553,7 +2015,8 @@ function hostStepWidgetLines(job: AsyncJobState, theme: Theme, indent: string):
 }
 
 function foregroundStyleWidgetDetails(job: AsyncJobState, theme: Theme, expanded: boolean, width: number, frame?: number): string[] {
-	if (!job.steps?.length) {
+	const steps = workflowWidgetSteps(job);
+	if (!steps.length) {
 		const lane = projectAsyncLane(job);
 		return [
 			...workflowPreflightLines(job, expanded),
@@ -1564,14 +2027,31 @@ function foregroundStyleWidgetDetails(job: AsyncJobState, theme: Theme, expanded
 		];
 	}
 	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width, frame);
-	const total = job.stepsTotal ?? job.steps.length;
-	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
 	const lines: string[] = workflowPreflightLines(job, expanded);
-	for (const [index, step] of job.steps.entries()) {
-		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index + 1, total, expanded, width, frame));
+	const group = activeParallelWidgetGroup(job);
+	if (group) {
+		lines.push(...parallelWidgetGroupDetails(job, theme, group, expanded, width, frame, Boolean(job.activeParallelGroup)));
+	} else {
+		const stageProgress = workflowStageProgress(job);
+		const total = job.mode === "chain"
+			? job.chainStepCount ?? job.stepsTotal ?? steps.length
+			: stageProgress?.total ?? job.stepsTotal ?? steps.length;
+		const stageTotal = stageProgress?.total ?? total;
+		const plannedKeys = stageProgress ? new Set(workflowGraphStageNodes(job.workflowGraph).map((node) => node.id)) : undefined;
+		const extraStepCount = plannedKeys
+			? steps.filter((step) => step.workflowKey === undefined || !plannedKeys.has(step.workflowKey)).length
+			: total;
+		let extraStepIndex = 0;
+		for (const [index, step] of steps.entries()) {
+			const isPlannedStage = plannedKeys !== undefined && step.workflowKey !== undefined && plannedKeys.has(step.workflowKey);
+			const itemTitle = isPlannedStage ? "Stage" : "Step";
+			const displayIndex = isPlannedStage ? (step.index ?? index) + 1 : plannedKeys ? ++extraStepIndex : index + 1;
+			const displayTotal = isPlannedStage ? stageTotal : extraStepCount;
+			lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, displayIndex, displayTotal, expanded, width, frame));
+		}
 	}
 	lines.push(...hostStepWidgetLines(job, theme, "  "));
-	const attached = new Set(job.steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
+	const attached = new Set(steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
 	const unattached = job.nestedChildren?.filter((child) => !attached.has(child.id)) ?? [];
 	for (const nestedLine of formatNestedWidgetLines(unattached, theme, width, expanded, job.updatedAt, expanded ? 12 : 6)) {
 		lines.push(`  ${nestedLine}`);
@@ -1581,12 +2061,16 @@ function foregroundStyleWidgetDetails(job: AsyncJobState, theme: Theme, expanded
 
 function buildSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, expanded: boolean, frame?: number): string[] {
 	const stats = widgetStats(job, theme);
-	const count = job.mode === "chain" ? job.chainStepCount : job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
+	const count = job.mode === "chain" ? job.chainStepCount : workflowStageProgress(job)?.total ?? job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
 	const mode = widgetJobName(job);
-	const title = `async subagent ${mode}${count && count > 1 ? ` (${count})` : ""}`;
+	const title = isSingleChildAsyncJob(job)
+		? "async subagent"
+		: `async subagent ${mode}${count && count > 1 ? ` (${count})` : ""}`;
+	const collapseDetails = job.steps?.length === 1 && shouldCollapseSingleChildDetails(job, job.steps[0]!);
+	const summary = `${widgetStatusGlyph(job, theme, frame)} ${themeBold(theme, mode)}${contextModeBadge(theme, job.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`;
 	return [
 		`${theme.fg("toolTitle", themeBold(theme, title))} ${theme.fg("dim", "· background")}`,
-		`${widgetStatusGlyph(job, theme, frame)} ${themeBold(theme, mode)}${contextModeBadge(theme, job.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+		...(collapseDetails ? [] : [summary]),
 		...foregroundStyleWidgetDetails(job, theme, expanded, width, frame),
 	].map((line) => truncLine(line, width));
 }
@@ -1595,10 +2079,13 @@ function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width: numbe
 	const fullLines = buildSingleWidgetLines(job, theme, width, false, frame);
 	if (fullLines.length <= 10 || !job.steps?.length || (job.mode !== "parallel" && !job.activeParallelGroup)) return fullLines;
 
-	const total = job.stepsTotal ?? job.steps.length;
-	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
+	const group = activeParallelWidgetGroup(job);
+	if (!group) return fullLines;
+	const rows = parallelWidgetStepRows(group.steps, group.total, Boolean(job.activeParallelGroup));
 	const lines = fullLines.slice(0, 2);
-	for (const [index, step] of job.steps.entries()) {
+	lines.push(parallelWidgetGroupHeader(group, theme, frame));
+	for (const [rowIndex, row] of rows.entries()) {
+		const step = row.step;
 		const status = widgetStepStatus(step.status, theme);
 		const activity = widgetStepActivityLine(step, width, false, job.updatedAt);
 		const stepStats = widgetStepStats(theme, step);
@@ -1606,10 +2093,11 @@ function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width: numbe
 		const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking);
 		const task = compactTaskText(step.description, step.label);
 		const taskSuffix = task ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", `task: ${task}`)}` : "";
-		lines.push(`  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index), frame)} ${itemTitle} ${index + 1}/${total}: ${themeBold(theme, childDisplayName(step))}${contextModeBadge(theme, step.context)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${taskSuffix}${activitySuffix}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}`);
+		const marker = rowIndex === rows.length - 1 && rowIndex >= group.total - 1 ? "└─" : "├─";
+		lines.push(`    ${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, row.index), frame)} ${themeBold(theme, row.rowLabel)}${contextModeBadge(theme, step.context)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${taskSuffix}${activitySuffix}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}`);
 		const lane = projectAsyncLane(job, step);
-		if (lane) lines.push(...formatLaneProjectionLines(lane, theme, "  "));
-		for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, false, job.updatedAt, 6)) lines.push(`    ${nestedLine}`);
+		if (lane) lines.push(...formatLaneProjectionLines(lane, theme, "      "));
+		for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, false, job.updatedAt, 6)) lines.push(`      ${nestedLine}`);
 	}
 	lines.push(...hostStepWidgetLines(job, theme, "  "));
 	if (job.steps.some((step) => step.status === "running")) lines.push(theme.fg("accent", `  ${liveDetailHintText()}`));
@@ -1852,6 +2340,10 @@ function fitAdaptiveWidgetLines(jobs: AsyncJobState[], buildLines: () => string[
 		widgetLayoutSession = { expanded, rows, columns, tier: "full", visibleJobKeys: [] };
 		return fitWidgetLineBudget(lines, theme, width, false);
 	}
+	if (availableRows > 2 && jobs.length === 1 && workflowStageProgress(jobs[0]!)) {
+		widgetLayoutSession = { expanded, rows, columns, tier: "full", visibleJobKeys: [] };
+		return fitWidgetLineBudget(lines, theme, width, false);
+	}
 
 	if (availableRows <= 2) {
 		widgetLayoutSession = { expanded, rows, columns, tier: "single-line", visibleJobKeys: [] };
@@ -1898,9 +2390,7 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 	let hiddenFinished = 0;
 	let queuedSummaryShown = false;
 	let slots = MAX_WIDGET_JOBS;
-
-	for (const job of running) {
-		if (slots <= 0) { hiddenRunning++; continue; }
+	const appendJob = (job: AsyncJobState): void => {
 		const stats = widgetStats(job, theme);
 		items.push([
 			`${widgetStatusGlyph(job, theme, frame)} ${themeBold(theme, widgetJobName(job))}${contextModeBadge(theme, job.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
@@ -1908,6 +2398,11 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 			...widgetLaneDetailLines(job, theme),
 			...widgetParallelAgentDetails(job, theme, expanded, width, frame),
 		]);
+	};
+
+	for (const job of running) {
+		if (slots <= 0) { hiddenRunning++; continue; }
+		appendJob(job);
 		slots--;
 	}
 
@@ -1919,13 +2414,7 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 
 	for (const job of finished) {
 		if (slots <= 0) { hiddenFinished++; continue; }
-		const stats = widgetStats(job, theme);
-		items.push([
-			`${widgetStatusGlyph(job, theme, frame)} ${themeBold(theme, widgetJobName(job))}${contextModeBadge(theme, job.context)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
-			`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
-			...widgetLaneDetailLines(job, theme),
-			...widgetParallelAgentDetails(job, theme, expanded, width, frame),
-		]);
+		appendJob(job);
 		slots--;
 	}
 
@@ -1991,7 +2480,7 @@ function renderSingleCompact(
 	const detailIndent = mainWindowIndent(layout, 1);
 	const continuationIndent = mainWindowIndent(layout, 2) + (layout.horizontalSpacing > 0 ? " " : "");
 	const modelDisplay = modelThinkingBadge(theme, r.model ?? r.progress?.model, r.thinking ?? r.progress?.thinking);
-	c.addChild(new Text(truncLine(`${resultGlyph(r, output, theme, isRunning, undefined, frame)} ${theme.fg("toolTitle", theme.bold(childDisplayName(r)))}${modelDisplay}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
+	c.addChild(new Text(truncLine(`${resultGlyph(r, output, theme, isRunning, undefined, frame)} ${theme.fg("toolTitle", theme.bold(foregroundSingleDisplayName(r)))}${modelDisplay}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
 
 	if (isRunning && r.progress) {
 		const task = compactTaskText(r.task);
@@ -2144,19 +2633,13 @@ function renderMultiCompact(d: Details, theme: Theme, layout: MainWindowRenderLa
 	const displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0;
 	const displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : (useResultsDirectly ? d.results.length : d.chainAgents!.length);
 	const chainEntries = buildChainRenderEntries(d, multiLabel);
-	const renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset): ChainRenderEntry => {
-		const i = displayStart + offset;
-		const r = d.results[i];
-		const fallbackLabel = itemTitle.toLowerCase();
-		const rowNumber = multiLabel.showActiveGroupOnly ? (i - multiLabel.groupStartIndex + 1) : (i + 1);
-		const fallbackAgent = useResultsDirectly ? (r?.agent || `${fallbackLabel}-${rowNumber}`) : (d.chainAgents![i] || r?.agent || `${fallbackLabel}-${rowNumber}`);
-		return { kind: "result", resultIndex: i, rowNumber, agentName: r?.sessionName?.trim() || fallbackAgent };
-	});
+	const renderEntries = chainEntries ?? buildForegroundResultEntries(d, multiLabel, displayStart, displayEnd, useResultsDirectly);
 	for (const entry of renderEntries) {
-		if (entry.kind === "placeholder") {
+		if (entry.kind === "group") {
 			const glyph = widgetStepGlyph(entry.status as AsyncJobStep["status"], theme);
 			const statusLabel = widgetStepStatus(entry.status as AsyncJobStep["status"], theme);
-			c.addChild(new Text(truncLine(`${rowIndent}${glyph} ${entry.stepLabel}: ${themeBold(theme, entry.agentName)} ${theme.fg("dim", "·")} ${statusLabel}`, width), 0, 0));
+			const groupLabel = entry.groupLabel ? ` (${compactTaskText(undefined, entry.groupLabel) ?? entry.groupLabel})` : "";
+			c.addChild(new Text(truncLine(`${rowIndent}${glyph} ${entry.stepLabel}${groupLabel} ${theme.fg("dim", "·")} ${statusLabel}`, width), 0, 0));
 			if (entry.error) c.addChild(new Text(truncLine(theme.fg("error", `${detailIndent}⎿  Error: ${entry.error}`), width), 0, 0));
 			continue;
 		}
@@ -2165,23 +2648,24 @@ function renderMultiCompact(d: Details, theme: Theme, layout: MainWindowRenderLa
 		const rowNumber = entry.rowNumber;
 		const agentName = entry.agentName;
 		if (!r) {
-			const pendingLabel = entry.rowLabel ?? `${itemTitle} ${rowNumber}`;
-			c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}◦ ${pendingLabel}: ${agentName} · pending`), width), 0, 0));
+			const pendingLabel = entry.rowLabel ?? (entry.isParallel ? "" : `${itemTitle} ${rowNumber}`);
+			const labelPrefix = pendingLabel ? `${pendingLabel}: ` : "";
+			c.addChild(new Text(truncLine(theme.fg("dim", `${rowIndent}◦ ${labelPrefix}${agentName} · pending`), width), 0, 0));
 			continue;
 		}
 		const output = getSingleResultOutput(r);
-		const progressFromArray = d.progress?.find((p) => p.index === i) || d.progress?.find((p) => p.agent === r.agent && p.status === "running");
+		const progressFromArray = foregroundProgressForResult(d, i);
 		const rProg = r.progress || progressFromArray || r.progressSummary;
 		const rRunning = rProg && "status" in rProg && isResultRunning(r, rProg.status);
 		const rPending = rProg && "status" in rProg && rProg.status === "pending";
-		const stepNumber = r.progress?.index !== undefined ? r.progress.index + 1 : progressFromArray?.index !== undefined ? progressFromArray.index + 1 : i + 1;
 		const stepStats = formatProgressStats(theme, rProg);
 		const glyph = rPending ? theme.fg("dim", "◦") : resultGlyph(r, output, theme, rRunning, progressRunningSeed(rProg), frame);
 		const pendingLabel = rPending ? ` ${theme.fg("dim", "· pending")}` : "";
-		const stepLabel = entry.rowLabel ?? resultRowLabel(multiLabel, i, stepNumber);
+		const stepLabel = entry.rowLabel;
 		const rowProgressModel = rProg && "status" in rProg ? rProg : undefined;
 		const rowModelDisplay = modelThinkingBadge(theme, r.model ?? rowProgressModel?.model, r.thinking ?? rowProgressModel?.thinking);
-		const line = `${glyph} ${stepLabel}: ${themeBold(theme, agentName)}${contextModeBadge(theme, r.context)}${rowModelDisplay}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${pendingLabel}`;
+		const labelPrefix = stepLabel ? `${stepLabel}: ` : "";
+		const line = `${glyph} ${labelPrefix}${themeBold(theme, agentName)}${contextModeBadge(theme, r.context)}${rowModelDisplay}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${pendingLabel}`;
 		c.addChild(new Text(truncLine(`${rowIndent}${line}`, width), 0, 0));
 		if (rRunning || rPending) {
 			const task = compactTaskText(r.task, workflowLabelForResult(d, i));
@@ -2242,7 +2726,7 @@ export function renderSubagentSummary(
 				? theme.fg("error", "✗")
 				: theme.fg("warning", "■");
 	const label = details?.mode === "single" && results.length === 1
-		? childDisplayName(results[0])
+		? foregroundSingleDisplayName(results[0])
 		: details?.mode || "subagent";
 	return new Text(
 		truncLine(`${glyph} ${theme.fg("toolTitle", theme.bold(label))} ${theme.fg("dim", "·")} ${theme.fg(state === "failed" ? "error" : state === "completed" ? "success" : state === "running" ? "accent" : "warning", state)}`, getTermWidth() - 4),
@@ -2315,7 +2799,7 @@ export function renderSubagentResult(
 		const fit = (text: string) => expanded ? text : truncLine(text, w);
 		const toolCallLines = getToolCallLines(r, expanded);
 		const c = new Container();
-		c.addChild(new Text(fit(`${presentation.glyph} ${theme.fg("toolTitle", theme.bold(childDisplayName(r)))}${contextBadge}${progressInfo} ${theme.fg("dim", "·")} ${presentation.label}`), 0, 0));
+		c.addChild(new Text(fit(`${presentation.glyph} ${theme.fg("toolTitle", theme.bold(foregroundSingleDisplayName(r)))}${contextBadge}${progressInfo} ${theme.fg("dim", "·")} ${presentation.label}`), 0, 0));
 		c.addChild(new Spacer(1));
 		const taskMaxLen = Math.max(20, w - 8);
 		const taskPreview = expanded || r.task.length <= taskMaxLen
@@ -2325,6 +2809,9 @@ export function renderSubagentResult(
 			new Text(fit(theme.fg("dim", `Task: ${taskPreview}`)), 0, 0),
 		);
 		c.addChild(new Spacer(1));
+		if (!isRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped)) {
+			c.addChild(new Text(fit(theme.fg(r.exitCode !== 0 ? "error" : "dim", `  ⎿  ${resultStatusLine(r, output)}`)), 0, 0));
+		}
 
 		if (isRunning && r.progress) {
 			const progressSnapshotNow = snapshotNowForProgress(r.progress);
@@ -2456,7 +2943,7 @@ export function renderSubagentResult(
 		? d.chainAgents
 				.map((agent, i) => {
 					const result = d.results[i];
-					const displayName = result?.sessionName?.trim() || agent;
+					const displayName = foregroundResultDisplayName(d, i, result, agent);
 					const isCurrent = i === (d.currentStepIndex ?? d.results.length);
 					const stepPresentation = result
 						? styledResultPresentation(resultPresentation(result, getSingleResultOutput(result), isCurrent && hasRunning && !hasTerminalResultFlag(result)), theme)
@@ -2487,20 +2974,15 @@ export function renderSubagentResult(
 	const displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0;
 	const displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : (useResultsDirectly ? d.results.length : d.chainAgents!.length);
 	const chainEntries = buildChainRenderEntries(d, multiLabel);
-	const renderEntries = chainEntries ?? Array.from({ length: displayEnd - displayStart }, (_, offset): ChainRenderEntry => {
-		const i = displayStart + offset;
-		const r = d.results[i];
-		const rowNumber = multiLabel.showActiveGroupOnly ? (i - multiLabel.groupStartIndex + 1) : (i + 1);
-		const fallbackAgent = useResultsDirectly ? (r?.agent || `step-${rowNumber}`) : (d.chainAgents![i] || r?.agent || `step-${rowNumber}`);
-		return { kind: "result", resultIndex: i, rowNumber, agentName: r?.sessionName?.trim() || fallbackAgent };
-	});
+	const renderEntries = chainEntries ?? buildForegroundResultEntries(d, multiLabel, displayStart, displayEnd, useResultsDirectly);
 
 	c.addChild(new Spacer(1));
 
 	for (const entry of renderEntries) {
-		if (entry.kind === "placeholder") {
+		if (entry.kind === "group") {
 			const statusLabel = widgetStepStatus(entry.status as AsyncJobStep["status"], theme);
-			c.addChild(new Text(fit(`  ${statusLabel} ${entry.stepLabel}: ${theme.bold(entry.agentName)}`), 0, 0));
+			const groupLabel = entry.groupLabel ? ` (${compactTaskText(undefined, entry.groupLabel) ?? entry.groupLabel})` : "";
+			c.addChild(new Text(fit(`  ${statusLabel} ${entry.stepLabel}${groupLabel}`), 0, 0));
 			c.addChild(new Text(theme.fg(entry.status === "failed" ? "error" : "dim", `    status: ${entry.status}`), 0, 0));
 			if (entry.error) c.addChild(new Text(theme.fg("error", `    error: ${entry.error}`), 0, 0));
 			c.addChild(new Spacer(1));
@@ -2512,28 +2994,28 @@ export function renderSubagentResult(
 		const agentName = entry.agentName;
 
 		if (!r) {
-			const pendingLabel = entry.rowLabel ?? `${itemTitle} ${rowNumber}`;
-			c.addChild(new Text(fit(theme.fg("dim", `  ${pendingLabel}: ${agentName}`)), 0, 0));
+			const pendingLabel = entry.rowLabel ?? (entry.isParallel ? "" : `${itemTitle} ${rowNumber}`);
+			const labelPrefix = pendingLabel ? `${pendingLabel}: ` : "";
+			c.addChild(new Text(fit(theme.fg("dim", `  ${labelPrefix}${agentName}`)), 0, 0));
 			c.addChild(new Text(theme.fg("dim", `    status: pending`), 0, 0));
 			c.addChild(new Spacer(1));
 			continue;
 		}
 
-		const progressFromArray = d.progress?.find((p) => p.index === i) 
-			|| d.progress?.find((p) => p.agent === r.agent && p.status === "running");
+		const progressFromArray = foregroundProgressForResult(d, i);
 		const rProg = r.progress || progressFromArray || r.progressSummary;
 		const rRunning = isResultRunning(r, rProg?.status);
-		const stepNumber = typeof rProg?.index === "number" ? rProg.index + 1 : i + 1;
 
 		const resultOutput = getSingleResultOutput(r);
 		const rowPresentation = styledResultPresentation(resultPresentation(r, resultOutput, rRunning, progressRunningSeed(rProg), frame), theme);
 		const stats = rProg ? ` | ${rProg.toolCount} tools, ${formatDuration(rProg.durationMs)}` : "";
 		const modelDisplay = modelThinkingBadge(theme, r.model ?? rProg?.model, r.thinking ?? rProg?.thinking);
-		const stepLabel = entry.rowLabel ?? resultRowLabel(multiLabel, i, stepNumber);
+		const stepLabel = entry.rowLabel;
 		const contextBadge = contextModeBadge(theme, r.context);
+		const labelPrefix = stepLabel ? `${stepLabel}: ` : "";
 		const stepHeader = rRunning
-			? `${rowPresentation.glyph} ${stepLabel}: ${theme.bold(theme.fg("warning", childDisplayName(r)))}${contextBadge}${modelDisplay}${stats} ${theme.fg("dim", "·")} ${rowPresentation.label}`
-			: `${rowPresentation.glyph} ${stepLabel}: ${theme.bold(childDisplayName(r))}${contextBadge}${modelDisplay}${stats} ${theme.fg("dim", "·")} ${rowPresentation.label}`;
+			? `${rowPresentation.glyph} ${labelPrefix}${theme.bold(theme.fg("warning", agentName))}${contextBadge}${modelDisplay}${stats} ${theme.fg("dim", "·")} ${rowPresentation.label}`
+			: `${rowPresentation.glyph} ${labelPrefix}${theme.bold(agentName)}${contextBadge}${modelDisplay}${stats} ${theme.fg("dim", "·")} ${rowPresentation.label}`;
 		const toolCallLines = getToolCallLines(r, expanded);
 		c.addChild(new Text(fit(stepHeader), 0, 0));
 
@@ -2547,6 +3029,9 @@ export function renderSubagentResult(
 		if (outputTarget) {
 			c.addChild(new Text(fit(theme.fg("dim", `    output: ${outputTarget}`)), 0, 0));
 		}
+		if (!rRunning && (r.exitCode !== 0 || r.interrupted || r.detached || r.stopped)) {
+			c.addChild(new Text(fit(theme.fg(r.exitCode !== 0 ? "error" : "dim", `    ⎿  ${resultStatusLine(r, resultOutput)}`)), 0, 0));
+		}
 
 		if (r.skills?.length) {
 			c.addChild(new Text(fit(theme.fg("dim", `    skills: ${r.skills.join(", ")}`)), 0, 0));