@gajae-code/coding-agent 0.11.11 → 0.12.1

package/src/gjc-runtime/ultragoal-runtime.ts

@@ -1,6 +1,6 @@
 import * as crypto from "node:crypto";
-import * as os from "node:os";
 import * as path from "node:path";
+import { getConfigRootDir } from "@gajae-code/utils";
 import type { WorkflowHudSummary } from "../skill-state/active-state";
 import { buildUltragoalHudSummary as buildWorkflowUltragoalHudSummary } from "../skill-state/workflow-hud";
 import { renderCliWriteReceipt } from "./cli-write-receipt";
@@ -19,6 +19,7 @@ import {
 	computeCriticVerdictPlanGeneration,
 	computeUltragoalPlanGeneration,
 	countNonOkayTerminalCriticVerdicts,
+	finalAggregateReceiptMissingCriticOkay,
 	findFreshBatchCloseReceipt,
 	findLedgerReceiptEvent,
 	isCleanPauseCriticVerdictShape,
@@ -85,47 +86,6 @@ export type UltragoalGoalStatus =
 	| "review_blocked"
 	| "superseded";
 
-export type UltragoalPipelineMetadataSource = "original_plan_graph" | "legacy_brief_only" | "steering";
-export type UltragoalPipelineOverlapState =
-	| "none"
-	| "open"
-	| "joined_clean"
-	| "blocked_disjoint_continue"
-	| "quarantine_required"
-	| "rebaseline_complete";
-
-export interface UltragoalPipelineTargets extends JsonObject {
-	files: string[];
-	surfaces: string[];
-}
-
-export interface UltragoalPipelineMetadata extends JsonObject {
-	schemaVersion: 1;
-	goalId: string;
-	source: UltragoalPipelineMetadataSource;
-	eligible: boolean;
-	dependsOn: string[];
-	independentOf: string[];
-	targets: UltragoalPipelineTargets;
-	metadataHash: string;
-	overlap: UltragoalPipelineOverlapState;
-	overlapId?: string;
-	priorGoalId?: string;
-	nextGoalId?: string;
-	blockerFootprints?: UltragoalPipelineTargets[];
-	invalidationReason?: string;
-	invalidatedAt?: string;
-}
-
-export interface UltragoalGoalMetadataInput {
-	schemaVersion: 1;
-	goalId: string;
-	source: UltragoalPipelineMetadataSource;
-	dependsOn?: string[];
-	independentOf?: string[];
-	targets?: Partial<UltragoalPipelineTargets>;
-}
-
 export interface UltragoalValidationBatchMetadata extends JsonObject {
 	schemaVersion: 1;
 	batchId: string;
@@ -142,39 +102,6 @@ export interface UltragoalValidationBatchInput {
 	finalGoalId: string;
 }
 
-export interface UltragoalPipelineOverlapHandles extends JsonObject {
-	review: JsonObject;
-	qa: JsonObject;
-	implementation: JsonObject;
-}
-
-export interface UltragoalPipelineOverlapReceipt extends JsonObject {
-	ok: true;
-	event: string;
-	overlap_id: string;
-	prior_goal_id: string;
-	next_goal_id?: string;
-	goal_id?: string;
-	status?: UltragoalPipelineOverlapState;
-	next_goal_status?: UltragoalGoalStatus;
-	goals_path: string;
-	ledger_path: string;
-}
-
-export type UltragoalPipelineLedgerEventName =
-	| "pipeline_overlap_started"
-	| "pipeline_overlap_joined"
-	| "pipeline_overlap_blocked"
-	| "pipeline_overlap_quarantined"
-	| "pipeline_overlap_rebaselined";
-
-export interface UltragoalPipelineLedgerEvent extends UltragoalLedgerEvent {
-	event: UltragoalPipelineLedgerEventName;
-	schemaVersion: 1;
-	overlapId: string;
-	priorGoalId: string;
-	nextGoalId: string;
-}
 export interface UltragoalGoal {
 	id: string;
 	title: string;
@@ -187,7 +114,6 @@ export interface UltragoalGoal {
 	evidence?: string;
 	steering?: Record<string, unknown>;
 	completionVerification?: UltragoalCompletionVerification;
-	pipelineMetadata?: UltragoalPipelineMetadata;
 	validationBatch?: UltragoalValidationBatchMetadata;
 }
 
@@ -322,7 +248,6 @@ export interface UltragoalStatusSummary {
 	nudgeRemaining?: number;
 	nudgeGoalId?: string;
 	nudgeTargetKind?: UltragoalNudgeTargetKind;
-	pipelineOverlap?: JsonObject;
 }
 
 export interface UltragoalCommandResult {
@@ -490,8 +415,7 @@ export async function resolveUltragoalNudgeBudget(cwd: string): Promise<{ budget
 	const projectPath = path.join(gjcRoot(cwd), "settings.json");
 	const project = await readSettingsNudgeBudget(projectPath);
 	if (project !== null) return { budget: project, source: projectPath };
-	const userDir = process.env.GJC_CONFIG_DIR?.trim() || path.join(os.homedir(), ".gjc");
-	const userPath = path.join(userDir, "settings.json");
+	const userPath = path.join(getConfigRootDir(), "settings.json");
 	const user = await readSettingsNudgeBudget(userPath);
 	if (user !== null) return { budget: user, source: userPath };
 	return { budget: DEFAULT_ULTRAGOAL_NUDGE_BUDGET, source: "default" };
@@ -742,61 +666,6 @@ export function stringArray(value: unknown): string[] | null {
 	return Array.isArray(value) && value.every(item => typeof item === "string") ? value.map(item => item.trim()) : null;
 }
 
-function normalizePipelineStringArray(value: unknown, fieldName: string): string[] {
-	const items = stringArray(value) ?? [];
-	const filtered = items.filter(item => item.length > 0);
-	if (items.length !== filtered.length) throw new Error(`${fieldName} must contain only non-empty strings`);
-	return filtered;
-}
-
-function normalizePipelinePath(value: string, fieldName: string): string {
-	const raw = value.trim();
-	if (raw.split(/[\\/]+/).includes("..")) throw new Error(`${fieldName} contains unsafe path ${value}`);
-	const normalized = normalizeRepoPath(raw);
-	if (
-		!normalized ||
-		normalized.startsWith("../") ||
-		normalized === ".." ||
-		path.isAbsolute(normalized) ||
-		normalized.includes("\0")
-	) {
-		throw new Error(`${fieldName} contains unsafe path ${value}`);
-	}
-	return normalized;
-}
-
-function normalizePipelineTargets(value: unknown, fieldName: string): UltragoalPipelineTargets {
-	const record = typeof value === "object" && value !== null && !Array.isArray(value) ? (value as JsonObject) : {};
-	const files = normalizePipelineStringArray(record.files, `${fieldName}.files`).map(item =>
-		normalizePipelinePath(item, `${fieldName}.files`),
-	);
-	const surfaces = normalizePipelineStringArray(record.surfaces, `${fieldName}.surfaces`).map(normalizeSurfaceToken);
-	if (new Set(files).size !== files.length) throw new Error(`${fieldName}.files contains duplicate normalized paths`);
-	if (new Set(surfaces).size !== surfaces.length)
-		throw new Error(`${fieldName}.surfaces contains duplicate normalized surfaces`);
-	return { files, surfaces };
-}
-
-function pipelineMetadataHashBasis(metadata: Omit<UltragoalPipelineMetadata, "metadataHash">): JsonObject {
-	return {
-		schemaVersion: metadata.schemaVersion,
-		goalId: metadata.goalId,
-		source: metadata.source,
-		dependsOn: metadata.dependsOn,
-		independentOf: metadata.independentOf,
-		targets: metadata.targets,
-	};
-}
-
-export function hashPipelineMetadata(metadata: Omit<UltragoalPipelineMetadata, "metadataHash">): string {
-	return hashStructuredValue(pipelineMetadataHashBasis(metadata));
-}
-
-function withPipelineMetadataHash(
-	metadata: Omit<UltragoalPipelineMetadata, "metadataHash">,
-): UltragoalPipelineMetadata {
-	return { ...metadata, metadataHash: hashPipelineMetadata(metadata) } as UltragoalPipelineMetadata;
-}
 function validationBatchHashBasis(metadata: Omit<UltragoalValidationBatchMetadata, "metadataHash">): JsonObject {
 	return {
 		schemaVersion: metadata.schemaVersion,
@@ -900,22 +769,12 @@ function normalizeSavedValidationBatch(record: unknown, id: string): UltragoalVa
 	return normalized;
 }
 
-function pipelineMetadataConflictsWithValidationBatch(metadata: UltragoalPipelineMetadata | undefined): boolean {
-	return metadata?.eligible === true || metadata?.source === "original_plan_graph" || metadata?.source === "steering";
-}
-
-export function validateValidationBatchPipelineExclusion(goal: UltragoalGoal): void {
-	if (goal.validationBatch && pipelineMetadataConflictsWithValidationBatch(goal.pipelineMetadata)) {
-		throw new Error(`Goal ${goal.id} cannot combine validationBatch with eligible pipeline metadata`);
-	}
-}
 function requireFreshValidationBatchMetadata(goal: UltragoalGoal): UltragoalValidationBatchMetadata | undefined {
 	const metadata = goal.validationBatch;
 	if (!metadata) return undefined;
 	const { metadataHash, ...basis } = metadata;
 	if (metadataHash !== hashValidationBatch(basis))
 		throw new Error(`Goal ${goal.id} has stale validation batch metadata hash`);
-	validateValidationBatchPipelineExclusion(goal);
 	return metadata;
 }
 
@@ -1048,245 +907,6 @@ function requireValidationBatchSteeringAllowed(
 			`steer ${kind} cannot invalidate validation batch ${metadata.batchId} while member ${blocker.id} has a fresh deferred receipt`,
 		);
 }
-function legacyPipelineMetadata(goalId: string): UltragoalPipelineMetadata {
-	const basis: Omit<UltragoalPipelineMetadata, "metadataHash"> = {
-		schemaVersion: 1,
-		goalId,
-		source: "legacy_brief_only",
-		eligible: false,
-		dependsOn: [],
-		independentOf: [],
-		targets: { files: [], surfaces: [] },
-		overlap: "none",
-		invalidationReason: "missing_pipeline_metadata",
-	};
-	return withPipelineMetadataHash(basis);
-}
-
-function normalizePipelineMetadataRecord(value: unknown, goalIds: ReadonlySet<string>): UltragoalPipelineMetadata {
-	if (typeof value !== "object" || value === null || Array.isArray(value))
-		throw new Error("goal metadata rows must be objects");
-	const record = value as JsonObject;
-	if (record.schemaVersion !== 1) throw new Error("goal metadata schemaVersion must be 1");
-	const goalId = nonEmptyString(record.goalId);
-	if (!goalId || !goalIds.has(goalId)) throw new Error(`goal metadata references unknown goal id ${goalId ?? ""}`);
-	const source = record.source;
-	if (source !== "original_plan_graph" && source !== "legacy_brief_only" && source !== "steering") {
-		throw new Error("goal metadata source must be original_plan_graph, legacy_brief_only, or steering");
-	}
-	const dependsOn = normalizePipelineStringArray(record.dependsOn, `metadata ${goalId}.dependsOn`);
-	const independentOf = normalizePipelineStringArray(record.independentOf, `metadata ${goalId}.independentOf`);
-	if (dependsOn.includes(goalId) || independentOf.includes(goalId))
-		throw new Error(`goal metadata ${goalId} cannot reference itself`);
-	for (const id of [...dependsOn, ...independentOf]) {
-		if (!goalIds.has(id)) throw new Error(`goal metadata ${goalId} references unknown goal id ${id}`);
-	}
-	if (dependsOn.some(id => independentOf.includes(id)))
-		throw new Error(`goal metadata ${goalId} has dependency/independence conflict`);
-	const targets = requireNonEmptyPipelineTargets(record.targets, `metadata ${goalId}.targets`);
-	const basis: Omit<UltragoalPipelineMetadata, "metadataHash"> = {
-		schemaVersion: 1,
-		goalId,
-		source,
-		eligible: false,
-		dependsOn,
-		independentOf,
-		targets,
-		overlap: "none",
-	};
-	return withPipelineMetadataHash(basis);
-}
-
-export function targetsAreDisjoint(left: UltragoalPipelineTargets, right: UltragoalPipelineTargets): boolean {
-	return (
-		left.files.every(file => !right.files.includes(file)) &&
-		left.surfaces.every(surface => !right.surfaces.includes(surface))
-	);
-}
-
-export function targetsOverlap(left: UltragoalPipelineTargets, right: UltragoalPipelineTargets): boolean {
-	return (
-		left.files.some(file => right.files.includes(file)) ||
-		left.surfaces.some(surface => right.surfaces.includes(surface))
-	);
-}
-
-export function requireNonEmptyPipelineTargets(value: unknown, fieldName: string): UltragoalPipelineTargets {
-	const targets = normalizePipelineTargets(value, fieldName);
-	if (targets.files.length === 0 && targets.surfaces.length === 0)
-		throw new Error(`${fieldName} requires files or surfaces`);
-	return targets;
-}
-
-export function collectPipelineBlockerFootprints(result: JsonObject, fieldName: string): UltragoalPipelineTargets[] {
-	const raw = Array.isArray(result.blockers)
-		? result.blockers
-		: Array.isArray(result.blockerFootprints)
-			? result.blockerFootprints
-			: [];
-	return raw.map((item, index) => {
-		const record = requireJsonObjectValue(item, `${fieldName}.blockers[${index}]`);
-		const footprint = typeof record.footprint === "object" && record.footprint !== null ? record.footprint : record;
-		return requireNonEmptyPipelineTargets(footprint, `${fieldName}.blockers[${index}].footprint`);
-	});
-}
-
-function pipelineTargetsCoverPath(targets: UltragoalPipelineTargets, filePath: string): boolean {
-	const normalized = normalizeRepoPath(filePath);
-	return targets.files.some(target => normalized === target || normalized.startsWith(`${target}/`));
-}
-
-export function pipelinePeer(plan: UltragoalPlan, metadata: UltragoalPipelineMetadata): UltragoalGoal | undefined {
-	const peerId = metadata.goalId === metadata.priorGoalId ? metadata.nextGoalId : metadata.priorGoalId;
-	return peerId ? plan.goals.find(goal => goal.id === peerId) : undefined;
-}
-
-export function handleIdsFromValue(value: JsonObject | JsonObject[], fieldName: string): string[] {
-	const records = Array.isArray(value) ? value : [value];
-	const ids = records.map(
-		(record, index) =>
-			nonEmptyString(record.id) ??
-			nonEmptyString(record.handleId) ??
-			nonEmptyString(record.name) ??
-			`${fieldName}-${index}`,
-	);
-	if (ids.some(id => id.length === 0)) throw new Error(`${fieldName} handles require ids`);
-	return ids;
-}
-
-export function resultHandleIds(value: JsonObject, fieldName: string): string[] {
-	const ids = stringArray(value.handleIds) ?? stringArray(value.handles) ?? [];
-	if (ids.length === 0) throw new Error(`${fieldName} requires handleIds`);
-	return ids;
-}
-
-export function requireCoveredHandles(expected: readonly string[], actual: readonly string[], fieldName: string): void {
-	const missing = expected.filter(id => !actual.includes(id));
-	if (missing.length > 0) throw new Error(`${fieldName} is missing handle coverage for ${missing.join(", ")}`);
-}
-
-function validatePipelineEligibility(metadata: UltragoalPipelineMetadata[]): UltragoalPipelineMetadata[] {
-	const byId = new Map(metadata.map(item => [item.goalId, item]));
-	return metadata.map(item => {
-		const invalidationReasons: string[] = [];
-		if (item.source !== "original_plan_graph") invalidationReasons.push("not_original_plan_graph");
-		if (item.targets.files.length === 0 && item.targets.surfaces.length === 0)
-			invalidationReasons.push("empty_targets");
-		for (const otherId of item.independentOf) {
-			const other = byId.get(otherId);
-			if (!other?.independentOf.includes(item.goalId))
-				invalidationReasons.push(`missing_symmetric_independence:${otherId}`);
-			if (other && !targetsAreDisjoint(item.targets, other.targets))
-				invalidationReasons.push(`shared_targets:${otherId}`);
-		}
-		const eligible = invalidationReasons.length === 0;
-		return {
-			...item,
-			eligible,
-			...(eligible ? {} : { invalidationReason: invalidationReasons.join(",") || "ineligible" }),
-		};
-	});
-}
-
-function parseGoalMetadataInput(value: unknown, goalIds: ReadonlySet<string>): UltragoalPipelineMetadata[] {
-	if (!Array.isArray(value)) throw new Error("goal metadata JSON must be an array");
-	const seen = new Set<string>();
-	const metadata = value.map(row => {
-		const item = normalizePipelineMetadataRecord(row, goalIds);
-		if (seen.has(item.goalId)) throw new Error(`duplicate goal metadata for ${item.goalId}`);
-		seen.add(item.goalId);
-		return item;
-	});
-	return validatePipelineEligibility(metadata);
-}
-function normalizeSavedPipelineMetadata(value: unknown, goalId: string): UltragoalPipelineMetadata | undefined {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
-	const record = value as JsonObject;
-	const source =
-		record.source === "original_plan_graph" || record.source === "legacy_brief_only" || record.source === "steering"
-			? record.source
-			: "legacy_brief_only";
-	const overlap =
-		record.overlap === "open" ||
-		record.overlap === "joined_clean" ||
-		record.overlap === "blocked_disjoint_continue" ||
-		record.overlap === "quarantine_required" ||
-		record.overlap === "rebaseline_complete"
-			? record.overlap
-			: "none";
-	const basis: Omit<UltragoalPipelineMetadata, "metadataHash"> = {
-		schemaVersion: 1,
-		goalId,
-		source,
-		eligible: record.eligible === true,
-		dependsOn: normalizePipelineStringArray(record.dependsOn, `metadata ${goalId}.dependsOn`),
-		independentOf: normalizePipelineStringArray(record.independentOf, `metadata ${goalId}.independentOf`),
-		targets: normalizePipelineTargets(record.targets, `metadata ${goalId}.targets`),
-		overlap,
-		...(nonEmptyString(record.overlapId) ? { overlapId: nonEmptyString(record.overlapId)! } : {}),
-		...(nonEmptyString(record.priorGoalId) ? { priorGoalId: nonEmptyString(record.priorGoalId)! } : {}),
-		...(nonEmptyString(record.nextGoalId) ? { nextGoalId: nonEmptyString(record.nextGoalId)! } : {}),
-		...(Array.isArray(record.blockerFootprints)
-			? {
-					blockerFootprints: record.blockerFootprints.map((item, index) =>
-						normalizePipelineTargets(item, `metadata ${goalId}.blockerFootprints[${index}]`),
-					),
-				}
-			: {}),
-		...(nonEmptyString(record.invalidationReason)
-			? { invalidationReason: nonEmptyString(record.invalidationReason)! }
-			: {}),
-		...(nonEmptyString(record.invalidatedAt) ? { invalidatedAt: nonEmptyString(record.invalidatedAt)! } : {}),
-	};
-	return {
-		...basis,
-		metadataHash: nonEmptyString(record.metadataHash) ?? hashPipelineMetadata(basis),
-	} as UltragoalPipelineMetadata;
-}
-
-function currentPipelineHash(metadata: UltragoalPipelineMetadata): string {
-	return hashPipelineMetadata(metadata);
-}
-
-export function requireFreshPipelineMetadata(goal: UltragoalGoal): UltragoalPipelineMetadata {
-	const metadata = goal.pipelineMetadata;
-	if (!metadata) throw new Error(`Goal ${goal.id} has no pipeline metadata`);
-	if (metadata.metadataHash !== currentPipelineHash(metadata))
-		throw new Error(`Goal ${goal.id} has stale pipeline metadata hash`);
-	return metadata;
-}
-
-export function openPipelineOverlap(
-	plan: UltragoalPlan,
-): { prior: UltragoalGoal; next: UltragoalGoal; overlapId: string } | null {
-	const openGoals = plan.goals.filter(goal => goal.pipelineMetadata?.overlap === "open");
-	if (openGoals.length === 0) return null;
-	const overlapId = openGoals[0]?.pipelineMetadata?.overlapId;
-	if (!overlapId) return null;
-	const peers = openGoals.filter(goal => goal.pipelineMetadata?.overlapId === overlapId);
-	if (peers.length !== 2) return null;
-	const prior = peers[0];
-	const next = peers[1];
-	if (!prior || !next) return null;
-	return { prior, next, overlapId };
-}
-
-function invalidatePipelineMetadata(goal: UltragoalGoal, reason: string, now: string): void {
-	const basis: Omit<UltragoalPipelineMetadata, "metadataHash"> = {
-		schemaVersion: 1,
-		goalId: goal.id,
-		source: goal.pipelineMetadata?.source ?? "steering",
-		eligible: false,
-		dependsOn: goal.pipelineMetadata?.dependsOn ?? [],
-		independentOf: goal.pipelineMetadata?.independentOf ?? [],
-		targets: goal.pipelineMetadata?.targets ?? { files: [], surfaces: [] },
-		overlap: "none",
-		invalidationReason: reason,
-		invalidatedAt: now,
-	};
-	goal.pipelineMetadata = withPipelineMetadataHash(basis);
-}
-
 function normalizeGoalStatus(value: unknown): UltragoalGoalStatus {
 	switch (value) {
 		case "pending":
@@ -1327,7 +947,6 @@ function normalizePlan(raw: unknown): UltragoalPlan {
 		const title = nonEmptyString(goalRecord.title) ?? id;
 		const objective = nonEmptyString(goalRecord.objective) ?? title;
 		const goalCreatedAt = nonEmptyString(goalRecord.createdAt) ?? createdAt;
-		const pipelineMetadata = normalizeSavedPipelineMetadata(goalRecord.pipelineMetadata, id);
 		const validationBatch = normalizeSavedValidationBatch(goalRecord.validationBatch, id);
 		return {
 			...goalRecord,
@@ -1348,7 +967,6 @@ function normalizePlan(raw: unknown): UltragoalPlan {
 				typeof goalRecord.completionVerification === "object" && goalRecord.completionVerification !== null
 					? (goalRecord.completionVerification as UltragoalCompletionVerification)
 					: undefined,
-			pipelineMetadata,
 			validationBatch,
 		};
 	});
@@ -1411,7 +1029,6 @@ export async function getUltragoalStatus(cwd: string, sessionId?: string | null)
 	if (!plan) return { exists: false, status: "missing", paths, counts, goals: [] };
 	for (const goal of plan.goals) counts[goal.status] += 1;
 	const currentGoal = plan.goals.find(goal => SCHEDULABLE_STATUSES.has(goal.status));
-	const overlap = openPipelineOverlap(plan);
 	let status: UltragoalStatusSummary["status"] = "pending";
 	if (plan.goals.length > 0 && plan.goals.every(goal => TERMINAL_OR_SKIPPED_STATUSES.has(goal.status)))
 		status = "complete";
@@ -1441,16 +1058,6 @@ export async function getUltragoalStatus(cwd: string, sessionId?: string | null)
 		counts,
 		goals: plan.goals,
 		...nudgeFields,
-		...(overlap
-			? {
-					pipelineOverlap: {
-						overlapId: overlap.overlapId,
-						priorGoalId: overlap.prior.id,
-						nextGoalId: overlap.next.id,
-						status: overlap.next.pipelineMetadata?.overlap,
-					},
-				}
-			: {}),
 	};
 }
 export function buildUltragoalHudSummary(
@@ -1525,8 +1132,6 @@ export async function createUltragoalPlan(input: {
 	brief: string;
 	gjcGoalMode?: UltragoalGjcGoalMode;
 	sessionId?: string | null;
-	goalMetadata?: UltragoalGoalMetadataInput[];
-	goalMetadataJson?: string;
 	validationBatches?: UltragoalValidationBatchInput[];
 	validationBatchJson?: string;
 }): Promise<UltragoalPlan> {
@@ -1545,31 +1150,18 @@ export async function createUltragoalPlan(input: {
 		updatedAt: now,
 	}));
 	const goalIds = new Set(goals.map(goal => goal.id));
-	const metadataInput = input.goalMetadataJson
-		? await readStructuredValue(input.cwd, input.goalMetadataJson)
-		: input.goalMetadata;
 	const validationBatchInput = input.validationBatchJson
 		? await readStructuredValue(input.cwd, input.validationBatchJson)
 		: input.validationBatches;
-	if (metadataInput !== undefined && validationBatchInput !== undefined) {
-		const metadataRows = Array.isArray(metadataInput) ? metadataInput : [];
-		const batchRows = Array.isArray(validationBatchInput) ? validationBatchInput : [];
-		if (metadataRows.length > 0 && batchRows.length > 0)
-			throw new Error("validation-batch-json and goal-metadata-json are mutually exclusive");
-	}
-	const metadata = metadataInput === undefined ? [] : parseGoalMetadataInput(metadataInput, goalIds);
 	const validationBatches =
 		validationBatchInput === undefined
 			? []
 			: parseValidationBatchInput(validationBatchInput, goalIds, input.gjcGoalMode ?? "aggregate");
-	const metadataByGoalId = new Map(metadata.map(item => [item.goalId, item]));
 	const validationBatchByGoalId = new Map<string, UltragoalValidationBatchMetadata>();
 	for (const batch of validationBatches)
 		for (const memberId of batch.memberIds) validationBatchByGoalId.set(memberId, batch);
 	for (const goal of goals) {
-		goal.pipelineMetadata = metadataByGoalId.get(goal.id) ?? legacyPipelineMetadata(goal.id);
 		goal.validationBatch = validationBatchByGoalId.get(goal.id);
-		validateValidationBatchPipelineExclusion(goal);
 	}
 	const repositoryBinding = await captureRepositoryBinding(input.cwd, {
 		displayPath: input.cwd,
@@ -1604,41 +1196,6 @@ export interface UltragoalRunCompletionState {
 	hasBlockers: boolean;
 	needsFinalAggregateReceipt: boolean;
 }
-export function requireJsonObjectValue(value: unknown, fieldName: string): JsonObject {
-	if (typeof value !== "object" || value === null || Array.isArray(value))
-		throw new Error(`${fieldName} must be an object`);
-	if (Object.keys(value).length === 0) throw new Error(`${fieldName} must be non-empty`);
-	return value as JsonObject;
-}
-
-export function requireJsonObjectOrArrayValue(value: unknown, fieldName: string): JsonObject | JsonObject[] {
-	if (Array.isArray(value)) {
-		if (value.length === 0) throw new Error(`${fieldName} must be non-empty`);
-		return value.map((item, index) => requireJsonObjectValue(item, `${fieldName}[${index}]`));
-	}
-	return requireJsonObjectValue(value, fieldName);
-}
-
-async function readRequiredJsonObject(cwd: string, value: string, fieldName: string): Promise<JsonObject> {
-	return requireJsonObjectValue(await readStructuredValue(cwd, value), fieldName);
-}
-
-async function readRequiredJsonObjectOrArray(
-	cwd: string,
-	value: string,
-	fieldName: string,
-): Promise<JsonObject | JsonObject[]> {
-	return requireJsonObjectOrArrayValue(await readStructuredValue(cwd, value), fieldName);
-}
-
-import {
-	joinUltragoalPipelineOverlap,
-	rebaselineUltragoalPipelineOverlap,
-	startUltragoalPipelineOverlap,
-} from "./ultragoal-pipeline";
-
-export { joinUltragoalPipelineOverlap, rebaselineUltragoalPipelineOverlap, startUltragoalPipelineOverlap };
-
 export function getUltragoalRunCompletionState(
 	plan: UltragoalPlan,
 	options: { retryFailed?: boolean } = {},
@@ -1767,6 +1324,72 @@ export function nonEmptyStringArray(value: unknown): string[] | null {
 	return strings.length === value.length && strings.length > 0 ? strings : null;
 }
 
+export interface UltragoalQualityGateDiagnostic {
+	path: string;
+	code: string;
+	message: string;
+}
+
+/**
+ * Collects every quality-gate defect in one pass instead of throwing on the first.
+ * Authoring a valid gate is otherwise an edit/retry loop at the most expensive phase
+ * of a run (#3474). The aggregate error message keeps each individual message verbatim
+ * so existing callers and assertions that match on a single message still work, and
+ * `diagnostics` carries the machine-readable stable `path` + `code` pairs.
+ */
+export class UltragoalQualityGateError extends Error {
+	readonly diagnostics: readonly UltragoalQualityGateDiagnostic[];
+	constructor(diagnostics: readonly UltragoalQualityGateDiagnostic[]) {
+		super(diagnostics.map(diagnostic => diagnostic.message).join("\n"));
+		this.name = "UltragoalQualityGateError";
+		this.diagnostics = diagnostics;
+	}
+}
+
+class QualityGateDiagnostics {
+	private readonly collected: UltragoalQualityGateDiagnostic[] = [];
+
+	/**
+	 * Runs one independent check. A thrown error is recorded and swallowed so later
+	 * checks still run; unrelated defects therefore surface together.
+	 */
+	check(path: string, code: string, run: () => void): boolean {
+		try {
+			run();
+			return true;
+		} catch (error) {
+			this.add(path, code, error instanceof Error ? error.message : String(error));
+			return false;
+		}
+	}
+
+	async checkAsync(path: string, code: string, run: () => Promise<void>): Promise<boolean> {
+		try {
+			await run();
+			return true;
+		} catch (error) {
+			this.add(path, code, error instanceof Error ? error.message : String(error));
+			return false;
+		}
+	}
+
+	add(path: string, code: string, message: string): void {
+		this.collected.push({ path, code, message });
+	}
+
+	get empty(): boolean {
+		return this.collected.length === 0;
+	}
+
+	get diagnostics(): readonly UltragoalQualityGateDiagnostic[] {
+		return this.collected;
+	}
+
+	throwIfAny(): void {
+		if (this.collected.length > 0) throw new UltragoalQualityGateError(this.collected);
+	}
+}
+
 function requireNonEmptyString(value: unknown, fieldName: string): void {
 	if (typeof value !== "string" || value.trim().length === 0) {
 		throw new Error(`qualityGate ${fieldName} must be a non-empty string`);
@@ -2561,10 +2184,56 @@ function requireValidationBatchTuple(
 	}
 }
 
+const DEFERRABLE_REVIEW_LANES = new Set(["architectReview", "executorQa"]);
+const DECLARABLE_DEFERRED_LANES: Record<string, string> = {
+	targetedVerification: "targetedVerification",
+	aiSlopCleaner: "aiSlopCleaner",
+	iteration: "iteration",
+};
+
+/**
+ * Declaration-vs-evidence check. Per-subgoal enforcement is relaxed: the agent
+ * chooses which verification lanes to run and declares them in `ranLanes`. The
+ * runtime does not dictate that set, but it fails closed when the declaration and
+ * the submitted evidence disagree in either direction, so a declaration can never
+ * be cheaper than the proof behind it.
+ */
+function validateDeferredLaneDeclaration(deferred: JsonObject, fieldName: string): void {
+	const declared = stringArray(deferred.ranLanes)?.filter(lane => lane.length > 0);
+	// `ranLanes` is optional for compatibility with gates that only carry the
+	// mandatory targeted-verification lane; an explicit empty array is a claim
+	// that nothing ran and is rejected, because targetedVerification is required.
+	if (declared === undefined) return;
+	const declaredSet = new Set(declared);
+	if (declaredSet.size !== declared.length) throw new Error(`${fieldName}.ranLanes must not repeat a lane`);
+	for (const lane of declaredSet) {
+		if (DEFERRABLE_REVIEW_LANES.has(lane)) {
+			throw new Error(
+				`${fieldName}.ranLanes cannot declare ${lane}: a deferred gate structurally cannot carry review-lane evidence, so it is deferred to the boundary`,
+			);
+		}
+		const evidenceKey = DECLARABLE_DEFERRED_LANES[lane];
+		if (!evidenceKey) throw new Error(`${fieldName}.ranLanes contains unknown lane ${lane}`);
+		const laneRecord = qualityGateObject(deferred[evidenceKey]);
+		if (!laneRecord || !nonEmptyString(laneRecord.evidence)) {
+			throw new Error(`${fieldName}.ranLanes declares ${lane} but ${fieldName}.${evidenceKey}.evidence is missing`);
+		}
+	}
+	if (!declaredSet.has("targetedVerification")) {
+		throw new Error(`${fieldName}.ranLanes must declare targetedVerification`);
+	}
+	for (const [lane, evidenceKey] of Object.entries(DECLARABLE_DEFERRED_LANES)) {
+		if (declaredSet.has(lane)) continue;
+		if (qualityGateObject(deferred[evidenceKey])) {
+			throw new Error(`${fieldName}.${evidenceKey} is present but ${lane} is not declared in ${fieldName}.ranLanes`);
+		}
+	}
+}
+
 function validateDeferredCompletionQualityGate(
 	gate: JsonObject,
 	goal: UltragoalGoal,
-	metadata: UltragoalValidationBatchMetadata,
+	metadata: UltragoalValidationBatchMetadata | undefined,
 	changeSet?: UltragoalChangeSet,
 ): void {
 	const allowedKeys = new Set(["deferredToBatch"]);
@@ -2575,9 +2244,11 @@ function validateDeferredCompletionQualityGate(
 	if (!deferred) throw new Error("deferred qualityGate requires deferredToBatch object");
 	if (deferred.kind !== "validation-batch-deferred")
 		throw new Error("deferredToBatch.kind must be validation-batch-deferred");
-	requireValidationBatchTuple(metadata, deferred, "deferredToBatch");
-	if (goal.id === metadata.finalGoalId)
-		throw new Error("final validation batch goal cannot use deferredToBatch quality gate");
+	if (metadata) {
+		requireValidationBatchTuple(metadata, deferred, "deferredToBatch");
+		if (goal.id === metadata.finalGoalId)
+			throw new Error("final validation batch goal cannot use deferredToBatch quality gate");
+	}
 	const deferredLanes = stringArray(deferred.deferredLanes)?.filter(Boolean).sort();
 	if (deferredLanes?.join(",") !== "architectReview,executorQa")
 		throw new Error("deferredToBatch.deferredLanes must be architectReview and executorQa");
@@ -2585,16 +2256,23 @@ function validateDeferredCompletionQualityGate(
 	if (!targeted || targeted.status !== PASSED_STATUS || !nonEmptyStringArray(targeted.commands))
 		throw new Error("deferredToBatch.targetedVerification must pass with non-empty commands");
 	requireNonEmptyString(targeted.evidence, "deferredToBatch.targetedVerification.evidence");
+	// The ai-slop-cleaner pass and a full verification rerun are no longer
+	// mandatory per subgoal; they are boundary duties. When either is supplied it
+	// must still be internally consistent and blocker-free.
 	const cleaner = qualityGateObject(deferred.aiSlopCleaner);
-	if (!cleaner || cleaner.status !== PASSED_STATUS) throw new Error("deferredToBatch.aiSlopCleaner must pass");
-	requireNonEmptyString(cleaner.evidence, "deferredToBatch.aiSlopCleaner.evidence");
+	if (cleaner) {
+		if (cleaner.status !== PASSED_STATUS) throw new Error("deferredToBatch.aiSlopCleaner must pass when present");
+		requireNonEmptyString(cleaner.evidence, "deferredToBatch.aiSlopCleaner.evidence");
+	}
 	const iteration = qualityGateObject(deferred.iteration);
-	if (!iteration || iteration.status !== PASSED_STATUS || iteration.fullRerun !== true)
-		throw new Error("deferredToBatch.iteration must pass with fullRerun true");
-	if (!nonEmptyStringArray(iteration.rerunCommands))
-		throw new Error("deferredToBatch.iteration.rerunCommands must be non-empty");
-	requireNonEmptyString(iteration.evidence, "deferredToBatch.iteration.evidence");
-	requireEmptyBlockers(iteration.blockers, "deferredToBatch.iteration.blockers");
+	if (iteration) {
+		if (iteration.status !== PASSED_STATUS) throw new Error("deferredToBatch.iteration must pass when present");
+		if (!nonEmptyStringArray(iteration.rerunCommands))
+			throw new Error("deferredToBatch.iteration.rerunCommands must be non-empty");
+		requireNonEmptyString(iteration.evidence, "deferredToBatch.iteration.evidence");
+		requireEmptyBlockers(iteration.blockers, "deferredToBatch.iteration.blockers");
+	}
+	validateDeferredLaneDeclaration(deferred, "deferredToBatch");
 	const declaredChangeSet = qualityGateObject(deferred.changeSet);
 	if (!declaredChangeSet) throw new Error("deferredToBatch.changeSet is required");
 	if (declaredChangeSet.memberGoalId !== goal.id)
@@ -2606,6 +2284,80 @@ function validateDeferredCompletionQualityGate(
 	if (declaredChangeSet.changeSetHash !== changeSetHashForPaths(paths))
 		throw new Error("deferredToBatch.changeSet.changeSetHash does not match declared paths");
 }
+const COHORT_LANE_KEYS = ["cleaner", "architect", "qa"] as const;
+
+/**
+ * Frozen-source-hash review cohort (#3473). One boundary generation runs at most one
+ * cleaner, one architect, and one QA lane, every lane verdict is bound to the same
+ * immutable source hash, and findings must be joined before any repair starts. Later
+ * generations are delta-only. Cohort state rides the existing `iteration` gate key so
+ * no new top-level quality-gate key is introduced.
+ */
+function validateReviewCohort(gate: JsonObject, iteration: JsonObject): void {
+	const cohort = qualityGateObject(iteration.reviewCohort);
+	if (!cohort) throw new Error("qualityGate iteration.reviewCohort is required at the review boundary");
+	const generation = cohort.reviewGeneration;
+	if (typeof generation !== "number" || !Number.isInteger(generation) || generation < 1)
+		throw new Error("iteration.reviewCohort.reviewGeneration must be an integer >= 1");
+	const sourceHash = nonEmptyString(cohort.sourceHash);
+	if (!sourceHash) throw new Error("iteration.reviewCohort.sourceHash is required");
+	if (cohort.joined !== true)
+		throw new Error("iteration.reviewCohort.joined must be true: all lane findings must join before checkpoint");
+	const lanes = qualityGateObject(cohort.lanes);
+	if (!lanes) throw new Error("iteration.reviewCohort.lanes is required");
+	const unsupportedLanes = Object.keys(lanes).filter(key => !(COHORT_LANE_KEYS as readonly string[]).includes(key));
+	if (unsupportedLanes.length > 0)
+		throw new Error(`iteration.reviewCohort.lanes contains unsupported lanes: ${unsupportedLanes.join(", ")}`);
+	for (const lane of COHORT_LANE_KEYS) {
+		if (Array.isArray(lanes[lane]))
+			throw new Error(`iteration.reviewCohort.lanes.${lane} must be one lane per generation, not a list`);
+		const record = qualityGateObject(lanes[lane]);
+		if (!record) throw new Error(`iteration.reviewCohort.lanes.${lane} is required`);
+		const laneHash = nonEmptyString(record.sourceHash);
+		if (!laneHash) throw new Error(`iteration.reviewCohort.lanes.${lane}.sourceHash is required`);
+		if (laneHash !== sourceHash)
+			throw new Error(
+				`iteration.reviewCohort.lanes.${lane}.sourceHash does not match the frozen cohort sourceHash: every lane must inspect the same immutable source`,
+			);
+		if (record.status !== "CLEAR" && record.status !== PASSED_STATUS)
+			throw new Error(`iteration.reviewCohort.lanes.${lane}.status must be CLEAR or passed`);
+		requireNonEmptyString(record.evidence, `iteration.reviewCohort.lanes.${lane}.evidence`);
+		requireEmptyBlockers(record.blockers, `iteration.reviewCohort.lanes.${lane}.blockers`);
+	}
+	// Generation 1 is the full cohort review; every later generation exists only
+	// because one consolidated blocker batch produced it, so its scope is the delta.
+	if (generation > 1) {
+		if (cohort.deltaOnly !== true)
+			throw new Error("iteration.reviewCohort.deltaOnly must be true for reviewGeneration > 1");
+		requireNonEmptyString(cohort.priorGenerationSourceHash, "iteration.reviewCohort.priorGenerationSourceHash");
+		if (nonEmptyString(cohort.priorGenerationSourceHash) === sourceHash)
+			throw new Error(
+				"iteration.reviewCohort.priorGenerationSourceHash must differ from sourceHash: a new generation requires a new frozen source",
+			);
+		const deltaPaths = stringArray(cohort.deltaPaths)?.filter(path => path.length > 0);
+		if (!deltaPaths || deltaPaths.length === 0)
+			throw new Error("iteration.reviewCohort.deltaPaths must be non-empty for reviewGeneration > 1");
+		const expansion = qualityGateObject(cohort.scopeExpansion);
+		if (expansion) {
+			requireNonEmptyString(expansion.severity, "iteration.reviewCohort.scopeExpansion.severity");
+			requireNonEmptyString(expansion.novelty, "iteration.reviewCohort.scopeExpansion.novelty");
+			requireNonEmptyString(expansion.justification, "iteration.reviewCohort.scopeExpansion.justification");
+		}
+	} else if (cohort.deltaOnly === true) {
+		throw new Error("iteration.reviewCohort.deltaOnly cannot be true for the first reviewGeneration");
+	}
+	// The terminal critic is one verdict on the final joined generation, never a
+	// per-lane or per-generation vote.
+	const critic = qualityGateObject(gate.criticReview);
+	if (critic) {
+		const criticHash = nonEmptyString(critic.sourceHash);
+		if (criticHash && criticHash !== sourceHash)
+			throw new Error(
+				"criticReview.sourceHash must match the final joined cohort sourceHash: the terminal critic runs once on the terminal generation",
+			);
+	}
+}
+
 async function validateCompletionQualityGate(
 	cwd: string,
 	gate: JsonObject,
@@ -2622,8 +2374,26 @@ async function validateCompletionQualityGate(
 			? chooseReceiptKind(options.plan, options.ledger, options.goal, "complete")
 			: undefined;
 	const isFinalAggregate = receiptKind === "final-aggregate";
+	// Every independent defect is collected instead of thrown, so one validate run
+	// reports the whole list rather than forcing an edit/retry loop per field (#3474).
+	const found = new QualityGateDiagnostics();
 	if (batchMode && options.goal && options.goal.id !== batchMode.finalGoalId) {
-		validateDeferredCompletionQualityGate(gate, options.goal, batchMode, options.changeSet);
+		found.check("deferredToBatch", "deferred_gate_invalid", () => {
+			validateDeferredCompletionQualityGate(gate, options.goal!, batchMode, options.changeSet);
+		});
+		found.throwIfAny();
+		return;
+	}
+	// Boundary-by-default: in aggregate mode every checkpoint before the run's
+	// final boundary may present the lightweight deferred gate, so heavyweight
+	// architect/QA review runs once per boundary instead of once per story. The
+	// boundary is derived from `chooseReceiptKind` rather than from synthesized
+	// durable batch metadata, which would restale/deadlock on appended goals.
+	if (!batchMode && options.goal && receiptKind === "per-goal" && qualityGateObject(gate.deferredToBatch)) {
+		found.check("deferredToBatch", "deferred_gate_invalid", () => {
+			validateDeferredCompletionQualityGate(gate, options.goal!, undefined, options.changeSet);
+		});
+		found.throwIfAny();
 		return;
 	}
 	if (batchMode && options.goal && options.goal.id === batchMode.finalGoalId) {
@@ -2636,13 +2406,22 @@ async function validateCompletionQualityGate(
 		]);
 		const unsupportedKeys = Object.keys(gate).filter(key => !allowedKeys.has(key));
 		if (unsupportedKeys.length > 0)
-			throw new Error(`qualityGate contains unsupported keys: ${unsupportedKeys.join(", ")}`);
+			found.add(
+				"qualityGate",
+				"unsupported_keys",
+				`qualityGate contains unsupported keys: ${unsupportedKeys.join(", ")}`,
+			);
 		if (!qualityGateObject(gate.validationBatchClose))
-			throw new Error("final validation batch goal requires validationBatchClose");
+			found.add(
+				"validationBatchClose",
+				"missing_validation_batch_close",
+				"final validation batch goal requires validationBatchClose",
+			);
 	}
-	const codeReview = qualityGateObject(gate.codeReview);
-	if (codeReview) {
-		throw new Error(
+	if (qualityGateObject(gate.codeReview)) {
+		found.add(
+			"codeReview",
+			"legacy_code_review_gate",
 			"checkpoint --status complete requires architect review approval through architectReview, executorQa, and iteration quality-gate evidence; legacy codeReview-only gates are not sufficient",
 		);
 	}
@@ -2653,13 +2432,23 @@ async function validateCompletionQualityGate(
 	);
 	const unsupportedKeys = Object.keys(gate).filter(key => !allowedKeys.has(key));
 	if (unsupportedKeys.length > 0) {
-		throw new Error(`qualityGate contains unsupported keys: ${unsupportedKeys.join(", ")}`);
+		found.add(
+			"qualityGate",
+			"unsupported_keys",
+			`qualityGate contains unsupported keys: ${unsupportedKeys.join(", ")}`,
+		);
 	}
 	const architectReview = qualityGateObject(gate.architectReview);
 	const executorQa = qualityGateObject(gate.executorQa);
 	const iteration = qualityGateObject(gate.iteration);
 	if (!architectReview || !executorQa || !iteration) {
-		throw new Error("qualityGate requires architectReview, executorQa, and iteration objects");
+		found.add(
+			"qualityGate",
+			"missing_required_sections",
+			"qualityGate requires architectReview, executorQa, and iteration objects",
+		);
+		found.throwIfAny();
+		return;
 	}
 	if (isFinalAggregate) {
 		if (
@@ -2667,18 +2456,28 @@ async function validateCompletionQualityGate(
 			terminalCriticCeilingReached(options.ledger) &&
 			!terminalCriticGateOverridden(options.ledger)
 		) {
-			throw new Error(
+			found.add(
+				"criticReview",
+				"terminal_critic_ceiling",
 				"checkpoint --status complete blocked: terminal-critic ceiling reached; requires human/leader gjc ultragoal record-critic-gate-override before completion",
 			);
 		}
 		const criticReview = qualityGateObject(gate.criticReview);
 		if (criticReview?.verdict !== "OKAY") {
-			throw new Error(
+			found.add(
+				"criticReview.verdict",
+				"critic_verdict_not_okay",
 				"checkpoint --status complete (final aggregate) requires criticReview with verdict OKAY, non-empty evidence, and empty blockers",
 			);
 		}
-		requireNonEmptyString(criticReview.evidence, "criticReview.evidence");
-		requireEmptyBlockers(criticReview.blockers, "criticReview.blockers");
+		if (criticReview) {
+			found.check("criticReview.evidence", "missing_evidence", () =>
+				requireNonEmptyString(criticReview.evidence, "criticReview.evidence"),
+			);
+			found.check("criticReview.blockers", "non_empty_blockers", () =>
+				requireEmptyBlockers(criticReview.blockers, "criticReview.blockers"),
+			);
+		}
 	}
 	if (
 		architectReview.architectureStatus !== CLEAN_ARCHITECT_STATUS ||
@@ -2686,39 +2485,75 @@ async function validateCompletionQualityGate(
 		architectReview.codeStatus !== CLEAN_ARCHITECT_STATUS ||
 		architectReview.recommendation !== APPROVE_RECOMMENDATION
 	) {
-		throw new Error(
+		found.add(
+			"architectReview",
+			"architect_not_clear",
 			"checkpoint --status complete requires architect review approval: architectReview architecture/product/code must be CLEAR and recommendation must be APPROVE",
 		);
 	}
 	if (!nonEmptyStringArray(architectReview.commands)) {
-		throw new Error("qualityGate architectReview.commands must be a non-empty string array");
+		found.add(
+			"architectReview.commands",
+			"missing_command_array",
+			"qualityGate architectReview.commands must be a non-empty string array",
+		);
 	}
-	requireNonEmptyString(architectReview.evidence, "architectReview.evidence");
-	requireEmptyBlockers(architectReview.blockers, "architectReview.blockers");
+	found.check("architectReview.evidence", "missing_evidence", () =>
+		requireNonEmptyString(architectReview.evidence, "architectReview.evidence"),
+	);
+	found.check("architectReview.blockers", "non_empty_blockers", () =>
+		requireEmptyBlockers(architectReview.blockers, "architectReview.blockers"),
+	);
 	if (
 		executorQa.status !== PASSED_STATUS ||
 		executorQa.e2eStatus !== PASSED_STATUS ||
 		executorQa.redTeamStatus !== PASSED_STATUS
 	) {
-		throw new Error("qualityGate executorQa status, e2eStatus, and redTeamStatus must be passed");
+		found.add(
+			"executorQa",
+			"executor_qa_not_passed",
+			"qualityGate executorQa status, e2eStatus, and redTeamStatus must be passed",
+		);
 	}
 	if (!nonEmptyStringArray(executorQa.e2eCommands) || !nonEmptyStringArray(executorQa.redTeamCommands)) {
-		throw new Error("qualityGate executorQa e2eCommands and redTeamCommands must be non-empty string arrays");
+		found.add(
+			"executorQa.e2eCommands",
+			"missing_command_array",
+			"qualityGate executorQa e2eCommands and redTeamCommands must be non-empty string arrays",
+		);
 	}
-	requireNonEmptyString(executorQa.evidence, "executorQa.evidence");
-	requireEmptyBlockers(executorQa.blockers, "executorQa.blockers");
-	await validateExecutorQaRedTeamEvidence(cwd, executorQa, { changeSet: options.changeSet });
+	found.check("executorQa.evidence", "missing_evidence", () =>
+		requireNonEmptyString(executorQa.evidence, "executorQa.evidence"),
+	);
+	found.check("executorQa.blockers", "non_empty_blockers", () =>
+		requireEmptyBlockers(executorQa.blockers, "executorQa.blockers"),
+	);
+	await found.checkAsync("executorQa", "executor_qa_evidence_invalid", () =>
+		validateExecutorQaRedTeamEvidence(cwd, executorQa, { changeSet: options.changeSet }),
+	);
 	if (iteration.status !== PASSED_STATUS || iteration.fullRerun !== true) {
-		throw new Error("qualityGate iteration must be passed with fullRerun true");
+		found.add("iteration", "iteration_not_passed", "qualityGate iteration must be passed with fullRerun true");
 	}
 	if (!nonEmptyStringArray(iteration.rerunCommands)) {
-		throw new Error("qualityGate iteration.rerunCommands must be a non-empty string array");
+		found.add(
+			"iteration.rerunCommands",
+			"missing_command_array",
+			"qualityGate iteration.rerunCommands must be a non-empty string array",
+		);
 	}
-	requireNonEmptyString(iteration.evidence, "iteration.evidence");
-	requireEmptyBlockers(iteration.blockers, "iteration.blockers");
+	found.check("iteration.evidence", "missing_evidence", () =>
+		requireNonEmptyString(iteration.evidence, "iteration.evidence"),
+	);
+	found.check("iteration.blockers", "non_empty_blockers", () =>
+		requireEmptyBlockers(iteration.blockers, "iteration.blockers"),
+	);
+	found.check("iteration.reviewCohort", "review_cohort_invalid", () => validateReviewCohort(gate, iteration));
 	if (batchMode && options.goal && options.plan && options.ledger) {
-		validateBatchCloseQualityGate(gate, options.plan, batchMode, options.ledger, options.changeSet);
+		found.check("validationBatchClose", "batch_close_invalid", () =>
+			validateBatchCloseQualityGate(gate, options.plan!, batchMode, options.ledger!, options.changeSet),
+		);
 	}
+	found.throwIfAny();
 }
 
 function validateBatchCloseQualityGate(
@@ -2940,6 +2775,56 @@ function hydrateReviewedBatchReplacementClose(input: {
 		},
 	};
 }
+/**
+ * Read-only quality-gate validation (#3474). Applies exactly the same rules as
+ * `checkpoint --status complete` — including deferred-vs-boundary gate selection and
+ * artifact existence checks — but never touches `goals.json`, `ledger.jsonl`, or goal
+ * state, and reports every diagnostic in one run instead of the first failure.
+ */
+export async function validateUltragoalQualityGateReadOnly(input: {
+	cwd: string;
+	qualityGateJson: string;
+	goalId?: string;
+	sessionId?: string | null;
+}): Promise<{ valid: boolean; errors: readonly UltragoalQualityGateDiagnostic[] }> {
+	const sessionId = input.sessionId?.trim() || currentUltragoalSessionId(input.cwd);
+	const plan = await readUltragoalPlan(input.cwd, sessionId);
+	const goal = input.goalId
+		? plan?.goals.find(item => item.id === input.goalId)
+		: plan?.goals.find(item => SCHEDULABLE_STATUSES.has(item.status));
+	if (input.goalId && !goal) {
+		return {
+			valid: false,
+			errors: [{ path: "goalId", code: "unknown_goal", message: `Unknown ultragoal goal ${input.goalId}` }],
+		};
+	}
+	const gate = qualityGateObject(await readStructuredValue(input.cwd, input.qualityGateJson));
+	if (!gate) {
+		return {
+			valid: false,
+			errors: [{ path: "qualityGate", code: "not_an_object", message: "qualityGate must be a JSON object" }],
+		};
+	}
+	const ledger = plan ? await readUltragoalLedger(input.cwd, sessionId) : undefined;
+	const changeSet = await computeCheckpointChangeSet(input.cwd);
+	try {
+		await validateCompletionQualityGate(input.cwd, gate, { changeSet, plan: plan ?? undefined, goal, ledger });
+		return { valid: true, errors: [] };
+	} catch (error) {
+		if (error instanceof UltragoalQualityGateError) return { valid: false, errors: error.diagnostics };
+		return {
+			valid: false,
+			errors: [
+				{
+					path: "qualityGate",
+					code: "validation_failed",
+					message: error instanceof Error ? error.message : String(error),
+				},
+			],
+		};
+	}
+}
+
 async function readRequiredCompletionQualityGate(
 	cwd: string,
 	value: string | undefined,
@@ -2979,46 +2864,6 @@ async function readRequiredCompletionQualityGate(
 	return hydratedGate;
 }
 
-function validatePipelineCheckpointSafety(
-	plan: UltragoalPlan,
-	goal: UltragoalGoal,
-	changeSet?: UltragoalChangeSet,
-): void {
-	const metadata = goal.pipelineMetadata;
-	if (!metadata) return;
-	validateValidationBatchPipelineExclusion(goal);
-	requireFreshPipelineMetadata(goal);
-	if (metadata.overlap === "open") {
-		throw new Error(
-			`Cannot complete ${goal.id} while pipeline overlap ${metadata.overlapId ?? ""} is open; join or quarantine first.`,
-		);
-	}
-	if (metadata.overlap === "quarantine_required") {
-		throw new Error(
-			`Cannot complete ${goal.id} while pipeline overlap ${metadata.overlapId ?? ""} requires rebaseline.`,
-		);
-	}
-	if (metadata.goalId === metadata.priorGoalId && metadata.overlap !== "none" && metadata.overlap !== "joined_clean") {
-		throw new Error(
-			`Cannot complete ${goal.id} without a clean join for pipeline overlap ${metadata.overlapId ?? ""}.`,
-		);
-	}
-	const peer = pipelinePeer(plan, metadata);
-	if (changeSet && metadata.overlap !== "none") {
-		const peerTargets = peer?.pipelineMetadata?.targets;
-		for (const row of changeSet.paths) {
-			const ownedByGoal = pipelineTargetsCoverPath(metadata.targets, row.path);
-			const ownedByPeer = peerTargets ? pipelineTargetsCoverPath(peerTargets, row.path) : false;
-			if (ownedByGoal && ownedByPeer)
-				throw new Error(`Cannot complete ${goal.id} with shared pipeline change-set path ${row.path}.`);
-			if (!ownedByGoal && !ownedByPeer)
-				throw new Error(`Cannot complete ${goal.id} with unattributable pipeline change-set path ${row.path}.`);
-			if (!ownedByGoal && ownedByPeer)
-				throw new Error(`Cannot complete ${goal.id} with next-goal pipeline change-set path ${row.path}.`);
-		}
-	}
-}
-
 function validateCompleteCheckpointTargetGoal(goal: UltragoalGoal): void {
 	if (COMPLETE_CHECKPOINT_ALLOWED_PRE_STATUSES.has(goal.status)) return;
 	if (goal.status === "pending") {
@@ -3091,8 +2936,13 @@ export async function checkpointUltragoalGoal(input: {
 	// receipt, the replay is a genuine re-verification: it must run the full
 	// quality gate and mint a fresh receipt, otherwise a completed goal with a
 	// context-staled receipt can never be repaired (different evidence is
-	// rejected on complete goals by design). A mutated goal row keeps the
-	// fail-loud tamper handling in the idempotent branch below.
+	// rejected on complete goals by design). A final-aggregate receipt whose
+	// recorded checkpoint gate lacks a clean criticReview OKAY is likewise
+	// repair-eligible: it is not "stale", but the completion guard rejects it
+	// forever (active_missing_critic_verdict), so a no-op replay would leave
+	// the run permanently unable to complete even after the terminal critic
+	// records OKAY. A mutated goal row keeps the fail-loud tamper handling in
+	// the idempotent branch below.
 	const staleCompleteReceiptReplay =
 		input.status === "complete" &&
 		goal.status === "complete" &&
@@ -3100,13 +2950,14 @@ export async function checkpointUltragoalGoal(input: {
 		Boolean(matchingIdempotentEvent) &&
 		(!goal.completionVerification ||
 			(goal.completionVerification.verifiedAt === goal.updatedAt &&
-				validateReceiptFreshBase({
+				(validateReceiptFreshBase({
 					plan,
 					ledger: ledgerBefore,
 					goal,
 					receipt: goal.completionVerification,
 					receiptKind: goal.completionVerification.receiptKind,
-				}) !== null));
+				}) !== null ||
+					finalAggregateReceiptMissingCriticOkay(ledgerBefore, goal.completionVerification))));
 	if (
 		goal.status === input.status &&
 		goal.evidence === evidence &&
@@ -3155,9 +3006,8 @@ export async function checkpointUltragoalGoal(input: {
 		return plan;
 	}
 	const changeSet = input.status === "complete" ? await computeCheckpointChangeSet(input.cwd) : undefined;
-	if (input.status === "complete") {
-		validatePipelineCheckpointSafety(plan, goal, changeSet);
-		if (!staleCompleteReceiptReplay) validateCompleteCheckpointTargetGoal(goal);
+	if (input.status === "complete" && !staleCompleteReceiptReplay) {
+		validateCompleteCheckpointTargetGoal(goal);
 	}
 	const qualityGateJson =
 		input.status === "complete"
@@ -3414,7 +3264,6 @@ async function addUltragoalSubgoalToPlan(input: {
 		createdAt: now,
 		updatedAt: now,
 		steering: { kind, evidence, rationale },
-		pipelineMetadata: legacyPipelineMetadata(nextId),
 	});
 	input.plan.updatedAt = now;
 	await writePlan(input.cwd, input.plan);
@@ -3465,7 +3314,6 @@ async function splitUltragoalSubgoal(input: {
 	target.evidence = evidence;
 	target.updatedAt = now;
 	target.steering = { kind, evidence, rationale, replacementGoalIds };
-	invalidatePipelineMetadata(target, "split_subgoal_superseded", now);
 	clearValidationBatchForBatch(input.plan, target.validationBatch);
 	const replacementGoals = replacements.map(
 		(replacement, index): UltragoalGoal => ({
@@ -3476,7 +3324,6 @@ async function splitUltragoalSubgoal(input: {
 			createdAt: now,
 			updatedAt: now,
 			steering: { kind: "split_replacement", sourceGoalId: target.id, evidence, rationale },
-			pipelineMetadata: legacyPipelineMetadata(replacementGoalIds[index]!),
 		}),
 	);
 	const targetIndex = input.plan.goals.findIndex(goal => goal.id === target.id);
@@ -3575,7 +3422,6 @@ async function revisePendingUltragoalWording(input: {
 	const now = new Date().toISOString();
 	goal.updatedAt = now;
 	goal.steering = { kind, evidence, rationale, changedFields };
-	invalidatePipelineMetadata(goal, "revised_pending_wording", now);
 	clearValidationBatchForBatch(input.plan, goal.validationBatch);
 	input.plan.updatedAt = now;
 	await writePlan(input.cwd, input.plan);
@@ -4138,17 +3984,7 @@ const FLAGS_WITH_VALUES = new Set([
 	"--replacements-json",
 	"--order-json",
 	"--classification",
-	"--goal-metadata-json",
 	"--validation-batch-json",
-	"--prior-goal-id",
-	"--next-goal-id",
-	"--review-handles-json",
-	"--qa-handles-json",
-	"--implementation-handle-json",
-	"--overlap-id",
-	"--review-result-json",
-	"--qa-result-json",
-	"--target-state-json",
 ]);
 
 function isHelpArg(arg: string): boolean {
@@ -4295,10 +4131,8 @@ function renderUltragoalHelp(args: readonly string[]): string | null {
 		"  classify-blocker",
 		"  record-critic-verdict",
 		"  record-critic-gate-override",
+		"  quality-gate validate",
 
-		"  start-pipeline-overlap",
-		"  join-pipeline-overlap",
-		"  rebaseline-pipeline-overlap",
 		"",
 		"Run `gjc ultragoal checkpoint --help`, `gjc ultragoal review --help`, `gjc ultragoal classify-blocker --help`, `gjc ultragoal record-critic-verdict --help`, or `gjc ultragoal record-critic-gate-override --help` for command-specific requirements.",
 		"",
@@ -4629,18 +4463,11 @@ async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<Ul
 				return { status: 0, stdout: renderStatus(await getUltragoalStatus(cwd, sessionId), json) };
 			case "create":
 			case "create-goals": {
-				if (
-					flagValue(args, "--goal-metadata-json") !== undefined &&
-					flagValue(args, "--validation-batch-json") !== undefined
-				) {
-					throw new Error("--validation-batch-json and --goal-metadata-json are mutually exclusive");
-				}
 				const mode = flagValue(args, "--gjc-goal-mode") === "per-story" ? "per-story" : "aggregate";
 				const plan = await createUltragoalPlan({
 					cwd,
 					brief: await readBrief(cwd, args),
 					gjcGoalMode: mode,
-					goalMetadataJson: flagValue(args, "--goal-metadata-json"),
 					validationBatchJson: flagValue(args, "--validation-batch-json"),
 				});
 				return {
@@ -4682,6 +4509,38 @@ async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<Ul
 					stdout: renderCheckpointContinuation(result, status, json, cwd),
 				};
 			}
+			case "quality-gate": {
+				const positional = args.filter(arg => !arg.startsWith("--"));
+				const subcommand = positional[1];
+				if (subcommand !== "validate") {
+					return {
+						status: 1,
+						stderr: `Unknown gjc ultragoal quality-gate subcommand: ${subcommand ?? "(missing)"}; only validate is supported\n`,
+					};
+				}
+				const qualityGateJson = flagValue(args, "--quality-gate-json");
+				if (!qualityGateJson?.trim()) {
+					return { status: 1, stderr: "quality-gate validate requires --quality-gate-json\n" };
+				}
+				const result = await validateUltragoalQualityGateReadOnly({
+					cwd,
+					qualityGateJson,
+					goalId: flagValue(args, "--goal-id"),
+				});
+				if (json) {
+					return {
+						status: result.valid ? 0 : 1,
+						stdout: `${JSON.stringify({ valid: result.valid, errors: result.errors }, null, 2)}\n`,
+					};
+				}
+				if (result.valid) return { status: 0, stdout: "quality gate is valid.\n" };
+				return {
+					status: 1,
+					stderr: `${result.errors.length} quality-gate error(s):\n${result.errors
+						.map(diagnostic => `  ${diagnostic.path} [${diagnostic.code}]: ${diagnostic.message}`)
+						.join("\n")}\n`,
+				};
+			}
 			case "review": {
 				const result = await runUltragoalReview(cwd, args);
 				return {
@@ -4781,65 +4640,6 @@ async function dispatchUltragoalCommand(args: string[], cwd: string): Promise<Ul
 						: `Recorded terminal critic gate override event-id=${String(event.eventId)}.\n`,
 				};
 			}
-			case "start-pipeline-overlap": {
-				const receipt = await startUltragoalPipelineOverlap({
-					cwd,
-					priorGoalId: flagValue(args, "--prior-goal-id") ?? "",
-					nextGoalId: flagValue(args, "--next-goal-id") ?? "",
-					reviewHandles: await readRequiredJsonObjectOrArray(
-						cwd,
-						flagValue(args, "--review-handles-json") ?? "",
-						"review handles",
-					),
-					qaHandles: await readRequiredJsonObjectOrArray(
-						cwd,
-						flagValue(args, "--qa-handles-json") ?? "",
-						"QA handles",
-					),
-					implementationHandle: await readRequiredJsonObject(
-						cwd,
-						flagValue(args, "--implementation-handle-json") ?? "",
-						"implementation handle",
-					),
-				});
-				return {
-					status: 0,
-					stdout: json ? renderCliWriteReceipt(receipt) : `Started pipeline overlap ${receipt.overlap_id}.\n`,
-				};
-			}
-			case "join-pipeline-overlap": {
-				const receipt = await joinUltragoalPipelineOverlap({
-					cwd,
-					overlapId: flagValue(args, "--overlap-id") ?? "",
-					reviewResult: await readRequiredJsonObject(
-						cwd,
-						flagValue(args, "--review-result-json") ?? "",
-						"review result",
-					),
-					qaResult: await readRequiredJsonObject(cwd, flagValue(args, "--qa-result-json") ?? "", "QA result"),
-				});
-				return {
-					status: 0,
-					stdout: json ? renderCliWriteReceipt(receipt) : `Joined pipeline overlap ${receipt.overlap_id}.\n`,
-				};
-			}
-			case "rebaseline-pipeline-overlap": {
-				const receipt = await rebaselineUltragoalPipelineOverlap({
-					cwd,
-					overlapId: flagValue(args, "--overlap-id") ?? "",
-					goalId: flagValue(args, "--goal-id") ?? "",
-					evidence: flagValue(args, "--evidence") ?? "",
-					targetState: await readRequiredJsonObject(
-						cwd,
-						flagValue(args, "--target-state-json") ?? "",
-						"target state",
-					),
-				});
-				return {
-					status: 0,
-					stdout: json ? renderCliWriteReceipt(receipt) : `Rebaselined pipeline overlap ${receipt.overlap_id}.\n`,
-				};
-			}
 			default:
 				return { status: 1, stderr: `Unknown gjc ultragoal command: ${command}\n` };
 		}
@@ -4860,9 +4660,6 @@ const RECONCILE_COMMANDS = new Set([
 	"classify-blocker",
 	"record-critic-verdict",
 	"record-critic-gate-override",
-	"start-pipeline-overlap",
-	"join-pipeline-overlap",
-	"rebaseline-pipeline-overlap",
 ]);
 
 /**
@@ -4899,7 +4696,6 @@ async function reconcileUltragoalState(cwd: string): Promise<void> {
 		if (summary.nudgeRemaining !== undefined) payload.nudge_remaining = summary.nudgeRemaining;
 		if (summary.nudgeGoalId !== undefined) payload.nudge_goal_id = summary.nudgeGoalId;
 		if (summary.nudgeTargetKind !== undefined) payload.nudge_target_kind = summary.nudgeTargetKind;
-		if (summary.pipelineOverlap) payload.pipeline_overlap = summary.pipelineOverlap;
 		const ledgerText = await Bun.file(summary.paths.ledgerPath)
 			.text()
 			.catch(() => "");