@selesai/code 0.5.29 → 0.6.1

package/dist/extensions/pi-subagents/src/runs/foreground/chain-execution.ts

@@ -91,6 +91,34 @@ import { usageBudgetExceededMessage, usageBudgetState } from "../shared/usage-bu
 import type { ContextMode } from "../shared/context-mode.ts";
 import type { ResolvedSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
 
+/**
+ * Resolve a chain step's output path and effective output mode.
+ *
+ * Explicit `output` paths pass through unchanged (absolute as-is, relative under
+ * the chain dir). Omitted output generates a collision-safe per-child durable
+ * path `<chainDir>/outputs/<flat-index>-<agent>.md` unless the caller explicitly
+ * used `output: false`. Omitted `outputMode` resolves to `file-only` when an
+ * output path is active; explicit `outputMode: "inline"` is preserved exactly.
+ */
+function resolveChainStepOutput(input: {
+	behaviorOutput: string | false;
+	rawOutput: string | false | undefined;
+	rawOutputMode: "inline" | "file-only" | undefined;
+	chainDir: string;
+	flatIndex: number;
+	agent: string;
+}): { outputPath?: string; outputMode: "inline" | "file-only" } {
+	const explicit = typeof input.behaviorOutput === "string" ? input.behaviorOutput : undefined;
+	let outputPath: string | undefined;
+	if (explicit) {
+		outputPath = path.isAbsolute(explicit) ? explicit : path.join(input.chainDir, explicit);
+	} else if (input.behaviorOutput === false && input.rawOutput !== false && input.rawOutput !== "false") {
+		outputPath = path.join(input.chainDir, "outputs", `${input.flatIndex}-${input.agent}.md`);
+	}
+	return { outputPath, outputMode: input.rawOutputMode ?? (outputPath ? "file-only" : "inline") };
+}
+
+
 interface ChainExecutionDetailsInput {
 	results: SingleResult[];
 	includeProgress?: boolean;
@@ -353,9 +381,16 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				? input.worktreeSetup.worktrees[taskIndex]!.agentCwd
 				: resolveChildCwd(input.cwd ?? input.ctx.cwd, task.cwd);
 
-			const outputPath = typeof behavior.output === "string"
-				? (path.isAbsolute(behavior.output) ? behavior.output : path.join(input.chainDir, behavior.output))
-				: undefined;
+			const resolvedTaskOutput = resolveChainStepOutput({
+				behaviorOutput: behavior.output,
+				rawOutput: task.output,
+				rawOutputMode: task.outputMode,
+				chainDir: input.chainDir,
+				flatIndex: childIndex,
+				agent: task.agent,
+			});
+			const outputPath = resolvedTaskOutput.outputPath;
+			const effectiveOutputMode = resolvedTaskOutput.outputMode;
 			taskStr = injectSingleOutputInstruction(taskStr, outputPath, taskAgentConfig);
 			const interruptController = new AbortController();
 			if (input.foregroundControl) {
@@ -399,7 +434,7 @@ async function runParallelChainTasks(input: ParallelChainRunInput): Promise<Sing
 				artifactsDir: input.artifactConfig.enabled ? input.artifactsDir : undefined,
 				artifactConfig: input.artifactConfig,
 				outputPath,
-				outputMode: behavior.outputMode,
+				outputMode: effectiveOutputMode,
 				maxSubagentDepth,
 				controlConfig: input.controlConfig,
 				onControlEvent: input.onControlEvent,
@@ -793,10 +828,16 @@ ${step.message}` : ""}` }],
 					.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"
-						? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
-						: undefined;
-					const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Parallel chain step ${stepIndex + 1} task ${taskIndex + 1} (${step.parallel[taskIndex]!.agent})`);
+					const task = step.parallel[taskIndex]!;
+					const resolvedOutput = resolveChainStepOutput({
+						behaviorOutput: behavior.output,
+						rawOutput: task.output,
+						rawOutputMode: task.outputMode,
+						chainDir,
+						flatIndex: globalTaskIndex + taskIndex,
+						agent: task.agent,
+					});
+					const validationError = validateFileOnlyOutputMode(resolvedOutput.outputMode, resolvedOutput.outputPath, `Parallel chain step ${stepIndex + 1} task ${taskIndex + 1} (${task.agent})`);
 					if (validationError) return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex + taskIndex }));
 				}
 				progressCreated = ensureParallelProgressFile(chainDir, progressCreated, parallelBehaviors);
@@ -1049,10 +1090,16 @@ ${step.message}` : ""}` }],
 
 			for (let taskIndex = 0; taskIndex < dynamicParallelStep.parallel.length; taskIndex++) {
 				const behavior = parallelBehaviors[taskIndex]!;
-				const outputPath = typeof behavior.output === "string"
-					? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
-					: undefined;
-				const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${dynamicParallelStep.parallel[taskIndex]!.agent})`);
+				const task = dynamicParallelStep.parallel[taskIndex]!;
+				const resolvedOutput = resolveChainStepOutput({
+					behaviorOutput: behavior.output,
+					rawOutput: task.output,
+					rawOutputMode: task.outputMode,
+					chainDir,
+					flatIndex: globalTaskIndex + taskIndex,
+					agent: task.agent,
+				});
+				const validationError = validateFileOnlyOutputMode(resolvedOutput.outputMode, resolvedOutput.outputPath, `Dynamic chain step ${stepIndex + 1} item ${taskIndex + 1} (${task.agent})`);
 				if (validationError) {
 					dynamicGroupStatuses[stepIndex] = { status: "failed", error: validationError };
 					return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex + taskIndex }));
