pi-subagents 0.21.4 → 0.22.0

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/manager-ui/agent-manager-edit.ts

@@ -4,30 +4,31 @@ import { buildRuntimeName, defaultSystemPromptMode, frontmatterNameForConfig, pa
 import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "../tui/text-editor.ts";
 import type { TextEditorState } from "../tui/text-editor.ts";
 import { pad, row, renderHeader, renderFooter, formatScrollInfo } from "../tui/render-helpers.ts";
+import { findModelInfo, getSupportedThinkingLevels, type ModelInfo, type ThinkingLevel } from "../shared/model-info.ts";
 
-export interface ModelInfo { provider: string; id: string; fullId: string; }
+export type { ModelInfo };
 export interface SkillInfo { name: string; source: string; description?: string; }
 export type EditScreen = "edit" | "edit-field" | "edit-prompt";
 export type EditField = typeof FIELD_ORDER[number];
 
 export interface EditState {
 	draft: AgentConfig; isNew: boolean; fieldIndex: number; fieldMode: "text" | "model" | "thinking" | "skills" | null;
-	fieldEditor: TextEditorState; promptEditor: TextEditorState; modelSearchQuery: string; modelCursor: number; filteredModels: ModelInfo[];
+	fieldEditor: TextEditorState; promptEditor: TextEditorState; modelSearchQuery: string; modelCursor: number; models: ModelInfo[]; filteredModels: ModelInfo[];
 	thinkingCursor: number; skillSearchQuery: string; skillCursor: number; filteredSkills: SkillInfo[]; skillSelected: Set<string>; error?: string;
 	fields: EditField[];
 	title?: string;
 	overrideBase?: BuiltinAgentOverrideBase;
+	preferredProvider?: string;
 }
 interface EditInputResult { action?: "save" | "discard" | "delete"; nextScreen?: EditScreen; }
 interface CreateEditStateOptions {
 	fields?: EditField[];
 	title?: string;
 	overrideBase?: BuiltinAgentOverrideBase;
+	preferredProvider?: string;
 }
 
-const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"] as const;
 const FIELD_ORDER = ["name", "package", "description", "model", "fallbackModels", "thinking", "systemPromptMode", "inheritProjectContext", "inheritSkills", "defaultContext", "tools", "extensions", "skills", "output", "reads", "progress", "interactive", "prompt"] as const;
-type ThinkingLevel = typeof THINKING_LEVELS[number];
 const PROMPT_VIEWPORT_HEIGHT = 16;
 const MODEL_SELECTOR_HEIGHT = 10;
 const SKILL_SELECTOR_HEIGHT = 10;
@@ -86,8 +87,8 @@ export function createEditState(draft: AgentConfig, isNew: boolean, models: Mode
 	return {
 		draft: { ...draft, tools: draft.tools ? [...draft.tools] : undefined, mcpDirectTools: draft.mcpDirectTools ? [...draft.mcpDirectTools] : undefined, skills: draft.skills ? [...draft.skills] : undefined, fallbackModels: draft.fallbackModels ? [...draft.fallbackModels] : undefined, extensions: draft.extensions ? [...draft.extensions] : draft.extensions, defaultReads: draft.defaultReads ? [...draft.defaultReads] : undefined, extraFields: draft.extraFields ? { ...draft.extraFields } : undefined },
 		isNew, fieldIndex: 0, fieldMode: null, fieldEditor: createEditorState(), promptEditor: createEditorState(draft.systemPrompt ?? ""),
-		modelSearchQuery: "", modelCursor: 0, filteredModels: [...models], thinkingCursor: 0, skillSearchQuery: "", skillCursor: 0, filteredSkills: [...skills], skillSelected: new Set(draft.skills ?? []),
-		fields: options.fields ?? [...FIELD_ORDER], title: options.title, overrideBase: options.overrideBase,
+		modelSearchQuery: "", modelCursor: 0, models: [...models], filteredModels: [...models], thinkingCursor: 0, skillSearchQuery: "", skillCursor: 0, filteredSkills: [...skills], skillSelected: new Set(draft.skills ?? []),
+		fields: options.fields ?? [...FIELD_ORDER], title: options.title, overrideBase: options.overrideBase, preferredProvider: options.preferredProvider,
 	};
 }
 
@@ -180,9 +181,16 @@ function openModelPicker(state: EditState, models: ModelInfo[]): void {
 	state.fieldIndex = state.fields.indexOf("model"); state.fieldMode = "model"; state.modelSearchQuery = ""; state.filteredModels = [...models];
 	const idx = state.filteredModels.findIndex((m) => m.fullId === state.draft.model || m.id === state.draft.model); state.modelCursor = idx >= 0 ? idx : 0;
 }
+function getDraftThinkingLevels(state: EditState): ThinkingLevel[] {
+	return getSupportedThinkingLevels(findModelInfo(state.draft.model, state.models, state.preferredProvider));
+}
+
 function openThinkingPicker(state: EditState): void {
 	state.fieldIndex = state.fields.indexOf("thinking"); state.fieldMode = "thinking";
-	const idx = THINKING_LEVELS.indexOf((state.draft.thinking ?? "off") as ThinkingLevel); state.thinkingCursor = idx >= 0 ? idx : 0;
+	const levels = getDraftThinkingLevels(state);
+	const currentLevel = state.draft.thinking ?? "off";
+	const idx = levels.findIndex((level) => level === currentLevel);
+	state.thinkingCursor = idx >= 0 ? idx : Math.max(0, levels.indexOf("off"));
 }
 function openSkillPicker(state: EditState, skills: SkillInfo[]): void {
 	state.fieldIndex = state.fields.indexOf("skills"); state.fieldMode = "skills"; state.skillSearchQuery = ""; state.filteredSkills = [...skills]; state.skillSelected = new Set(state.draft.skills ?? []); state.skillCursor = 0;
@@ -230,16 +238,22 @@ function renderThinkingPicker(state: EditState, width: number, theme: Theme): st
 		high: "Deep reasoning",
 		xhigh: "Maximum reasoning (ultrathink)",
 	};
-	for (let i = 0; i < THINKING_LEVELS.length; i++) {
-		const level = THINKING_LEVELS[i]!;
-		const isSelected = i === state.thinkingCursor;
-		const prefix = isSelected ? theme.fg("accent", "→ ") : "  ";
-		const levelText = isSelected ? theme.fg("accent", level) : level;
-		const desc = theme.fg("dim", ` - ${descriptions[level]}`);
-		lines.push(row(` ${prefix}${levelText}${desc}`, width, theme));
+	const levels = getDraftThinkingLevels(state);
+	if (levels.length === 0) {
+		lines.push(row(` ${theme.fg("dim", "No supported thinking levels")}`, width, theme));
+	} else {
+		for (let i = 0; i < levels.length; i++) {
+			const level = levels[i]!;
+			const isSelected = i === state.thinkingCursor;
+			const prefix = isSelected ? theme.fg("accent", "→ ") : "  ";
+			const levelText = isSelected ? theme.fg("accent", level) : level;
+			const desc = theme.fg("dim", ` - ${descriptions[level]}`);
+			lines.push(row(` ${prefix}${levelText}${desc}`, width, theme));
+		}
 	}
 	while (lines.length < 19) lines.push(row("", width, theme));
-	lines.push(renderFooter(" [enter] select  [esc] cancel  [↑↓] navigate ", width, theme));
+	const footer = levels.length === 0 ? " [esc] cancel " : " [enter] select  [esc] cancel  [↑↓] navigate ";
+	lines.push(renderFooter(footer, width, theme));
 	return lines;
 }
 
@@ -323,7 +337,15 @@ export function handleEditInput(screen: EditScreen, state: EditState, data: stri
 	if (screen === "edit-field") {
 		if (state.fieldMode === "model") {
 			if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { state.fieldMode = null; return { nextScreen: "edit" }; }
-			if (matchesKey(data, "return")) { const selected = state.filteredModels[state.modelCursor]; if (selected) state.draft.model = selected.fullId; state.fieldMode = null; return { nextScreen: "edit" }; }
+			if (matchesKey(data, "return")) {
+				const selected = state.filteredModels[state.modelCursor];
+				if (selected) {
+					state.draft.model = selected.fullId;
+					if (state.draft.thinking && !getDraftThinkingLevels(state).some((level) => level === state.draft.thinking)) state.draft.thinking = undefined;
+				}
+				state.fieldMode = null;
+				return { nextScreen: "edit" };
+			}
 			if (matchesKey(data, "up")) { if (state.filteredModels.length > 0) state.modelCursor = state.modelCursor === 0 ? state.filteredModels.length - 1 : state.modelCursor - 1; return; }
 			if (matchesKey(data, "down")) { if (state.filteredModels.length > 0) state.modelCursor = state.modelCursor === state.filteredModels.length - 1 ? 0 : state.modelCursor + 1; return; }
 			if (matchesKey(data, "backspace")) { if (state.modelSearchQuery.length > 0) state.modelSearchQuery = state.modelSearchQuery.slice(0, -1); }
@@ -334,10 +356,12 @@ export function handleEditInput(screen: EditScreen, state: EditState, data: stri
 			return;
 		}
 		if (state.fieldMode === "thinking") {
+			const levels = getDraftThinkingLevels(state);
 			if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { state.fieldMode = null; return { nextScreen: "edit" }; }
-			if (matchesKey(data, "return")) { const selected = THINKING_LEVELS[state.thinkingCursor]; state.draft.thinking = selected === "off" ? undefined : selected; state.fieldMode = null; return { nextScreen: "edit" }; }
-			if (matchesKey(data, "up")) { state.thinkingCursor = state.thinkingCursor === 0 ? THINKING_LEVELS.length - 1 : state.thinkingCursor - 1; return; }
-			if (matchesKey(data, "down")) { state.thinkingCursor = state.thinkingCursor === THINKING_LEVELS.length - 1 ? 0 : state.thinkingCursor + 1; return; }
+			if (levels.length === 0) return;
+			if (matchesKey(data, "return")) { const selected = levels[state.thinkingCursor] ?? "off"; state.draft.thinking = selected === "off" ? undefined : selected; state.fieldMode = null; return { nextScreen: "edit" }; }
+			if (matchesKey(data, "up")) { state.thinkingCursor = state.thinkingCursor === 0 ? levels.length - 1 : state.thinkingCursor - 1; return; }
+			if (matchesKey(data, "down")) { state.thinkingCursor = state.thinkingCursor === levels.length - 1 ? 0 : state.thinkingCursor + 1; return; }
 			return;
 		}
 		if (state.fieldMode === "skills") {

package/src/manager-ui/agent-manager.ts

@@ -45,7 +45,7 @@ interface ChainEntry { id: string; kind: "chain"; config: ChainConfig; }
 interface NameInputState { mode: "new-agent" | "clone-agent" | "clone-chain" | "new-chain"; editor: TextEditorState; scope: "user" | "project"; allowProject: boolean; sourceId?: string; template?: AgentTemplate; error?: string; }
 interface StatusMessage { text: string; type: "error" | "info"; }
 interface OverrideScopeState { selectedScope: "user" | "project"; allowProject: boolean; }
-export interface AgentManagerOptions { newShortcut?: string; }
+export interface AgentManagerOptions { newShortcut?: string; preferredModelProvider?: string; }
 
 const BUILTIN_OVERRIDE_FIELDS: EditField[] = ["model", "fallbackModels", "thinking", "systemPromptMode", "inheritProjectContext", "inheritSkills", "defaultContext", "disabled", "tools", "skills", "prompt"];
 
@@ -135,6 +135,7 @@ export class AgentManagerComponent implements Component {
 	private skills: SkillInfo[];
 	private done: (result: ManagerResult) => void;
 	private shortcuts: ListShortcuts;
+	private preferredModelProvider: string | undefined;
 
 	constructor(tui: TUI, theme: Theme, agentData: AgentData, models: ModelInfo[], skills: SkillInfo[], done: (result: ManagerResult) => void, options: AgentManagerOptions = {}) {
 		this.tui = tui;
@@ -144,6 +145,7 @@ export class AgentManagerComponent implements Component {
 		this.skills = skills;
 		this.done = done;
 		this.shortcuts = { newShortcut: options.newShortcut?.trim() || DEFAULT_AGENT_MANAGER_NEW_SHORTCUT };
+		this.preferredModelProvider = options.preferredModelProvider;
 		this.loadEntries();
 	}
 
@@ -196,7 +198,7 @@ export class AgentManagerComponent implements Component {
 
 	private enterDetail(entry: AgentEntry): void { this.currentAgentId = entry.id; this.detailState = { resolved: true, scrollOffset: 0, recentRuns: loadRunsForAgent(entry.config.name).slice(0, 5) }; this.screen = "detail"; }
 	private enterChainDetail(entry: ChainEntry): void { this.currentChainId = entry.id; this.chainDetailState = { scrollOffset: 0 }; this.screen = "chain-detail"; }
-	private enterEdit(entry: AgentEntry): void { this.currentAgentId = entry.id; this.builtinOverrideScope = null; this.editState = createEditState(entry.config, entry.isNew, this.models, this.skills); this.screen = "edit"; }
+	private enterEdit(entry: AgentEntry): void { this.currentAgentId = entry.id; this.builtinOverrideScope = null; this.editState = createEditState(entry.config, entry.isNew, this.models, this.skills, { preferredProvider: this.preferredModelProvider }); this.screen = "edit"; }
 	private enterBuiltinOverrideScope(entry: AgentEntry): void {
 		this.currentAgentId = entry.id;
 		this.overrideScopeState = { selectedScope: this.agentData.projectSettingsPath ? "project" : "user", allowProject: Boolean(this.agentData.projectSettingsPath) };
@@ -209,6 +211,7 @@ export class AgentManagerComponent implements Component {
 			fields: BUILTIN_OVERRIDE_FIELDS,
 			title: `Builtin Override: ${entry.config.name} [${scope}]`,
 			overrideBase: this.resolveBuiltinOverrideBase(entry),
+			preferredProvider: this.preferredModelProvider,
 		});
 		this.screen = "edit";
 	}

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,