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

package/dist/builtin/subagents/src/slash/slash-commands.ts

@@ -1,9 +1,14 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { type ExtensionAPI, type ExtensionContext, keyHintIfBound } from "@bastani/atomic";
+import {
+	type ExtensionAPI,
+	type ExtensionContext,
+	isStaleExtensionContextError,
+	keyHintIfBound,
+} from "@bastani/atomic";
 import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { type ChainConfig, discoverAgents, discoverAgentsAll } from "../agents/agents.ts";
+import { discoverAgents } from "../agents/agents.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import {
 	type SingleResult,
@@ -15,7 +20,7 @@ import {
 	SLASH_SUBAGENT_UPDATE_EVENT,
 	type SubagentState,
 } from "../shared/types.ts";
-import { mapSavedChainSteps } from "./saved-chain-mapping.ts";
+import { registerBridgeRequestSettlement } from "./bridge-settlement.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { applySlashUpdate, buildSlashInitialResult, failSlashResult, finalizeSlashResult } from "./slash-live-state.ts";
 
@@ -121,21 +126,6 @@ const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (pre
 		.map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
 };
 
-const discoverSavedChains = (cwd: string): ChainConfig[] => {
-	const chainsByName = new Map<string, ChainConfig>();
-	for (const chain of discoverAgentsAll(cwd).chains) {
-		chainsByName.set(chain.name, chain);
-	}
-	return Array.from(chainsByName.values());
-};
-
-const makeChainCompletions = (state: SubagentState) => (prefix: string) => {
-	if (prefix.includes(" ") || !state.baseCwd) return null;
-	return discoverSavedChains(state.baseCwd)
-		.filter((chain) => chain.name.startsWith(prefix))
-		.map((chain) => ({ value: chain.name, label: chain.name }));
-};
-
 async function requestSlashRun(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
@@ -186,8 +176,12 @@ async function requestSlashRun(
 		const onTerminalInput = ctx.hasUI
 			? ctx.ui.onTerminalInput((input) => {
 					if (!matchesKey(input, Key.escape)) return undefined;
-					pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
-					finish(() => reject(new Error("Cancelled")));
+					try {
+						pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
+						finish(() => reject(new Error("Cancelled")));
+					} catch (error) {
+						finish(() => reject(error));
+					}
 					return { consume: true };
 				})
 			: undefined;
@@ -196,6 +190,8 @@ async function requestSlashRun(
 		const unsubResponse = pi.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, onResponse);
 		const unsubUpdate = pi.events.on(SLASH_SUBAGENT_UPDATE_EVENT, onUpdate);
 
+		let unregisterSettlement: (() => void) | undefined;
+		let reportedStop = false;
 		const finish = (next: () => void) => {
 			if (done) return;
 			done = true;
@@ -204,10 +200,29 @@ async function requestSlashRun(
 			unsubResponse();
 			unsubUpdate();
 			onTerminalInput?.();
+			unregisterSettlement?.();
 			next();
 		};
 
-		pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params });
+		unregisterSettlement = registerBridgeRequestSettlement("slash", requestId, {
+			reject: (error: unknown) => {
+				if (!reportedStop) {
+					reportedStop = true;
+					console.error(
+						isStaleExtensionContextError(error)
+							? "Subagent slash command stopped because its response runtime was replaced or reloaded."
+							: "Subagent slash command stopped before its response was delivered.",
+					);
+				}
+				finish(() => reject(error));
+			},
+		});
+		try {
+			pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params });
+		} catch (error) {
+			finish(() => reject(error));
+			return;
+		}
 
 		// Bridge emits STARTED synchronously during REQUEST emit.
 		// If not started, no bridge received the request.
