pi-subagents 0.21.4 → 0.22.0

package/src/shared/model-info.ts

@@ -0,0 +1,68 @@
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
+export type ThinkingLevel = typeof THINKING_LEVELS[number];
+export type ThinkingLevelMap = Partial<Record<ThinkingLevel, string | null>>;
+
+export interface ModelInfo {
+	provider: string;
+	id: string;
+	fullId: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: ThinkingLevelMap;
+}
+
+interface RegistryModelLike {
+	provider: string;
+	id: string;
+	reasoning?: boolean;
+	thinkingLevelMap?: ThinkingLevelMap;
+}
+
+export function toModelInfo(model: RegistryModelLike): ModelInfo {
+	return {
+		provider: model.provider,
+		id: model.id,
+		fullId: `${model.provider}/${model.id}`,
+		reasoning: model.reasoning,
+		thinkingLevelMap: model.thinkingLevelMap,
+	};
+}
+
+export function splitKnownThinkingSuffix(model: string): { baseModel: string; thinkingSuffix: string } {
+	const colonIdx = model.lastIndexOf(":");
+	if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
+	const suffix = THINKING_LEVELS.find((level) => level === model.substring(colonIdx + 1));
+	if (!suffix) return { baseModel: model, thinkingSuffix: "" };
+	return {
+		baseModel: model.substring(0, colonIdx),
+		thinkingSuffix: `:${suffix}`,
+	};
+}
+
+export function findModelInfo(model: string | undefined, availableModels: ModelInfo[] | undefined, preferredProvider?: string): ModelInfo | undefined {
+	if (!model || !availableModels || availableModels.length === 0) return undefined;
+	const { baseModel } = splitKnownThinkingSuffix(model);
+	const exact = availableModels.find((entry) => entry.fullId === baseModel);
+	if (exact) return exact;
+
+	const matches = availableModels.filter((entry) => entry.id === baseModel);
+	if (preferredProvider) {
+		const preferred = matches.find((entry) => entry.provider === preferredProvider);
+		if (preferred) return preferred;
+	}
+	return matches.length === 1 ? matches[0] : undefined;
+}
+
+export function getSupportedThinkingLevels(model: ModelInfo | undefined): ThinkingLevel[] {
+	if (!model) return [...THINKING_LEVELS];
+	if (model.reasoning === false) return ["off"];
+
+	if (!model.thinkingLevelMap) return [...THINKING_LEVELS];
+
+	const levels = THINKING_LEVELS.filter((level) => {
+		const mapped = model.thinkingLevelMap?.[level];
+		if (mapped === null) return false;
+		if (level === "xhigh") return mapped !== undefined;
+		return true;
+	});
+	return levels;
+}

package/src/shared/session-identity.ts

@@ -0,0 +1,10 @@
+interface SessionIdentityManager {
+	getSessionFile(): string | null | undefined;
+	getSessionId(): string | null | undefined;
+}
+
+export function resolveCurrentSessionId(sessionManager: SessionIdentityManager): string {
+	const sessionId = sessionManager.getSessionFile() ?? sessionManager.getSessionId();
+	if (!sessionId) throw new Error("Current session identity is unavailable.");
+	return sessionId;
+}

package/src/shared/types.ts

@@ -96,6 +96,7 @@ export interface ControlEvent {
 }
 
 export type SubagentResultStatus = "completed" | "failed" | "paused" | "detached";
