pi-cohort 7.3.1 → 7.4.1

package/src/runs/foreground/execution.ts

@@ -46,7 +46,7 @@ import { PINNED_AGENT_DIR_OVERRIDE } from "../../shared/agent-dir.ts";
 import { createJsonlWriter } from "../../shared/jsonl-writer.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
 import { buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
-import { captureSingleOutputSnapshot, validateFileOnlyOutputMode } from "../shared/single-output.ts";
+import { captureSingleOutputSnapshot, formatFileOnlyFailure, validateFileOnlyOutputMode } from "../shared/single-output.ts";
 import {
 	buildModelCandidates,
 	formatModelAttemptNote,
@@ -669,7 +669,7 @@ export async function runSync(
 		dynamic: options.acceptanceContext?.dynamic,
 		dynamicGroup: options.acceptanceContext?.dynamicGroup,
 	});
-	const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance);
+	const acceptancePrompt = formatAcceptancePrompt(effectiveAcceptance, { structuredOutput: Boolean(options.structuredOutput) });
 	const taskWithAcceptance = acceptancePrompt ? `${task}\n${acceptancePrompt}` : task;
 	const sessionEnabled = Boolean(options.sessionFile || options.sessionDir) || shareEnabled;
 	const skillNames = options.skills ?? agent.skills ?? [];
@@ -815,6 +815,8 @@ export async function runSync(
 	} satisfies SingleResult;
 
 	let postLoopError: unknown;
