pi-subagents 0.27.0 → 0.29.0

package/src/runs/shared/model-fallback.ts

@@ -20,6 +20,44 @@ export function splitThinkingSuffix(model: string): { baseModel: string; thinkin
 	};
 }
 
+/** Sentinel model value requesting that a subagent inherit the parent session's model. */
+export const INHERIT_MODEL = "inherit";
+
+/** Minimal shape of the parent session's in-memory model (`ctx.model`). */
+export interface ParentModel {
+	provider: string;
+	id: string;
+}
+
+/**
+ * Resolve the `--model` override passed to a spawned subagent.
+ *
+ * When no model is requested (`undefined`, `false`, empty, or the `"inherit"`
+ * sentinel), the child must inherit the parent session's *in-memory* model
+ * (`provider/id`) instead of being left to resolve its own model. Without an
+ * explicit `provider/id`, the child falls back to the global
+ * `~/.pi/agent/settings.json` default, which is shared across every open PI
+ * session — so a different session that last changed its model in the TUI would
+ * silently contaminate this session's subagents (see issue #266). Passing an
+ * explicit `provider/id` keeps each session's children isolated to that
+ * session's model.
+ *
+ * An explicitly requested model string is resolved via {@link resolveModelCandidate}.
+ */
+export function resolveSubagentModelOverride(
+	requestedModel: string | boolean | undefined,
+	parentModel: ParentModel | undefined,
+	availableModels: AvailableModelInfo[] | undefined,
+	preferredProvider?: string,
+): string | undefined {
+	const trimmed = typeof requestedModel === "string" ? requestedModel.trim() : "";
+	const explicit = trimmed && trimmed !== INHERIT_MODEL ? trimmed : undefined;
+	if (explicit === undefined) {
+		return parentModel ? `${parentModel.provider}/${parentModel.id}` : undefined;
+	}
+	return resolveModelCandidate(explicit, availableModels, preferredProvider);
+}
+
 export function resolveModelCandidate(
 	model: string | undefined,
 	availableModels: AvailableModelInfo[] | undefined,

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

@@ -1,6 +1,3 @@
-import type { DynamicCollectSpec, DynamicExpandSpec } from "../../shared/settings.ts";
-import type { JsonSchemaObject, ResolvedAcceptanceConfig } from "../../shared/types.ts";
-
 export interface RunnerSubagentStep {
 	agent: string;
 	task: string;
@@ -26,12 +23,12 @@ export interface RunnerSubagentStep {
 	sessionFile?: string;
 	maxSubagentDepth?: number;
 	structuredOutput?: {
-		schema: JsonSchemaObject;
+		schema: import("../../shared/types.ts").JsonSchemaObject;
 		schemaPath: string;
 		outputPath: string;
 	};
-	structuredOutputSchema?: JsonSchemaObject;
-	effectiveAcceptance?: ResolvedAcceptanceConfig;
+	structuredOutputSchema?: import("../../shared/types.ts").JsonSchemaObject;
+	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
 }
 
 export interface ParallelStepGroup {
@@ -42,13 +39,14 @@ export interface ParallelStepGroup {
 }
 
 export interface DynamicRunnerGroup {
-	expand: DynamicExpandSpec;
+	expand: import("../../shared/settings.ts").DynamicExpandSpec;
 	parallel: RunnerSubagentStep;
-	collect: DynamicCollectSpec;
+	collect: import("../../shared/settings.ts").DynamicCollectSpec;
 	concurrency?: number;
 	failFast?: boolean;
 	phase?: string;
 	label?: string;
+	effectiveAcceptance?: import("../../shared/types.ts").ResolvedAcceptanceConfig;
 }
 
 export type RunnerStep = RunnerSubagentStep | ParallelStepGroup | DynamicRunnerGroup;

package/src/runs/shared/subagent-prompt-runtime.ts

@@ -135,14 +135,15 @@ function stripAssistantSubagentToolCallBlocks(message: unknown): unknown | undef
 }
 
 export function stripParentOnlySubagentMessages(messages: unknown[]): unknown[] {
+	const preserveCurrentFanoutToolHistory = process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1";
 	let changed = false;
 	const filtered: unknown[] = [];
 	for (const message of messages) {
-		if (isParentOnlySubagentMessage(message) || isSubagentToolResultMessage(message)) {
+		if (isParentOnlySubagentMessage(message) || (!preserveCurrentFanoutToolHistory && isSubagentToolResultMessage(message))) {
 			changed = true;
 			continue;
 		}
-		const stripped = stripAssistantSubagentToolCallBlocks(message);
+		const stripped = preserveCurrentFanoutToolHistory ? message : stripAssistantSubagentToolCallBlocks(message);
 		if (stripped === undefined) {
 			changed = true;
 			continue;

package/src/shared/atomic-json.ts

@@ -1,16 +1,73 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-export function writeAtomicJson(filePath: string, payload: object): void {
-	fs.mkdirSync(path.dirname(filePath), { recursive: true });
-	const tempPath = path.join(
-		path.dirname(filePath),
-		`.${path.basename(filePath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`,
-	);
-	try {
-		fs.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
-		fs.renameSync(tempPath, filePath);
-	} finally {
-		fs.rmSync(tempPath, { force: true });
+type AtomicJsonFs = Pick<typeof fs, "mkdirSync" | "writeFileSync" | "renameSync" | "rmSync">;
+
+type AtomicJsonWriterOptions = {
+	fs?: AtomicJsonFs;
+	now?: () => number;
+	pid?: number;
+	random?: () => number;
+	retryRenameErrors?: boolean;
+	retryDelaysMs?: readonly number[];
+	wait?: (delayMs: number) => void;
+};
+
+const DEFAULT_RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200] as const;
+const RETRYABLE_RENAME_ERROR_CODES = new Set(["EACCES", "EBUSY", "EPERM"]);
+
+function waitSync(delayMs: number): void {
+	const end = Date.now() + delayMs;
+	while (Date.now() < end) {
+		// writeAtomicJson is synchronous because callers often update status from sync callbacks.
 	}
 }
+
+function isRetryableRenameError(error: unknown): boolean {
+	const code = (error as NodeJS.ErrnoException | undefined)?.code;
+	return typeof code === "string" && RETRYABLE_RENAME_ERROR_CODES.has(code);
+}
+
+function renameWithRetry(
+	fsImpl: AtomicJsonFs,
+	sourcePath: string,
+	targetPath: string,
+	retryDelaysMs: readonly number[],
+	wait: (delayMs: number) => void,
+): void {
+	for (let attempt = 0; ; attempt++) {
+		try {
+			fsImpl.renameSync(sourcePath, targetPath);
+			return;
+		} catch (error) {
+			const delayMs = retryDelaysMs[attempt];
+			if (delayMs === undefined || !isRetryableRenameError(error)) throw error;
+			wait(delayMs);
+		}
+	}
+}
+
+export function createAtomicJsonWriter(options: AtomicJsonWriterOptions = {}): (filePath: string, payload: object) => void {
+	const fsImpl = options.fs ?? fs;
+	const now = options.now ?? Date.now;
+	const pid = options.pid ?? process.pid;
+	const random = options.random ?? Math.random;
+	const retryRenameErrors = options.retryRenameErrors ?? process.platform === "win32";
+	const retryDelaysMs = retryRenameErrors ? options.retryDelaysMs ?? DEFAULT_RENAME_RETRY_DELAYS_MS : [];
+	const wait = options.wait ?? waitSync;
+	return (filePath: string, payload: object): void => {
+		fsImpl.mkdirSync(path.dirname(filePath), { recursive: true });
+		const tempPath = path.join(
+			path.dirname(filePath),
+			`.${path.basename(filePath)}.${pid}.${now()}.${random().toString(36).slice(2)}.tmp`,
+		);
+		try {
+			fsImpl.writeFileSync(tempPath, JSON.stringify(payload, null, 2), "utf-8");
+			renameWithRetry(fsImpl, tempPath, filePath, retryDelaysMs, wait);
+		} finally {
+			fsImpl.rmSync(tempPath, { force: true });
+		}
+	};
+}
+
+export const writeAtomicJson = createAtomicJsonWriter();

package/src/shared/settings.ts

@@ -103,6 +103,7 @@ export interface DynamicParallelStep {
 	failFast?: boolean;
 	phase?: string;
 	label?: string;
+	acceptance?: AcceptanceInput;
 }
 
 /** Parallel step: multiple agents running concurrently */

package/src/shared/types.ts

@@ -239,7 +239,7 @@ export interface ModelAttempt {
 	usage?: Usage;
 }
 
-export type AcceptanceProvenanceLevel = "none" | "attested" | "checked" | "verified" | "reviewed";
+export type AcceptanceLevel = "auto" | "none" | "attested" | "checked" | "verified" | "reviewed";
 
 export type AcceptanceEvidenceKind =
 	| "changed-files"
@@ -275,15 +275,16 @@ export interface AcceptanceReviewGate {
 }
 
 export interface AcceptanceConfig {
+	level?: AcceptanceLevel;
 	criteria?: Array<string | AcceptanceGate>;
 	evidence?: AcceptanceEvidenceKind[];
 	verify?: AcceptanceVerifyCommand[];
-	review?: AcceptanceReviewGate;
+	review?: AcceptanceReviewGate | false;
 	stopRules?: string[];
-	maxFinalizationTurns?: number;
+	reason?: string;
 }
 
-export type AcceptanceInput = AcceptanceConfig;
+export type AcceptanceInput = AcceptanceLevel | false | AcceptanceConfig;
 
 export interface ResolvedAcceptanceGate extends AcceptanceGate {
 	id: string;
@@ -293,18 +294,15 @@ export interface ResolvedAcceptanceGate extends AcceptanceGate {
 }
 
 export interface ResolvedAcceptanceConfig {
-	level: AcceptanceProvenanceLevel;
+	level: Exclude<AcceptanceLevel, "auto">;
 	explicit: boolean;
 	inferredReason: string[];
 	criteria: ResolvedAcceptanceGate[];
 	evidence: AcceptanceEvidenceKind[];
 	verify: AcceptanceVerifyCommand[];
-	review?: AcceptanceReviewGate;
+	review?: AcceptanceReviewGate | false;
 	stopRules: string[];
-	finalization: {
-		mode: "none" | "self-review-loop";
-		maxTurns: number;
-	};
+	reason?: string;
 }
 
 export interface AcceptanceReport {
@@ -368,25 +366,6 @@ export type AcceptanceLedgerStatus =
 	| "accepted"
 	| "rejected";
 
-export interface AcceptanceFinalizationTurn {
-	turn: number;
-	prompt: string;
-	status: AcceptanceLedgerStatus;
-	rawOutput?: string;
-	report?: AcceptanceReport;
-	parseError?: string;
-	runtimeChecks: AcceptanceRuntimeCheck[];
-	verifyRuns: AcceptanceVerifyResult[];
-	failureMessage?: string;
-}
-
-export interface AcceptanceFinalizationLedger {
-	mode: "self-review-loop";
-	status: "not-run" | "completed" | "failed";
-	maxTurns: number;
-	turns: AcceptanceFinalizationTurn[];
-}
-
 export interface AcceptanceLedger {
 	status: AcceptanceLedgerStatus;
 	explicit: boolean;
@@ -395,12 +374,9 @@ export interface AcceptanceLedger {
 	criteria: ResolvedAcceptanceGate[];
 	childReport?: AcceptanceReport;
 	childReportParseError?: string;
-	initialChildReport?: AcceptanceReport;
-	initialChildReportParseError?: string;
 	runtimeChecks: AcceptanceRuntimeCheck[];
 	verifyRuns: AcceptanceVerifyResult[];
 	reviewResult?: AcceptanceReviewResult;
-	finalization?: AcceptanceFinalizationLedger;
 	parentDecision?: {
 		status: "accepted" | "rejected";
 		at: string;

package/src/shared/utils.ts

@@ -192,7 +192,8 @@ export function getFinalOutput(messages: Message[]): string {
 			const hasAssistantError = ("errorMessage" in msg && typeof msg.errorMessage === "string" && msg.errorMessage.length > 0)
 				|| ("stopReason" in msg && msg.stopReason === "error");
 			if (hasAssistantError) continue;
-			for (const part of msg.content) {
+			for (let j = msg.content.length - 1; j >= 0; j--) {
+				const part = msg.content[j];
 				if (part.type === "text" && part.text.trim().length > 0) return part.text;
 			}
 		}

package/src/tui/render.ts

@@ -222,21 +222,11 @@ function firstOutputLine(text: string): string {
 	return text.split("\n").find((line) => line.trim())?.trim() ?? "";
 }
 
-function formatAcceptanceStatus(result: Details["results"][number]): string | undefined {
-	const acceptance = result.acceptance;
-	if (!acceptance?.status || acceptance.status === "not-required") return undefined;
-	const finalization = acceptance.finalization
-		? ` · finalization: ${acceptance.finalization.status} after ${acceptance.finalization.turns.length}/${acceptance.finalization.maxTurns} turns`
-		: "";
-	return `acceptance: ${acceptance.status}${finalization}`;
-}
-
 function resultStatusLine(result: Details["results"][number], output: string): string {
 	if (result.detached) return result.detachedReason ? `Detached: ${result.detachedReason}` : "Detached";
 	if (result.interrupted) return "Paused";
 	if (result.exitCode !== 0) return `Error: ${result.error ?? (firstOutputLine(output) || `exit ${result.exitCode}`)}`;
-	const acceptance = formatAcceptanceStatus(result);
-	if (acceptance) return `Done · ${acceptance}`;
+	if (result.acceptance?.status && result.acceptance.status !== "not-required") return `Done · acceptance: ${result.acceptance.status}`;
 	if (hasEmptyTextOutputWithoutOutputTarget(result.task, output)) return "Done (no text output)";
 	return "Done";
 }

package/src/runs/shared/acceptance-contract.ts

@@ -1,291 +0,0 @@
-import type {
-	AcceptanceConfig,
-	AcceptanceEvidenceKind,
-	AcceptanceInput,
-	AcceptanceProvenanceLevel,
-	ResolvedAcceptanceConfig,
-	ResolvedAcceptanceGate,
-	SubagentRunMode,
-} from "../../shared/types.ts";
-
-const DEFAULT_FINALIZATION_MAX_TURNS = 3;
-const MAX_FINALIZATION_TURNS = 10;
-
-const VALID_EVIDENCE = new Set<AcceptanceEvidenceKind>([
-	"changed-files",
-	"tests-added",
-	"commands-run",
-	"validation-output",
-	"residual-risks",
-	"no-staged-files",
-	"diff-summary",
-	"review-findings",
-	"manual-notes",
-]);
-
-const ACCEPTANCE_KEYS = new Set([
-	"criteria",
-	"evidence",
-	"verify",
-	"review",
-	"stopRules",
-	"maxFinalizationTurns",
-]);
-
-const REMOVED_ACCEPTANCE_KEYS = new Set(["level", "finalization", "reason"]);
-
-function hasArrayItems(value: unknown): boolean {
-	return Array.isArray(value) && value.length > 0;
-}
-
-export function validateAcceptanceInput(input: unknown, pathLabel = "acceptance"): string[] {
-	const errors: string[] = [];
-	if (input === undefined) return errors;
-	if (input === false || typeof input === "string") {
-		errors.push(`${pathLabel} must be an object. Public acceptance levels and false disables are no longer supported.`);
-		return errors;
-	}
-	if (!input || typeof input !== "object" || Array.isArray(input)) {
-		errors.push(`${pathLabel} must be an object.`);
-		return errors;
-	}
-
-	const value = input as Record<string, unknown>;
-	if (Object.hasOwn(value, "level")) {
-		errors.push(`${pathLabel}.level is no longer supported; configure criteria, evidence, verify, and review directly.`);
-	}
-	if (Object.hasOwn(value, "finalization")) {
-		errors.push(`${pathLabel}.finalization is not supported; acceptance contracts always run the self-review loop.`);
-	}
-	if (Object.hasOwn(value, "reason")) {
-		errors.push(`${pathLabel}.reason is not supported because acceptance is disabled by omitting the field.`);
-	}
-	for (const key of Object.keys(value)) {
-		if (!ACCEPTANCE_KEYS.has(key) && !REMOVED_ACCEPTANCE_KEYS.has(key)) errors.push(`${pathLabel}.${key} is not supported.`);
-	}
-
-	if (value.criteria !== undefined) {
-		if (!Array.isArray(value.criteria)) {
-			errors.push(`${pathLabel}.criteria must be an array.`);
-		} else {
-			for (const [index, criterion] of value.criteria.entries()) {
-				if (typeof criterion === "string") {
-					if (!criterion.trim()) errors.push(`${pathLabel}.criteria[${index}] must not be empty.`);
-					continue;
-				}
-				if (!criterion || typeof criterion !== "object" || Array.isArray(criterion)) {
-					errors.push(`${pathLabel}.criteria[${index}] must be a string or object.`);
-					continue;
-				}
-				const item = criterion as Record<string, unknown>;
-				if (typeof item.id !== "string" || !item.id.trim()) errors.push(`${pathLabel}.criteria[${index}].id is required.`);
-				if (typeof item.must !== "string" || !item.must.trim()) errors.push(`${pathLabel}.criteria[${index}].must is required.`);
-				if (item.evidence !== undefined && !Array.isArray(item.evidence)) errors.push(`${pathLabel}.criteria[${index}].evidence must be an array.`);
-				if (Array.isArray(item.evidence)) {
-					for (const [evidenceIndex, evidence] of item.evidence.entries()) {
-						if (typeof evidence !== "string" || !VALID_EVIDENCE.has(evidence as AcceptanceEvidenceKind)) {
-							errors.push(`${pathLabel}.criteria[${index}].evidence[${evidenceIndex}] is not a supported evidence kind.`);
-						}
-					}
-				}
-				if (item.severity !== undefined && item.severity !== "required" && item.severity !== "recommended") {
-					errors.push(`${pathLabel}.criteria[${index}].severity must be required or recommended.`);
-				}
-			}
-		}
-	}
-
-	if (Array.isArray(value.evidence)) {
-		for (const [index, item] of value.evidence.entries()) {
-			if (typeof item !== "string" || !VALID_EVIDENCE.has(item as AcceptanceEvidenceKind)) {
-				errors.push(`${pathLabel}.evidence[${index}] is not a supported evidence kind.`);
-			}
-		}
-	} else if (value.evidence !== undefined) {
-		errors.push(`${pathLabel}.evidence must be an array.`);
-	}
-
-	if (value.verify !== undefined && !Array.isArray(value.verify)) errors.push(`${pathLabel}.verify must be an array.`);
-	if (Array.isArray(value.verify)) {
-		for (const [index, command] of value.verify.entries()) {
-			if (!command || typeof command !== "object" || Array.isArray(command)) {
-				errors.push(`${pathLabel}.verify[${index}] must be an object.`);
-				continue;
-			}
-			const cmd = command as Record<string, unknown>;
-			if (typeof cmd.id !== "string" || !cmd.id.trim()) errors.push(`${pathLabel}.verify[${index}].id is required.`);
-			if (typeof cmd.command !== "string" || !cmd.command.trim()) errors.push(`${pathLabel}.verify[${index}].command is required.`);
-			if (cmd.timeoutMs !== undefined && (!Number.isInteger(cmd.timeoutMs) || Number(cmd.timeoutMs) <= 0)) {
-				errors.push(`${pathLabel}.verify[${index}].timeoutMs must be a positive integer.`);
-			}
-			if (cmd.cwd !== undefined && typeof cmd.cwd !== "string") errors.push(`${pathLabel}.verify[${index}].cwd must be a string.`);
-			if (cmd.env !== undefined) {
-				if (!cmd.env || typeof cmd.env !== "object" || Array.isArray(cmd.env)) {
-					errors.push(`${pathLabel}.verify[${index}].env must be an object with string values.`);
-				} else {
-					for (const [key, envValue] of Object.entries(cmd.env as Record<string, unknown>)) {
-						if (typeof envValue !== "string") errors.push(`${pathLabel}.verify[${index}].env.${key} must be a string.`);
-					}
-				}
-			}
-			if (cmd.allowFailure !== undefined && typeof cmd.allowFailure !== "boolean") errors.push(`${pathLabel}.verify[${index}].allowFailure must be a boolean.`);
-		}
-	}
-
-	if (value.review !== undefined) {
-		if (!value.review || typeof value.review !== "object" || Array.isArray(value.review)) {
-			errors.push(`${pathLabel}.review must be an object.`);
-		} else {
-			const review = value.review as Record<string, unknown>;
-			if (review.agent !== undefined && typeof review.agent !== "string") errors.push(`${pathLabel}.review.agent must be a string.`);
-			if (review.focus !== undefined && typeof review.focus !== "string") errors.push(`${pathLabel}.review.focus must be a string.`);
-			if (review.required !== undefined && typeof review.required !== "boolean") errors.push(`${pathLabel}.review.required must be a boolean.`);
-		}
-	}
-
-	if (value.stopRules !== undefined) {
-		if (!Array.isArray(value.stopRules)) {
-			errors.push(`${pathLabel}.stopRules must be an array.`);
-		} else {
-			for (const [index, rule] of value.stopRules.entries()) {
-				if (typeof rule !== "string" || !rule.trim()) errors.push(`${pathLabel}.stopRules[${index}] must be a non-empty string.`);
-			}
-		}
-	}
-
-	if (value.maxFinalizationTurns !== undefined) {
-		if (!Number.isInteger(value.maxFinalizationTurns) || Number(value.maxFinalizationTurns) < 1 || Number(value.maxFinalizationTurns) > MAX_FINALIZATION_TURNS) {
-			errors.push(`${pathLabel}.maxFinalizationTurns must be an integer from 1 to ${MAX_FINALIZATION_TURNS}.`);
-		}
-	}
-
-	const hasContract = hasArrayItems(value.criteria)
-		|| hasArrayItems(value.evidence)
-		|| hasArrayItems(value.verify)
-		|| value.review !== undefined
-		|| hasArrayItems(value.stopRules);
-	if (!hasContract) {
-		errors.push(`${pathLabel} must include at least one of criteria, evidence, verify, review, or stopRules.`);
-	}
-
-	return errors;
-}
-
-function normalizeCriteria(criteria: AcceptanceConfig["criteria"], evidence: AcceptanceEvidenceKind[]): ResolvedAcceptanceGate[] {
-	return (criteria ?? []).map((criterion, index) => {
-		if (typeof criterion === "string") {
-			return { id: `criterion-${index + 1}`, must: criterion, evidence, severity: "required" as const };
-		}
-		return {
-			id: criterion.id.trim(),
-			must: criterion.must,
-			evidence: criterion.evidence?.filter((item) => VALID_EVIDENCE.has(item)) ?? evidence,
-			severity: criterion.severity ?? "required",
-		};
-	}).filter((criterion) => criterion.must.trim());
-}
-
-function deriveAcceptanceLevel(config: AcceptanceConfig): AcceptanceProvenanceLevel {
-	if (config.review) return "reviewed";
-	if ((config.verify?.length ?? 0) > 0) return "verified";
-	return "checked";
-}
-
-export function resolveEffectiveAcceptance(input: {
-	explicit?: AcceptanceInput;
-	agentName: string;
-	task?: string;
-	mode?: SubagentRunMode;
-	async?: boolean;
-	dynamic?: boolean;
-	dynamicGroup?: boolean;
-}): ResolvedAcceptanceConfig {
-	if (input.explicit === undefined) {
-		return {
-			level: "none",
-			explicit: false,
-			inferredReason: ["acceptance not configured"],
-			criteria: [],
-			evidence: [],
-			verify: [],
-			stopRules: [],
-			finalization: { mode: "none", maxTurns: 0 },
-		};
-	}
-
-	const validationErrors = validateAcceptanceInput(input.explicit);
-	if (validationErrors.length > 0) throw new Error(validationErrors.join(" "));
-	const explicit = input.explicit;
-	const evidence = [...new Set(explicit.evidence ?? [])];
-	const criteria = normalizeCriteria(explicit.criteria, evidence);
-	const verify = explicit.verify ?? [];
-	const stopRules = explicit.stopRules ?? [];
-	return {
-		level: deriveAcceptanceLevel(explicit),
-		explicit: true,
-		inferredReason: ["explicit acceptance contract"],
-		criteria,
-		evidence,
-		verify,
-		...(explicit.review ? { review: explicit.review } : {}),
-		stopRules,
-		finalization: { mode: "self-review-loop", maxTurns: explicit.maxFinalizationTurns ?? DEFAULT_FINALIZATION_MAX_TURNS },
-	};
-}
-
-export function shouldRunAcceptanceFinalization(acceptance: ResolvedAcceptanceConfig): boolean {
-	return acceptance.explicit && acceptance.finalization.mode === "self-review-loop" && acceptance.finalization.maxTurns > 0;
-}
-
-export function acceptanceSelfReviewConfig(acceptance: ResolvedAcceptanceConfig): ResolvedAcceptanceConfig {
-	if (!acceptance.review && acceptance.verify.length === 0) return acceptance;
-	const { review: _review, verify: _verify, ...selfReview } = acceptance;
-	return {
-		...selfReview,
-		level: "checked",
-		verify: [],
-	};
-}
-
-export function formatAcceptancePrompt(acceptance: ResolvedAcceptanceConfig): string {
-	if (acceptance.level === "none") return "";
-	const lines = [
-		"",
-		"## Acceptance Contract",
-		"Completion is not accepted from prose alone. End the initial response with a structured acceptance report.",
-		"After the initial response, the runtime will continue this same session for a bounded self-review/repair loop before accepting the run.",
-		"",
-		"Criteria:",
-		...(acceptance.criteria.length ? acceptance.criteria.map((criterion) => `- ${criterion.id}: ${criterion.must}`) : ["- No explicit criteria were configured; satisfy the requested task and the required evidence/checks below."]),
-		"",
-		`Required evidence: ${acceptance.evidence.join(", ") || "none explicitly requested"}`,
-	];
-	if (acceptance.verify.length > 0) {
-		lines.push("", "Runtime verification commands configured by parent:");
-		for (const command of acceptance.verify) lines.push(`- ${command.id}: ${command.command}`);
-	}
-	if (acceptance.review) {
-		lines.push("", `Independent review gate: ${acceptance.review.required === false ? "optional" : "required"}${acceptance.review.agent ? ` by ${acceptance.review.agent}` : ""}.`);
-		if (acceptance.review.focus) lines.push(`Review focus: ${acceptance.review.focus}`);
-	}
-	if (acceptance.stopRules.length > 0) {
-		lines.push("", "Stop rules:", ...acceptance.stopRules.map((rule) => `- ${rule}`));
-	}
-	lines.push(
-		"",
-		"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" }],
-			changedFiles: [],
-			testsAddedOrUpdated: [],
-			commandsRun: [{ command: "command", result: "passed", summary: "short result" }],
-			validationOutput: [],
-			residualRisks: [],
-			noStagedFiles: true,
-			notes: "anything else the parent should know",
-		}, null, 2),
-		"```",
-	);
-	return lines.join("\n");
-}