pi-subagents 0.18.1 → 0.19.1

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 ## [Unreleased]
 
+## [0.19.1] - 2026-04-26
+
+### Added
+- Added `subagent({ action: "doctor" })` and `/subagents-doctor` for read-only subagent environment diagnostics.
+- Added `/run-chain` to launch saved `.chain.md` workflows directly from slash commands with completion, shared task input, and `--bg`/`--fork` support.
+
+## [0.19.0] - 2026-04-26
+
+### Added
+- Added top-level parallel task support for per-task `output`, `reads`, and `progress`, including `/parallel` inline forwarding and async preservation.
+- Added `/agents` launch toggles for forked context, background execution, and worktree-isolated parallel runs.
+- Added a read-only detail view to `/subagents-status` for inspecting selected async runs, including recent events, output tails, and useful run paths.
+- Added a packaged `/parallel-review` prompt template for launching fresh-context adversarial review subagents.
+
+### Fixed
+- Parallel and chain child runs now detach cleanly when a child uses intercom, preventing incoming handoff messages from aborting the parent foreground run.
+
 ## [0.18.1] - 2026-04-25
 
 ### Changed

package/README.md

@@ -977,9 +977,9 @@ The inherited thread is reference-only. Do not continue that conversation or sen
 Use `intercom` only to coordinate with the orchestrator session `{orchestratorTarget}`.
 
 - Need a decision or you're blocked: `intercom({ action: "ask", to: "{orchestratorTarget}", message: "<question>" })`
-- Need to report progress or a completion handoff: `intercom({ action: "send", to: "{orchestratorTarget}", message: "DONE: <summary>" })`
+- Blocked or explicitly asked to send progress: `intercom({ action: "send", to: "{orchestratorTarget}", message: "UPDATE: <summary>" })`
 