+export type SubagentRunMode = "single" | "parallel" | "chain";
 
 export interface SubagentResultIntercomChild {
 	agent: string;
@@ -112,7 +113,7 @@ export interface SubagentResultIntercomPayload {
 	message: string;
 	requestId?: string;
 	runId: string;
-	mode: "single" | "parallel" | "chain";
+	mode: SubagentRunMode;
 	status: SubagentResultStatus;
 	summary: string;
 	source: "foreground" | "async";
@@ -205,7 +206,7 @@ export interface SingleResult {
 }
 
 export interface Details {
-	mode: "single" | "parallel" | "chain" | "management";
+	mode: SubagentRunMode | "management";
 	context?: "fresh" | "fork";
 	results: SingleResult[];
 	controlEvents?: ControlEvent[];
@@ -263,6 +264,8 @@ export interface AsyncStartedEvent {
 	id?: string;
 	asyncDir?: string;
 	pid?: number;
+	sessionId?: string;
+	mode?: SubagentRunMode;
 	agent?: string;
 	agents?: string[];
 	chain?: string[];
@@ -272,7 +275,8 @@ export interface AsyncStartedEvent {
 
 export interface AsyncStatus {
 	runId: string;
-	mode: "single" | "chain";
+	sessionId?: string;
+	mode: SubagentRunMode;
 	state: "queued" | "running" | "complete" | "failed" | "paused";
 	activityState?: ActivityState;
 	lastActivityAt?: number;
@@ -321,6 +325,7 @@ export interface AsyncJobState {
 	asyncDir: string;
 	status: "queued" | "running" | "complete" | "failed" | "paused";
 	pid?: number;
+	sessionId?: string;
 	activityState?: ActivityState;
 	lastActivityAt?: number;
 	currentTool?: string;
@@ -328,9 +333,12 @@ export interface AsyncJobState {
 	currentPath?: string;
 	turnCount?: number;
 	toolCount?: number;
-	mode?: "single" | "chain";
+	mode?: SubagentRunMode;
 	agents?: string[];
 	currentStep?: number;
+	chainStepCount?: number;
+	parallelGroups?: AsyncParallelGroupStatus[];
+	steps?: AsyncStatus["steps"];
 	stepsTotal?: number;
 	runningSteps?: number;
 	completedSteps?: number;
@@ -351,7 +359,7 @@ export interface SubagentState {
 	asyncJobs: Map<string, AsyncJobState>;
 	foregroundControls: Map<string, {
 		runId: string;
-		mode: "single" | "parallel" | "chain";
+		mode: SubagentRunMode;
 		startedAt: number;
 		updatedAt: number;
 		currentAgent?: string;
@@ -427,6 +435,7 @@ export interface RunSyncOptions {
 	onControlEvent?: (event: ControlEvent) => void;
 	controlConfig?: ResolvedControlConfig;
 	intercomSessionName?: string;
+	orchestratorIntercomTarget?: string;
 	maxOutput?: MaxOutputConfig;
 	artifactsDir?: string;
 	artifactConfig?: ArtifactConfig;

package/src/slash/slash-commands.ts

@@ -8,8 +8,10 @@ import { AgentManagerComponent, type ManagerResult } from "../manager-ui/agent-m
 import { SubagentsStatusComponent } from "../tui/subagents-status.ts";
 import { discoverAvailableSkills } from "../agents/skills.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import { resolveCurrentSessionId } from "../shared/session-identity.ts";
 import { isParallelStep, type ChainStep } from "../shared/settings.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
+import { toModelInfo } from "../shared/model-info.ts";
 import {
 	applySlashUpdate,
 	buildSlashInitialResult,
@@ -331,15 +333,11 @@ async function openAgentManager(
 	config: ExtensionConfig = {},
 ): Promise<void> {
 	const agentData = { ...discoverAgentsAll(ctx.cwd), cwd: ctx.cwd };
-	const models = ctx.modelRegistry.getAvailable().map((m) => ({
-		provider: m.provider,
-		id: m.id,
-		fullId: `${m.provider}/${m.id}`,
-	}));
+	const models = ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const skills = discoverAvailableSkills(ctx.cwd);
 
 	const result = await ctx.ui.custom<ManagerResult>(
-		(tui, theme, _kb, done) => new AgentManagerComponent(tui, theme, agentData, models, skills, done, { newShortcut: config.agentManager?.newShortcut }),
+		(tui, theme, _kb, done) => new AgentManagerComponent(tui, theme, agentData, models, skills, done, { newShortcut: config.agentManager?.newShortcut, preferredModelProvider: ctx.model?.provider }),
 		{ overlay: true, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } },
 	);
 	if (!result) return;
@@ -571,8 +569,11 @@ export function registerSlashCommands(
 	pi.registerCommand("subagents-status", {
 		description: "Show active and recent async subagent runs",
 		handler: async (_args, ctx) => {
+			const sessionId = resolveCurrentSessionId(ctx.sessionManager);
+			state.baseCwd = ctx.cwd;
+			state.currentSessionId = sessionId;
 			await ctx.ui.custom<void>(
-				(tui, theme, _kb, done) => new SubagentsStatusComponent(tui, theme, () => done(undefined)),
+				(tui, theme, _kb, done) => new SubagentsStatusComponent(tui, theme, () => done(undefined), { sessionId }),
 				{ overlay: true, overlayOptions: { anchor: "center", width: 84, maxHeight: "80%" } },
 			);
 		},

package/src/tui/render.ts

@@ -256,7 +256,17 @@ function hasAnimatedWidgetJobs(jobs: AsyncJobState[]): boolean {
 	return jobs.some((job) => job.status === "running");
 }
 
+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(", ");
+}
+
 function widgetJobName(job: AsyncJobState): string {
+	const agents = job.agents?.length ? formatWidgetAgents(job.agents) : undefined;
+	if (job.mode === "parallel") return agents ? `parallel · ${agents}` : "parallel";
+	if (job.activeParallelGroup) return agents ? `parallel group · ${agents}` : "parallel group";
 	if (job.agents?.length) return job.agents.join(" → ");
 	return job.mode ?? "subagent";
 }
@@ -297,6 +307,47 @@ function widgetStatusGlyph(job: AsyncJobState, theme: Theme): string {
 	return theme.fg("error", "✗");
 }
 
+function widgetStepGlyph(status: string, theme: Theme): string {
+	if (status === "running") return theme.fg("accent", "▶");
+	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", "◦");
+}
+
+function widgetStepStatus(status: string, 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);
+}
+
+function widgetStepActivity(step: NonNullable<AsyncJobState["steps"]>[number]): string {
+	const facts: string[] = [];
+	if (step.currentTool && step.currentToolStartedAt !== undefined) facts.push(`${step.currentTool} ${formatDuration(Math.max(0, Date.now() - 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 = formatActivityLabel(step.lastActivityAt, step.activityState);
+	if (activity && facts.length) return `${activity} · ${facts.join(" · ")}`;
+	if (activity) return activity;
+	return facts.join(" · ");
+}
+
+function widgetParallelAgentDetails(job: AsyncJobState, theme: Theme): string[] {
+	if (!job.activeParallelGroup || !job.steps?.length) return [];
+	if (job.mode !== "parallel" && job.mode !== "chain") return [];
+	const total = job.stepsTotal ?? job.steps.length;
+	return job.steps.map((step, index) => {
+		const marker = index === job.steps!.length - 1 ? "└" : "├";
+		const activity = widgetStepActivity(step);
+		return `  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme)} Agent ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${activity ? ` · ${activity}` : ""}`)}`;
+	});
+}
+
 function parseParallelGroupAgentCount(label: string | undefined): number | undefined {
 	if (!label || !label.startsWith("[") || !label.endsWith("]")) return undefined;
 	const inner = label.slice(1, -1).trim();
@@ -461,8 +512,20 @@ 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.status === "running") parts.push(formatAgentRunningLabel(running));
-		if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
+		if (job.mode === "parallel") {
+			if (job.status === "running") 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 groupProgress = job.status === "running"
+				? `${formatAgentRunningLabel(running)} · ${done}/${stepsTotal} done`
+				: `${done}/${stepsTotal} done`;
+			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupProgress}`);
+		}
 	} else if (job.currentStep !== undefined) {
 		parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
 	} else if (stepsTotal > 1) {
@@ -496,6 +559,7 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 		items.push([
 			`${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
 			`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
+			...widgetParallelAgentDetails(job, theme),
 		]);
 		slots--;
 	}
@@ -512,6 +576,7 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 		items.push([
 			`${widgetStatusGlyph(job, theme)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
 			`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
+			...widgetParallelAgentDetails(job, theme),
 		]);
 		slots--;
 	}

package/src/tui/subagents-status.ts

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import type { Component, TUI } from "@mariozechner/pi-tui";
 import { matchesKey, truncateToWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui";
-import { type AsyncRunOverlayData, type AsyncRunSummary, formatAsyncRunProgressLabel, listAsyncRunsForOverlay } from "../runs/background/async-status.ts";
+import { type AsyncRunOverlayData, type AsyncRunOverlayOptions, type AsyncRunSummary, formatAsyncRunProgressLabel, listAsyncRunsForOverlay } from "../runs/background/async-status.ts";
 import { ASYNC_DIR } from "../shared/types.ts";
 import { formatDuration, formatTokens, shortenPath } from "../shared/formatters.ts";
 import { formatScrollInfo, renderFooter, renderHeader, row } from "./render-helpers.ts";
@@ -20,8 +20,18 @@ interface StatusRow {
 	run?: AsyncRunSummary;
 }
 
+type AsyncRunStep = AsyncRunSummary["steps"][number];
+
+interface ChainStepSpan {
+	stepIndex: number;
+	start: number;
+	count: number;
+	isParallel: boolean;
+}
+
 interface StatusOverlayDeps {
-	listRunsForOverlay?: (asyncDirRoot: string, recentLimit?: number) => AsyncRunOverlayData;
+	sessionId: string;
+	listRunsForOverlay?: (asyncDirRoot: string, options?: AsyncRunOverlayOptions) => AsyncRunOverlayData;
 	refreshMs?: number;
 }
 
@@ -44,6 +54,14 @@ function stepStatusColor(theme: Theme, status: string): string {
 	return status;
 }
 
+function stepGlyph(theme: Theme, status: string): string {
+	if (status === "running") return theme.fg("accent", "▶");
+	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("dim", "◦");
+}
+
 function runLabel(theme: Theme, run: AsyncRunSummary, selected: boolean): string {
 	const prefix = selected ? theme.fg("accent", ">") : " ";
 	const stepLabel = formatAsyncRunProgressLabel(run);
@@ -76,6 +94,40 @@ function buildRows(active: AsyncRunSummary[], recent: AsyncRunSummary[]): Status
 	return rows;
 }
 
+function buildChainStepSpans(run: AsyncRunSummary): ChainStepSpan[] {
+	const total = run.chainStepCount ?? run.steps.length;
+	const groups = [...(run.parallelGroups ?? [])].sort((a, b) => a.stepIndex - b.stepIndex);
+	const spans: ChainStepSpan[] = [];
+	let flatIndex = 0;
+	for (let stepIndex = 0; stepIndex < total; stepIndex++) {
+		const group = groups.find((candidate) => candidate.stepIndex === stepIndex);
+		if (group) {
+			spans.push({ stepIndex, start: group.start, count: group.count, isParallel: true });
+			flatIndex = Math.max(flatIndex, group.start + group.count);
+			continue;
+		}
+		spans.push({ stepIndex, start: flatIndex, count: flatIndex < run.steps.length ? 1 : 0, isParallel: false });
+		flatIndex++;
+	}
+	return spans;
+}
+
+function aggregateStepStatus(steps: AsyncRunStep[]): string {
+	if (steps.some((step) => step.status === "running")) return "running";
+	if (steps.some((step) => step.status === "failed")) return "failed";
+	if (steps.some((step) => step.status === "paused")) return "paused";
+	if (steps.length > 0 && steps.every((step) => step.status === "complete" || step.status === "completed")) return "complete";
+	return "pending";
+}
+
+function compactStepStats(step: AsyncRunStep): string {
+	const stats: string[] = [];
+	if (step.toolCount !== undefined) stats.push(`${step.toolCount} tools`);
+	if (step.tokens) stats.push(`${formatTokens(step.tokens.total)} tok`);
+	if (step.durationMs !== undefined) stats.push(formatDuration(step.durationMs));
+	return stats.join(" · ");
+}
+
 function resolveRunPath(asyncDir: string, filePath: string): string {
 	return path.isAbsolute(filePath) ? filePath : path.join(asyncDir, filePath);
 }
@@ -178,7 +230,8 @@ function readRecentEvents(eventsPath: string, limit: number): { events: string[]
 export class SubagentsStatusComponent implements Component {
 	private readonly width = 84;
 	private readonly viewportHeight = 12;
-	private readonly listRunsForOverlay: (asyncDirRoot: string, recentLimit?: number) => AsyncRunOverlayData;
+	private readonly listRunsForOverlay: (asyncDirRoot: string, options?: AsyncRunOverlayOptions) => AsyncRunOverlayData;
+	private readonly sessionId: string;
 	private readonly refreshTimer: NodeJS.Timeout;
 	private screen: "list" | "detail" = "list";
 	private cursor = 0;
@@ -197,12 +250,13 @@ export class SubagentsStatusComponent implements Component {
 		tui: TUI,
 		theme: Theme,
 		done: () => void,
-		deps: StatusOverlayDeps = {},
+		deps: StatusOverlayDeps,
 	) {
 		this.tui = tui;
 		this.theme = theme;
 		this.done = done;
 		this.listRunsForOverlay = deps.listRunsForOverlay ?? listAsyncRunsForOverlay;
+		this.sessionId = deps.sessionId;
 		const refreshMs = deps.refreshMs ?? AUTO_REFRESH_MS;
 		this.reload();
 		this.refreshTimer = setInterval(() => {
@@ -215,7 +269,7 @@ export class SubagentsStatusComponent implements Component {
 	private reload(): void {
 		const previousSelectedId = selectedRun(this.rows, this.cursor)?.id;
 		try {
-			const overlayData = this.listRunsForOverlay(ASYNC_DIR, 5);
+			const overlayData = this.listRunsForOverlay(ASYNC_DIR, { recentLimit: 5, sessionId: this.sessionId });
 			this.active = overlayData.active;
 			this.recent = overlayData.recent;
 			this.rows = buildRows(this.active, this.recent);
@@ -282,6 +336,13 @@ export class SubagentsStatusComponent implements Component {
 		return lines;
 	}
 
+	private formatStepActivity(step: AsyncRunStep): string {
+		if (!step.lastActivityAt) return "";
+		if (step.activityState === "needs_attention") return `no activity for ${formatDuration(Math.max(0, Date.now() - step.lastActivityAt))}`;
+		if (step.activityState === "active_long_running") return `active but long-running; last activity ${formatDuration(Math.max(0, Date.now() - step.lastActivityAt))} ago`;
+		return `active ${formatDuration(Math.max(0, Date.now() - step.lastActivityAt))} ago`;
+	}
+
 	private renderStepRows(run: AsyncRunSummary, width: number, innerW: number, options: { wrap?: boolean } = {}): string[] {
 		const lines: string[] = [];
 		for (const step of run.steps) {
@@ -291,14 +352,8 @@ export class SubagentsStatusComponent implements Component {
 				: "";
 			const duration = step.durationMs !== undefined ? ` | ${formatDuration(step.durationMs)}` : "";
 			const tokens = step.tokens ? ` | ${formatTokens(step.tokens.total)} tok` : "";
-			const activity = step.lastActivityAt
-				? step.activityState === "needs_attention"
-					? ` | no activity for ${formatDuration(Math.max(0, Date.now() - step.lastActivityAt))}`
-					: step.activityState === "active_long_running"
-						? ` | active but long-running; last activity ${formatDuration(Math.max(0, Date.now() - step.lastActivityAt))} ago`
-						: ` | active ${formatDuration(Math.max(0, Date.now() - step.lastActivityAt))} ago`
-				: "";
-			const line = `  ${step.index + 1}. ${step.agent} | ${stepStatusColor(this.theme, step.status)}${activity}${model}${attempts}${duration}${tokens}`;
+			const activity = this.formatStepActivity(step);
+			const line = `  ${step.index + 1}. ${step.agent} | ${stepStatusColor(this.theme, step.status)}${activity ? ` | ${activity}` : ""}${model}${attempts}${duration}${tokens}`;
 			if (options.wrap) {
 				lines.push(...detailRows(line, width, innerW, this.theme));
 			} else {
@@ -318,6 +373,57 @@ export class SubagentsStatusComponent implements Component {
 		return lines;
 	}
 
+	private renderStructuredStepRow(prefix: string, step: AsyncRunStep, width: number, innerW: number, errorIndent: string): string[] {
+		const suffix = [this.formatStepActivity(step), step.model, compactStepStats(step)].filter(Boolean).join(" · ");
+		const lines = detailRows(`${prefix}${step.agent} · ${stepStatusColor(this.theme, step.status)}${suffix ? ` · ${suffix}` : ""}`, width, innerW, this.theme);
+		if (step.error) lines.push(...detailRows(`${errorIndent}${step.error}`, width, innerW, this.theme));
+		return lines;
+	}
+
+	private renderAgentRows(run: AsyncRunSummary, width: number, innerW: number): string[] {
+		if (run.steps.length === 0) return [row(this.theme.fg("dim", "  No agent details available yet."), width, this.theme)];
+		const lines: string[] = [];
+		const total = run.steps.length;
+		for (const [index, step] of run.steps.entries()) {
+			lines.push(...this.renderStructuredStepRow(`  ${stepGlyph(this.theme, step.status)} Agent ${index + 1}/${total}: `, step, width, innerW, "     "));
+		}
+		return lines;
+	}
+
+	private renderChainProgressRows(run: AsyncRunSummary, width: number, innerW: number): string[] {
+		if (run.steps.length === 0) return [row(this.theme.fg("dim", "  No step details available yet."), width, this.theme)];
+		const lines: string[] = [];
+		const spans = buildChainStepSpans(run);
+		const total = run.chainStepCount ?? spans.length;
+		for (const span of spans) {
+			const steps = run.steps.slice(span.start, span.start + span.count);
+			const status = aggregateStepStatus(steps);
+			if (span.isParallel) {
+				const running = steps.filter((step) => step.status === "running").length;
+				const done = steps.filter((step) => step.status === "complete" || step.status === "completed").length;
+				const failed = steps.filter((step) => step.status === "failed").length;
+				const paused = steps.filter((step) => step.status === "paused").length;
+				const outcomeCounts = [`${done}/${span.count} done`];
+				if (failed > 0) outcomeCounts.push(`${failed} failed`);
+				if (paused > 0) outcomeCounts.push(`${paused} paused`);
+				if (running > 0) outcomeCounts.unshift(running === 1 ? "1 agent running" : `${running} agents running`);
+				const label = `${stepGlyph(this.theme, status)} Step ${span.stepIndex + 1}/${total}: parallel group · ${outcomeCounts.join(" · ")}`;
+				lines.push(...detailRows(`  ${label}`, width, innerW, this.theme));
+				for (const [localIndex, step] of steps.entries()) {
+					lines.push(...this.renderStructuredStepRow(`     ${stepGlyph(this.theme, step.status)} Agent ${localIndex + 1}/${span.count}: `, step, width, innerW, "        "));
+				}
+				continue;
+			}
+			const step = steps[0];
+			if (!step) {
+				lines.push(row(this.theme.fg("dim", `  ◦ Step ${span.stepIndex + 1}/${total}: pending`), width, this.theme));
+				continue;
+			}
+			lines.push(...this.renderStructuredStepRow(`  ${stepGlyph(this.theme, step.status)} Step ${span.stepIndex + 1}/${total}: `, step, width, innerW, "     "));
+		}
+		return lines;
+	}
+
 	private renderDetail(run: AsyncRunSummary, width: number, innerW: number): string[] {
 		const stepLabel = formatAsyncRunProgressLabel(run);
 		const duration = run.endedAt !== undefined
@@ -335,8 +441,16 @@ export class SubagentsStatusComponent implements Component {
 		body.push(...detailRows(`${run.id} | ${statusColor(this.theme, run.state)} | ${run.mode} | ${stepLabel} | ${duration}`, width, innerW, this.theme));
 		if (activity) body.push(...detailRows(activity, width, innerW, this.theme));
 		body.push(row("", width, this.theme));
-		body.push(row(this.theme.fg("accent", "Steps"), width, this.theme));
-		body.push(...this.renderStepRows(run, width, innerW, { wrap: true }));
+		if (run.mode === "chain" && (run.chainStepCount !== undefined || run.parallelGroups?.length)) {
+			body.push(row(this.theme.fg("accent", run.state === "running" ? "Chain progress" : "Chain results"), width, this.theme));
+			body.push(...this.renderChainProgressRows(run, width, innerW));
+		} else if (run.mode === "parallel") {
+			body.push(row(this.theme.fg("accent", "Agents"), width, this.theme));
+			body.push(...this.renderAgentRows(run, width, innerW));
+		} else {
+			body.push(row(this.theme.fg("accent", "Steps"), width, this.theme));
+			body.push(...this.renderStepRows(run, width, innerW, { wrap: true }));
+		}
 
 		const eventsPath = path.join(run.asyncDir, "events.jsonl");
 		const eventResult = readRecentEvents(eventsPath, DETAIL_EVENT_LIMIT);