pi-subagents 0.18.1 → 0.19.0

package/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## [Unreleased]
 
+## [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),

package/execution.ts

@@ -243,13 +243,11 @@ async function runSingleAttempt(
 		};
 
 		const unsubscribeIntercomDetach = options.intercomEvents?.on?.(INTERCOM_DETACH_REQUEST_EVENT, (payload) => {
-			if (!options.allowIntercomDetach || detached || processClosed) return;
+			if (!options.allowIntercomDetach || detached || processClosed || !intercomStarted) return;
 			if (!payload || typeof payload !== "object") return;
 			const requestId = (payload as { requestId?: unknown }).requestId;
 			if (typeof requestId !== "string" || requestId.length === 0) return;
-			const accepted = intercomStarted;
-			options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted });
-			if (!accepted) return;
+			options.intercomEvents?.emit(INTERCOM_DETACH_RESPONSE_EVENT, { requestId, accepted: true });
 			detachForIntercom();
 		});
 

package/index.ts

@@ -401,7 +401,7 @@ EXECUTION (use exactly ONE mode):
 • Before executing, use { action: "list" } to inspect configured agents/chains. Only execute agents listed as executable/non-disabled.
 • SINGLE: { agent, task? } - one task; omit task for self-contained agents
 • CHAIN: { chain: [{agent:"agent-a"}, {parallel:[{agent:"agent-b",count:3}]}] } - sequential pipeline with optional parallel fan-out
-• PARALLEL: { tasks: [{agent,task,count?}, ...], concurrency?: number, worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
+• PARALLEL: { tasks: [{agent,task,count?,output?,reads?,progress?}, ...], concurrency?: number, worktree?: true } - concurrent execution (worktree: isolate each task in a git worktree)
 • Optional context: { context: "fresh" | "fork" } (default: "fresh")
 
 CHAIN TEMPLATE VARIABLES (use in task strings):

package/intercom-bridge.ts

@@ -8,14 +8,14 @@ const DEFAULT_INTERCOM_EXTENSION_DIR = path.join(os.homedir(), ".pi", "agent", "
 const DEFAULT_INTERCOM_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "intercom", "config.json");
 const DEFAULT_SUBAGENT_CONFIG_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", "subagent");
 const DEFAULT_INTERCOM_TARGET_PREFIX = "subagent-chat";
-const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
+export const INTERCOM_BRIDGE_MARKER = "Intercom orchestration channel:";
 const DEFAULT_INTERCOM_BRIDGE_TEMPLATE = `The inherited thread is reference-only. Do not continue that conversation or send questions, status updates, or completion handoffs to the orchestrator in normal assistant text.
 
 Use intercom only for coordination with the orchestrator session "{orchestratorTarget}".
 - Need a decision or 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.`;
 
 export interface IntercomBridgeState {
 	active: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-subagents",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "description": "Pi extension for delegating tasks to subagents with chains, parallel execution, and TUI clarification",
   "author": "Nico Bailon",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "*.mjs",
     "agents/",
     "skills/**/*",
+    "prompts/**/*",
     "README.md",
     "CHANGELOG.md"
   ],
@@ -46,6 +47,9 @@
     ],
     "skills": [
       "./skills"
+    ],
+    "prompts": [
+      "./prompts"
     ]
   },
   "peerDependencies": {

package/prompts/parallel-review.md

@@ -0,0 +1,8 @@
+---
+description: Parallel subagents review
+---
+Great. Now let's launch parallel reviewers to conduct an adversarial review.
+
+Important: launch reviewers with fresh context, not forked context. Reviewers should inspect the repository and current diff directly from files and commands, without inheriting the main agent chat. Use forked context only if I explicitly ask for it.
+
+$@

package/schemas.ts

@@ -26,6 +26,9 @@ export const TaskItem = Type.Object({
 	task: Type.String(), 
 	cwd: Type.Optional(Type.String()),
 	count: Type.Optional(Type.Integer({ minimum: 1, description: "Repeat this parallel task N times with the same settings." })),
+	output: Type.Optional(OutputOverride),
+	reads: Type.Optional(ReadsOverride),
+	progress: Type.Optional(Type.Boolean({ description: "Enable progress.md tracking for this task" })),
 	model: Type.Optional(Type.String({ description: "Override model for this task (e.g. 'google/gemini-3-pro')" })),
 	skill: Type.Optional(SkillOverride),
 });
@@ -124,7 +127,7 @@ export const SubagentParams = Type.Object({
 		additionalProperties: true,
 		description: "Agent or chain config for create/update. Agent: name, description, scope ('user'|'project', default 'user'), systemPrompt, systemPromptMode, inheritProjectContext, inheritSkills, model, tools (comma-separated), extensions (comma-separated), skills (comma-separated), thinking, output, reads, progress, maxSubagentDepth. Chain: name, description, scope, steps (array of {agent, task?, output?, reads?, model?, skills?, progress?}). Presence of 'steps' creates a chain instead of an agent. String values must be valid JSON."
 	})),
-	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task, count?}, ...]" })),
+	tasks: Type.Optional(Type.Array(TaskItem, { description: "PARALLEL mode: [{agent, task, count?, output?, reads?, progress?}, ...]" })),
 	concurrency: Type.Optional(Type.Integer({ minimum: 1, description: "Top-level PARALLEL mode only: max concurrent tasks. Defaults to config.parallel.concurrency or 4." })),
 	worktree: Type.Optional(Type.Boolean({
 		description: "Create isolated git worktrees for each parallel task. " +