-If no upstream coordination is needed, continue the task normally and return a focused task result.
+Do not send routine completion handoffs through intercom. If no coordination is needed, return a focused task result.
 ```
 
 Bridge activation also requires all of the following:

package/agent-manager-chain-detail.ts

@@ -2,6 +2,7 @@ import type { Theme } from "@mariozechner/pi-coding-agent";
 import { matchesKey, truncateToWidth } from "@mariozechner/pi-tui";
 import type { ChainConfig, ChainStepConfig } from "./agents.ts";
 import { row, renderFooter, renderHeader, formatPath, formatScrollInfo } from "./render-helpers.ts";
+import { isParallelStep, type ChainStep } from "./settings.ts";
 
 export interface ChainDetailState {
 	scrollOffset: number;
@@ -14,11 +15,24 @@ export type ChainDetailAction =
 
 const CHAIN_DETAIL_VIEWPORT_HEIGHT = 12;
 
-export function buildDependencyMap(steps: ChainStepConfig[]): Map<number, number[]> {
+type DetailChainStep = ChainStepConfig | ChainStep;
+
+export function buildDependencyMap(steps: DetailChainStep[]): Map<number, number[]> {
 	const outputMap = new Map<string, number>();
 	const deps = new Map<number, number[]>();
 	for (let i = 0; i < steps.length; i++) {
 		const step = steps[i]!;
+		if (isParallelStep(step as ChainStep)) {
+			const reads = step.parallel.flatMap((task) => Array.isArray(task.reads) ? task.reads : []);
+			const sources = reads
+				.map((file) => outputMap.get(file))
+				.filter((idx): idx is number => idx !== undefined);
+			if (sources.length > 0) deps.set(i, [...new Set(sources)]);
+			for (const task of step.parallel) {
+				if (typeof task.output === "string" && task.output.length > 0) outputMap.set(task.output, i);
+			}
+			continue;
+		}
 		if (typeof step.output === "string" && step.output.length > 0) outputMap.set(step.output, i);
 		if (Array.isArray(step.reads) && step.reads.length > 0) {
 			const sources = step.reads
@@ -33,21 +47,51 @@ export function buildDependencyMap(steps: ChainStepConfig[]): Map<number, number
 function buildChainDetailLines(chain: ChainConfig, width: number): string[] {
 	const contentWidth = width - 3;
 	const lines: string[] = [];
-	const dependencyMap = buildDependencyMap(chain.steps);
+	const steps = chain.steps as DetailChainStep[];
+	const dependencyMap = buildDependencyMap(steps);
 	lines.push(truncateToWidth(chain.description, contentWidth));
 	lines.push("");
 	lines.push(truncateToWidth(`File: ${formatPath(chain.filePath)}`, contentWidth));
 	lines.push("");
 	lines.push(truncateToWidth("── Flow ──", contentWidth));
 
-	for (let i = 0; i < chain.steps.length; i++) {
-		const step = chain.steps[i]!;
+	for (let i = 0; i < steps.length; i++) {
+		const step = steps[i]!;
+		const sources = dependencyMap.get(i);
+		const fromText = sources && sources.length > 0 ? ` (from ${sources.map((s) => s + 1).join(", ")})` : "";
+		if (isParallelStep(step as ChainStep)) {
+			lines.push(truncateToWidth(`  ${i + 1}  Parallel: ${step.parallel.map((task) => task.agent).join(" + ")}`, contentWidth));
+			if (step.concurrency !== undefined) lines.push(truncateToWidth(`     concurrency: ${step.concurrency}`, contentWidth));
+			if (step.failFast !== undefined) lines.push(truncateToWidth(`     fail fast: ${step.failFast ? "on" : "off"}`, contentWidth));
+			if (step.worktree !== undefined) lines.push(truncateToWidth(`     worktree: ${step.worktree ? "on" : "off"}`, contentWidth));
+			for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
+				const task = step.parallel[taskIndex]!;
+				lines.push(truncateToWidth(`     ${taskIndex + 1}. ${task.agent}`, contentWidth));
+				const taskPreview = (task.task ?? "").split("\n")[0] ?? "";
+				if (taskPreview) lines.push(truncateToWidth(`        task: ${taskPreview}`, contentWidth));
+				if (Array.isArray(task.reads) && task.reads.length > 0) lines.push(truncateToWidth(`        ← reads: ${task.reads.join(", ")}${fromText}`, contentWidth));
+				else if (task.reads === false) lines.push(truncateToWidth("        ← reads: (disabled)", contentWidth));
+				if (typeof task.output === "string" && task.output.length > 0) lines.push(truncateToWidth(`        → output: ${task.output}`, contentWidth));
+				else if (task.output === false) lines.push(truncateToWidth("        → output: (disabled)", contentWidth));
+				if (task.model) lines.push(truncateToWidth(`        model: ${task.model}`, contentWidth));
+				if (task.skill !== undefined) {
+					const skillsText =
+						task.skill === false
+							? "(disabled)"
+							: Array.isArray(task.skill)
+								? (task.skill.length > 0 ? task.skill.join(", ") : "(none)")
+								: task.skill;
+					lines.push(truncateToWidth(`        skills: ${skillsText}`, contentWidth));
+				}
+				if (task.progress !== undefined) lines.push(truncateToWidth(`        progress: ${task.progress ? "on" : "off"}`, contentWidth));
+			}
+			lines.push("");
+			continue;
+		}
 		lines.push(truncateToWidth(`  ${i + 1}  ${step.agent}`, contentWidth));
 		const taskPreview = step.task.split("\n")[0] ?? "";
 		lines.push(truncateToWidth(`     task: ${taskPreview || "(none)"}`, contentWidth));
 		if (Array.isArray(step.reads) && step.reads.length > 0) {
-			const sources = dependencyMap.get(i);
-			const fromText = sources && sources.length > 0 ? ` (from ${sources.map((s) => s + 1).join(", ")})` : "";
 			lines.push(truncateToWidth(`     ← reads: ${step.reads.join(", ")}${fromText}`, contentWidth));
 		} else if (step.reads === false) {
 			lines.push(truncateToWidth("     ← reads: (disabled)", contentWidth));

package/agent-manager-detail.ts

@@ -180,12 +180,19 @@ export function renderDetail(
 	return lines;
 }
 
+export interface LaunchToggleState {
+	fork: boolean;
+	background: boolean;
+	worktree?: boolean;
+}
+
 export function renderTaskInput(
 	title: string,
 	editor: TextEditorState,
 	skipClarify: boolean,
 	width: number,
 	theme: Theme,
+	launchToggles?: LaunchToggleState,
 ): string[] {
 	const lines: string[] = [];
 	lines.push(renderHeader(` ${title} `, width, theme));
@@ -209,8 +216,14 @@ export function renderTaskInput(
 	lines.push(row(` ${bottom}`, width, theme));
 
 	lines.push(row("", width, theme));
-	const enterLabel = skipClarify ? "quick run" : "run";
 	const quickLabel = skipClarify ? "on" : "off";
-	lines.push(renderFooter(` [enter] ${enterLabel}  [tab] quick: ${quickLabel}  [esc] cancel `, width, theme));
+	const footerParts = ["[enter] run", `[tab] quick:${quickLabel}`];
+	if (launchToggles) {
+		footerParts.push(`[ctrl+f] fork:${launchToggles.fork ? "on" : "off"}`);
+		footerParts.push(`[ctrl+b] bg:${launchToggles.background ? "on" : "off"}`);
+		if (launchToggles.worktree !== undefined) footerParts.push(`[ctrl+w] worktree:${launchToggles.worktree ? "on" : "off"}`);
+	}
+	footerParts.push("[esc]");
+	lines.push(renderFooter(` ${footerParts.join("  ")} `, width, theme));
 	return lines;
 }

package/agent-manager.ts

@@ -20,19 +20,20 @@ import { TEMPLATE_ITEMS, type AgentTemplate, type TemplateItem } from "./agent-t
 import { parseChain, serializeChain } from "./chain-serializer.ts";
 import { renderList, handleListInput, type ListAgent, type ListState, type ListAction } from "./agent-manager-list.ts";
 import { createParallelState, handleParallelInput, renderParallel, formatParallelTitle, type ParallelState, type AgentOption } from "./agent-manager-parallel.ts";
-import { renderDetail, handleDetailInput, renderTaskInput, type DetailState, type DetailAction } from "./agent-manager-detail.ts";
+import { renderDetail, handleDetailInput, renderTaskInput, type DetailState, type DetailAction, type LaunchToggleState } from "./agent-manager-detail.ts";
 import { renderChainDetail, handleChainDetailInput, type ChainDetailAction, type ChainDetailState } from "./agent-manager-chain-detail.ts";
 import { createEditState, handleEditInput, renderEdit, type EditField, type EditScreen, type EditState, type ModelInfo, type SkillInfo } from "./agent-manager-edit.ts";
 import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "./text-editor.ts";
 import type { TextEditorState } from "./text-editor.ts";
 import { loadRunsForAgent } from "./run-history.ts";
 import { pad, row, renderHeader, renderFooter } from "./render-helpers.ts";
+import { isParallelStep, type ChainStep } from "./settings.ts";
 
 export type ManagerResult =
-	| { action: "launch"; agent: string; task: string; skipClarify?: boolean }
-	| { action: "chain"; agents: string[]; task: string; skipClarify?: boolean }
-	| { action: "parallel"; tasks: Array<{ agent: string; task: string }>; skipClarify?: boolean }
-	| { action: "launch-chain"; chain: ChainConfig; task: string; skipClarify?: boolean }
+	| { action: "launch"; agent: string; task: string; skipClarify?: boolean; fork?: boolean; background?: boolean }
+	| { action: "chain"; agents: string[]; task: string; skipClarify?: boolean; fork?: boolean; background?: boolean }
+	| { action: "parallel"; tasks: Array<{ agent: string; task: string }>; skipClarify?: boolean; fork?: boolean; background?: boolean; worktree?: boolean }
+	| { action: "launch-chain"; chain: ChainConfig; task: string; skipClarify?: boolean; fork?: boolean; background?: boolean; worktree?: boolean }
 	| undefined;
 
 export interface AgentData { builtin: AgentConfig[]; user: AgentConfig[]; project: AgentConfig[]; chains: ChainConfig[]; userDir: string; projectDir: string | null; userSettingsPath: string; projectSettingsPath: string | null; cwd: string; }
@@ -69,7 +70,27 @@ function cloneConfig(config: AgentConfig): AgentConfig {
 			: undefined,
 	};
 }
-function cloneChainConfig(config: ChainConfig): ChainConfig { return { ...config, steps: config.steps.map((step) => ({ ...step, reads: Array.isArray(step.reads) ? [...step.reads] : step.reads, skills: Array.isArray(step.skills) ? [...step.skills] : step.skills })), extraFields: config.extraFields ? { ...config.extraFields } : undefined }; }
+function cloneChainConfig(config: ChainConfig): ChainConfig {
+	const steps = (config.steps as unknown as ChainStep[]).map((step) => {
+		if (isParallelStep(step)) {
+			return {
+				...step,
+				parallel: step.parallel.map((task) => ({
+					...task,
+					reads: Array.isArray(task.reads) ? [...task.reads] : task.reads,
+					skill: Array.isArray(task.skill) ? [...task.skill] : task.skill,
+				})),
+			};
+		}
+		return {
+			...step,
+			reads: Array.isArray(step.reads) ? [...step.reads] : step.reads,
+			...(Array.isArray((step as typeof step & { skills?: string[] | false }).skills) ? { skills: [...(step as typeof step & { skills: string[] }).skills] } : { skills: (step as typeof step & { skills?: false }).skills }),
+			...(Array.isArray(step.skill) ? { skill: [...step.skill] } : { skill: step.skill }),
+		};
+	});
+	return { ...config, steps: steps as unknown as ChainConfig["steps"], extraFields: config.extraFields ? { ...config.extraFields } : undefined };
+}
 function slugTemplateName(name: string): string { return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, ""); }
 function nextSelectableIndex(items: TemplateItem[], current: number, direction: 1 | -1): number { let next = current + direction; while (next >= 0 && next < items.length && items[next]!.type === "separator") next += direction; if (next < 0 || next >= items.length) return current; return next; }
 const CHAIN_EDIT_VIEWPORT = 10;
@@ -90,6 +111,9 @@ export class AgentManagerComponent implements Component {
 	private chainEditState: { editor: TextEditorState; error?: string } | null = null;
 	private taskEditor: TextEditorState = createEditorState();
 	private skipClarify = false;
+	private launchFork = false;
+	private launchBackground = false;
+	private launchWorktree = false;
 	private chainAgentIds: string[] = [];
 	private chainLaunchId: string | null = null;
 	private parallelMode = false;
@@ -187,10 +211,21 @@ export class AgentManagerComponent implements Component {
 		this.parallelState = createParallelState(names);
 		this.screen = "parallel-builder";
 	}
+	private resetLaunchToggles(): void { this.launchFork = false; this.launchBackground = false; this.launchWorktree = false; }
+	private enterParallelTaskInput(): void {
+		this.chainAgentIds = [];
+		this.chainLaunchId = null;
+		this.parallelMode = true;
+		this.taskBackScreen = "parallel-builder";
+		this.taskEditor = createEditorState();
+		this.skipClarify = true;
+		this.resetLaunchToggles();
+		this.screen = "task-input";
+	}
 	private enterTaskInput(ids: string[], backScreen: ManagerScreen = "list"): void {
-		this.chainAgentIds = ids; this.chainLaunchId = null; this.parallelMode = false; this.taskBackScreen = backScreen; this.taskEditor = createEditorState(); this.skipClarify = true; this.screen = "task-input";
+		this.chainAgentIds = ids; this.chainLaunchId = null; this.parallelMode = false; this.taskBackScreen = backScreen; this.taskEditor = createEditorState(); this.skipClarify = true; this.resetLaunchToggles(); this.screen = "task-input";
 	}
-	private enterSavedChainLaunch(entry: ChainEntry): void { this.chainLaunchId = entry.id; this.chainAgentIds = []; this.parallelMode = false; this.taskBackScreen = "chain-detail"; this.taskEditor = createEditorState(); this.skipClarify = true; this.screen = "task-input"; }
+	private enterSavedChainLaunch(entry: ChainEntry): void { this.chainLaunchId = entry.id; this.chainAgentIds = []; this.parallelMode = false; this.taskBackScreen = "chain-detail"; this.taskEditor = createEditorState(); this.skipClarify = true; this.resetLaunchToggles(); this.screen = "task-input"; }
 	private enterTemplateSelect(): void { this.templateCursor = TEMPLATE_ITEMS.findIndex((item) => item.type !== "separator"); if (this.templateCursor < 0) this.templateCursor = 0; this.screen = "template-select"; }
 
 	private enterChainEdit(entry: ChainEntry): void {
@@ -276,6 +311,27 @@ export class AgentManagerComponent implements Component {
 		catch (err) { state.error = err instanceof Error ? err.message : "Failed to save chain."; return false; }
 	}
 
+	private canToggleLaunchWorktree(): boolean {
+		if (this.parallelMode && this.parallelState) return true;
+		if (!this.chainLaunchId) return false;
+		const chainEntry = this.getChainEntry(this.chainLaunchId);
+		return chainEntry ? (chainEntry.config.steps as unknown as ChainStep[]).some(isParallelStep) : false;
+	}
+	private launchFlags(): { fork?: boolean; background?: boolean; worktree?: boolean } {
+		return {
+			...(this.launchFork ? { fork: true } : {}),
+			...(this.launchBackground ? { background: true } : {}),
+			...(this.launchWorktree && this.canToggleLaunchWorktree() ? { worktree: true } : {}),
+		};
+	}
+	private launchToggleState(): LaunchToggleState {
+		return {
+			fork: this.launchFork,
+			background: this.launchBackground,
+			...(this.canToggleLaunchWorktree() ? { worktree: this.launchWorktree } : {}),
+		};
+	}
+
 	private handleTemplateSelectInput(data: string): void {
 		if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.screen = "list"; this.tui.requestRender(); return; }
 		if (matchesKey(data, "up")) { this.templateCursor = nextSelectableIndex(TEMPLATE_ITEMS, this.templateCursor, -1); this.tui.requestRender(); return; }
@@ -476,13 +532,7 @@ export class AgentManagerComponent implements Component {
 				const agentOptions: AgentOption[] = this.agents.map((e) => ({ name: e.config.name, description: e.config.description, model: e.config.model }));
 				const pAction = handleParallelInput(this.parallelState, agentOptions, data, this.overlayWidth);
 				if (pAction?.type === "proceed") {
-					this.chainAgentIds = [];
-					this.chainLaunchId = null;
-					this.parallelMode = true;
-					this.taskBackScreen = "parallel-builder";
-					this.taskEditor = createEditorState();
-					this.skipClarify = true;
-					this.screen = "task-input";
+					this.enterParallelTaskInput();
 				} else if (pAction?.type === "back") {
 					this.parallelState = null;
 					this.parallelMode = false;
@@ -493,28 +543,31 @@ export class AgentManagerComponent implements Component {
 			}
 			case "task-input": {
 				if (matchesKey(data, "tab")) { this.skipClarify = !this.skipClarify; this.tui.requestRender(); return; }
+				if (matchesKey(data, "ctrl+f")) { this.launchFork = !this.launchFork; this.tui.requestRender(); return; }
+				if (matchesKey(data, "ctrl+b")) { this.launchBackground = !this.launchBackground; this.tui.requestRender(); return; }
+				if (matchesKey(data, "ctrl+w") && this.canToggleLaunchWorktree()) { this.launchWorktree = !this.launchWorktree; this.tui.requestRender(); return; }
 				const innerW = this.overlayWidth - 2; const boxInnerWidth = Math.max(10, innerW - 4); const nextState = handleEditorInput(this.taskEditor, data, boxInnerWidth);
 				if (nextState) { this.taskEditor = nextState; this.tui.requestRender(); return; }
 				if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) { this.screen = this.taskBackScreen; this.tui.requestRender(); return; }
 				if (matchesKey(data, "return")) {
 					if (this.chainLaunchId) {
 						const chainEntry = this.getChainEntry(this.chainLaunchId); if (!chainEntry) { this.screen = "list"; this.tui.requestRender(); return; }
-						this.done({ action: "launch-chain", chain: cloneChainConfig(chainEntry.config), task: this.taskEditor.buffer, skipClarify: this.skipClarify }); return;
+						this.done({ action: "launch-chain", chain: cloneChainConfig(chainEntry.config), task: this.taskEditor.buffer, skipClarify: this.skipClarify, ...this.launchFlags() }); return;
 					} else if (this.parallelMode && this.parallelState) {
 						const sharedTask = this.taskEditor.buffer;
 						const tasks = this.parallelState.slots.map((slot) => ({ agent: slot.agentName, task: slot.customTask || sharedTask }));
-						this.done({ action: "parallel", tasks, skipClarify: this.skipClarify }); return;
+						this.done({ action: "parallel", tasks, skipClarify: this.skipClarify, ...this.launchFlags() }); return;
 					}
 					if (this.chainAgentIds.length > 1) {
 						const agents = this.chainAgentIds
 							.map((id) => this.getAgentEntry(id)?.config.name)
 							.filter((name): name is string => Boolean(name));
 						if (agents.length !== this.chainAgentIds.length) { this.screen = "list"; this.tui.requestRender(); return; }
-						this.done({ action: "chain", agents, task: this.taskEditor.buffer, skipClarify: this.skipClarify }); return;
+						this.done({ action: "chain", agents, task: this.taskEditor.buffer, skipClarify: this.skipClarify, ...this.launchFlags() }); return;
 					}
 					const name = this.getAgentEntry(this.chainAgentIds[0] ?? null)?.config.name;
 					if (!name) { this.screen = "list"; this.tui.requestRender(); return; }
-					this.done({ action: "launch", agent: name, task: this.taskEditor.buffer, skipClarify: this.skipClarify }); return;
+					this.done({ action: "launch", agent: name, task: this.taskEditor.buffer, skipClarify: this.skipClarify, ...this.launchFlags() }); return;
 				}
 				return;
 			}
@@ -628,16 +681,16 @@ export class AgentManagerComponent implements Component {
 				return renderParallel(this.parallelState, agentOptions, w, this.theme);
 			}
 			case "task-input": {
-				if (this.chainLaunchId) { const entry = this.getChainEntry(this.chainLaunchId); const title = entry ? `Chain: ${entry.config.name}` : "Chain"; return renderTaskInput(title, this.taskEditor, this.skipClarify, w, this.theme); }
-				if (this.parallelMode && this.parallelState) return renderTaskInput(formatParallelTitle(this.parallelState.slots), this.taskEditor, this.skipClarify, w, this.theme);
+				if (this.chainLaunchId) { const entry = this.getChainEntry(this.chainLaunchId); const title = entry ? `Chain: ${entry.config.name}` : "Chain"; return renderTaskInput(title, this.taskEditor, this.skipClarify, w, this.theme, this.launchToggleState()); }
+				if (this.parallelMode && this.parallelState) return renderTaskInput(formatParallelTitle(this.parallelState.slots), this.taskEditor, this.skipClarify, w, this.theme, this.launchToggleState());
 				if (this.chainAgentIds.length > 1) {
 					const names = this.chainAgentIds
 						.map((id) => this.getAgentEntry(id)?.config.name)
 						.filter((name): name is string => Boolean(name));
-					return renderTaskInput(`Chain: ${names.join(" → ")}`, this.taskEditor, this.skipClarify, w, this.theme);
+					return renderTaskInput(`Chain: ${names.join(" → ")}`, this.taskEditor, this.skipClarify, w, this.theme, this.launchToggleState());
 				}
 				const name = this.getAgentEntry(this.chainAgentIds[0] ?? null)?.config.name ?? "Agent";
-				return renderTaskInput(`Run: ${name}`, this.taskEditor, this.skipClarify, w, this.theme);
+				return renderTaskInput(`Run: ${name}`, this.taskEditor, this.skipClarify, w, this.theme, this.launchToggleState());
 			}
 			case "confirm-delete": return this.renderConfirmDelete(w);
 			case "name-input": return this.renderNameInput(w);

package/async-execution.ts

@@ -12,12 +12,13 @@ import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { AgentConfig } from "./agents.ts";
 import { applyThinkingSuffix } from "./pi-args.ts";
 import { injectSingleOutputInstruction, resolveSingleOutputPath } from "./single-output.ts";
-import { isParallelStep, resolveStepBehavior, type ChainStep, type SequentialStep, type StepOverrides } from "./settings.ts";
+import { buildChainInstructions, isParallelStep, resolveStepBehavior, writeInitialProgressFile, type ChainStep, type ResolvedStepBehavior, type SequentialStep, type StepOverrides } from "./settings.ts";
 import type { RunnerStep } from "./parallel-utils.ts";
 import { resolvePiPackageRoot } from "./pi-spawn.ts";
 import { buildSkillInjection, normalizeSkillInput, resolveSkillsWithFallback } from "./skills.ts";
 import { resolveChildCwd } from "./utils.ts";
 import { buildModelCandidates, resolveModelCandidate, type AvailableModelInfo } from "./model-fallback.ts";
+import { resolveExpectedWorktreeAgentCwd } from "./worktree.ts";
 import {
 	type ArtifactConfig,
 	type Details,
@@ -221,12 +222,22 @@ export function executeAsyncChain(
 		};
 	}
 
-	const buildSeqStep = (s: SequentialStep, sessionFile?: string) => {
+	let progressInstructionCreated = false;
+	const buildStepOverrides = (s: SequentialStep): StepOverrides => {
+		const stepSkillInput = normalizeSkillInput(s.skill);
+		return {
+			...(s.output !== undefined ? { output: s.output } : {}),
+			...(s.reads !== undefined ? { reads: s.reads } : {}),
+			...(s.progress !== undefined ? { progress: s.progress } : {}),
+			...(stepSkillInput !== undefined ? { skills: stepSkillInput } : {}),
+			...(s.model ? { model: s.model } : {}),
+		};
+	};
+	const buildSeqStep = (s: SequentialStep, sessionFile?: string, behaviorCwd?: string, progressPrecreated = false, resolvedBehavior?: ResolvedStepBehavior) => {
 		const a = agents.find((x) => x.name === s.agent)!;
 		const stepCwd = resolveChildCwd(runnerCwd, s.cwd);
-		const stepSkillInput = normalizeSkillInput(s.skill);
-		const stepOverrides: StepOverrides = { skills: stepSkillInput };
-		const behavior = resolveStepBehavior(a, stepOverrides, chainSkills);
+		const instructionCwd = behaviorCwd ?? stepCwd;
+		const behavior = resolvedBehavior ?? resolveStepBehavior(a, buildStepOverrides(s), chainSkills);
 		const skillNames = behavior.skills === false ? [] : behavior.skills;
 		const { resolved: resolvedSkills } = resolveSkillsWithFallback(skillNames, stepCwd, ctx.cwd);
 
@@ -236,16 +247,20 @@ export function executeAsyncChain(
 			systemPrompt = systemPrompt ? `${systemPrompt}\n\n${injection}` : injection;
 		}
 
-		const outputPath = resolveSingleOutputPath(s.output, ctx.cwd, stepCwd);
-		const task = injectSingleOutputInstruction(s.task ?? "{previous}", outputPath);
+		const readInstructions = buildChainInstructions({ ...behavior, output: false, progress: false }, instructionCwd, false);
+		const isFirstProgressAgent = behavior.progress && !progressPrecreated && !progressInstructionCreated;
+		if (behavior.progress) progressInstructionCreated = true;
+		const progressInstructions = buildChainInstructions({ ...behavior, output: false, reads: false }, runnerCwd, isFirstProgressAgent);
+		const outputPath = resolveSingleOutputPath(behavior.output, ctx.cwd, instructionCwd);
+		const task = injectSingleOutputInstruction(`${readInstructions.prefix}${s.task ?? "{previous}"}${progressInstructions.suffix}`, outputPath);
 
-		const primaryModel = resolveModelCandidate(s.model ?? a.model, availableModels, ctx.currentModelProvider);
+		const primaryModel = resolveModelCandidate(behavior.model ?? a.model, availableModels, ctx.currentModelProvider);
 		return {
 			agent: s.agent,
 			task,
 			cwd: stepCwd,
 			model: applyThinkingSuffix(primaryModel, a.thinking),
-			modelCandidates: buildModelCandidates(s.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
+			modelCandidates: buildModelCandidates(behavior.model ?? a.model, a.fallbackModels, availableModels, ctx.currentModelProvider).map((candidate) =>
 				applyThinkingSuffix(candidate, a.thinking),
 			),
 			tools: a.tools,
@@ -269,17 +284,29 @@ export function executeAsyncChain(
 		return sessionFile;
 	};
 
-	const steps: RunnerStep[] = chain.map((s) => {
+	const steps: RunnerStep[] = chain.map((s, stepIndex) => {
 		if (isParallelStep(s)) {
+			const parallelBehaviors = s.parallel.map((task) => {
+				const agent = agents.find((candidate) => candidate.name === task.agent)!;
+				return resolveStepBehavior(agent, buildStepOverrides(task), chainSkills);
+			});
+			const progressPrecreated = parallelBehaviors.some((behavior) => behavior.progress);
+			if (progressPrecreated) {
+				if (!s.worktree) writeInitialProgressFile(runnerCwd);
+				progressInstructionCreated = true;
+			}
 			return {
-				parallel: s.parallel.map((t) => buildSeqStep({
-					agent: t.agent,
-					task: t.task,
-					cwd: t.cwd,
-					skill: t.skill,
-					model: t.model,
-					output: t.output,
-				}, nextSessionFile())),
+				parallel: s.parallel.map((t, taskIndex) => {
+					let behaviorCwd: string | undefined;
+					if (s.worktree) {
+						try {
+							behaviorCwd = resolveExpectedWorktreeAgentCwd(runnerCwd, `${id}-s${stepIndex}`, taskIndex);
+						} catch {
+							behaviorCwd = undefined;
+						}
+					}
+					return buildSeqStep(t, nextSessionFile(), behaviorCwd, progressPrecreated, parallelBehaviors[taskIndex]);
+				}),
 				concurrency: s.concurrency,
 				failFast: s.failFast,
 				worktree: s.worktree,

package/chain-execution.ts

@@ -15,6 +15,7 @@ import {
 	resolveStepBehavior,
 	resolveParallelBehaviors,
 	buildChainInstructions,
+	writeInitialProgressFile,
 	createParallelDirs,
 	aggregateParallelOutputs,
 	isParallelStep,
@@ -26,6 +27,7 @@ import {
 	type ResolvedTemplates,
 } from "./settings.ts";
 import { discoverAvailableSkills, normalizeSkillInput } from "./skills.ts";
+import { INTERCOM_BRIDGE_MARKER } from "./intercom-bridge.ts";
 import { runSync } from "./execution.ts";
 import { buildChainSummary } from "./formatters.ts";
 import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, resolveChildCwd } from "./utils.ts";
@@ -46,6 +48,7 @@ import {
 	type ArtifactPaths,
 	type ControlEvent,
 	type Details,
+	type IntercomEventBus,
 	type ResolvedControlConfig,
 	type SingleResult,
 	MAX_CONCURRENCY,
@@ -75,6 +78,7 @@ interface ParallelChainRunInput {
 	prev: string;
 	originalTask: string;
 	ctx: ExtensionContext;
+	intercomEvents?: IntercomEventBus;
 	cwd?: string;
 	runId: string;
 	globalTaskIndex: number;
@@ -134,8 +138,7 @@ function ensureParallelProgressFile(
 	if (progressCreated || !parallelBehaviors.some((behavior) => behavior.progress)) {
 		return progressCreated;
 	}
-	const progressPath = path.join(chainDir, "progress.md");
-	fs.writeFileSync(progressPath, "# Progress\n\n## Status\nIn Progress\n\n## Tasks\n\n## Files Changed\n\n## Notes\n");
+	writeInitialProgressFile(chainDir);
 	return true;
 }
 
@@ -221,6 +224,8 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				cwd: taskCwd,
 				signal: input.signal,
 				interruptSignal: interruptController.signal,
+				allowIntercomDetach: taskAgentConfig?.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+				intercomEvents: input.intercomEvents,
 				runId: input.runId,
 				index: input.globalTaskIndex + taskIndex,
 				sessionDir: input.sessionDirForIndex(input.globalTaskIndex + taskIndex),
@@ -287,6 +292,7 @@ export interface ChainExecutionParams {
 	task?: string;
 	agents: AgentConfig[];
 	ctx: ExtensionContext;
+	intercomEvents?: IntercomEventBus;
 	signal?: AbortSignal;
 	runId: string;
 	cwd?: string;
@@ -352,6 +358,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 		controlConfig,
 		childIntercomTarget,
 		foregroundControl,
+		intercomEvents,
 		chainSkills: chainSkillsParam,
 		chainDir: chainDirBase,
 	} = params;
@@ -536,6 +543,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					prev,
 					originalTask,
 					ctx,
+					intercomEvents,
 					cwd,
 					runId,
 					globalTaskIndex,
@@ -709,6 +717,8 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				cwd: resolveChildCwd(cwd ?? ctx.cwd, seqStep.cwd),
 				signal,
 				interruptSignal: interruptController.signal,
+				allowIntercomDetach: agentConfig.systemPrompt?.includes(INTERCOM_BRIDGE_MARKER) === true,
+				intercomEvents,
 				runId,
 				index: globalTaskIndex,
 				sessionDir: sessionDirForIndex(globalTaskIndex),