pi-subagents 0.22.0 → 0.23.1

package/src/runs/foreground/chain-clarify.ts

@@ -9,9 +9,8 @@ import type { Theme } from "@mariozechner/pi-coding-agent";
 import type { Component, TUI } from "@mariozechner/pi-tui";
 import { matchesKey, visibleWidth, truncateToWidth } from "@mariozechner/pi-tui";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import type { AgentConfig, ChainConfig, ChainStepConfig } from "../../agents/agents.ts";
+import { getUserChainDir, type AgentConfig, type ChainConfig, type ChainStepConfig } from "../../agents/agents.ts";
 import type { ResolvedStepBehavior } from "../../shared/settings.ts";
 import type { TextEditorState } from "../../tui/text-editor.ts";
 import { createEditorState, ensureCursorVisible, getCursorDisplayPos, handleEditorInput, renderEditor, wrapText } from "../../tui/text-editor.ts";
@@ -317,7 +316,7 @@ export class ChainClarifyComponent implements Component {
 				return;
 			}
 			try {
-				const dir = path.join(os.homedir(), ".pi", "agent", "agents");
+				const dir = getUserChainDir();
 				fs.mkdirSync(dir, { recursive: true });
 				const filePath = path.join(dir, `${name}.chain.md`);
 				const config = this.buildChainConfig(name);

package/src/runs/foreground/chain-execution.ts

@@ -18,6 +18,7 @@ import {
 	buildChainInstructions,
 	writeInitialProgressFile,
 	createParallelDirs,
+	suppressProgressForReadOnlyTask,
 	aggregateParallelOutputs,
 	isParallelStep,
 	type StepOverrides,
@@ -178,8 +179,8 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				} as SingleResult;
 			}
 
-			const behavior = input.parallelBehaviors[taskIndex]!;
 			const taskTemplate = input.parallelTemplates[taskIndex] ?? "{previous}";
+			const behavior = suppressProgressForReadOnlyTask(input.parallelBehaviors[taskIndex]!, taskTemplate, input.originalTask);
 			const templateHasPrevious = taskTemplate.includes("{previous}");
 			const { prefix, suffix } = buildChainInstructions(
 				behavior,
@@ -537,7 +538,8 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 
 			try {
 				const agentNames = step.parallel.map((task) => task.agent);
-				const parallelBehaviors = resolveParallelBehaviors(step.parallel, agents, stepIndex, chainSkills);
+				const parallelBehaviors = resolveParallelBehaviors(step.parallel, agents, stepIndex, chainSkills)
+					.map((behavior, taskIndex) => suppressProgressForReadOnlyTask(behavior, parallelTemplates[taskIndex] ?? step.parallel[taskIndex]?.task, originalTask));
 				for (let taskIndex = 0; taskIndex < step.parallel.length; taskIndex++) {
 					const behavior = parallelBehaviors[taskIndex]!;
 					const outputPath = typeof behavior.output === "string"
@@ -616,6 +618,23 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 						}),
 					};
 				}
+				const detachedIndexInStep = parallelResults.findIndex((result) => result.detached);
+				const detached = detachedIndexInStep >= 0 ? parallelResults[detachedIndexInStep] : undefined;
+				if (detached) {
+					return {
+						content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${detached.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
+						details: buildChainExecutionDetails({
+							results,
+							includeProgress,
+							allProgress,
+							allArtifactPaths,
+							artifactsDir,
+							chainAgents,
+							totalSteps,
+							currentStepIndex: stepIndex,
+						}),
+					};
+				}
 
 				const failures = parallelResults
 					.map((result, originalIndex) => ({ ...result, originalIndex }))
@@ -695,7 +714,7 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 						? tuiOverride.skills
 						: normalizeSkillInput(seqStep.skill),
 			};
