@bastani/atomic 0.9.13-alpha.1 → 0.9.13-alpha.3

package/dist/builtin/subagents/src/tui/render-event-formatting.ts

@@ -1,290 +1,7 @@
-import { formatNestedAggregate } from "../runs/inprocess/runtime-support/nested-rendering.ts";
-import { formatDuration, formatModelThinking, shortenPath } from "../shared/formatters.ts";
-import { formatAgentRunningLabel } from "../shared/status-format.ts";
-import {
-	type AsyncJobState,
-	type AsyncJobStep,
-	MAX_SUBAGENT_NESTING_DEPTH,
-	type NestedRunSummary,
-	type NestedStepSummary,
-} from "../shared/types.ts";
-import { runningGlyph, runningPulseGlyph, type Theme, truncLine } from "./render-layout.ts";
-import {
-	buildLiveStatusLine,
-	formatCurrentToolLine,
-	formatTokenStat,
-	formatToolUseStat,
-	statJoin,
-} from "./render-status-progress.ts";
-
-function flatToLogicalStepIndex(
-	currentStep: number,
-	_total: number,
-	groups: Array<{ start: number; count: number; stepIndex?: number }>,
-): number {
-	return (
-		groups.find((group) => currentStep >= group.start && currentStep < group.start + group.count)?.stepIndex ??
-		currentStep
-	);
-}
-
-export function formatWidgetAgents(agents: string[]): string {
-	const distinct = [...new Set(agents)];
-	if (distinct.length === 1 && agents.length > 1) return `${distinct[0]} ×${agents.length}`;
-	if (agents.length > 3) return `${agents.slice(0, 2).join(", ")} +${agents.length - 2} more`;
-	return agents.join(", ");
-}
-
-export function widgetJobName(job: AsyncJobState): string {
-	if (job.mode === "parallel") return "parallel";
-	if (job.mode === "chain") return "chain";
-	if (job.mode === "single" && job.agents?.length === 1) return job.agents[0]!;
-	if (job.agents?.length) return formatWidgetAgents(job.agents);
-	return job.mode ?? "subagent";
-}
-
-export 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))}`);
-	else if (job.currentTool) facts.push(job.currentTool);
-	if (job.currentPath) facts.push(shortenPath(job.currentPath));
-	if (job.turnCount !== undefined) facts.push(`${job.turnCount} turns`);
-	if (job.toolCount !== undefined) facts.push(`${job.toolCount} tools`);
-	const activity = buildLiveStatusLine(job, job.updatedAt);
-	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
-	if (activity) return activity;
-	if (facts.length) return facts.join(" · ");
-	if (job.status === "running") return "thinking…";
-	if (job.status === "queued") return "queued…";
-	if (job.status === "paused") return "Paused";
-	if (job.status === "failed") return "Failed";
-	return "Done";
-}
-
-export function widgetStatusGlyph(job: AsyncJobState, theme: Theme, pulseFrame?: number): string {
-	if (job.status === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
-	if (job.status === "queued") return theme.fg("muted", "◦");
-	if (job.status === "complete") return theme.fg("success", "✓");
-	if (job.status === "paused") return theme.fg("warning", "■");
-	return theme.fg("error", "✗");
-}
-
-export function widgetStepGlyph(status: AsyncJobStep["status"], theme: Theme, seed?: number, now?: number): string {
-	if (status === "running") return theme.fg("accent", runningGlyph(seed, now));
-	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
-	if (status === "failed") return theme.fg("error", "✗");
-	if (status === "paused") return theme.fg("warning", "■");
-	return theme.fg("muted", "◦");
-}
-
-export function widgetStepPulseGlyph(status: AsyncJobStep["status"], theme: Theme, pulseFrame?: number): string {
-	if (status === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
-	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
-	if (status === "failed") return theme.fg("error", "✗");
-	if (status === "paused") return theme.fg("warning", "■");
-	return theme.fg("muted", "◦");
-}
-
-export function widgetStepStatus(status: AsyncJobStep["status"], theme: Theme): string {
-	if (status === "running") return theme.fg("accent", "running");
-	if (status === "complete" || status === "completed") return theme.fg("success", "complete");
-	if (status === "failed") return theme.fg("error", "failed");
-	if (status === "paused") return theme.fg("warning", "paused");
-	return theme.fg("dim", status);
-}
-
-export function widgetStepActivity(step: NonNullable<AsyncJobState["steps"]>[number], snapshotNow?: number): string {
-	const facts: string[] = [];
-	if (step.currentTool && step.currentToolStartedAt !== undefined && snapshotNow !== undefined)
-		facts.push(`${step.currentTool} ${formatDuration(Math.max(0, snapshotNow - step.currentToolStartedAt))}`);
-	else if (step.currentTool) facts.push(step.currentTool);
-	if (step.currentPath) facts.push(shortenPath(step.currentPath));
-	if (step.turnCount !== undefined) facts.push(`${step.turnCount} turns`);
-	if (step.toolCount !== undefined) facts.push(`${step.toolCount} tools`);
-	if (step.tokens?.total) facts.push(formatTokenStat(step.tokens.total));
-	const activity = buildLiveStatusLine(step, snapshotNow);
-	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
-	if (activity) return activity;
-	return facts.join(" · ");
-}
-
-export function widgetStats(job: AsyncJobState, theme: Theme): string {
-	const parts: string[] = [];
-	const stepsTotal = job.stepsTotal ?? job.agents?.length ?? 1;
-	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") {
-			if (job.status === "running" && running > 0) parts.push(formatAgentRunningLabel(running));
-			if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
-		} else {
-			const activeGroup =
-				job.currentStep !== undefined
-					? job.parallelGroups?.find(
-							(group) => job.currentStep! >= group.start && job.currentStep! < group.start + group.count,
-						)
-					: job.parallelGroups?.find((group) => group.start === 0);
-			const logicalStep = activeGroup?.stepIndex ?? job.currentStep ?? 0;
-			const total = job.chainStepCount ?? stepsTotal;
-			const groupParts = [`${done}/${stepsTotal} done`];
-			if (job.status === "running" && running > 0) groupParts.unshift(formatAgentRunningLabel(running));
-			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupParts.join(" · ")}`);
-		}
-	} else if (job.currentStep !== undefined) {
-		if (job.mode === "chain" && job.parallelGroups?.length) {
-			const total = job.chainStepCount ?? stepsTotal;
-			parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups) + 1}/${total}`);
-		} else {
-			parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
-		}
-	} else if (stepsTotal > 1) {
-		parts.push(`steps ${stepsTotal}`);
-	}
-	if (job.toolCount !== undefined) parts.push(formatToolUseStat(job.toolCount));
-	if (job.totalTokens?.total) parts.push(formatTokenStat(job.totalTokens.total));
-	if (job.startedAt !== undefined && job.updatedAt !== undefined)
-		parts.push(formatDuration(Math.max(0, job.updatedAt - job.startedAt)));
-	return statJoin(theme, parts);
-}
-
-export function widgetStepStats(theme: Theme, step: NonNullable<AsyncJobState["steps"]>[number]): string {
-	return statJoin(theme, [
-		step.turnCount !== undefined ? `${step.turnCount} turns` : "",
-		step.toolCount !== undefined ? formatToolUseStat(step.toolCount) : "",
-		step.tokens?.total ? formatTokenStat(step.tokens.total) : "",
-		step.durationMs !== undefined ? formatDuration(step.durationMs) : "",
-	]);
-}
+import { formatModelThinking } from "../shared/formatters.ts";
+import type { Theme } from "./render-layout.ts";
 
 export function modelThinkingBadge(theme: Theme, model?: string, thinking?: string, fastMode?: boolean): string {
 	const label = formatModelThinking(model, thinking, fastMode);
 	return label ? theme.fg("dim", ` (${label})`) : "";
 }
-
-export function widgetStepActivityLine(
-	step: NonNullable<AsyncJobState["steps"]>[number],
-	width: number,
-	expanded: boolean,
-	snapshotNow?: number,
-): string {
-	const toolLine = formatCurrentToolLine(step, width, expanded, snapshotNow);
-	if (toolLine) return toolLine;
-	const activity = buildLiveStatusLine(step, snapshotNow);
-	if (activity) return activity;
-	if (step.status === "running") return "thinking…";
-	return "";
-}
-
-export function nestedRunName(run: NestedRunSummary): string {
-	if (run.agent) return run.agent;
-	if (run.agents?.length) return formatWidgetAgents(run.agents);
-	return run.id;
-}
-
-export function nestedStatusGlyph(
-	state: NestedRunSummary["state"] | NestedStepSummary["status"],
-	theme: Theme,
-	pulseFrame?: number,
-): string {
-	if (state === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
-	if (state === "complete" || state === "completed") return theme.fg("success", "✓");
-	if (state === "failed") return theme.fg("error", "✗");
-	if (state === "paused") return theme.fg("warning", "■");
-	return theme.fg("muted", "◦");
-}
-
-export function nestedActivity(
-	input: Pick<
-		NestedRunSummary | NestedStepSummary,
-		| "activityState"
-		| "lastActivityAt"
-		| "currentTool"
-		| "currentToolStartedAt"
-		| "currentPath"
-		| "turnCount"
-		| "toolCount"
-	>,
-	state: NestedRunSummary["state"] | NestedStepSummary["status"],
-	snapshotNow?: number,
-): string {
-	const facts: string[] = [];
-	if (input.currentTool && input.currentToolStartedAt !== undefined && snapshotNow !== undefined)
-		facts.push(`${input.currentTool} ${formatDuration(Math.max(0, snapshotNow - input.currentToolStartedAt))}`);
-	else if (input.currentTool) facts.push(input.currentTool);
-	if (input.currentPath) facts.push(shortenPath(input.currentPath));
-	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
-	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
-	const activity = buildLiveStatusLine(input, snapshotNow);
-	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
-	if (activity) return activity;
-	if (facts.length) return facts.join(" · ");
-	if (state === "running") return "thinking…";
-	if (state === "queued" || state === "pending") return "queued…";
-	if (state === "paused") return "Paused";
-	if (state === "failed") return "Failed";
-	return "Done";
-}
-
-export function formatNestedWidgetLines(
-	children: NestedRunSummary[] | undefined,
-	theme: Theme,
-	width: number,
-	expanded: boolean,
-	snapshotNow?: number,
-	lineBudget = expanded ? 12 : 1,
-	now?: number,
-): string[] {
-	if (!children?.length || lineBudget <= 0) return [];
-	if (!expanded) {
-		const aggregate = formatNestedAggregate(children);
-		return aggregate ? [theme.fg("dim", `↳ ${aggregate}`)] : [];
-	}
-	const lines: string[] = [];
-	const maxDepth = MAX_SUBAGENT_NESTING_DEPTH;
-	const append = (items: NestedRunSummary[] | undefined, depth: number, prefix: string): void => {
-		if (!items?.length || lines.length >= lineBudget) return;
-		if (depth > maxDepth) {
-			const aggregate = formatNestedAggregate(items);
-			if (aggregate && lines.length < lineBudget) lines.push(theme.fg("dim", `${prefix}↳ ${aggregate}`));
-			return;
-		}
-		for (let index = 0; index < items.length; index++) {
-			const child = items[index]!;
-			if (lines.length >= lineBudget) {
-				const aggregate = formatNestedAggregate(items.slice(index));
-				if (aggregate) lines[lines.length - 1] = theme.fg("dim", `${prefix}↳ ${aggregate}`);
-				return;
-			}
-			const activity = nestedActivity(child, child.state, snapshotNow ?? child.lastUpdate);
-			const error = child.error ? ` · ${child.error}` : "";
-			lines.push(
-				theme.fg(
-					"dim",
-					`${prefix}↳ ${nestedStatusGlyph(child.state, theme, now)} ${nestedRunName(child)} · ${child.state} · ${activity}${error}`,
-				),
-			);
-			if (depth === maxDepth) {
-				const aggregate = formatNestedAggregate([
-					...(child.steps?.flatMap((step) => step.children ?? []) ?? []),
-					...(child.children ?? []),
-				]);
-				if (aggregate && lines.length < lineBudget) lines.push(theme.fg("dim", `${prefix}  ↳ ${aggregate}`));
-				continue;
-			}
-			for (const step of child.steps ?? []) {
-				if (lines.length >= lineBudget) return;
-				lines.push(
-					theme.fg(
-						"dim",
-						`${prefix}  ↳ ${nestedStatusGlyph(step.status, theme, now)} ${step.agent} · ${step.status} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`,
-					),
-				);
-				append(step.children, depth + 1, `${prefix}    `);
-			}
-			append(child.children, depth + 1, `${prefix}  `);
-		}
-	};
-	append(children, 0, "");
-	return lines.map((line) => truncLine(line, width));
-}

package/dist/builtin/subagents/src/tui/render-layout.ts

@@ -76,7 +76,7 @@ export const RUNNING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦",
  * the clock. This fixes the frozen/stuttering spinner from issue #1084.
  *
  * IMPORTANT: a wall-clock spinner only stays flicker-free for widgets pinned to
- * the bottom of the buffer (e.g. the below-editor async widget), where every
+ * the bottom of the buffer (e.g. a below-editor widget), where every
  * tick stays inside the viewport. Content rendered into chat scrollback (live
  * foreground subagent results) can scroll above the viewport fold; there, even
  * a single-cell spinner diff forces pi-tui into a destructive full-screen +
@@ -135,9 +135,9 @@ export function pulseGlyph(frame?: number): string {
 }
 
 /**
- * Running async/background subagent pulse. It reuses the exact foreground pulse
- * glyph frames while accepting an explicit frame advanced by the widget only on
- * real async progress/status updates, matching foreground result semantics.
+ * Running subagent pulse. It reuses the exact foreground pulse glyph frames
+ * while accepting an explicit frame advanced by the renderer on real progress
+ * updates, matching foreground result semantics.
  */
 export function runningPulseGlyph(frame?: number): string {
 	return pulseGlyph(frame);

package/dist/builtin/subagents/src/tui/render-progress.ts

@@ -0,0 +1,89 @@
+import { formatAgentRunningLabel } from "../shared/status-format.ts";
+import type { Details } from "../shared/types.ts";
+
+export function isDoneResult(result: Details["results"][number]): boolean {
+	const status = result.progress?.status;
+	if (status === "completed") return true;
+	if (status === "running" || status === "pending") return false;
+	if (result.interrupted || result.detached || result.status !== "ok") return false;
+	return true;
+}
+
+export interface MultiProgressLabel {
+	headerLabel: string;
+	itemTitle: "Step" | "Agent";
+	totalCount: number;
+	groupStartIndex: number;
+	groupEndIndex: number;
+	showActiveGroupOnly: boolean;
+}
+
+export function buildMultiProgressLabel(
+	details: Pick<Details, "mode" | "results" | "progress" | "totalSteps">,
+	hasRunning: boolean,
+): MultiProgressLabel {
+	const itemTitle: "Step" | "Agent" = details.mode === "parallel" ? "Agent" : "Step";
+	const totalCount = details.totalSteps ?? details.results.length;
+
+	if (details.mode === "parallel") {
+		const statuses = new Array(totalCount).fill("pending") as Array<
+			"pending" | "running" | "completed" | "failed" | "paused" | "detached"
+		>;
+		for (const progress of details.progress ?? []) {
+			if (progress.index >= 0 && progress.index < totalCount) statuses[progress.index] = progress.status;
+		}
+		for (let i = 0; i < details.results.length; i++) {
+			const result = details.results[i]!;
+			const progressFromArray =
+				details.progress?.find((progress) => progress.index === i) ||
+				details.progress?.find((progress) => progress.agent === result.agent && progress.status === "running");
+			const index = result.progress?.index ?? progressFromArray?.index ?? i;
+			if (index < 0 || index >= totalCount) continue;
+			const status =
+				result.progress?.status ??
+				(result.interrupted || result.status === "interrupted"
+					? "paused"
+					: result.detached || result.status === "continued"
+						? "detached"
+						: result.status === "ok"
+							? "completed"
+							: "failed");
+			statuses[index] = status;
+		}
+		const running = statuses.filter((status) => status === "running").length;
+		const done = statuses.filter((status) => status === "completed").length;
+		const headerLabel = hasRunning
+			? `${formatAgentRunningLabel(running)} · ${done}/${totalCount} done`
+			: `${done}/${totalCount} done`;
+		return {
+			headerLabel,
+			itemTitle,
+			totalCount,
+			groupStartIndex: 0,
+			groupEndIndex: totalCount,
+			showActiveGroupOnly: false,
+		};
+	}
+
+	const done = details.results.filter(isDoneResult).length;
+	const currentStep = Math.min(totalCount, done + (hasRunning ? 1 : 0));
+	const headerLabel = hasRunning ? `step ${currentStep}/${totalCount}` : `step ${done}/${totalCount}`;
+	return {
+		headerLabel,
+		itemTitle,
+		totalCount,
+		groupStartIndex: 0,
+		groupEndIndex: details.results.length,
+		showActiveGroupOnly: false,
+	};
+}
+
+export function resultRowLabel(
+	details: Pick<Details, "mode">,
+	label: MultiProgressLabel,
+	_resultIndex: number,
+	stepNumber: number,
+): string {
+	if (label.itemTitle === "Agent") return `Agent ${stepNumber}/${label.totalCount}`;
+	return details.mode === "parallel" ? `Agent ${stepNumber}` : `Step ${stepNumber}`;
+}

package/dist/builtin/subagents/src/tui/render-result-compact.ts

@@ -1,17 +1,11 @@
 import { keyHintIfBound } from "@bastani/atomic";
 import { type Component, Container, Text } from "@earendil-works/pi-tui";
 import { shortenPath } from "../shared/formatters.ts";
-import type { AgentProgress, AsyncJobStep, Details } from "../shared/types.ts";
+import type { AgentProgress, Details } from "../shared/types.ts";
 import { getSingleResultOutput } from "../shared/utils.ts";
-import {
-	buildChainRenderEntries,
-	buildMultiProgressLabel,
-	type ChainRenderEntry,
-	resultRowLabel,
-	workflowGraphHasStatus,
-} from "./render-chain-graph.ts";
-import { modelThinkingBadge, widgetStepGlyph, widgetStepStatus } from "./render-event-formatting.ts";
+import { modelThinkingBadge } from "./render-event-formatting.ts";
 import { getTermWidth, pulseGlyph, type Theme, truncLine } from "./render-layout.ts";
+import { buildMultiProgressLabel, resultRowLabel } from "./render-progress.ts";
 import {
 	buildLiveStatusLine,
 	compactCurrentActivity,
@@ -43,7 +37,7 @@ export function renderSingleCompact(
 	]);
 	const c = new Container();
 	const width = getTermWidth() - 4;
-	const modelDisplay = modelThinkingBadge(theme, r.model, undefined, r.fastMode);
+	const modelDisplay = modelThinkingBadge(theme, r.model, r.thinking, r.fastMode);
 	c.addChild(
 		new Text(
 			truncLine(
@@ -91,22 +85,17 @@ export function renderSingleCompact(
 
 export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulseFrame?: number): Component {
 	const hasRunning =
-		d.progress?.some((p) => p.status === "running") ||
-		d.results.some((r) => r.progress?.status === "running") ||
-		workflowGraphHasStatus(d, ["running"]);
-	const failed =
-		d.results.some((r) => r.status === "error" && r.progress?.status !== "running") ||
-		workflowGraphHasStatus(d, ["failed"]);
-	const paused =
-		d.results.some(
-			(r) =>
-				(r.interrupted ||
-					r.detached ||
-					r.status === "interrupted" ||
-					r.status === "continued" ||
-					r.status === "skipped") &&
-				r.progress?.status !== "running",
-		) || workflowGraphHasStatus(d, ["paused", "detached"]);
+		d.progress?.some((p) => p.status === "running") || d.results.some((r) => r.progress?.status === "running");
+	const failed = d.results.some((r) => r.status === "error" && r.progress?.status !== "running");
+	const paused = d.results.some(
+		(r) =>
+			(r.interrupted ||
+				r.detached ||
+				r.status === "interrupted" ||
+				r.status === "continued" ||
+				r.status === "skipped") &&
+			r.progress?.status !== "running",
+	);
 	let totalSummary = d.progressSummary;
 	if (!totalSummary) {
 		let sawProgress = false;
@@ -117,8 +106,7 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulse
 			sawProgress = true;
 			summary.toolCount += prog.toolCount;
 			summary.tokens += prog.tokens;
-			summary.durationMs =
-				d.mode === "chain" ? summary.durationMs + prog.durationMs : Math.max(summary.durationMs, prog.durationMs);
+			summary.durationMs = Math.max(summary.durationMs, prog.durationMs);
 		}
 		if (sawProgress) totalSummary = summary;
 	}
@@ -146,52 +134,24 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulse
 		),
 	);
 
-	const useResultsDirectly = multiLabel.hasParallelInChain || !d.chainAgents?.length;
 	const progressSpan = d.progress?.length ? Math.max(...d.progress.map((p) => p.index + 1)) : 0;
 	const resultsSpan = Math.max(d.results.length, progressSpan, d.mode === "parallel" ? (d.totalSteps ?? 0) : 0);
 	const displayStart = multiLabel.showActiveGroupOnly ? multiLabel.groupStartIndex : 0;
-	const displayEnd = multiLabel.showActiveGroupOnly
-		? multiLabel.groupEndIndex
-		: useResultsDirectly
-			? resultsSpan
-			: 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 progressAgent = d.progress?.find((p) => p.index === i)?.agent;
-			const fallbackLabel = itemTitle.toLowerCase();
-			const rowNumber = multiLabel.showActiveGroupOnly ? i - multiLabel.groupStartIndex + 1 : i + 1;
-			return {
-				kind: "result",
-				resultIndex: i,
-				rowNumber,
-				agentName: useResultsDirectly
-					? r?.agent || progressAgent || `${fallbackLabel}-${rowNumber}`
-					: d.chainAgents![i] || r?.agent || progressAgent || `${fallbackLabel}-${rowNumber}`,
-			};
-		});
+	const displayEnd = multiLabel.showActiveGroupOnly ? multiLabel.groupEndIndex : resultsSpan;
+	const renderEntries = Array.from({ length: displayEnd - displayStart }, (_, offset) => {
+		const i = displayStart + offset;
+		const r = d.results[i];
+		const progressAgent = d.progress?.find((p) => p.index === i)?.agent;
+		const fallbackLabel = itemTitle.toLowerCase();
+		const rowNumber = multiLabel.showActiveGroupOnly ? i - multiLabel.groupStartIndex + 1 : i + 1;
+		return {
+			resultIndex: i,
+			rowNumber,
+			agentName: r?.agent || progressAgent || `${fallbackLabel}-${rowNumber}`,
+		};
+	});
 	let liveDetailHintShown = false;
 	for (const entry of renderEntries) {
-		if (entry.kind === "placeholder") {
-			const glyph = widgetStepGlyph(entry.status as AsyncJobStep["status"], theme);
-			const statusLabel = widgetStepStatus(entry.status as AsyncJobStep["status"], theme);
-			c.addChild(
-				new Text(
-					truncLine(
-						`  ${glyph} ${entry.stepLabel}: ${themeBold(theme, entry.agentName)} ${theme.fg("dim", "·")} ${statusLabel}`,
-						width,
-					),
-					0,
-					0,
-				),
-			);
-			if (entry.error)
-				c.addChild(new Text(truncLine(theme.fg("error", `    ⎿  Error: ${entry.error}`), width), 0, 0));
-			continue;
-		}
 		const i = entry.resultIndex;
 		const r = d.results[i];
 		const rowNumber = entry.rowNumber;
@@ -203,7 +163,13 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulse
 				| undefined;
 			if (runningProg) {
 				const runningStats = formatProgressStats(theme, runningProg, true, now);
-				const runningLine = `${theme.fg("accent", pulseGlyph(pulseFrame))} ${rowLabel}: ${themeBold(theme, agentName)}${runningStats ? ` ${theme.fg("dim", "·")} ${runningStats}` : ""}`;
+				const runningBadge = modelThinkingBadge(
+					theme,
+					runningProg.model,
+					runningProg.thinking,
+					runningProg.fastMode,
+				);
+				const runningLine = `${theme.fg("accent", pulseGlyph(pulseFrame))} ${rowLabel}: ${themeBold(theme, agentName)}${runningBadge}${runningStats ? ` ${theme.fg("dim", "·")} ${runningStats}` : ""}`;
 				c.addChild(new Text(truncLine(`  ${runningLine}`, width), 0, 0));
 				const activity = compactCurrentActivity(runningProg, now);
 				c.addChild(new Text(truncLine(theme.fg("dim", `    ⎿  ${activity}`), width), 0, 0));
@@ -231,10 +197,16 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulse
 					? progressFromArray.index + 1
 					: i + 1;
 		const stepStats = formatProgressStats(theme, rProg, true, now);
+		const modelDisplay = modelThinkingBadge(
+			theme,
+			r.model ?? rProg?.model,
+			r.thinking ?? rProg?.thinking,
+			r.fastMode ?? rProg?.fastMode,
+		);
 		const glyph = rPending ? theme.fg("dim", "◦") : resultGlyph(r, output, theme, rRunning, pulseFrame);
 		const pendingLabel = rPending ? ` ${theme.fg("dim", "· pending")}` : "";
 		const stepLabel = resultRowLabel(d, multiLabel, i, stepNumber);
-		const line = `${glyph} ${stepLabel}: ${themeBold(theme, agentName)}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${pendingLabel}`;
+		const line = `${glyph} ${stepLabel}: ${themeBold(theme, agentName)}${modelDisplay}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${pendingLabel}`;
 		c.addChild(new Text(truncLine(`  ${line}`, width), 0, 0));
 		if (rRunning && rProg && "status" in rProg) {
 			const activity = compactCurrentActivity(rProg, now);