pi-cohort 7.3.1 → 7.4.0

package/src/runs/foreground/execution.ts

@@ -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 ?? [];

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/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;