-			const behavior = resolveStepBehavior(agentConfig, stepOverride, chainSkills);
+			const behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(agentConfig, stepOverride, chainSkills), stepTemplate, originalTask);
 
 			const isFirstProgress = behavior.progress && !progressCreated;
 			if (isFirstProgress) {
@@ -822,24 +841,6 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 			if (r.progress) allProgress.push(r.progress);
 			if (r.artifactPaths) allArtifactPaths.push(r.artifactPaths);
 
-			if (behavior.output && r.exitCode === 0) {
-				try {
-					const expectedPath = path.isAbsolute(behavior.output)
-						? behavior.output
-						: path.join(chainDir, behavior.output);
-					if (!fs.existsSync(expectedPath)) {
-						const dirFiles = fs.readdirSync(chainDir);
-						const mdFiles = dirFiles.filter((file) => file.endsWith(".md") && file !== "progress.md");
-						const warning = mdFiles.length > 0
-							? `Agent wrote to different file(s): ${mdFiles.join(", ")} instead of ${behavior.output}`
-							: `Agent did not create expected output file: ${behavior.output}`;
-						r.error = r.error ? `${r.error}\n${warning}` : warning;
-					}
-				} catch {
-					// Ignore validation errors - this is just a diagnostic
-				}
-			}
-
 			if (r.interrupted) {
 				return {
 					content: [{ type: "text", text: `Chain paused after interrupt at step ${stepIndex + 1} (${r.agent}). Waiting for explicit next action.` }],
@@ -855,6 +856,21 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 					}),
 				};
 			}