@@ -1289,11 +1336,18 @@ ${step.message}` : ""}` }],
 				{ scope: modelScope },
 			);
 
-			const outputPath = typeof behavior.output === "string"
-				? (path.isAbsolute(behavior.output) ? behavior.output : path.join(chainDir, behavior.output))
-				: undefined;
+			const resolvedStepOutput = resolveChainStepOutput({
+				behaviorOutput: behavior.output,
+				rawOutput: stepOverride.output,
+				rawOutputMode: seqStep.outputMode,
+				chainDir,
+				flatIndex: globalTaskIndex,
+				agent: seqStep.agent,
+			});
+			const outputPath = resolvedStepOutput.outputPath;
+			const effectiveOutputMode = resolvedStepOutput.outputMode;
 			stepTask = injectSingleOutputInstruction(stepTask, outputPath, agentConfig);
-			const validationError = validateFileOnlyOutputMode(behavior.outputMode, outputPath, `Chain step ${stepIndex + 1} (${seqStep.agent})`);
+			const validationError = validateFileOnlyOutputMode(effectiveOutputMode, outputPath, `Chain step ${stepIndex + 1} (${seqStep.agent})`);
 			if (validationError) {
 				return buildChainExecutionErrorResult(validationError, makeDetailsInput({ currentStepIndex: stepIndex, currentFlatIndex: globalTaskIndex }));
 			}
@@ -1339,7 +1393,7 @@ ${step.message}` : ""}` }],
 					dynamicChildren,
 					dynamicGroupStatuses,
 				});
-				r = await runSync(ctx.cwd, agents, seqStep.agent, stepTask, {
+			r = await runSync(ctx.cwd, agents, seqStep.agent, stepTask, {
 				parentSessionId: ctx.sessionManager.getSessionId() ?? undefined,
 				capabilityCeiling: params.capabilityCeiling,
 				context: params.contextForAgent?.(seqStep.agent),
@@ -1358,7 +1412,7 @@ ${step.message}` : ""}` }],
 				artifactsDir: artifactConfig.enabled ? artifactsDir : undefined,
 				artifactConfig,
 				outputPath,
-				outputMode: behavior.outputMode,
+				outputMode: effectiveOutputMode,
 				maxSubagentDepth,
 				controlConfig,
 				onControlEvent,

package/dist/extensions/pi-subagents/src/runs/foreground/execution.ts

@@ -62,7 +62,7 @@ import { resolveEffectiveThinking } from "../../shared/model-info.ts";
 import { MISSING_STRUCTURED_OUTPUT_CALL_ERROR, readStructuredOutput } from "../shared/structured-output.ts";
 import { formatProcessSignalError, isUnexplainedProcessSignal } from "../shared/process-signal.ts";
 import { readChildToolDiagnosticError } from "../shared/tool-availability.ts";
-import { captureSingleOutputSnapshot, extractChildWrittenOutput, formatSavedOutputReference, injectOutputPathSystemPrompt, resolveSingleOutput, validateFileOnlyOutputMode, type SingleOutputSnapshot } from "../shared/single-output.ts";
+import { captureSingleOutputSnapshot, extractChildWrittenOutput, formatBoundedPersistenceFallback, formatSavedOutputReference, injectOutputPathSystemPrompt, resolveSingleOutput, validateFileOnlyOutputMode, type SingleOutputSnapshot } from "../shared/single-output.ts";
 import {
 	buildModelCandidates,
 	formatModelAttemptNote,
@@ -1282,7 +1282,12 @@ async function runSingleAttempt(
 			reason: "completion_guard",
 		}));
 	}
