pi-subagents 0.21.4 → 0.21.5

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 ## [Unreleased]
 
+## [0.21.5] - 2026-05-02
+
+### Fixed
+- Show top-level async parallel runs as `parallel` instead of `chain`, with foreground-style running/done wording in widgets and status output, and group running async chain detail by chain step.
+- Scoped `/subagents-status` to async runs launched from the current pi session instead of showing prior or unrelated sessions.
+- Declared the Pi TUI package as a direct dev dependency and added a manifest guard so CI installs do not rely on transitive optional peer dependencies for tests.
+- Made prompt-runtime extension path assertions portable on Windows.
+
 ## [0.21.4] - 2026-05-01
 
 ### Added

package/README.md

@@ -150,12 +150,14 @@ Use `~/.pi/agent/settings.json` for a user override or `.pi/settings.json` for a
 
 Foreground runs stream progress in the conversation while they run.
 
-Background runs keep working after control returns to you. They show completion notifications and can be inspected with:
+Background runs keep working after control returns to you. They show a compact async widget, send completion notifications, and can be inspected with:
 
 ```text
 /subagents-status
 ```
 
+The status view shows active and recent runs for the current Pi session. Parallel background runs are shown as parallel work, with per-agent progress instead of fake chain steps. Chains with parallel groups keep their grouped shape in both progress and results views, so failed or paused agents stay visible next to completed ones.
+
 You can also ask naturally:
 
 ```text

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.21.4",
+  "version": "0.21.5",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -77,6 +77,7 @@
   "devDependencies": {
     "@mariozechner/pi-agent-core": "^0.65.0",
     "@mariozechner/pi-ai": "^0.65.0",
-    "@mariozechner/pi-coding-agent": "^0.65.0"
+    "@mariozechner/pi-coding-agent": "^0.65.0",
+    "@mariozechner/pi-tui": "^0.65.2"
   }
 }

package/src/extension/index.ts

@@ -20,6 +20,7 @@ import { type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@
 import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@mariozechner/pi-tui";
 import { discoverAgents } from "../agents/agents.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
+import { resolveCurrentSessionId } from "../shared/session-identity.ts";
 import { cleanupOldChainDirs } from "../shared/settings.ts";
 import { renderWidget, renderSubagentResult, stopResultAnimations, stopWidgetAnimation, syncResultAnimation } from "../tui/render.ts";
 import { SubagentParams } from "./schemas.ts";
@@ -271,6 +272,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	const runtimeCleanup = () => {
 		stopWidgetAnimation();
 		stopResultAnimations();
+		stopResultWatcher();
 		clearPendingForegroundControlNotices(state);
 		if (state.poller) {
 			clearInterval(state.poller);
@@ -523,12 +525,13 @@ DIAGNOSTICS:
 
 	const resetSessionState = (ctx: ExtensionContext) => {
 		state.baseCwd = ctx.cwd;
-		state.currentSessionId = ctx.sessionManager.getSessionFile() ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
 		state.lastUiContext = ctx;
 		cleanupSessionArtifacts(ctx);
 		clearPendingForegroundControlNotices(state);
 		resetJobs(ctx);
 		restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
+		primeExistingResults();
 	};
 
 	pi.on("session_start", (_event, ctx) => {

package/src/intercom/result-intercom.ts

@@ -6,6 +6,7 @@ import {
 	type SubagentResultIntercomChild,
 	type SubagentResultIntercomPayload,
 	type SubagentResultStatus,
+	type SubagentRunMode,
 	SUBAGENT_RESULT_INTERCOM_DELIVERY_EVENT,
 	SUBAGENT_RESULT_INTERCOM_EVENT,
 } from "../shared/types.ts";
@@ -61,7 +62,7 @@ function resolveGroupedStatus(children: SubagentResultIntercomChild[]): Subagent
 interface GroupedResultIntercomMessageInput {
 	to: string;
 	runId: string;
-	mode: "single" | "parallel" | "chain";
+	mode: SubagentRunMode;
 	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
 	asyncId?: string;
@@ -84,7 +85,7 @@ function asyncResumeGuidance(input: {
 
 function formatSubagentResultIntercomMessage(input: {
 	runId: string;
-	mode: "single" | "parallel" | "chain";
+	mode: SubagentRunMode;
 	status: SubagentResultStatus;
 	source: "foreground" | "async";
 	children: SubagentResultIntercomChild[];
@@ -218,7 +219,7 @@ export function stripDetailsOutputsForIntercomReceipt(details: Details): Details
 }
 
 export function formatSubagentResultReceipt(input: {
-	mode: "single" | "parallel" | "chain";
+	mode: SubagentRunMode;
 	runId: string;
 	payload: SubagentResultIntercomPayload;
 }): string {

package/src/runs/background/async-execution.ts

@@ -24,6 +24,7 @@ import {
 	type Details,
 	type MaxOutputConfig,
 	type ResolvedControlConfig,
+	type SubagentRunMode,
 	ASYNC_DIR,
 	RESULTS_DIR,
 	SUBAGENT_ASYNC_STARTED_EVENT,
@@ -64,7 +65,7 @@ interface AsyncExecutionContext {
 
 interface AsyncChainParams {
 	chain: ChainStep[];
-	resultMode?: "parallel" | "chain";
+	resultMode?: Exclude<SubagentRunMode, "single">;
 	agents: AgentConfig[];
 	ctx: AsyncExecutionContext;
 	availableModels?: AvailableModelInfo[];
@@ -160,7 +161,7 @@ function spawnRunner(cfg: object, suffix: string, cwd: string): { pid?: number;
 	return { pid: proc.pid };
 }
 
-function formatAsyncStartError(mode: "single" | "chain", message: string): AsyncExecutionResult {
+function formatAsyncStartError(mode: SubagentRunMode, message: string): AsyncExecutionResult {
 	return {
 		content: [{ type: "text", text: message }],
 		isError: true,
@@ -198,6 +199,7 @@ export function executeAsyncChain(
 		controlIntercomTarget,
 		childIntercomTarget,
 	} = params;
+	const resultMode = params.resultMode ?? "chain";
 	const chainSkills = params.chainSkills ?? [];
 	const availableModels = params.availableModels;
 	const runnerCwd = resolveChildCwd(ctx.cwd, cwd);
@@ -211,7 +213,7 @@ export function executeAsyncChain(
 				return {
 					content: [{ type: "text", text: `Unknown agent: ${agentName}` }],
 					isError: true,
-					details: { mode: "chain" as const, results: [] },
+					details: { mode: resultMode, results: [] },
 				};
 			}
 		}
@@ -225,7 +227,7 @@ export function executeAsyncChain(
 		return {
 			content: [{ type: "text", text: `Failed to create async run directory '${asyncDir}': ${message}` }],
 			isError: true,
-			details: { mode: "chain" as const, results: [] },
+			details: { mode: resultMode, results: [] },
 		};
 	}
 
@@ -329,7 +331,7 @@ export function executeAsyncChain(
 			return buildSeqStep(s as SequentialStep, nextSessionFile());
 		});
 	} catch (error) {
-		if (error instanceof UnavailableSubagentSkillError || error instanceof AsyncStartValidationError) return formatAsyncStartError("chain", error.message);
+		if (error instanceof UnavailableSubagentSkillError || error instanceof AsyncStartValidationError) return formatAsyncStartError(resultMode, error.message);
 		throw error;
 	}
 	let childTargetIndex = 0;
@@ -363,18 +365,18 @@ export function executeAsyncChain(
 				controlConfig,
 				controlIntercomTarget,
 				childIntercomTargets,
-				resultMode: params.resultMode ?? "chain",
+				resultMode,
 			},
 			id,
 			runnerCwd,
 		);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		return formatAsyncStartError("chain", `Failed to start async chain '${id}': ${message}`);
+		return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': ${message}`);
 	}
 
 	if (spawnResult.error) {
-		return formatAsyncStartError("chain", `Failed to start async chain '${id}': ${spawnResult.error}`);
+		return formatAsyncStartError(resultMode, `Failed to start async ${resultMode} '${id}': ${spawnResult.error}`);
 	}
 
 	if (spawnResult.pid) {
@@ -399,6 +401,8 @@ export function executeAsyncChain(
 		ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
 			id,
 			pid: spawnResult.pid,
+			sessionId: ctx.currentSessionId,
+			mode: resultMode,
 			agent: firstAgents[0],
 			agents: flatAgents,
 			task: isParallelStep(firstStep)
@@ -421,8 +425,8 @@ export function executeAsyncChain(
 		.join(" -> ");
 
 	return {
-		content: [{ type: "text", text: `Async chain: ${chainDesc} [${id}]` }],
-		details: { mode: "chain", results: [], asyncId: id, asyncDir },
+		content: [{ type: "text", text: `Async ${resultMode}: ${chainDesc} [${id}]` }],
+		details: { mode: resultMode, results: [], asyncId: id, asyncDir },
 	};
 }
 
@@ -543,6 +547,8 @@ export function executeAsyncSingle(
 		ctx.pi.events.emit(SUBAGENT_ASYNC_STARTED_EVENT, {
 			id,
 			pid: spawnResult.pid,
+			sessionId: ctx.currentSessionId,
+			mode: "single",
 			agent,
 			task: task?.slice(0, 50),
 			cwd: runnerCwd,

package/src/runs/background/async-job-tracker.ts

@@ -5,7 +5,6 @@ import { renderWidget } from "../../tui/render.ts";
 import { formatControlNoticeMessage } from "../shared/subagent-control.ts";
 import {
 	type AsyncJobState,
-	type AsyncParallelGroupStatus,
 	type AsyncStartedEvent,
 	type ControlEvent,
 	type SubagentState,
@@ -15,25 +14,9 @@ import {
 	SUBAGENT_CONTROL_INTERCOM_EVENT,
 } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
+import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
 
-
-function isValidParallelGroup(group: AsyncParallelGroupStatus, stepCount: number, chainStepCount: number): boolean {
-	return Number.isInteger(group.start)
-		&& Number.isInteger(group.count)
-		&& Number.isInteger(group.stepIndex)
-		&& group.start >= 0
-		&& group.count > 0
-		&& group.stepIndex >= 0
-		&& group.stepIndex < chainStepCount
-		&& group.start + group.count <= stepCount;
-}
-
-function normalizeParallelGroups(groups: AsyncParallelGroupStatus[] | undefined, stepCount: number, chainStepCount: number): AsyncParallelGroupStatus[] {
-	if (!groups?.length) return [];
-	return groups.filter((group) => isValidParallelGroup(group, stepCount, chainStepCount));
-}
-
 interface AsyncJobTrackerOptions {
 	completionRetentionMs?: number;
 	pollIntervalMs?: number;
@@ -145,8 +128,11 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 						startedRun: {
 							runId: job.asyncId,
 							pid: job.pid,
+							sessionId: job.sessionId,
 							mode: job.mode,
 							agents: job.agents,
+							chainStepCount: job.chainStepCount,
+							parallelGroups: job.parallelGroups,
 							startedAt: job.startedAt,
 							sessionFile: job.sessionFile,
 						},
@@ -155,6 +141,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 					if (status) {
 						const previousStatus = job.status;
 						job.status = status.state;
+						job.sessionId = status.sessionId ?? job.sessionId;
 						job.activityState = status.activityState;
 						job.lastActivityAt = status.lastActivityAt ?? job.lastActivityAt;
 						job.currentTool = status.currentTool;
@@ -164,10 +151,12 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 						job.toolCount = status.toolCount ?? job.toolCount;
 						job.mode = status.mode;
 						job.currentStep = status.currentStep ?? job.currentStep;
+						job.chainStepCount = status.chainStepCount ?? job.chainStepCount;
 						job.startedAt = status.startedAt ?? job.startedAt;
 						job.updatedAt = status.lastUpdate ?? Date.now();
 						if (status.steps?.length) {
 							const groups = normalizeParallelGroups(status.parallelGroups, status.steps.length, status.chainStepCount ?? status.steps.length);
+							job.parallelGroups = groups.length ? groups : job.parallelGroups;
 							job.hasParallelGroups = groups.length > 0 || job.hasParallelGroups;
 							const activeGroup = status.currentStep !== undefined
 								? groups.find((group) => status.currentStep! >= group.start && status.currentStep! < group.start + group.count)
@@ -177,6 +166,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 								: status.steps;
 							job.activeParallelGroup = Boolean(activeGroup);
 							job.agents = visibleSteps.map((step) => step.agent);
+							job.steps = visibleSteps;
 							job.stepsTotal = visibleSteps.length;
 							job.runningSteps = visibleSteps.filter((step) => step.status === "running").length;
 							job.completedSteps = visibleSteps.filter((step) => step.status === "complete" || step.status === "completed").length;
@@ -225,8 +215,11 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 			asyncDir,
 			status: "queued",
 			pid: typeof info.pid === "number" ? info.pid : undefined,
-			mode: info.chain ? "chain" : "single",
+			...(typeof info.sessionId === "string" ? { sessionId: info.sessionId } : {}),
+			mode: info.mode ?? (info.chain ? "chain" : "single"),
 			agents,
+			chainStepCount: info.chainStepCount,
+			parallelGroups: validParallelGroups,
 			stepsTotal: firstGroupCount ?? agents?.length,
 			hasParallelGroups: validParallelGroups.length > 0,
 			activeParallelGroup: Boolean(firstGroupCount && firstGroupCount > 0),

package/src/runs/background/async-resume.ts

@@ -202,6 +202,7 @@ function resultState(result: AsyncResultFile): AsyncStatus["state"] {
 function validateStatusForResume(status: AsyncStatus | null, source: string): void {
 	if (!status) return;
 	if (typeof status.runId !== "string") throw new Error(`Invalid async status '${source}': runId must be a string.`);
+	if (status.sessionId !== undefined && typeof status.sessionId !== "string") throw new Error(`Invalid async status '${source}': sessionId must be a string.`);
 	if (status.cwd !== undefined && typeof status.cwd !== "string") throw new Error(`Invalid async status '${source}': cwd must be a string.`);
 	if (status.sessionFile !== undefined && typeof status.sessionFile !== "string") throw new Error(`Invalid async status '${source}': sessionFile must be a string.`);
 	if (status.steps !== undefined) {

package/src/runs/background/async-status.ts

@@ -1,8 +1,9 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatTokens, shortenPath } from "../../shared/formatters.ts";
-import { type ActivityState, type AsyncParallelGroupStatus, type AsyncStatus, type TokenUsage } from "../../shared/types.ts";
+import { type ActivityState, type AsyncParallelGroupStatus, type AsyncStatus, type SubagentRunMode, type TokenUsage } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
+import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
 
 interface AsyncRunStepSummary {
@@ -27,6 +28,7 @@ interface AsyncRunStepSummary {
 export interface AsyncRunSummary {
 	id: string;
 	asyncDir: string;
+	sessionId?: string;
 	state: "queued" | "running" | "complete" | "failed" | "paused";
 	activityState?: ActivityState;
 	lastActivityAt?: number;
@@ -35,7 +37,7 @@ export interface AsyncRunSummary {
 	currentPath?: string;
 	turnCount?: number;
 	toolCount?: number;
-	mode: "single" | "chain";
+	mode: SubagentRunMode;
 	cwd?: string;
 	startedAt: number;
 	lastUpdate?: number;
@@ -50,45 +52,9 @@ export interface AsyncRunSummary {
 	sessionFile?: string;
 }
 
-function isValidParallelGroup(group: AsyncParallelGroupStatus, stepCount: number, chainStepCount: number): boolean {
-	return Number.isInteger(group.start)
-		&& Number.isInteger(group.count)
-		&& Number.isInteger(group.stepIndex)
-		&& group.start >= 0
-		&& group.count > 0
-		&& group.stepIndex >= 0
-		&& group.stepIndex < chainStepCount
-		&& group.start + group.count <= stepCount;
-}
-
-function normalizeParallelGroups(groups: AsyncParallelGroupStatus[] | undefined, stepCount: number, chainStepCount: number): AsyncParallelGroupStatus[] {
-	if (!groups?.length) return [];
-	return groups.filter((group) => isValidParallelGroup(group, stepCount, chainStepCount));
-}
-
-function flatToLogicalStepIndex(flatIndex: number, chainStepCount: number, parallelGroups: AsyncParallelGroupStatus[]): number {
-	let logicalIndex = 0;
-	let cursor = 0;
-	for (const group of parallelGroups) {
-		while (logicalIndex < chainStepCount && cursor < group.start) {
-			if (flatIndex === cursor) return logicalIndex;
-			logicalIndex++;
-			cursor++;
-		}
-		if (flatIndex >= group.start && flatIndex < group.start + group.count) return group.stepIndex;
-		logicalIndex = Math.max(logicalIndex, group.stepIndex + 1);
-		cursor = group.start + group.count;
-	}
-	while (logicalIndex < chainStepCount) {
-		if (flatIndex === cursor) return logicalIndex;
-		logicalIndex++;
-		cursor++;
-	}
-	return Math.max(0, chainStepCount - 1);
-}
-
 interface AsyncRunListOptions {
 	states?: Array<AsyncRunSummary["state"]>;
+	sessionId?: string;
 	limit?: number;
 	resultsDir?: string;
 	kill?: (pid: number, signal?: NodeJS.Signals | 0) => boolean;
@@ -101,6 +67,11 @@ export interface AsyncRunOverlayData {
 	recent: AsyncRunSummary[];
 }
 
+export interface AsyncRunOverlayOptions {
+	recentLimit?: number;
+	sessionId?: string;
+}
+
 function getErrorMessage(error: unknown): string {
 	return error instanceof Error ? error.message : String(error);
 }
@@ -147,6 +118,9 @@ function deriveAsyncActivityState(asyncDir: string, status: AsyncStatus): { acti
 }
 
 function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }): AsyncRunSummary {
+	if (status.sessionId !== undefined && typeof status.sessionId !== "string") {
+		throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': sessionId must be a string.`);
+	}
 	const { activityState, lastActivityAt } = deriveAsyncActivityState(asyncDir, status);
 	const steps = status.steps ?? [];
 	const chainStepCount = status.chainStepCount ?? steps.length;
@@ -154,6 +128,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 	return {
 		id: status.runId || path.basename(asyncDir),
 		asyncDir,
+		...(status.sessionId ? { sessionId: status.sessionId } : {}),
 		state: status.state,
 		activityState,
 		lastActivityAt,
@@ -240,6 +215,7 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 		if (!status) continue;
 		const summary = statusToSummary(asyncDir, status);
 		if (allowedStates && !allowedStates.has(summary.state)) continue;
+		if (options.sessionId && summary.sessionId !== options.sessionId) continue;
 		runs.push(summary);
 	}
 
@@ -247,8 +223,9 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 	return options.limit !== undefined ? sorted.slice(0, options.limit) : sorted;
 }
 
-export function listAsyncRunsForOverlay(asyncDirRoot: string, recentLimit = 5): AsyncRunOverlayData {
-	const all = listAsyncRuns(asyncDirRoot);
+export function listAsyncRunsForOverlay(asyncDirRoot: string, options: AsyncRunOverlayOptions = {}): AsyncRunOverlayData {
+	const recentLimit = options.recentLimit ?? 5;
+	const all = listAsyncRuns(asyncDirRoot, { sessionId: options.sessionId });
 	const recent = all
 		.filter((run) => run.state === "complete" || run.state === "failed" || run.state === "paused")
 		.sort((a, b) => (b.lastUpdate ?? b.endedAt ?? b.startedAt) - (a.lastUpdate ?? a.endedAt ?? a.startedAt))
@@ -287,6 +264,18 @@ function formatStepLine(step: AsyncRunStepSummary): string {
 	return parts.join(" | ");
 }
 
+function formatParallelProgress(steps: Pick<AsyncRunStepSummary, "status">[], total: number, showRunning: boolean): string {
+	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 parts = [`${done}/${total} done`];
+	if (showRunning) parts.unshift(running === 1 ? "1 agent running" : `${running} agents running`);
+	if (failed > 0) parts.push(`${failed} failed`);
+	if (paused > 0) parts.push(`${paused} paused`);
+	return parts.join(" · ");
+}
+
 export function formatAsyncRunProgressLabel(run: Pick<AsyncRunSummary, "mode" | "state" | "currentStep" | "chainStepCount" | "parallelGroups" | "steps">): string {
 	const stepCount = run.steps.length || 1;
 	const chainStepCount = run.chainStepCount ?? stepCount;
@@ -294,16 +283,13 @@ export function formatAsyncRunProgressLabel(run: Pick<AsyncRunSummary, "mode" |
 	const activeGroup = run.currentStep !== undefined
 		? groups.find((group) => run.currentStep! >= group.start && run.currentStep! < group.start + group.count)
 		: undefined;
-	if (run.mode === "chain" && activeGroup) {
+	if (activeGroup) {
 		const groupSteps = run.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count);
-		const running = groupSteps.filter((step) => step.status === "running").length;
-		const done = groupSteps.filter((step) => step.status === "complete" || step.status === "completed").length;
-		const runningLabel = running === 1 ? "1 agent running" : `${running} agents running`;
-		const groupLabel = run.state === "running"
-			? `parallel group: ${runningLabel} · ${done}/${activeGroup.count} done`
-			: `parallel group: ${done}/${activeGroup.count} done`;
-		return `step ${activeGroup.stepIndex + 1}/${chainStepCount} · ${groupLabel}`;
+		const groupLabel = formatParallelProgress(groupSteps, activeGroup.count, run.state === "running");
+		if (run.mode === "parallel") return groupLabel;
+		return `step ${activeGroup.stepIndex + 1}/${chainStepCount} · parallel group: ${groupLabel}`;
 	}
+	if (run.mode === "parallel") return formatParallelProgress(run.steps, stepCount, run.state === "running");
 	if (run.mode === "chain" && run.currentStep !== undefined && groups.length > 0) {
 		const logicalStep = flatToLogicalStepIndex(run.currentStep, chainStepCount, groups);
 		return `step ${logicalStep + 1}/${chainStepCount}`;

package/src/runs/background/parallel-groups.ts

@@ -0,0 +1,45 @@
+import type { AsyncParallelGroupStatus } from "../../shared/types.ts";
+
+function isValidParallelGroup(group: unknown, stepCount: number, chainStepCount: number): group is AsyncParallelGroupStatus {
+	if (typeof group !== "object" || group === null) return false;
+	const { start, count, stepIndex } = group as Partial<AsyncParallelGroupStatus>;
+	return typeof start === "number"
+		&& typeof count === "number"
+		&& typeof stepIndex === "number"
+		&& Number.isInteger(start)
+		&& Number.isInteger(count)
+		&& Number.isInteger(stepIndex)
+		&& start >= 0
+		&& count > 0
+		&& stepIndex >= 0
+		&& stepIndex < chainStepCount
+		&& start + count <= stepCount;
+}
+
+export function normalizeParallelGroups(groups: unknown, stepCount: number, chainStepCount: number): AsyncParallelGroupStatus[] {
+	if (!Array.isArray(groups)) return [];
+	return groups
+		.filter((group): group is AsyncParallelGroupStatus => isValidParallelGroup(group, stepCount, chainStepCount))
+		.sort((left, right) => left.stepIndex - right.stepIndex || left.start - right.start);
+}
+
+export function flatToLogicalStepIndex(flatIndex: number, chainStepCount: number, groups: AsyncParallelGroupStatus[]): number {
+	let logicalIndex = 0;
+	let cursor = 0;
+	for (const group of groups) {
+		while (cursor < group.start && logicalIndex < chainStepCount) {
+			if (cursor === flatIndex) return logicalIndex;
+			cursor++;
+			logicalIndex++;
+		}
+		if (flatIndex >= group.start && flatIndex < group.start + group.count) return group.stepIndex;
+		cursor = group.start + group.count;
+		logicalIndex = group.stepIndex + 1;
+	}
+	while (cursor <= flatIndex && logicalIndex < chainStepCount) {
+		if (cursor === flatIndex) return logicalIndex;
+		cursor++;
+		logicalIndex++;
+	}
+	return Math.max(0, chainStepCount - 1);
+}

package/src/runs/background/result-watcher.ts

@@ -1,10 +1,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.ts";
 import { createFileCoalescer } from "../../shared/file-coalescer.ts";
 import {
 	SUBAGENT_ASYNC_COMPLETE_EVENT,
+	type IntercomEventBus,
 	type SubagentState,
 } from "../../shared/types.ts";
 import {
@@ -46,7 +46,7 @@ function shouldFallBackToPolling(error: unknown): boolean {
 }
 
 export function createResultWatcher(
-	pi: ExtensionAPI,
+	pi: { events: IntercomEventBus },
 	state: SubagentState,
 	resultsDir: string,
 	completionTtlMs: number,

package/src/runs/background/run-status.ts

@@ -1,10 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentToolResult } from "@mariozechner/pi-agent-core";
-import { formatAsyncRunList, listAsyncRuns } from "./async-status.ts";
-import { ASYNC_DIR, RESULTS_DIR, type Details } from "../../shared/types.ts";
+import { formatAsyncRunList, formatAsyncRunProgressLabel, listAsyncRuns } from "./async-status.ts";
+import { ASYNC_DIR, RESULTS_DIR, type AsyncStatus, type Details } from "../../shared/types.ts";
 import { resolveSubagentIntercomTarget } from "../../intercom/intercom-bridge.ts";
 import { resolveAsyncRunLocation } from "./async-resume.ts";
+import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun } from "./stale-run-reconciler.ts";
 
 interface RunStatusParams {
@@ -31,6 +32,19 @@ function canShowRevive(stepCount: number, sessionFile: unknown): sessionFile is
 	return stepCount === 1 && typeof sessionFile === "string" && fs.existsSync(sessionFile);
 }
 
+function stepLineLabel(status: AsyncStatus, index: number): string {
+	const steps = status.steps ?? [];
+	if (status.mode === "parallel") return `Agent ${index + 1}/${steps.length || 1}`;
+	if (status.mode === "chain") {
+		const chainStepCount = status.chainStepCount ?? (steps.length || 1);
+		const groups = normalizeParallelGroups(status.parallelGroups, steps.length, chainStepCount);
+		const group = groups.find((candidate) => index >= candidate.start && index < candidate.start + candidate.count);
+		if (group) return `Step ${group.stepIndex + 1}/${chainStepCount} Agent ${index - group.start + 1}/${group.count}`;
+		return `Step ${flatToLogicalStepIndex(index, chainStepCount, groups) + 1}/${chainStepCount}`;
+	}
+	return `Step ${index + 1}`;
+}
+
 export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDeps = {}): AgentToolResult<Details> {
 	const asyncDirRoot = deps.asyncDirRoot ?? ASYNC_DIR;
 	const resultsDir = deps.resultsDir ?? RESULTS_DIR;
@@ -89,9 +103,14 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 		const logPath = path.join(asyncDir, `subagent-log-${effectiveRunId}.md`);
 		const eventsPath = path.join(asyncDir, "events.jsonl");
 		if (status) {
-			const stepsTotal = status.steps?.length ?? 1;
-			const current = status.currentStep !== undefined ? status.currentStep + 1 : undefined;
-			const stepLine = current !== undefined ? `Step: ${current}/${stepsTotal}` : `Steps: ${stepsTotal}`;
+			const progressLabel = formatAsyncRunProgressLabel({
+				mode: status.mode,
+				state: status.state,
+				currentStep: status.currentStep,
+				chainStepCount: status.chainStepCount,
+				parallelGroups: status.parallelGroups,
+				steps: (status.steps ?? []).map((step, index) => ({ index, agent: step.agent, status: step.status })),
+			});
 			const started = new Date(status.startedAt).toISOString();
 			const updated = status.lastUpdate ? new Date(status.lastUpdate).toISOString() : "n/a";
 			const statusActivityText = status.state === "running" ? activityText(status.activityState, status.lastActivityAt) : undefined;
@@ -101,7 +120,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 				`State: ${status.state}`,
 				statusActivityText ? `Activity: ${statusActivityText}` : undefined,
 				`Mode: ${status.mode}`,
-				stepLine,
+				`Progress: ${progressLabel}`,
 				`Started: ${started}`,
 				`Updated: ${updated}`,
 				`Dir: ${asyncDir}`,
@@ -111,7 +130,7 @@ export function inspectSubagentStatus(params: RunStatusParams, deps: RunStatusDe
 			for (const [index, step] of (status.steps ?? []).entries()) {
 				const stepActivityText = step.status === "running" ? activityText(step.activityState, step.lastActivityAt) : undefined;
 				const errorText = step.error ? `, error: ${step.error}` : "";
-				lines.push(`Step ${index + 1}: ${step.agent} ${step.status}${stepActivityText ? `, ${stepActivityText}` : ""}${errorText}`);
+				lines.push(`${stepLineLabel(status, index)}: ${step.agent} ${step.status}${stepActivityText ? `, ${stepActivityText}` : ""}${errorText}`);
 				if (step.status === "running") {
 					lines.push(`  Intercom target: ${resolveSubagentIntercomTarget(status.runId, step.agent, index)} (if registered)`);
 				}

package/src/runs/background/stale-run-reconciler.ts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { writeAtomicJson } from "../../shared/atomic-json.ts";
-import { RESULTS_DIR, type AsyncStatus } from "../../shared/types.ts";
+import { RESULTS_DIR, type AsyncParallelGroupStatus, type AsyncStatus, type SubagentRunMode } from "../../shared/types.ts";
+import { normalizeParallelGroups } from "./parallel-groups.ts";
 
 export type PidLiveness = "alive" | "dead" | "unknown";
 
@@ -10,8 +11,11 @@ type KillFn = (pid: number, signal?: NodeJS.Signals | 0) => boolean;
 interface StartedRunMetadata {
 	runId: string;
 	pid?: number;
-	mode?: "single" | "chain";
+	sessionId?: string;
+	mode?: SubagentRunMode;
 	agents?: string[];
+	chainStepCount?: number;
+	parallelGroups?: AsyncParallelGroupStatus[];
 	startedAt?: number;
 	sessionFile?: string;
 }
@@ -133,13 +137,21 @@ function terminalStatusFromResult(status: AsyncStatus, resultPath: string, now:
 function buildStartedStatus(asyncDir: string, startedRun: StartedRunMetadata, now: number): AsyncStatus {
 	const startedAt = startedRun.startedAt ?? now;
 	const agents = startedRun.agents?.length ? startedRun.agents : ["subagent"];
+	const chainStepCount = startedRun.chainStepCount;
+	const parallelGroups = chainStepCount !== undefined
+		? normalizeParallelGroups(startedRun.parallelGroups, agents.length, chainStepCount)
+		: [];
 	return {
 		runId: startedRun.runId || path.basename(asyncDir),
+		...(startedRun.sessionId ? { sessionId: startedRun.sessionId } : {}),
 		mode: startedRun.mode ?? "single",
 		state: "running",
 		pid: startedRun.pid,
 		startedAt,
 		lastUpdate: now,
+		currentStep: 0,
+		...(chainStepCount !== undefined ? { chainStepCount } : {}),
+		...(parallelGroups.length ? { parallelGroups } : {}),
 		steps: agents.map((agent) => ({
 			agent,
 			status: "running" as const,
@@ -197,6 +209,7 @@ function buildFailedRepair(status: AsyncStatus, asyncDir: string, now: number, r
 			timestamp: now,
 			durationMs: Math.max(0, now - status.startedAt),
 			asyncDir,
+			sessionId: status.sessionId,
 			sessionFile: status.sessionFile,
 		},
 	};

package/src/runs/background/subagent-runner.ts

@@ -16,6 +16,7 @@ import {
 	type AsyncStatus,
 	type ModelAttempt,
 	type ResolvedControlConfig,
+	type SubagentRunMode,
 	type Usage,
 	DEFAULT_MAX_OUTPUT,
 	type MaxOutputConfig,
@@ -90,7 +91,7 @@ interface SubagentRunConfig {
 	controlConfig?: ResolvedControlConfig;
 	controlIntercomTarget?: string;
 	childIntercomTargets?: Array<string | undefined>;
-	resultMode?: "single" | "parallel" | "chain";
+	resultMode?: SubagentRunMode;
 }
 
 interface StepResult {
@@ -472,7 +473,7 @@ function writeRunLog(
 	logPath: string,
 	input: {
 		id: string;
-		mode: "single" | "chain";
+		mode: SubagentRunMode;
 		cwd: string;
 		startedAt: number;
 		endedAt: number;
@@ -877,7 +878,8 @@ async function runSubagent(config: SubagentRunConfig): Promise<void> {
 		|| flatSteps.some((step) => Boolean(step.sessionFile));
 	const statusPayload: RunnerStatusPayload = {
 		runId: id,
-		mode: flatSteps.length > 1 ? "chain" : "single",
+		...(config.sessionId ? { sessionId: config.sessionId } : {}),
+		mode: config.resultMode ?? (flatSteps.length > 1 ? "chain" : "single"),
 		state: "running",
 		lastActivityAt: overallStartTime,
 		startedAt: overallStartTime,

package/src/runs/foreground/subagent-executor.ts

@@ -29,6 +29,7 @@ import {
 import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
 import { executeAsyncChain, executeAsyncSingle, isAsyncAvailable } from "../background/async-execution.ts";
 import { createForkContextResolver } from "../../shared/fork-context.ts";
+import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
 import { applyIntercomBridgeToAgent, INTERCOM_BRIDGE_MARKER, resolveIntercomBridge, resolveIntercomSessionTarget, resolveSubagentIntercomTarget, type IntercomBridgeState } from "../../intercom/intercom-bridge.ts";
 import { formatControlIntercomMessage, formatControlNoticeMessage, resolveControlConfig, shouldNotifyControlEvent } from "../shared/subagent-control.ts";
 import { finalizeSingleOutput, injectSingleOutputInstruction, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
@@ -65,6 +66,7 @@ import {
 	type MaxOutputConfig,
 	type ResolvedControlConfig,
 	type SingleResult,
+	type SubagentRunMode,
 	type SubagentState,
 	DEFAULT_ARTIFACT_CONFIG,
 	SUBAGENT_ACTIONS,
@@ -332,7 +334,7 @@ async function resumeAsyncRun(input: {
 	}
 
 	const parentSessionFile = input.ctx.sessionManager.getSessionFile() ?? null;
-	input.deps.state.currentSessionId = parentSessionFile ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+	input.deps.state.currentSessionId = resolveCurrentSessionId(input.ctx.sessionManager);
 	const effectiveCwd = target.cwd ?? input.requestCwd;
 	const scope: AgentScope = resolveExecutionAgentScope(input.params.agentScope);
 	const discoveredAgents = input.deps.discoverAgents(effectiveCwd, scope).agents;
@@ -423,7 +425,7 @@ async function emitForegroundResultIntercom(input: {
 	pi: ExtensionAPI;
 	intercomBridge: IntercomBridgeState;
 	runId: string;
-	mode: "single" | "parallel" | "chain";
+	mode: SubagentRunMode;
 	results: SingleResult[];
 	chainSteps?: number;
 }): Promise<ReturnType<typeof buildSubagentResultIntercomPayload> | null> {
@@ -459,7 +461,7 @@ async function maybeBuildForegroundIntercomReceipt(input: {
 	pi: ExtensionAPI;
 	intercomBridge: IntercomBridgeState;
 	runId: string;
-	mode: "single" | "parallel" | "chain";
+	mode: SubagentRunMode;
 	details: Details;
 }): Promise<{ text: string; details: Details } | null> {
 	const payload = await emitForegroundResultIntercom({
@@ -1966,7 +1968,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		const scope: AgentScope = resolveExecutionAgentScope(effectiveParams.agentScope);
 		const effectiveCwd = effectiveParams.cwd ?? ctx.cwd;
 		const parentSessionFile = ctx.sessionManager.getSessionFile() ?? null;
-		deps.state.currentSessionId = parentSessionFile ?? `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		deps.state.currentSessionId = resolveCurrentSessionId(ctx.sessionManager);
 		const discoveredAgents = deps.discoverAgents(effectiveCwd, scope).agents;
 		effectiveParams = applyAgentDefaultContext(effectiveParams, discoveredAgents);
 		const sessionName = resolveIntercomSessionTarget(deps.pi.getSessionName(), ctx.sessionManager.getSessionId());

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;

package/src/slash/slash-commands.ts

@@ -8,6 +8,7 @@ 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 {
@@ -571,8 +572,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);