+			if (r.detached) {
+				return {
+					content: [{ type: "text", text: `Chain detached for intercom coordination at step ${stepIndex + 1} (${r.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
+					details: buildChainExecutionDetails({
+						results,
+						includeProgress,
+						allProgress,
+						allArtifactPaths,
+						artifactsDir,
+						chainAgents,
+						totalSteps,
+						currentStepIndex: stepIndex,
+					}),
+				};
+			}
 
 			if (r.exitCode !== 0) {
 				const summary = buildChainSummary(chainSteps, results, chainDir, "failed", {
@@ -877,6 +893,24 @@ export async function executeChain(params: ChainExecutionParams): Promise<ChainE
 				};
 			}
 
+			if (behavior.output) {
+				try {
+					const expectedPath = path.isAbsolute(behavior.output)
+						? behavior.output
+						: path.join(chainDir, behavior.output);
+					if (!fs.existsSync(expectedPath)) {
+						const dirFiles = fs.readdirSync(chainDir);
+						const mdFiles = dirFiles.filter((file) => file.endsWith(".md") && file !== "progress.md");
+						const warning = mdFiles.length > 0
+							? `Agent wrote to different file(s): ${mdFiles.join(", ")} instead of ${behavior.output}`
+							: `Agent did not create expected output file: ${behavior.output}`;
+						r.error = r.error ? `${r.error}\n${warning}` : warning;
+					}
+				} catch {
+					// Ignore validation errors; this diagnostic should not mask successful chain output.
+				}
+			}
+
 			prev = getSingleResultOutput(r);
 		}
 	}

package/src/runs/foreground/execution.ts

@@ -421,7 +421,7 @@ async function runSingleAttempt(
 				const toolArgs = evt.args && typeof evt.args === "object" && !Array.isArray(evt.args)
 					? evt.args as Record<string, unknown>
 					: {};
-				if (options.allowIntercomDetach && evt.toolName === "intercom") {
+				if (options.allowIntercomDetach && (evt.toolName === "intercom" || evt.toolName === "contact_supervisor")) {
 					intercomStarted = true;
 				}
 				progress.toolCount++;
@@ -633,7 +633,10 @@ async function runSingleAttempt(
 		return result;
 	}
 
-	if (exitCode === 0 && !result.error) {
+	if (result.error && result.exitCode === 0) {
+		result.exitCode = 1;
+	}
+	if (result.exitCode === 0 && !result.error) {
 		const errInfo = detectSubagentError(result.messages);
 		if (errInfo.hasError) {
 			result.exitCode = errInfo.exitCode ?? 1;
@@ -746,7 +749,6 @@ export async function runSync(
 
 	const shareEnabled = options.share === true;
 	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
-	const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
 	const skillNames = options.skills ?? agent.skills ?? [];
 	const skillCwd = options.cwd ?? runtimeCwd;
 	const { resolved: resolvedSkills, missing: missingSkills } = resolveSkillsWithFallback(skillNames, skillCwd, runtimeCwd);
@@ -797,6 +799,7 @@ export async function runSync(
 	for (let i = 0; i < modelsToTry.length; i++) {
 		const candidate = modelsToTry[i];
 		if (candidate) attemptedModels.push(candidate);
+		const outputSnapshot = captureSingleOutputSnapshot(options.outputPath);
 		const result = await runSingleAttempt(runtimeCwd, agent, task, candidate, options, {
 			sessionEnabled,
 			systemPrompt,
@@ -811,15 +814,16 @@ export async function runSync(
 		sumUsage(aggregateUsage, result.usage);
 		totalToolCount += result.progressSummary?.toolCount ?? 0;
 		totalDurationMs += result.progressSummary?.durationMs ?? 0;
+		const attemptSucceeded = result.exitCode === 0 && !result.error;
 		const attempt: ModelAttempt = {
 			model: candidate ?? result.model ?? agent.model ?? "default",
-			success: result.exitCode === 0,
+			success: attemptSucceeded,
 			exitCode: result.exitCode,
 			error: result.error,
 			usage: { ...result.usage },
 		};
 		modelAttempts.push(attempt);
-		if (result.exitCode === 0) {
+		if (attemptSucceeded) {
 			break;
 		}
 		if (!isRetryableModelFailure(result.error) || i === modelsToTry.length - 1) {

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

@@ -22,13 +22,15 @@ import {
 	getStepAgents,
 	isParallelStep,
 	resolveStepBehavior,
+	suppressProgressForReadOnlyTask,
+	taskDisallowsFileUpdates,
 	type ChainStep,
 	type ResolvedStepBehavior,
 	type SequentialStep,
 	type StepOverrides,
 } from "../../shared/settings.ts";
 import { discoverAvailableSkills, normalizeSkillInput } from "../../agents/skills.ts";
-import { executeAsyncChain, executeAsyncSingle, isAsyncAvailable } from "../background/async-execution.ts";
+import { executeAsyncChain, executeAsyncSingle, formatAsyncStartedMessage, isAsyncAvailable } from "../background/async-execution.ts";
 import { createForkContextResolver } from "../../shared/fork-context.ts";
 import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
 import { applyIntercomBridgeToAgent, INTERCOM_BRIDGE_MARKER, resolveIntercomBridge, resolveIntercomSessionTarget, resolveSubagentIntercomTarget, type IntercomBridgeState } from "../../intercom/intercom-bridge.ts";
@@ -206,6 +208,115 @@ function foregroundStatusResult(control: SubagentState["foregroundControls"] ext
 	return { content: [{ type: "text", text: lines.join("\n") }], details: { mode: "management", results: [] } };
 }
 
+function rememberForegroundRun(state: SubagentState, input: { runId: string; mode: "single" | "parallel" | "chain"; cwd: string; results: SingleResult[] }): void {
+	state.foregroundRuns ??= new Map();
+	state.foregroundRuns.set(input.runId, {
+		runId: input.runId,
+		mode: input.mode,
+		cwd: input.cwd,
+		updatedAt: Date.now(),
+		children: input.results.map((result, index) => ({
+			agent: result.agent,
+			index,
+			status: resolveSubagentResultStatus({ exitCode: result.exitCode, interrupted: result.interrupted, detached: result.detached }),
+			...(result.sessionFile ? { sessionFile: result.sessionFile } : {}),
+		})),
+	});
+	while (state.foregroundRuns.size > 50) {
+		const oldest = [...state.foregroundRuns.values()].sort((left, right) => left.updatedAt - right.updatedAt)[0];
+		if (!oldest) break;
+		state.foregroundRuns.delete(oldest.runId);
+	}
+}
+
+function resolveForegroundResumeTarget(params: SubagentParamsLike, state: SubagentState): { runId: string; mode: "single" | "parallel" | "chain"; state: "complete"; agent: string; index: number; intercomTarget: string; cwd: string; sessionFile: string } | undefined {
+	const requested = (params.id ?? params.runId)?.trim();
+	if (!requested || !state.foregroundRuns?.size) return undefined;
+	const direct = state.foregroundRuns.get(requested);
+	const matches = direct ? [direct] : [...state.foregroundRuns.values()].filter((run) => run.runId.startsWith(requested));
+	if (matches.length === 0) return undefined;
+	if (matches.length > 1) throw new Error(`Ambiguous foreground run id prefix '${requested}' matched: ${matches.map((run) => run.runId).join(", ")}. Provide a longer id.`);
+	const run = matches[0]!;
+	if (run.children.length > 1 && params.index === undefined) throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Provide index to choose one.`);
+	const index = params.index ?? 0;
+	if (!Number.isInteger(index)) throw new Error(`Foreground run '${run.runId}' index must be an integer.`);
+	if (index < 0 || index >= run.children.length) throw new Error(`Foreground run '${run.runId}' has ${run.children.length} children. Index ${index} is out of range.`);
+	const child = run.children[index]!;
+	if (child.status === "detached") throw new Error(`Foreground run '${run.runId}' child ${index} is detached for intercom coordination and cannot be revived safely from the remembered foreground state. Reply to the supervisor request first; after the child exits, start a fresh follow-up if needed.`);
+	if (!child.sessionFile) throw new Error(`Foreground run '${run.runId}' child ${index} does not have a persisted session file to resume from.`);
+	if (path.extname(child.sessionFile) !== ".jsonl") throw new Error(`Foreground run '${run.runId}' child ${index} session file must be a .jsonl file: ${child.sessionFile}`);
+	const sessionFile = path.resolve(child.sessionFile);
+	if (!fs.existsSync(sessionFile)) throw new Error(`Foreground run '${run.runId}' child ${index} session file does not exist: ${child.sessionFile}`);
+	return { runId: run.runId, mode: run.mode, state: "complete", agent: child.agent, index, intercomTarget: resolveSubagentIntercomTarget(run.runId, child.agent, index), cwd: run.cwd, sessionFile };
+}
+
+type AsyncResumeSourceTarget = ReturnType<typeof resolveAsyncResumeTarget> & { source: "async" };
+type ForegroundResumeSourceTarget = NonNullable<ReturnType<typeof resolveForegroundResumeTarget>> & { kind: "revive"; source: "foreground" };
+type ResumeSourceTarget = AsyncResumeSourceTarget | ForegroundResumeSourceTarget;
+
+function isAsyncRunNotFound(error: unknown): boolean {
+	return error instanceof Error && error.message.startsWith("Async run not found.");
+}
+
+function isResumeAmbiguity(error: unknown): boolean {
+	return error instanceof Error && /Ambiguous .*run id prefix/.test(error.message);
+}
+
+function resumeTargetExact(target: { runId: string } | undefined, requested: string): boolean {
+	return target?.runId === requested;
+}
+
+function escapeRegExp(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function isExactResumeError(error: unknown, source: "async" | "foreground", requested: string): boolean {
+	if (!(error instanceof Error) || !requested) return false;
+	return new RegExp(`\\b${source} run '${escapeRegExp(requested)}'`, "i").test(error.message);
+}
+
+function resolveResumeTarget(params: SubagentParamsLike, state: SubagentState): ResumeSourceTarget {
+	const requested = (params.id ?? params.runId)?.trim() ?? "";
+	let foregroundTarget: ForegroundResumeSourceTarget | undefined;
+	let foregroundError: unknown;
+	let asyncTarget: AsyncResumeSourceTarget | undefined;
+	let asyncError: unknown;
+
+	try {
+		const target = resolveForegroundResumeTarget(params, state);
+		if (target) foregroundTarget = { kind: "revive", source: "foreground", ...target };
+	} catch (error) {
+		foregroundError = error;
+	}
+	try {
+		asyncTarget = { source: "async", ...resolveAsyncResumeTarget(params) };
+	} catch (error) {
+		asyncError = error;
+	}
+
+	if (foregroundTarget && asyncTarget) {
+		const foregroundExact = resumeTargetExact(foregroundTarget, requested);
+		const asyncExact = resumeTargetExact(asyncTarget, requested);
+		if (foregroundExact && !asyncExact) return foregroundTarget;
+		if (asyncExact && !foregroundExact) return asyncTarget;
+		throw new Error(`Resume id '${requested}' is ambiguous between foreground run '${foregroundTarget.runId}' and async run '${asyncTarget.runId}'. Provide a full run id.`);
+	}
+	if (foregroundTarget) {
+		if (isExactResumeError(asyncError, "async", requested)) throw asyncError;
+		if (isResumeAmbiguity(asyncError) && !resumeTargetExact(foregroundTarget, requested)) throw asyncError;
+		return foregroundTarget;
+	}
+	if (asyncTarget) {
+		if (isExactResumeError(foregroundError, "foreground", requested)) throw foregroundError;
+		if (isResumeAmbiguity(foregroundError) && !resumeTargetExact(asyncTarget, requested)) throw foregroundError;
+		return asyncTarget;
+	}
+	if (foregroundError && !isAsyncRunNotFound(asyncError)) throw foregroundError;
+	if (foregroundError) throw foregroundError;
+	if (asyncError) throw asyncError;
+	throw new Error("Run not found. Provide id or runId.");
+}
+
 function getAsyncInterruptTarget(state: SubagentState, runId: string | undefined): { asyncId: string; asyncDir: string } | undefined {
 	if (runId) {
 		const direct = state.asyncJobs.get(runId);
@@ -296,9 +407,9 @@ async function resumeAsyncRun(input: {
 		};
 	}
 
-	let target: ReturnType<typeof resolveAsyncResumeTarget>;
+	let target: ResumeSourceTarget;
 	try {
-		target = resolveAsyncResumeTarget(input.params);
+		target = resolveResumeTarget(input.params, input.deps.state);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
 		return { content: [{ type: "text", text: message }], isError: true, details: { mode: "management", results: [] } };
@@ -344,6 +455,7 @@ async function resumeAsyncRun(input: {
 		config: input.deps.config.intercomBridge,
 		context: input.params.context,
 		orchestratorTarget: sessionName,
+		cwd: effectiveCwd,
 	});
 	const agents = intercomBridge.active
 		? discoveredAgents.map((agent) => applyIntercomBridgeToAgent(agent, intercomBridge))
@@ -351,7 +463,7 @@ async function resumeAsyncRun(input: {
 	const agentConfig = agents.find((agent) => agent.name === target.agent);
 	if (!agentConfig) {
 		return {
-			content: [{ type: "text", text: `Unknown agent for async resume: ${target.agent}` }],
+			content: [{ type: "text", text: `Unknown agent for resume: ${target.agent}` }],
 			isError: true,
 			details: { mode: "management", results: [] },
 		};
@@ -389,16 +501,17 @@ async function resumeAsyncRun(input: {
 
 	const revivedId = result.details.asyncId ?? runId;
 	const revivedTarget = intercomBridge.active ? resolveSubagentIntercomTarget(revivedId, target.agent, 0) : undefined;
+	const sourceLabel = target.source === "foreground" ? "foreground" : "async";
 	const lines = [
-		`Revived async subagent from ${target.runId}.`,
+		`Revived ${sourceLabel} subagent from ${target.runId}.`,
 		`Revived run: ${revivedId}`,
 		`Agent: ${target.agent}`,
 		`Session: ${target.sessionFile}`,
 		result.details.asyncDir ? `Async dir: ${result.details.asyncDir}` : undefined,
 		revivedTarget ? `Intercom target: ${revivedTarget} (if registered)` : undefined,
-		`Follow: subagent({ action: "status", id: "${revivedId}" })`,
+		`Status if needed: subagent({ action: "status", id: "${revivedId}" })`,
 	].filter((line): line is string => Boolean(line));
-	return { content: [{ type: "text", text: lines.join("\n") }], details: result.details };
+	return { content: [{ type: "text", text: formatAsyncStartedMessage(lines.join("\n")) }], details: result.details };
 }
 
 function resultSummaryForIntercom(result: SingleResult): string {
@@ -835,6 +948,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		const chain = wrapChainTasksForFork(params.chain as ChainStep[], params.context);
 		return executeAsyncChain(id, {
 			chain,
+			task: params.task,
 			agents,
 			ctx: asyncCtx,
 			availableModels,
@@ -971,6 +1085,7 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 		const asyncChain = wrapChainTasksForFork(chainResult.requestedAsync.chain, params.context);
 		return executeAsyncChain(id, {
 			chain: asyncChain,
+			task: params.task,
 			agents,
 			ctx: asyncCtx,
 			availableModels: ctx.modelRegistry.getAvailable().map(toModelInfo),
@@ -991,8 +1106,9 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 		});
 	}
 
-	const chainDetails = chainResult.details ? compactForegroundDetails(chainResult.details) : undefined;
-	const intercomReceipt = chainDetails && !chainDetails.results.some((result) => result.interrupted)
+	const chainDetails = chainResult.details ? compactForegroundDetails({ ...chainResult.details, runId }) : undefined;
+	if (chainDetails) rememberForegroundRun(deps.state, { runId, mode: "chain", cwd: effectiveCwd, results: chainDetails.results });
+	const intercomReceipt = chainDetails && !chainDetails.results.some((result) => result.interrupted || result.detached)
 		? await maybeBuildForegroundIntercomReceipt({
 			pi: deps.pi,
 			intercomBridge: data.intercomBridge,
@@ -1009,7 +1125,7 @@ async function runChainPath(data: ExecutionContextData, deps: ExecutorDeps): Pro
 		};
 	}
 
-	return chainResult;
+	return chainDetails ? { ...chainResult, details: chainDetails } : chainResult;
 }
 
 interface ForegroundParallelRunInput {
@@ -1375,17 +1491,21 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 				currentSessionId: deps.state.currentSessionId!,
 				currentModelProvider: ctx.model?.provider,
 			};
-			const parallelTasks = tasks.map((t, i) => ({
-				agent: t.agent,
-				task: params.context === "fork" ? wrapForkTask(taskTexts[i]!) : taskTexts[i]!,
-				cwd: t.cwd,
-				...(modelOverrides[i] ? { model: modelOverrides[i] } : {}),
-				...(skillOverrides[i] !== undefined ? { skill: skillOverrides[i] } : {}),
-				...(behaviorOverrides[i]?.output !== undefined ? { output: behaviorOverrides[i]!.output } : {}),
-				...(behaviorOverrides[i]?.outputMode !== undefined ? { outputMode: behaviorOverrides[i]!.outputMode } : {}),
-				...(behaviorOverrides[i]?.reads !== undefined ? { reads: behaviorOverrides[i]!.reads } : {}),
-				...(behaviorOverrides[i]?.progress !== undefined ? { progress: behaviorOverrides[i]!.progress } : {}),
-			}));
+			const parallelTasks = tasks.map((t, i) => {
+				const taskText = params.context === "fork" ? wrapForkTask(taskTexts[i]!) : taskTexts[i]!;
+				const progress = taskDisallowsFileUpdates(taskText) ? false : behaviorOverrides[i]?.progress;
+				return {
+					agent: t.agent,
+					task: taskText,
+					cwd: t.cwd,
+					...(modelOverrides[i] ? { model: modelOverrides[i] } : {}),
+					...(skillOverrides[i] !== undefined ? { skill: skillOverrides[i] } : {}),
+					...(behaviorOverrides[i]?.output !== undefined ? { output: behaviorOverrides[i]!.output } : {}),
+					...(behaviorOverrides[i]?.outputMode !== undefined ? { outputMode: behaviorOverrides[i]!.outputMode } : {}),
+					...(behaviorOverrides[i]?.reads !== undefined ? { reads: behaviorOverrides[i]!.reads } : {}),
+					...(progress !== undefined ? { progress } : {}),
+				};
+			});
 			return executeAsyncChain(id, {
 				chain: [{ parallel: parallelTasks, concurrency: parallelConcurrency, worktree: params.worktree }],
 				resultMode: "parallel",
@@ -1410,7 +1530,7 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		}
 	}
 
-	const behaviors = agentConfigs.map((config, index) => resolveStepBehavior(config, behaviorOverrides[index]!));
+	const behaviors = agentConfigs.map((config, index) => suppressProgressForReadOnlyTask(resolveStepBehavior(config, behaviorOverrides[index]!), taskTexts[index]));
 	const firstProgressIndex = behaviors.findIndex((behavior) => behavior.progress);
 	const liveResults: (SingleResult | undefined)[] = new Array(tasks.length).fill(undefined);
 	const liveProgress: (AgentProgress | undefined)[] = new Array(tasks.length).fill(undefined);
@@ -1494,16 +1614,26 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		const interrupted = results.find((result) => result.interrupted);
 		const details = compactForegroundDetails({
 			mode: "parallel",
+			runId,
 			results,
 			progress: params.includeProgress ? allProgress : undefined,
 			artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 		});
+		rememberForegroundRun(deps.state, { runId, mode: "parallel", cwd: effectiveCwd, results: details.results });
 		if (interrupted) {
 			return {
 				content: [{ type: "text", text: `Parallel run paused after interrupt (${interrupted.agent}). Waiting for explicit next action.` }],
 				details,
 			};
 		}
+		const detachedIndex = results.findIndex((result) => result.detached);
+		const detached = detachedIndex >= 0 ? results[detachedIndex] : undefined;
+		if (detached) {
+			return {
+				content: [{ type: "text", text: `Parallel run detached for intercom coordination (${detached.agent}). Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
+				details,
+			};
+		}
 
 		const intercomReceipt = await maybeBuildForegroundIntercomReceipt({
 			pi: deps.pi,
@@ -1775,11 +1905,13 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 	});
 	const details = compactForegroundDetails({
 		mode: "single",
+		runId,
 		results: [r],
 		progress: params.includeProgress ? allProgress : undefined,
 		artifacts: allArtifactPaths.length ? { dir: artifactsDir, files: allArtifactPaths } : undefined,
 		truncation: r.truncation,
 	});
+	rememberForegroundRun(deps.state, { runId, mode: "single", cwd: effectiveCwd, results: details.results });
 
 	if (!r.detached && !r.interrupted) {
 		const intercomReceipt = await maybeBuildForegroundIntercomReceipt({
@@ -1800,7 +1932,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 
 	if (r.detached) {
 		return {
-			content: [{ type: "text", text: `Detached for intercom coordination: ${params.agent}` }],
+			content: [{ type: "text", text: `Detached for intercom coordination: ${params.agent}. Reply to the supervisor request first. After the child exits, start a fresh follow-up if needed.` }],
 			details,
 		};
 	}
@@ -1841,6 +1973,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 		ctx: ExtensionContext,
 	): Promise<AgentToolResult<Details>> => {
 		deps.state.baseCwd = ctx.cwd;
+		deps.state.foregroundRuns ??= new Map();
 		deps.state.foregroundControls ??= new Map();
 		deps.state.lastForegroundControlId ??= null;
 		const requestCwd = resolveRequestedCwd(ctx.cwd, params.cwd);
@@ -1962,6 +2095,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 			config: deps.config.intercomBridge,
 			context: effectiveParams.context,
 			orchestratorTarget: sessionName,
+			cwd: effectiveCwd,
 		});
 		const agents = intercomBridge.active
 			? discoveredAgents.map((agent) => applyIntercomBridgeToAgent(agent, intercomBridge))

package/src/runs/shared/single-output.ts

@@ -69,6 +69,7 @@ export function captureSingleOutputSnapshot(outputPath: string | undefined): Sin
 		const stat = fs.statSync(outputPath);
 		return { exists: true, mtimeMs: stat.mtimeMs, size: stat.size };
 	} catch {
+		// The snapshot is advisory; resolveSingleOutput reports concrete read/write failures.
 		return { exists: false };
 	}
 }
@@ -94,18 +95,32 @@ export function resolveSingleOutput(
 ): { fullOutput: string; savedPath?: string; saveError?: string } {
 	if (!outputPath) return { fullOutput: fallbackOutput };
 
+	let changedSinceStart = false;
 	try {
 		const stat = fs.statSync(outputPath);
-		const changedSinceStart = !beforeRun?.exists
+		changedSinceStart = !beforeRun?.exists
 			|| stat.mtimeMs !== beforeRun.mtimeMs
 			|| stat.size !== beforeRun.size;
-		if (changedSinceStart) {
+	} catch (error) {
+		const code = error && typeof error === "object" && "code" in error ? (error as { code?: unknown }).code : undefined;
+		if (code !== "ENOENT" && code !== "ENOTDIR") {
 			return {
-				fullOutput: fs.readFileSync(outputPath, "utf-8"),
-				savedPath: outputPath,
+				fullOutput: fallbackOutput,
+				saveError: `Failed to inspect output file: ${error instanceof Error ? error.message : String(error)}`,
 			};
 		}
-	} catch {}
+	}
+
+	if (changedSinceStart) {
+		try {
+			return { fullOutput: fs.readFileSync(outputPath, "utf-8"), savedPath: outputPath };
+		} catch (error) {
+			return {
+				fullOutput: fallbackOutput,
+				saveError: `Failed to read changed output file: ${error instanceof Error ? error.message : String(error)}`,
+			};
+		}
+	}
 
 	const save = persistSingleOutput(outputPath, fallbackOutput);
 	if (save.savedPath) return { fullOutput: fallbackOutput, savedPath: save.savedPath };
@@ -132,7 +147,7 @@ export function finalizeSingleOutput(params: {
 		return { displayOutput, savedPath: params.savedPath, outputReference };
 	}
 	if (params.exitCode === 0 && params.saveError && params.outputPath) {
-		displayOutput += `\n\nFailed to save output to: ${params.outputPath}\n${params.saveError}`;
+		displayOutput += `\n\nOutput file error: ${params.outputPath}\n${params.saveError}`;
 		return { displayOutput, saveError: params.saveError };
 	}
 	return { displayOutput };

package/src/shared/settings.ts

@@ -220,6 +220,25 @@ export function resolveStepBehavior(
 	return { output, outputMode, reads, progress, skills, model };
 }
 
+export function resolveTaskTextForFileUpdatePolicy(task: string | undefined, originalTask?: string): string | undefined {
+	if (!task) return originalTask;
+	return originalTask ? task.replaceAll("{task}", originalTask) : task;
+}
+
+export function taskDisallowsFileUpdates(task: string | undefined): boolean {
+	if (!task) return false;
+	return /\breview[- ]only\b/i.test(task)
+		|| /\bread[- ]only\s+(?:review|audit|inspection|pass)\b/i.test(task)
+		|| /\b(?:no|without)\s+(?:file\s+)?edits?\b/i.test(task)
+		|| /\b(?:do not|don't|must not)\s+(?:edit|modify|write|touch)\b/i.test(task)
+		|| /\bleave\s+files?\s+unchanged\b/i.test(task);
+}
+
+export function suppressProgressForReadOnlyTask(behavior: ResolvedStepBehavior, task: string | undefined, originalTask?: string): ResolvedStepBehavior {
+	const policyTask = resolveTaskTextForFileUpdatePolicy(task, originalTask);
+	return behavior.progress && taskDisallowsFileUpdates(policyTask) ? { ...behavior, progress: false } : behavior;
+}
+
 // =============================================================================
 // Chain Instruction Injection
 // =============================================================================