-		if (options.outputPath && result.exitCode === 0) {
+		// Persist whenever an output path is configured and meaningful child output
+	// exists, not only for successful runs: failed children with output keep a
+	// readable result file and a saved-output reference instead of raw inline
+	// output. Synthetic failures without output (startup errors, empty responses)
+	// stay outputState "absent" and are not promoted to a bogus saved reference.
+	if (options.outputPath && (fullOutput.trim() || result.exitCode === 0)) {
 			const resolvedOutput = resolveSingleOutput(options.outputPath, fullOutput, shared.outputSnapshot);
 			fullOutput = stripAcceptanceReport(resolvedOutput.fullOutput);
 			result.savedOutputPath = resolvedOutput.savedPath;
@@ -1295,9 +1300,18 @@ async function runSingleAttempt(
 		artifactOutputByResult.set(result, fullOutput);
 		acceptanceOutputByResult.set(result, acceptanceOutput);
 	result.outputMode = options.outputMode ?? "inline";
-	result.finalOutput = options.outputMode === "file-only" && result.savedOutputPath && result.outputReference
-		? result.outputReference.message
-		: fullOutput;
+	const hasSavedReference = result.savedOutputPath && result.outputReference ? true : false;
+	result.finalOutput = hasSavedReference && (options.outputMode === "file-only" || result.exitCode !== 0)
+		? result.outputReference!.message
+		: result.outputSaveError && options.outputPath
+			? formatBoundedPersistenceFallback({
+				error: result.outputSaveError,
+				outputPath: options.outputPath,
+				fullOutput,
+				exitCode: result.exitCode,
+				processError: result.error,
+			})
+			: fullOutput;
 	result.controlEvents = allControlEvents.length ? allControlEvents : undefined;
 	if (options.onUpdate) {
 		const finalText = result.finalOutput || result.error || "(no output)";

package/dist/extensions/pi-subagents/src/runs/foreground/subagent-executor.ts

@@ -25,7 +25,6 @@ import { handleWatchdogToolAction, WATCHDOG_TOOL_ACTIONS } from "../../watchdog/
 import type { MainWatchdogRuntime } from "../../watchdog/runtime.ts";
 import { buildModelCandidates, normalizeParentModel, resolveEffectiveSubagentModel, resolveModelCandidate, type ParentModel } from "../shared/model-fallback.ts";
 import type { ModelScopeConfig } from "../shared/model-scope.ts";
-import { aggregateParallelOutputs } from "../shared/parallel-utils.ts";
 import { recordRun } from "../shared/run-history.ts";
 import {
 	buildChainInstructions,
@@ -57,7 +56,7 @@ import { validateToolBudgetConfig } from "../shared/tool-budget.ts";
 import { usageBudgetExceededMessage, usageBudgetState, validateUsageBudgetConfig } from "../shared/usage-budget.ts";
 import { intersectSubagentCapabilityCeilings, resolveCurrentSubagentCapabilityCeiling, type ResolvedSubagentCapabilityCeiling } from "../shared/capability-ceiling.ts";
 import { isAgentContractV1 } from "../shared/agent-contract.ts";
-import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
+import { finalizeSingleOutput, formatBoundedPersistenceFallback, formatSavedOutputReference, injectSingleOutputInstruction, normalizeSingleOutputOverride, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import { cleanupStructuredOutputRuntime, createStructuredOutputRuntime } from "../shared/structured-output.ts";
 import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, readStatus, resolveChildCwd, sumResultsCost, sumResultsUsage } from "../../shared/utils.ts";
 import { DEFAULT_GLOBAL_CONCURRENCY_LIMIT, Semaphore } from "../shared/parallel-utils.ts";
@@ -521,7 +520,12 @@ function updateRememberedForegroundChild(state: SubagentState, input: { runId: s
 		updatedAt,
 		...(input.result.exitCode !== undefined ? { exitCode: input.result.exitCode } : {}),
 		...(input.result.error ? { error: input.result.error } : {}),
-		...(input.result.finalOutput ? { finalOutput: input.result.finalOutput } : {}),
+		// Reference-first remembered state: when an authoritative saved output path
+		// exists, do not retain the full final output in memory; status/transcript
+		// views recover it from `savedOutputPath` via `rememberedForegroundChildOutput`
+		// (runs/background/run-status.ts) and the TUI via `resultOutputForUi`
+		// (tui/render.ts).
+		...(input.result.finalOutput && !input.result.savedOutputPath ? { finalOutput: input.result.finalOutput } : {}),
 		outputState: input.result.outputState,
 		outputMode: input.result.outputMode,
 		savedOutputPath: input.result.savedOutputPath,
@@ -541,10 +545,11 @@ function updateRememberedForegroundChild(state: SubagentState, input: { runId: s
 		...(input.result.capabilityAudit ? { capabilityAudit: input.result.capabilityAudit } : {}),
 	};
 	trimRememberedForegroundRuns(state);
-	const output = getSingleResultOutput(input.result).trim();
+	const reference = input.result.outputReference?.message;
+	const output = reference ?? getSingleResultOutput(input.result).trim();
 	const success = terminalStatus === "completed";
 	const summary = !success && input.result.error
-		? `${input.result.error}${output ? `\n\nOutput:\n${output}` : ""}`
+		? `${input.result.error}${output ? `\n\n${output}` : ""}`
 		: output || input.result.error || "Detached child exited without final output.";
 	// A detached callback may outlive its extension runtime. Stale sessions are
 	// intentionally dropped rather than routed through a replacement runtime.
@@ -1288,7 +1293,7 @@ async function resumeAsyncRun(input: {
 			};
 		}
 		const runId = randomUUID().slice(0, 8);
-		const artifactConfig: ArtifactConfig = { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts !== false, dir: input.deps.config.artifactDir ?? DEFAULT_ARTIFACT_CONFIG.dir };
+		const artifactConfig: ArtifactConfig = { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts === true, dir: input.deps.config.artifactDir ?? DEFAULT_ARTIFACT_CONFIG.dir };
 		const availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo);
 		const contextPolicy = resolveExplicitContextPolicy(input.params);
 		const workflowTask = (input.params.task ?? followUp) || undefined;
@@ -1354,7 +1359,7 @@ async function resumeAsyncRun(input: {
 
 	const runId = randomUUID().slice(0, 8);
 	const recoveryAgentConfig = recoveryDescriptor ? applySteeringRecoveryAgentConfig(agentConfig, recoveryDescriptor) : agentConfig;
-	const artifactConfig: ArtifactConfig = recoveryDescriptor?.artifactConfig ?? { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts !== false, dir: input.deps.config.artifactDir ?? DEFAULT_ARTIFACT_CONFIG.dir };
+	const artifactConfig: ArtifactConfig = recoveryDescriptor?.artifactConfig ?? { ...DEFAULT_ARTIFACT_CONFIG, enabled: input.params.artifacts === true, dir: input.deps.config.artifactDir ?? DEFAULT_ARTIFACT_CONFIG.dir };
 	const artifactsDir = recoveryDescriptor?.artifactsDir ?? getArtifactsDir(parentSessionFile, effectiveCwd, artifactConfig.dir);
 	const availableModels = input.ctx.modelRegistry.getAvailable().map(toModelInfo);
 	const parentModel = input.parentModel;
@@ -1435,14 +1440,82 @@ async function resumeAsyncRun(input: {
 }
 
 function resultSummaryForIntercom(result: SingleResult): string {
-	const output = getSingleResultOutput(result);
-	if (result.exitCode !== 0 && result.error) {
-		return output ? `${result.error}\n\nOutput:\n${output}` : result.error;
+	const reference = result.outputReference?.message;
+	if (reference) {
+		return result.exitCode !== 0 && result.error ? `${result.error}\n\n${reference}` : reference;
 	}
-	return output || result.error || "(no output)";
+	if (result.savedOutputPath) {
+		try {
+			const ref = formatSavedOutputReference(result.savedOutputPath, fs.readFileSync(result.savedOutputPath, "utf-8"));
+			return result.exitCode !== 0 && result.error ? `${result.error}\n\n${ref.message}` : ref.message;
+		} catch (error) {
+			const fallback = formatBoundedPersistenceFallback({
+				error: `Failed to read saved output: ${error instanceof Error ? error.message : String(error)}`,
+				outputPath: result.savedOutputPath,
+				fullOutput: getSingleResultOutput(result),
+				exitCode: result.exitCode,
+				processError: result.error,
+			});
+			return result.exitCode !== 0 && result.error ? `${result.error}\n\n${fallback}` : fallback;
+		}
+	}
+	if (result.outputSaveError) {
+		return formatBoundedPersistenceFallback({
+			error: result.outputSaveError,
+			outputPath: result.savedOutputPath,
+			fullOutput: getSingleResultOutput(result),
+			exitCode: result.exitCode,
+			processError: result.error,
+		});
+	}
+	// Legacy / `output: false` child without a durable saved path: bounded fallback
+	// only, never the raw full output.
+	return formatBoundedPersistenceFallback({
+		error: "No saved output path is available for this child.",
+		fullOutput: getSingleResultOutput(result),
+		exitCode: result.exitCode,
+		processError: result.error,
+	});
+}
+
+/**
+ * Compact terminal per-child line for bridge-off foreground parallel content:
+ * status plus either the saved-output reference (default/file-only), the legacy
+ * inline full output when explicitly requested, or the bounded fallback.
+ */
+function formatParallelChildResult(result: SingleResult, index: number): string {
+	const status = resolveSubagentResultStatus({
+		exitCode: result.exitCode,
+		interrupted: result.interrupted,
+		detached: result.detached,
+		processSignal: result.processSignal,
+		timedOut: result.timedOut,
+		stopped: result.stopped,
+		turnBudgetExceeded: result.turnBudgetExceeded,
+	});
+	const header = `=== Task ${index + 1}: ${result.agent} [${status}] ===`;
+	if (result.outputMode === "inline") {
+		const output = getSingleResultOutput(result).trim();
+		return `${header}\n${output || "(no output)"}`;
+	}
+	const reference = result.outputReference?.message;
+	if (reference) {
+		const body = result.exitCode !== 0 && result.error ? `${result.error}\n${reference}` : reference;
+		return `${header}\n${body}`;
+	}
+	return `${header}\n${formatBoundedPersistenceFallback({
+		error: result.outputSaveError ?? "No saved output path is available for this child.",
+		outputPath: result.savedOutputPath,
+		fullOutput: getSingleResultOutput(result),
+		exitCode: result.exitCode,
+		processError: result.error,
+	})}`;
 }
 
 function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
+	// Reference-first and persistence-failure fallbacks already carry error/status
+	// and must not be re-wrapped as raw "Output:" text.
+	if (result.savedOutputPath || result.outputSaveError) return displayOutput;
 	const error = result.error || "Failed";
 	const output = displayOutput.trim();
 	const lines = [error];
@@ -2287,7 +2360,6 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 		}
 		const rawOutput = params.output !== undefined ? params.output : a.output;
 		const effectiveOutput = normalizeSingleOutputOverride(rawOutput, a.output);
-		const effectiveOutputMode = params.outputMode ?? "inline";
 		const normalizedSkills = normalizeSkillInput(params.skill);
 		const skills = normalizedSkills === false ? [] : normalizedSkills;
 		const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, a.maxSubagentDepth);
@@ -2309,7 +2381,7 @@ function runAsyncPath(data: ExecutionContextData, deps: ExecutorDeps): AgentTool
 			context: contextPolicy.contextForAgent(params.agent!),
 			skills,
 			output: effectiveOutput,
-			outputMode: effectiveOutputMode,
+			outputMode: params.outputMode,
 			outputBaseDir: resolveSingleRunOutputBaseDir(deps, artifactsDir, id),
 			modelOverride,
 			thinkingOverride: thinkingOverrideForTask(params.agent!, 0, modelOverride),
@@ -2610,6 +2682,19 @@ function resolveSingleRunOutputBaseDir(deps: ExecutorDeps, artifactsDir: string,
 		: path.join(artifactsDir, "outputs", runId);
 }
 
+/**
+ * Generated per-run durable output path for foreground single runs when the
+ * caller omits `output` (and does not set `output: false`):
+ * `<singleRunOutputBaseDir>/<runId>/result.md`. The base is the configured
+ * `singleRunOutputBaseDir` when present, otherwise `{artifactsDir}/outputs`.
+ */
+function resolveGeneratedSingleOutputPath(deps: ExecutorDeps, artifactsDir: string, runId: string): string {
+	const base = deps.config.singleRunOutputBaseDir
+		? path.resolve(deps.expandTilde(deps.config.singleRunOutputBaseDir))
+		: path.join(artifactsDir, "outputs");
+	return path.join(base, runId, "result.md");
+}
+
 function buildChainWorktreeTaskCwdError(chain: ChainStep[], sharedCwd: string): string | undefined {
 	for (let stepIndex = 0; stepIndex < chain.length; stepIndex++) {
 		const step = chain[stepIndex]!;
@@ -3068,8 +3153,19 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 
 	const behaviors = tasks.map((task, index) => {
 		let behavior = suppressProgressForReadOnlyTask(resolveStepBehavior(agentConfigs[index]!, behaviorOverrides[index]!), taskTexts[index]);
-		if (behaviorOverrides[index]?.output === undefined && typeof behavior.output === "string" && !path.isAbsolute(behavior.output)) {
-			behavior = { ...behavior, output: path.join("parallel-0", `${index}-${task.agent}`, behavior.output) };
+		if (behaviorOverrides[index]?.output === undefined) {
+			if (typeof behavior.output === "string" && !path.isAbsolute(behavior.output)) {
+				behavior = { ...behavior, output: path.join("parallel-0", `${index}-${task.agent}`, behavior.output) };
+			} else if (behavior.output === false && behaviorOverrides[index]?.output !== false && behaviorOverrides[index]?.output !== "false") {
+				// Omitted output: generate a collision-safe per-task durable path in the
+				// existing per-task namespace (parallel-0/<index>-<agent>/result.md).
+				behavior = { ...behavior, output: path.join("parallel-0", `${index}-${task.agent}`, "result.md") };
+			}
+		}
+		// Omitted outputMode resolves to file-only whenever an output path is active;
+		// explicit `outputMode: "inline"` is preserved exactly.
+		if (behaviorOverrides[index]?.outputMode === undefined && typeof behavior.output === "string") {
+			behavior = { ...behavior, outputMode: "file-only" };
 		}
 		return behavior;
 	});
@@ -3235,21 +3331,12 @@ async function runParallelPath(data: ExecutionContextData, deps: ExecutorDeps):
 		const worktreeSuffix = handoff?.suffix ?? "";
 		const ok = results.filter((result) => result.exitCode === 0).length;
 		const downgradeNote = backgroundRequestedWhileClarifying ? " (background requested, but clarify kept this run foreground)" : "";
-		const aggregatedOutput = aggregateParallelOutputs(
-			results.map((result) => ({
-				agent: result.agent,
-				output: result.truncation?.text || getSingleResultOutput(result),
-				exitCode: result.exitCode,
-				error: result.error,
-				timedOut: result.timedOut,
-			})),
-			(i, agent) => `=== Task ${i + 1}: ${agent} ===`,
-		);
+		const perChildResults = results.map((result, i) => formatParallelChildResult(result, i)).join("\n\n");
 
 		const summary = `${ok}/${results.length} succeeded${downgradeNote}`;
 		const fullContent = worktreeSuffix
-			? `${summary}\n\n${aggregatedOutput}\n\n${worktreeSuffix}`
-			: `${summary}\n\n${aggregatedOutput}`;
+			? `${summary}\n\n${perChildResults}\n\n${worktreeSuffix}`
+			: `${summary}\n\n${perChildResults}`;
 
 		return {
 			content: [{ type: "text", text: fullContent }],
@@ -3309,7 +3396,6 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 	let skillOverride: string[] | false | undefined = normalizeSkillInput(params.skill);
 	const rawOutput = params.output !== undefined ? params.output : agentConfig.output;
 	let effectiveOutput = normalizeSingleOutputOverride(rawOutput, agentConfig.output);
-	const effectiveOutputMode = params.outputMode ?? "inline";
 	const currentMaxSubagentDepth = resolveCurrentMaxSubagentDepth(deps.config.maxSubagentDepth);
 	const maxSubagentDepth = resolveChildMaxSubagentDepth(currentMaxSubagentDepth, agentConfig.maxSubagentDepth);
 
@@ -3381,7 +3467,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 				context: contextPolicy.contextForAgent(params.agent!),
 				skills: skillOverride === false ? [] : skillOverride,
 				output: effectiveOutput,
-				outputMode: effectiveOutputMode,
+				outputMode: params.outputMode,
 				outputBaseDir: resolveSingleRunOutputBaseDir(deps, artifactsDir, id),
 				modelOverride,
 				thinkingOverride: thinkingOverrideForTask(params.agent!, 0, modelOverride),
@@ -3410,7 +3496,16 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		task = wrapForkTask(task);
 	}
 	const cleanTask = task;
-	const outputPath = resolveSingleOutputPath(effectiveOutput, ctx.cwd, effectiveCwd, resolveSingleRunOutputBaseDir(deps, artifactsDir, runId));
+	// Omitted output resolves to a generated per-run durable path
+	// (`<singleRunOutputBaseDir>/<runId>/result.md`); omitted outputMode resolves to
+	// file-only whenever an output path is active. Explicit paths, `output: false`,
+	// and explicit `outputMode: "inline"` are preserved exactly.
+	const outputPath = typeof effectiveOutput === "string"
+		? resolveSingleOutputPath(effectiveOutput, ctx.cwd, effectiveCwd, resolveSingleRunOutputBaseDir(deps, artifactsDir, runId))
+		: effectiveOutput === false
+			? undefined
+			: resolveGeneratedSingleOutputPath(deps, artifactsDir, runId);
+	const effectiveOutputMode = params.outputMode ?? (outputPath ? "file-only" : "inline");
 	const validationError = validateFileOnlyOutputMode(effectiveOutputMode, outputPath, `Single run (${params.agent})`);
 	if (validationError) {
 		return { content: [{ type: "text", text: validationError }], isError: true, details: { mode: "single", results: [] } };
@@ -3549,6 +3644,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		savedPath: r.savedOutputPath,
 		outputReference: r.outputReference,
 		saveError: r.outputSaveError,
+		error: r.error,
 	});
 	if (foregroundControl) {
 		updateForegroundNestedProjection(foregroundControl);
@@ -4225,7 +4321,7 @@ export function createSubagentExecutor(deps: ExecutorDeps): {
 
 		const artifactConfig: ArtifactConfig = {
 			...DEFAULT_ARTIFACT_CONFIG,
-			enabled: effectiveParams.artifacts !== false,
+			enabled: effectiveParams.artifacts === true,
 			dir: deps.config.artifactDir ?? DEFAULT_ARTIFACT_CONFIG.dir,
 		};
 		const artifactsDir = getArtifactsDir(parentSessionFile, effectiveCwd, artifactConfig.dir);

package/dist/extensions/pi-subagents/src/runs/shared/acceptance.ts

@@ -22,7 +22,7 @@ import type {
 	SubagentRunMode,
 } from "../../shared/types.ts";
 import { isAgentContractV1 } from "./agent-contract.ts";
-import { classifyTaskMutationIntent, taskMayMutate } from "./task-intent.ts";
+import { classifyTaskMutationIntent, resolveAgentRoutingRole, taskMayMutate } from "./task-intent.ts";
 
 const LEVEL_RANK: Record<Exclude<AcceptanceLevel, "auto">, number> = {
 	none: 0,
@@ -82,7 +82,6 @@ function inferLevel(input: {
 	dynamic?: boolean;
 	dynamicGroup?: boolean;
 }): { level: Exclude<AcceptanceLevel, "auto">; reasons: string[]; criteria: string[]; evidence: AcceptanceEvidenceKind[]; review?: { agent?: string; required?: boolean } } {
-	const agent = input.agentName.toLowerCase();
 	const task = input.task?.toLowerCase() ?? "";
 	const reasons: string[] = [];
 	// Declared roles replace name heuristics, so use the full writer grammar to detect explicit mutation independently of the actual agent name.
@@ -94,11 +93,10 @@ function inferLevel(input: {
 		&& !/\b(?:do not|don't|must not)\s+patch\b/.test(task)
 		&& /\bpatch\s+(?:(?:\.{0,2}[\\/])?(?:[\w.-]+[\\/])+[\w.-]+|[\w.-]+\.[a-z0-9]+\b|(?:the\s+)?parser\b)/.test(task);
 	const taskMayWrite = readOnlyTask ? false : taskMayMutate(input.task ?? "") || intent.kind === "implementation" || rolePatchTask;
-	const readOnlyAgent = input.acceptanceRole === "read-only"
-		|| (input.acceptanceRole === undefined && /\b(?:architect|commentator|explorer|recapper|researcher|analyst)\b/.test(agent));
+	const routingRole = resolveAgentRoutingRole(input.agentName, input.acceptanceRole);
+	const readOnlyAgent = routingRole === "read-only";
 	const writeTask = taskMayWrite
-		|| (input.acceptanceRole === "writer" && !readOnlyTask)
-		|| (input.acceptanceRole === undefined && /\bbuilder\b/.test(agent) && !readOnlyTask);
+		|| (routingRole === "writer" && !readOnlyTask);
 	const inferredReadOnly = readOnlyTask || (input.acceptanceRole === "read-only" && !taskMayWrite);
 	const roleResolvesReadOnly = input.acceptanceRole !== undefined && inferredReadOnly;
 	const keywordRiskReadOnly = input.acceptanceRole === undefined ? intent.kind === "read-only" : inferredReadOnly;

package/dist/extensions/pi-subagents/src/runs/shared/single-output.ts

@@ -1,9 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import type { Message } from "@earendil-works/pi-ai";
-import type { OutputMode, SavedOutputReference } from "../../shared/types.ts";
+import type { MaxOutputConfig, OutputMode, SavedOutputReference } from "../../shared/types.ts";
+import { truncateOutput } from "../../shared/types.ts";
 import { hasMutationToolCapability } from "./completion-guard.ts";
 
+/**
+ * Fixed internal context-fallback cap used when persisted output is unavailable
+ * (persistence/read failure, `output: false`, or legacy results without a saved
+ * path). Deliberately not exposed as a public parameter; reuse `truncateOutput()`
+ * so the excerpt is bounded by both lines and bytes and never falls back to
+ * unbounded output.
+ */
+export const CONTEXT_FALLBACK_LIMIT: Required<MaxOutputConfig> = { bytes: 4096, lines: 80 };
+
 export interface SingleOutputSnapshot {
 	exists: boolean;
 	mtimeMs?: number;
@@ -125,6 +135,34 @@ function formatByteSize(bytes: number): string {
 	return `${value.toFixed(1)} ${units[unitIndex]}`;
 }
 
+/**
+ * Bounded fallback for deliveries where the durable full output cannot be
+ * referenced: persistence/write errors, unreadable saved paths, or no saved
+ * path at all (legacy/`output: false`). Contains process status, the intended
+ * output path, the concrete error, and a bounded 80-line/4-KiB excerpt of the
+ * available output. Never claims a full artifact exists.
+ */
+export function formatBoundedPersistenceFallback(input: {
+	error: string;
+	outputPath?: string;
+	fullOutput: string;
+	exitCode: number;
+	processError?: string;
+}): string {
+	const status = input.processError?.trim()
+		? `Process status: ${input.processError}`
+		: `Process status: ${input.exitCode === 0 ? "completed" : `failed (exit ${input.exitCode})`}`;
+	const bounded = truncateOutput(input.fullOutput, CONTEXT_FALLBACK_LIMIT);
+	const lines = [
+		`[Full output unavailable] ${input.error}`,
+		status,
+		...(input.outputPath ? [`Intended output path: ${input.outputPath}`] : []),
+		"Full output is unavailable; showing a bounded excerpt (first 80 lines / 4 KiB).",
+		bounded.text,
+	];
+	return lines.join("\n");
+}
+
 export function formatSavedOutputReference(savedPath: string, fullOutput: string): SavedOutputReference {
 	const absolutePath = path.resolve(savedPath);
 	const bytes = Buffer.byteLength(fullOutput, "utf-8");
@@ -217,19 +255,35 @@ export function finalizeSingleOutput(params: {
 	savedPath?: string;
 	outputReference?: SavedOutputReference;
 	saveError?: string;
+	error?: string;
 }): { displayOutput: string; savedPath?: string; outputReference?: SavedOutputReference; saveError?: string } {
-	let displayOutput = params.truncatedOutput || params.fullOutput;
-	if (params.exitCode === 0 && params.savedPath) {
+	if (params.savedPath) {
 		const outputReference = params.outputReference ?? formatSavedOutputReference(params.savedPath, params.fullOutput);
-		if (params.outputMode === "file-only") {
+		if (params.exitCode === 0 && params.outputMode === "file-only") {
 			return { displayOutput: outputReference.message, savedPath: params.savedPath, outputReference };
 		}
-		displayOutput += `\n\n${outputReference.message}`;
+		if (params.exitCode !== 0) {
+			// Failed runs with a successfully persisted result surface the error/status
+			// plus the saved-output reference, never raw child output.
+			const status = params.error?.trim() || `Subagent failed with exit code ${params.exitCode}`;
+			return { displayOutput: `${status}\n\n${outputReference.message}`, savedPath: params.savedPath, outputReference };
+		}
+		const displayOutput = `${params.truncatedOutput || params.fullOutput}\n\n${outputReference.message}`;
 		return { displayOutput, savedPath: params.savedPath, outputReference };
 	}
-	if (params.exitCode === 0 && params.saveError && params.outputPath) {
-		displayOutput += `\n\nOutput file error: ${params.outputPath}\n${params.saveError}`;
-		return { displayOutput, saveError: params.saveError };
+	if (params.saveError && params.outputPath) {
+		// Persistence/read failure: only the bounded fallback is delivered. It must
+		// not claim a full artifact exists.
+		return {
+			displayOutput: formatBoundedPersistenceFallback({
+				error: params.saveError,
+				outputPath: params.outputPath,
+				fullOutput: params.fullOutput,
+				exitCode: params.exitCode,
+				processError: params.error,
+			}),
+			saveError: params.saveError,
+		};
 	}
-	return { displayOutput };
+	return { displayOutput: params.truncatedOutput || params.fullOutput };
 }

package/dist/extensions/pi-subagents/src/runs/shared/task-intent.ts

@@ -1,3 +1,5 @@
+import type { AcceptanceRole } from "../../shared/types.ts";
+
 /**
  * Shared task mutation-intent classifier.
  *
@@ -139,6 +141,25 @@ function isReviewerStyleAgent(agent: string): boolean {
 	return /\b(?:architect|commentator|explorer|recapper|researcher)\b/i.test(agent);
 }
 
+/**
+ * Resolve an agent's acceptance routing role: a declared `acceptanceRole`
+ * always wins; otherwise the established name heuristics apply (builder-named
+ * agents are writers; architect/commentator/explorer/recapper/researcher/
+ * analyst-named agents are read-only). This is the single shared source of
+ * truth for acceptance inference and task-aware advisory routing so the two
+ * cannot drift. Alias values are never role signals.
+ */
+export function resolveAgentRoutingRole(
+	agentName: string,
+	acceptanceRole?: AcceptanceRole,
+): "writer" | "read-only" | undefined {
+	if (acceptanceRole !== undefined) return acceptanceRole;
+	const agent = agentName.toLowerCase();
+	if (/\bbuilder\b/.test(agent)) return "writer";
+	if (/\b(?:architect|commentator|explorer|recapper|researcher|analyst)\b/.test(agent)) return "read-only";
+	return undefined;
+}
+
 function hasImplementationIntent(agent: string, taskText: string): boolean {
 	if (isReviewerStyleAgent(agent)) return REVIEWER_REQUIRED_EDIT_PATTERNS.some((pattern) => pattern.test(taskText));
 	if (agent === "builder") return WORKER_IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(taskText));