+	let preservedAt: string | undefined;
+	let notPreservedReason = "artifact output disabled";
 	try {
 		result.usage = aggregateUsage;
 		result.attemptedModels = attemptedModels.length > 0 ? attemptedModels : undefined;
@@ -834,7 +836,14 @@ export async function runSync(
 		if (artifactPathsResult && options.artifactConfig?.enabled !== false) {
 			result.artifactPaths = artifactPathsResult;
 			if (options.artifactConfig?.includeOutput !== false) {
-				writeArtifact(artifactPathsResult.outputPath, artifactOutputByResult.get(result) ?? result.finalOutput ?? "");
+				try {
+					writeArtifact(artifactPathsResult.outputPath, artifactOutputByResult.get(result) ?? result.finalOutput ?? "");
+					preservedAt = artifactPathsResult.outputPath;
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					notPreservedReason = `artifact write failed: ${message}`;
+					throw error;
+				}
 			}
 			if (options.artifactConfig?.includeMetadata !== false) {
 				writeMetadata(artifactPathsResult.metadataPath, {
@@ -912,9 +921,19 @@ export async function runSync(
 				: safeMessage;
 			result.executionSurface ??= { handle: externalOwner.surface, retained: true };
 		}
-	} else if (postLoopError) {
-		throw postLoopError;
 	}
 
+	if (options.outputMode === "file-only"
+		&& (result.exitCode !== 0 || result.outputSaveError)
+		&& !blockedLine(result.error ?? "")) {
+		result.finalOutput = formatFileOnlyFailure({
+			outputPath: options.outputPath,
+			saveError: result.outputSaveError,
+			...(preservedAt !== undefined ? { preservedAt } : { notPreservedReason }),
+		});
+		result.truncation = undefined;
+	}
+	if (!externalOwner && postLoopError) throw postLoopError;
+
 	return result;
 }

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

@@ -39,6 +39,7 @@ import { createForkContextResolver } from "../../shared/fork-context.ts";
 import { resolveCurrentSessionId } from "../../shared/session-identity.ts";
 import { formatControlNoticeMessage, resolveControlConfig, shouldNotifyControlEvent } from "../shared/subagent-control.ts";
 import { finalizeSingleOutput, injectSingleOutputInstruction, normalizeTopLevelOutput, resolveParallelTaskOutputPath, resolveSingleOutputPath, validateFileOnlyOutputMode } from "../shared/single-output.ts";
+import { blockedLine } from "../shared/completion-guard.ts";
 import { compactForegroundDetails, getSingleResultOutput, mapConcurrent, readStatus, resolveChildCwd } from "../../shared/utils.ts";
 import { resolveSubagentResultStatus } from "../shared/result-children.ts";
 import { buildRevivedAsyncTask, resolveAsyncResumeTarget } from "../background/async-resume.ts";
@@ -2064,7 +2065,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 	if (r.artifactPaths) allArtifactPaths.push(r.artifactPaths);
 
 	const fullOutput = getSingleResultOutput(r);
-	const finalizedOutput = finalizeSingleOutput({
+	const displayOutput = r.outputMode === "file-only" ? r.finalOutput : finalizeSingleOutput({
 		fullOutput,
 		truncatedOutput: r.truncation?.text,
 		outputPath,
@@ -2073,7 +2074,7 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		savedPath: r.savedOutputPath,
 		outputReference: r.outputReference,
 		saveError: r.outputSaveError,
-	});
+	}).displayOutput;
 	const details = compactForegroundDetails({
 		mode: "single",
 		runId,
@@ -2096,14 +2097,14 @@ async function runSinglePath(data: ExecutionContextData, deps: ExecutorDeps): Pr
 		};
 	}
 
-	if (r.exitCode !== 0)
-		return {
-			content: [{ type: "text", text: r.error || "Failed" }],
-			details,
-			isError: true,
-		};
+	if (r.exitCode !== 0) {
+		const text = r.outputMode === "file-only" && !blockedLine(r.error ?? "")
+			? `FAILED (exit code ${r.exitCode})${r.error ? `: ${r.error}` : ""}\n\n${r.finalOutput ?? ""}`
+			: r.error || "Failed";
+		return { content: [{ type: "text", text }], details, isError: true };
+	}
 	return {
-		content: [{ type: "text", text: finalizedOutput.displayOutput || "(no output)" }],
+		content: [{ type: "text", text: displayOutput || "(no output)" }],
 		details,
 	};
 }

package/src/runs/shared/acceptance.ts

@@ -238,7 +238,7 @@ export function resolveEffectiveAcceptance(input: {
 	};
 }
 
-export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig): string {
+export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig, options: { structuredOutput: boolean } = { structuredOutput: false }): string {
 	if (acceptance.level === "none") return "";
 	const lines = [
 		"",
@@ -264,7 +264,9 @@ export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig): st
 	}
 	lines.push(
 		"",
-		"Finish with a fenced JSON block tagged `acceptance-report` in this shape:",
+		options.structuredOutput
+			? "Write a fenced JSON block tagged `acceptance-report` in your final text message, then call `structured_output` as your final action. Shape:"
+			: "Finish with a fenced JSON block tagged `acceptance-report` in this shape:",
 		"```acceptance-report",
 		JSON.stringify({
 			criteriaSatisfied: [{ id: "criterion-1", status: "satisfied", evidence: "specific proof" }],

package/src/runs/shared/chain-outputs.ts

@@ -1,20 +1,23 @@
+import * as path from "node:path";
 import { isDynamicParallelStep, isParallelStep, type ChainStep, type SequentialStep } from "../../shared/settings.ts";
 import type { ChainOutputMap, ChainOutputMapEntry, SingleResult } from "../../shared/types.ts";
 import { getSingleResultOutput } from "../../shared/utils.ts";
 import { DynamicFanoutError, hasDynamicFanoutFields, type DynamicFanoutConfig, validateDynamicStepShape } from "./dynamic-fanout.ts";
+import { materializeTree } from "./worktree.ts";
 import { validateStopConditions } from "./stop-conditions.ts";
 
 const OUTPUT_REF_PATTERN = /\{outputs\.([^}]*)\}/g;
 const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const PATCH_PATH_FIELD = "patchPath";
 
-/** `name` or `name.patchPath`; anything else is invalid. */
-function parseOutputReference(raw: string): { name: string; field?: typeof PATCH_PATH_FIELD } | undefined {
+/** Only text and filesystem fields are valid output references. */
+function parseOutputReference(raw: string): { name: string; field?: "patchPath" | "treePath" } | undefined {
 	const dot = raw.indexOf(".");
 	const name = dot === -1 ? raw : raw.slice(0, dot);
 	if (!SAFE_OUTPUT_NAME_PATTERN.test(name)) return undefined;
 	if (dot === -1) return { name };
-	return raw.slice(dot + 1) === PATCH_PATH_FIELD ? { name, field: PATCH_PATH_FIELD } : undefined;
+	const field = raw.slice(dot + 1);
+	return field === PATCH_PATH_FIELD || field === "treePath" ? { name, field } : undefined;
 }
 
 export class ChainOutputValidationError extends Error {}
@@ -26,10 +29,22 @@ function outputNamesForStep(step: ChainStep): string[] {
 	return name ? [name] : [];
 }
 
-function taskTemplatesForStep(step: ChainStep): string[] {
-	if (isParallelStep(step)) return step.parallel.map((task) => task.task ?? "{previous}");
-	if (isDynamicParallelStep(step)) return [step.parallel.task ?? "{previous}", step.parallel.label ?? ""].filter(Boolean);
-	return [(step as SequentialStep).task ?? "{previous}"];
+function taskTemplatesForStep(step: ChainStep): Array<{ template: string; cwd: boolean }> {
+	const templates: Array<{ template: string; cwd: boolean }> = [];
+	const add = (value: { task?: string; label?: string; cwd?: string }) => {
+		for (const template of [value.task, value.label]) {
+			if (template) templates.push({ template, cwd: false });
+		}
+		if (value.cwd) templates.push({ template: value.cwd, cwd: true });
+	};
+	if (isParallelStep(step)) {
+		if (step.cwd) templates.push({ template: step.cwd, cwd: true });
+		for (const task of step.parallel) add(task);
+	} else if (isDynamicParallelStep(step)) {
+		add(step);
+		add(step.parallel);
+	} else add(step);
+	return templates;
 }
 
 export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutConfig: DynamicFanoutConfig = {}): void {
@@ -64,17 +79,23 @@ export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutCon
 			}
 			seen.add(name);
 		}
-		for (const template of taskTemplatesForStep(step)) {
+		for (const { template, cwd } of taskTemplatesForStep(step)) {
 			for (const match of template.matchAll(OUTPUT_REF_PATTERN)) {
+				if (cwd && isParallelStep(step) && step.worktree) {
+					throw new ChainOutputValidationError(`Chain step ${stepIndex + 1}: cwd output references cannot be combined with worktree: true.`);
+				}
 				const rawReference = match[0];
 				const parsed = parseOutputReference(match[1]!);
 				if (!parsed) {
 					throw new ChainOutputValidationError(`Invalid chain output reference '${rawReference}' at step ${stepIndex + 1}. Use {outputs.name} with /^[A-Za-z_][A-Za-z0-9_]*$/ names.`);
 				}
+				if (cwd && parsed.field !== "treePath") {
+					throw new ChainOutputValidationError(`Chain step ${stepIndex + 1}: only {outputs.<name>.treePath} may appear in cwd.`);
+				}
 				if (!available.has(parsed.name)) {
 					throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}' at step ${stepIndex + 1}. Named outputs are only available after producing step/group completes.`);
 				}
-				if (parsed.field === PATCH_PATH_FIELD && !worktreeProducers.has(parsed.name)) {
+				if (parsed.field && !worktreeProducers.has(parsed.name)) {
 					const producerStep = producerSteps.get(parsed.name)!;
 					throw new ChainOutputValidationError(`Chain step ${stepIndex + 1} references ${rawReference} but step ${producerStep + 1} is not a worktree step.`);
 				}
@@ -88,7 +109,7 @@ export function validateChainOutputBindings(steps: ChainStep[], dynamicFanoutCon
 	}
 }
 
-export function resolveOutputReferences(template: string, outputs: ChainOutputMap): string {
+export function resolveOutputReferences(template: string, outputs: ChainOutputMap, trees?: TreeRegistry): string {
 	return template.replace(OUTPUT_REF_PATTERN, (rawReference, rawName: string) => {
 		const parsed = parseOutputReference(rawName);
 		if (!parsed) {
@@ -96,25 +117,65 @@ export function resolveOutputReferences(template: string, outputs: ChainOutputMa
 		}
 		const entry = outputs[parsed.name];
 		if (!entry) throw new ChainOutputValidationError(`Unknown chain output reference '${rawReference}'.`);
-		if (parsed.field !== PATCH_PATH_FIELD) return entry.text;
+		if (parsed.field === "treePath") {
+			if (!trees) throw new ChainOutputValidationError(`Output '${parsed.name}' tree registry is unavailable.`);
+			return trees.resolve(parsed.name, entry);
+		}
+		if (!parsed.field) return entry.text;
 		if (entry.patchPath) return entry.patchPath;
 		const reason = entry.patchError ? `capture failed: ${entry.patchError}` : "no changes";
 		throw new ChainOutputValidationError(`Output '${parsed.name}' has no patch (${reason}).`);
 	});
 }
 
+export class TreeRegistry {
+	readonly built = new Map<string, string>();
+	readonly created: Array<{ repoCwd: string; dir: string }> = [];
+
+	private readonly chainDir: string;
+
+	constructor(chainDir: string) {
+		this.chainDir = chainDir;
+	}
+
+	resolve(name: string, entry: ChainOutputMapEntry): string {
+		if (this.built.has(name)) return this.built.get(name)!;
+		if (!entry.patchPath) {
+			const reason = entry.patchError ? `capture failed: ${entry.patchError}` : "no changes";
+			throw new ChainOutputValidationError(`Output '${name}' has no patch (${reason}).`);
+		}
+		const dir = path.join(this.chainDir, "worktree-trees", `step-${entry.stepIndex}`, `task-${entry.taskIndex}-${entry.agent}`);
+		this.created.push({ repoCwd: entry.repoCwd!, dir });
+		try {
+			materializeTree({ repoCwd: entry.repoCwd!, baseCommit: entry.baseCommit!, patchPath: entry.patchPath, dir });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			throw new ChainOutputValidationError(`Output '${name}' tree build failed: ${message.split("\n")[0]}`);
+		}
+		this.built.set(name, dir);
+		entry.treePath = dir;
+		return dir;
+	}
+}
+
 function compactStructuredText(value: unknown): string {
 	return JSON.stringify(value);
 }
 
 export interface OutputEntryPatchInfo {
+	taskIndex?: number;
+	baseCommit?: string;
+	repoCwd?: string;
 	patchPath?: string;
 	patchError?: string;
 }
 
-function patchFields(patch: OutputEntryPatchInfo | undefined): Pick<ChainOutputMapEntry, "patchPath" | "patchError"> {
+function patchFields(patch: OutputEntryPatchInfo | undefined): OutputEntryPatchInfo {
 	if (!patch) return {};
 	return {
+		...(patch.taskIndex !== undefined ? { taskIndex: patch.taskIndex } : {}),
+		...(patch.baseCommit !== undefined ? { baseCommit: patch.baseCommit } : {}),
+		...(patch.repoCwd !== undefined ? { repoCwd: patch.repoCwd } : {}),
 		...(patch.patchPath ? { patchPath: patch.patchPath } : {}),
 		...(patch.patchError ? { patchError: patch.patchError } : {}),
 	};

package/src/runs/shared/parallel-utils.ts

@@ -33,6 +33,7 @@ export interface RunnerSubagentStep {
 
 export interface ParallelStepGroup {
 	parallel: RunnerSubagentStep[];
+	cwd?: string;
 	concurrency?: number;
 	failFast?: boolean;
 	worktree?: boolean;

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

@@ -106,6 +106,16 @@ export function formatSavedOutputReference(savedPath: string, fullOutput: string
 	};
 }
 
+export function formatFileOnlyFailure(params: {
+	outputPath?: string;
+	saveError?: string;
+} & ({ preservedAt: string; notPreservedReason?: never } | { preservedAt?: never; notPreservedReason: string })): string {
+	const pointer = params.preservedAt !== undefined
+		? `Full reply preserved at ${params.preservedAt}`
+		: `Full reply not preserved (${params.notPreservedReason})`;
+	return params.saveError ? `Output file error: ${params.outputPath}\n${params.saveError}\n\n${pointer}` : pointer;
+}
+
 export function validateFileOnlyOutputMode(outputMode: OutputMode | undefined, outputPath: string | undefined, context: string): string | undefined {
 	if (outputMode === "file-only" && !outputPath) {
 		return `${context} sets outputMode: "file-only" but does not configure an output file. Set output to a path or use outputMode: "inline".`;

package/src/runs/shared/worktree.ts

@@ -557,6 +557,38 @@ export function diffWorktrees(setup: WorktreeSetup, agents: string[], diffsDir:
 	return diffs;
 }
 
+export function materializeTree({ repoCwd, baseCommit, patchPath, dir }: {
+	repoCwd: string;
+	baseCommit: string;
+	patchPath: string;
+	dir: string;
+}): string {
+	fs.mkdirSync(path.dirname(dir), { recursive: true });
+	const add = runGit(repoCwd, ["worktree", "add", "--detach", dir, baseCommit]);
+	if (add.status !== 0) {
+		throw new Error(add.stderr.split("\n").map((line) => line.trim()).find(Boolean) || "git worktree add failed");
+	}
+	const apply = runGit(dir, ["apply", "--index", patchPath]);
+	if (apply.status !== 0) {
+		throw new Error(apply.stderr.split("\n").map((line) => line.trim()).find(Boolean) || "git apply failed");
+	}
+	return dir;
+}
+
+export function removeTrees(entries: Array<{ repoCwd: string; dir: string }>): void {
+	for (const { repoCwd, dir } of entries) {
+		if (!fs.existsSync(dir)) continue;
+		try { runGitChecked(repoCwd, ["worktree", "remove", "--force", dir]); } catch (error) {
+			console.warn(`Failed to remove tree '${dir}': ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+	for (const repoCwd of new Set(entries.map((entry) => entry.repoCwd))) {
+		try { runGitChecked(repoCwd, ["worktree", "prune"]); } catch (error) {
+			console.warn(`Failed to prune worktrees in '${repoCwd}': ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+}
+
 export function cleanupWorktrees(setup: WorktreeSetup): void {
 	for (let index = setup.worktrees.length - 1; index >= 0; index--) {
 		cleanupSingleWorktree(setup.cwd, setup.worktrees[index]!);

package/src/shared/types.ts

@@ -58,6 +58,10 @@ export interface ChainTaskOutputEntry {
 }
 
 export interface ChainOutputMapEntry {
+	taskIndex?: number;
+	baseCommit?: string;
+	repoCwd?: string;
+	treePath?: string;
 	text: string;
 	structured?: unknown;
 	agent: string;