@@ -297,6 +312,7 @@ async function runSlashSubagent(pi: ExtensionAPI, ctx: ExtensionContext, params:
 			ctx.ui.notify(response.errorText || "Subagent failed", "error");
 		}
 	} catch (error) {
+		if (isStaleExtensionContextError(error)) throw error;
 		const message = error instanceof Error ? error.message : String(error);
 		const failedDetails = failSlashResult(requestId, params, message, pi);
 		pi.sendMessage({
@@ -332,9 +348,7 @@ const parseAgentArgs = (
 	const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
 	let steps: ParsedStep[];
 	let sharedTask: string;
-	let perStep = false;
 	if (input.includes(" -> ")) {
-		perStep = true;
 		const segments = input.split(" -> ");
 		steps = [];
 		for (const seg of segments) {
@@ -391,10 +405,6 @@ const parseAgentArgs = (
 			return null;
 		}
 	}
-	if (command === "chain" && !steps[0]?.task && (perStep || !sharedTask)) {
-		ctx.ui.notify(`First step must have a task: /chain agent "task" -> agent2`, "error");
-		return null;
-	}
 	if (command === "parallel" && !steps.some((s) => s.task) && !sharedTask) {
 		ctx.ui.notify("At least one step must have a task", "error");
 		return null;
@@ -437,61 +447,6 @@ export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): v
 			await runSlashSubagent(pi, ctx, params);
 		},
 	});
-	pi.registerCommand("chain", {
-		description: 'Run agents in sequence: /chain scout "task" -> planner [--bg] [--fork]',
-		getArgumentCompletions: makeAgentCompletions(state, true),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const parsed = parseAgentArgs(state, cleanedArgs, "chain", ctx);
-			if (!parsed) return;
-			const chain = parsed.steps.map(({ name, config, task: stepTask }, i) => ({
-				agent: name,
-				...(stepTask ? { task: stepTask } : i === 0 && parsed.task ? { task: parsed.task } : {}),
-				...(config.output !== undefined ? { output: config.output } : {}),
-				...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
-				...(config.reads !== undefined ? { reads: config.reads } : {}),
-				...(config.model ? { model: config.model } : {}),
-				...(config.skill !== undefined ? { skill: config.skill } : {}),
-				...(config.progress !== undefined ? { progress: config.progress } : {}),
-			}));
-			const params: SubagentParamsLike = { chain, task: parsed.task, agentScope: "both" };
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
-		},
-	});
-	pi.registerCommand("run-chain", {
-		description: "Run a saved chain: /run-chain chainName -- task [--bg] [--fork]",
-		getArgumentCompletions: makeChainCompletions(state),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const delimiterIndex = cleanedArgs.indexOf(" -- ");
-			const usage = "Usage: /run-chain <chainName> -- <task> [--bg] [--fork]";
-			if (delimiterIndex === -1) {
-				ctx.ui.notify(usage, "error");
-				return;
-			}
-			const chainName = cleanedArgs.slice(0, delimiterIndex).trim();
-			const task = cleanedArgs.slice(delimiterIndex + 4).trim();
-			if (!chainName || !task) {
-				ctx.ui.notify(usage, "error");
-				return;
-			}
-			if (!state.baseCwd) {
-				ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-				return;
-			}
-			const chain = discoverSavedChains(state.baseCwd).find((candidate) => candidate.name === chainName);
-			if (!chain) {
-				ctx.ui.notify(`Unknown chain: ${chainName}`, "error");
-				return;
-			}
-			const params: SubagentParamsLike = { chain: mapSavedChainSteps(chain), task, agentScope: "both" };
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
-		},
-	});
 	pi.registerCommand("parallel", {
 		description: 'Run agents in parallel: /parallel scout "task1" -> reviewer "task2" [--bg] [--fork]',
 		getArgumentCompletions: makeAgentCompletions(state, true),

package/dist/builtin/subagents/src/slash/slash-live-state.ts

@@ -20,17 +20,6 @@ export interface SlashSnapshotStore {
 	versionCounter: number;
 }
 
-interface SequentialChainStepLike {
-	agent: string;
-	task?: string;
-}
-
-interface ParallelChainStepLike {
-	parallel: Array<{ agent: string; task?: string }>;
-}
-
-type ChainStepLike = SequentialChainStepLike | ParallelChainStepLike;
-
 const defaultStoreOwner = {};
 
 function getStoreRegistry(): WeakMap<object, SlashSnapshotStore> {
@@ -119,80 +108,6 @@ function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult
 	};
 }
 
-function isParallelChainStep(step: ChainStepLike): step is ParallelChainStepLike {
-	return "parallel" in step && Array.isArray(step.parallel);
-}
-
-function chainStepLabel(step: ChainStepLike): string {
-	if (isParallelChainStep(step)) {
-		return `[${step.parallel.map((entry) => entry.agent).join("+")}]`;
-	}
-	return step.agent;
-}
-
-function flattenChainResults(chain: ChainStepLike[], fallbackTask: string | undefined): SingleResult[] {
-	const results: SingleResult[] = [];
-	let flatIndex = 0;
-	for (const step of chain) {
-		if (isParallelChainStep(step)) {
-			for (const task of step.parallel) {
-				results.push(
-					createPlaceholderResult(
-						task.agent,
-						task.task ?? fallbackTask ?? "",
-						results.length === 0 ? "running" : "pending",
-						flatIndex,
-					),
-				);
-				flatIndex++;
-			}
-			continue;
-		}
-		results.push(
-			createPlaceholderResult(
-				step.agent,
-				step.task ?? fallbackTask ?? "",
-				results.length === 0 ? "running" : "pending",
-				flatIndex,
-			),
-		);
-		flatIndex++;
-	}
-	return results;
-}
-
-function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
-	const chain = (params.chain ?? []) as ChainStepLike[];
-	const results = flattenChainResults(chain, params.task);
-	return {
-		content: [
-			{
-				type: "text",
-				text: results.map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`).join("\n\n"),
-			},
-		],
-		details: {
-			mode: "chain",
-			...(params.context ? { context: params.context } : {}),
-			results,
-			progress: results.map((result, index) => ({
-				index,
-				agent: result.agent,
-				status: index === 0 ? ("running" as const) : ("pending" as const),
-				task: result.task,
-				recentTools: [],
-				recentOutput: [],
-				toolCount: 0,
-				tokens: 0,
-				durationMs: 0,
-			})),
-			chainAgents: chain.map((step) => chainStepLabel(step)),
-			totalSteps: chain.length,
-			currentStepIndex: 0,
-		},
-	};
-}
-
 function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
 	const agent = params.agent ?? "subagent";
 	const task = params.task ?? "";
@@ -226,11 +141,7 @@ export function buildSlashInitialResult(
 ): SlashMessageDetails {
 	const store = getSlashSnapshotStore(owner);
 	const result =
-		(params.tasks?.length ?? 0) > 0
-			? buildParallelInitialResult(params)
-			: (params.chain?.length ?? 0) > 0
-				? buildChainInitialResult(params)
-				: buildSingleInitialResult(params);
+		(params.tasks?.length ?? 0) > 0 ? buildParallelInitialResult(params) : buildSingleInitialResult(params);
 	store.liveSnapshots.set(requestId, { result, version: nextVersion(store) });
 	store.finalSnapshots.delete(requestId);
 	return { requestId, result };
@@ -252,12 +163,10 @@ export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate,
 	if (!snapshot) return;
 	const progress = update.progress;
 	if (!progress || !snapshot.result.details) return;
-	const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
 	const nextDetails: Details = {
 		...snapshot.result.details,
 		progress,
 		results: cloneResultsWithProgress(snapshot.result.details.results, progress),
-		...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0 ? { currentStepIndex } : {}),
 	};
 	store.liveSnapshots.set(requestId, {
 		result: {

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

@@ -17,17 +17,6 @@ import {
 	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}`;
@@ -37,7 +26,6 @@ export function formatWidgetAgents(agents: string[]): string {
 
 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";
@@ -115,29 +103,8 @@ export function widgetStats(job: AsyncJobState, theme: Theme): string {
 	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}`);
-		}
+		if (job.status === "running" && running > 0) parts.push(formatAgentRunningLabel(running));
+		if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
 	} else if (stepsTotal > 1) {
 		parts.push(`steps ${stepsTotal}`);
 	}

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);