oh-my-opencode 5.0.0-beta.33 → 5.0.0-beta.35

package/packages/omo-codex/plugin/components/ulw-loop/src/checkpoint-template.ts

@@ -73,6 +73,7 @@ function gateTemplate(surface: UlwLoopToolkitSurface, base: string): Record<stri
 			reportPath: artifactPath(base, "gate-review.md"),
 			evidence: "<replace:gate review evidence>",
 			blockers: [],
+			notes: [],
 		},
 		iteration: {
 			fullRerun: true,
@@ -115,13 +116,19 @@ export async function checkpointTemplate(
 		throw new UlwLoopError(`Unknown ulw-loop id: ${goalId}.`, "ULW_LOOP_GOAL_NOT_FOUND", { details: { goalId } });
 	const hasAttempt = plan.evidenceLayoutVersion === 2 && active !== undefined;
 	const attemptDir = hasAttempt ? ulwLoopAttemptEvidenceDir(active.id, active.attempt, scope) : ".omo/evidence";
+	const guidance = [
+		"codex-goal-json requires goal.objective to equal the plan's codexObjective verbatim; do not paraphrase it.",
+		"Fill every <replace:...> value with plausible non-empty evidence and use real, non-empty artifact files.",
+		'Passing codex-goal-json example: {"goal":{"objective":"<plan codexObjective verbatim>","status":"complete"}}.',
+		'Passing quality-gate-json example requires gateReview {"by":"category:deep","recommendation":"APPROVE","evidence":"review passed","reportPath":"<attemptDir>/gate-review.md","blockers":[],"notes":[]}, manualQa.artifactRefs objects, iteration, and criteriaCoverage.',
+		...(hasAttempt ? [] : ["This plan is evidence-layout v1; artifacts go under .omo/evidence/."]),
+	].join(" ");
 	return {
 		qualityGateTemplate: gateTemplate(resolveToolkitSurface(), attemptDir),
 		codexGoalTemplate: {
 			goal: { objective: plan.codexObjective ?? "<replace:codex objective>", status: "complete" },
 		},
-		...(hasAttempt
-			? { attemptDir }
-			: { guidance: "This plan is evidence-layout v1; artifacts go under .omo/evidence/." }),
+		guidance,
+		...(hasAttempt ? { attemptDir } : {}),
 	};
 }

package/packages/omo-codex/plugin/components/ulw-loop/src/checkpoint.ts

@@ -3,18 +3,11 @@ import { existsSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import {
-	canReconcileActiveFinalTaskScopedAggregateSnapshot,
-	canReconcileCompletedTaskScopedAggregateSnapshot,
-	codexSnapshotMismatchError,
-} from "./checkpoint-reconciliation.js";
-import { readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot } from "./codex-goal-snapshot.js";
+	combineCheckpointValidationErrors,
+	validateCheckpointCodexGoal,
+} from "./checkpoint-codex-validation.js";
 import { requireAllCriteriaPass, requireAllPlanCriteriaPass, requireEssentialCriteriaPass } from "./evidence.js";
-import {
-	codexGoalMode,
-	compatibleCodexObjectives,
-	expectedCodexObjective,
-	isFinalRunCompletionCandidate,
-} from "./goal-status.js";
+import { codexGoalMode, isFinalRunCompletionCandidate } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
 import { ulwLoopAttemptEvidenceDir } from "./paths.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
@@ -54,9 +47,6 @@ const QUALITY_GATE_FS = { existsSync, statSync } as const;
 function ulwLoopFail(message: string, code: string): never {
 	throw new UlwLoopError(message, code);
 }
-function normalizeObjective(value: string): string {
-	return value.replace(/\s+/g, " ").trim();
-}
 function nonEmptyEvidence(value: string): string {
 	const trimmed = value.trim();
 	return trimmed || ulwLoopFail("Evidence must be a non-empty string.", "ulw_loop_evidence_required");
@@ -178,62 +168,41 @@ export async function checkpointUlwLoop(
 				requireAllValidationBatchesClosed(plan, goal.id);
 			} else if (aggregate) requireEssentialCriteriaPass(goal);
 			else requireAllCriteriaPass(goal);
-			const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
-			const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
-				expectedObjective: expectedCodexObjective(plan, goal),
-				...(aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {}),
-				allowedStatuses: aggregate ? (final ? ["complete"] : ["active"]) : ["complete"],
-				requireSnapshot: true,
-				requireComplete: !aggregate || final,
-			});
-			codexGoal = reconciliation.snapshot.raw;
-			if (!reconciliation.ok) {
-				const objective = snapshot?.objective;
-				const mismatchedTaskObjective =
-					snapshot?.available === true &&
-					objective !== undefined &&
-					normalizeObjective(objective) !== normalizeObjective(expectedCodexObjective(plan, goal));
-				const completedTaskScoped =
-					mismatchedTaskObjective &&
-					snapshot.status === "complete" &&
-					(await canReconcileCompletedTaskScopedAggregateSnapshot(
-						repoRoot,
-						plan,
-						goal,
-						objective,
-						evidence,
-						scope,
-					));
-				const activeFinalTaskScoped =
-					mismatchedTaskObjective &&
-					snapshot.status === "active" &&
-					(await canReconcileActiveFinalTaskScopedAggregateSnapshot(
-						repoRoot,
-						plan,
-						goal,
-						objective,
-						evidence,
-						scope,
-					));
-				const taskScoped = completedTaskScoped || activeFinalTaskScoped;
-				if (!taskScoped)
-					throw codexSnapshotMismatchError({ reconciliation, snapshot, expectedObjective: expectedCodexObjective(plan, goal), taskScopedHint: { goal, aggregate, final } });
+			let codexValidationError: UlwLoopError | undefined;
+			try {
+				codexGoal = await validateCheckpointCodexGoal({
+					repoRoot,
+					plan,
+					goal,
+					raw: args.codexGoalJson,
+					evidence,
+					...(scope === undefined ? {} : { scope }),
+				});
+			} catch (error) {
+				if (!(error instanceof UlwLoopError)) throw error;
+				codexValidationError = error;
 			}
 			if (closesBatch) requireBatchFinalReady(plan, goal);
 			if (closesBatch && args.qualityGateJson === undefined)
 				throw new UlwLoopError("Validation batch final checkpoint requires --quality-gate-json.", "ULW_LOOP_VALIDATION_BATCH_GATE_REQUIRED");
 			if (final) aggregateCompletion = makeAggregateCompletion(now, evidence, codexGoal);
 			if (final || aggregateCompletion !== undefined || closesBatch) {
-				qualityGate = validateQualityGate(await readJsonInput(args.qualityGateJson, repoRoot), {
-					repoRoot,
-					fs: QUALITY_GATE_FS,
-					reviewerSurface: resolveToolkitSurface(),
-					...(plan.evidenceLayoutVersion === 2
-						? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) }
-						: {}),
-				});
-				requireBatchGate(plan, goal, qualityGate);
+				try {
+					qualityGate = validateQualityGate(await readJsonInput(args.qualityGateJson, repoRoot), {
+						repoRoot,
+						fs: QUALITY_GATE_FS,
+						reviewerSurface: resolveToolkitSurface(),
+						...(plan.evidenceLayoutVersion === 2
+							? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) }
+							: {}),
+					});
+					requireBatchGate(plan, goal, qualityGate);
+				} catch (error) {
+					if (!(error instanceof UlwLoopError) || codexValidationError === undefined) throw error;
+					throw combineCheckpointValidationErrors(codexValidationError, error);
+				}
 			}
+			if (codexValidationError !== undefined) throw codexValidationError;
 			goal.status = "complete";
 			goal.completedAt = now;
 			goal.evidence = evidence;

package/packages/omo-codex/plugin/components/ulw-loop/src/quality-gate-aggregate.ts

@@ -1,57 +1,11 @@
-import { resolve } from "node:path";
 import type { ValidateQualityGateOptions } from "./quality-gate.js";
-import { isRecord } from "./quality-gate-fields.js";
-import { UlwLoopError } from "./types.js";
-
-type Defect = { readonly field: string; readonly message: string };
-const PLACEHOLDER = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
-
-function add(defects: Defect[], field: string, message: string): void {
-	defects.push({ field, message });
-}
-function text(value: unknown, field: string, defects: Defect[]): void {
-	if (typeof value !== "string" || value.trim() === "")
-		add(defects, field, `Final quality gate requires non-empty ${field}.`);
-	else if (PLACEHOLDER.test(value.trim())) add(defects, field, `Final quality gate rejects placeholder ${field}.`);
-}
-function section(value: unknown, field: string, defects: Defect[]): Record<string, unknown> {
-	if (!isRecord(value)) {
-		add(defects, field, `Final quality gate is missing ${field} evidence.`);
-		return {};
-	}
-	return value;
-}
+import { validateQualityGate } from "./quality-gate.js";
 
+/**
+ * Compatibility entry point for callers that used the former pre-pass API.
+ * Validation is performed by the real parser, which collects defects across
+ * every nested field before throwing one aggregate error.
+ */
 export function aggregateQualityGateDefects(input: unknown, opts: ValidateQualityGateOptions | undefined): void {
-	if (!isRecord(input)) return;
-	const defects: Defect[] = [];
-	const gate = input;
-	const manual = section(gate["manualQa"], "manualQa", defects);
-	const review = section(gate["gateReview"], "gateReview", defects);
-	text(manual["evidence"], "manualQa.evidence", defects);
-	text(review["evidence"], "gateReview.evidence", defects);
-	if (review["recommendation"] !== "APPROVE")
-		add(defects, "gateReview.recommendation", "gateReview.recommendation must be APPROVE.");
-	const artifacts = Array.isArray(manual["artifactRefs"]) ? manual["artifactRefs"] : [];
-	for (const [index, item] of artifacts.entries()) {
-		if (!isRecord(item)) continue;
-		const path = item["path"];
-		if (typeof path !== "string" || path.trim() === "") continue;
-		if (opts?.repoRoot !== undefined && opts.fs !== undefined && !opts.fs.existsSync(resolve(opts.repoRoot, path)))
-			add(
-				defects,
-				`manualQa.artifactRefs[${index}].path`,
-				`manualQa.artifactRefs[${index}].path must point to an existing artifact.`,
-			);
-	}
-	if (defects.length === 0) return;
-	const truncated = defects.length > 25;
-	const fields = defects.slice(0, 25).map(({ field, message }) => ({ field, message }));
-	const message = [
-		`Final quality gate has ${fields.length}${truncated ? "+" : ""} validation defects:`,
-		...fields.map((item) => `- ${item.field}: ${item.message}`),
-	].join("\n");
-	throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", {
-		details: { field: fields[0]?.field, fields, ...(truncated ? { truncated: true } : {}) },
-	});
+	validateQualityGate(input, opts);
 }

package/packages/omo-codex/plugin/components/ulw-loop/src/quality-gate-artifacts.ts

@@ -1,7 +1,14 @@
 import { resolve } from "node:path";
 import { isWithinAttemptDir } from "./paths.js";
 import type { ValidateQualityGateOptions } from "./quality-gate.js";
-import { invalid, section, stringArray, textField } from "./quality-gate-fields.js";
+import {
+	invalid,
+	isPoisoned,
+	markPoisonedArtifactKind,
+	section,
+	stringArray,
+	textField,
+} from "./quality-gate-fields.js";
 import type { UlwLoopManualQaArtifactKind, UlwLoopManualQaArtifactRef, UlwLoopManualQaSurface } from "./types.js";
 
 export function surfaceField(value: unknown, field: string): UlwLoopManualQaSurface {
@@ -15,8 +22,8 @@ export function surfaceField(value: unknown, field: string): UlwLoopManualQaSurf
 	)
 		return value;
 	invalid(`${field} must be a supported manual QA surface.`, field);
+	return "cli";
 }
-
 export function kindField(value: unknown, field: string): UlwLoopManualQaArtifactKind {
 	if (
 		value === "cli-transcript" ||
@@ -28,8 +35,8 @@ export function kindField(value: unknown, field: string): UlwLoopManualQaArtifac
 	)
 		return value;
 	invalid(`${field} must be a supported artifact kind.`, field);
+	return "log";
 }
-
 export function artifactCompatible(surface: UlwLoopManualQaSurface, kind: UlwLoopManualQaArtifactKind): boolean {
 	switch (surface) {
 		case "cli":
@@ -44,24 +51,26 @@ export function artifactCompatible(surface: UlwLoopManualQaSurface, kind: UlwLoo
 			return kind === "data-diff";
 		default:
 			invalid("manualQa.surfaceEvidence has an unsupported surface.", "manualQa.surfaceEvidence.surface");
+			return false;
 	}
 }
-
 export function checkFile(path: string, field: string, opts?: ValidateQualityGateOptions): void {
-	if (opts?.repoRoot === undefined || opts.fs === undefined) return;
+	if (opts?.repoRoot === undefined || opts.fs === undefined || isPoisoned(field)) return;
 	const absolute = resolve(opts.repoRoot, path);
-	if (!opts.fs.existsSync(absolute)) invalid(`${field} must point to an existing artifact.`, field);
-	if (opts.fs.statSync(absolute).size <= 0) invalid(`${field} must point to a non-empty artifact.`, field);
-	if (opts.currentAttemptDir !== undefined && opts.repoRoot !== undefined) {
-		const attemptRoot = resolve(opts.repoRoot, opts.currentAttemptDir);
-		if (!isWithinAttemptDir(absolute, attemptRoot))
-			invalid(
-				`${field} (${path}) must point to an artifact from the current attempt (${opts.currentAttemptDir}).`,
-				field,
-			);
+	if (!opts.fs.existsSync(absolute)) {
+		invalid(`${field} must point to an existing artifact.`, field);
+		return;
 	}
+	if (opts.fs.statSync(absolute).size <= 0) invalid(`${field} must point to a non-empty artifact.`, field);
+	if (
+		opts.currentAttemptDir !== undefined &&
+		!isWithinAttemptDir(absolute, resolve(opts.repoRoot, opts.currentAttemptDir))
+	)
+		invalid(
+			`${field} (${path}) must point to an artifact from the current attempt (${opts.currentAttemptDir}).`,
+			field,
+		);
 }
-
 export function artifactMap(refs: readonly UlwLoopManualQaArtifactRef[]): Map<string, UlwLoopManualQaArtifactRef> {
 	const byId = new Map<string, UlwLoopManualQaArtifactRef>();
 	for (const ref of refs) {
@@ -70,34 +79,44 @@ export function artifactMap(refs: readonly UlwLoopManualQaArtifactRef[]): Map<st
 	}
 	return byId;
 }
-
 export function parseArtifactRefs(
 	value: unknown,
 	opts?: ValidateQualityGateOptions,
 ): readonly UlwLoopManualQaArtifactRef[] {
-	if (!Array.isArray(value) || value.length === 0)
+	if (!Array.isArray(value) || value.length === 0) {
 		invalid("manualQa.artifactRefs must not be empty.", "manualQa.artifactRefs");
-	return value.map((item, index) => {
-		const ref = section(item, `manualQa.artifactRefs[${index}]`);
-		const path = textField(ref["path"], `manualQa.artifactRefs[${index}].path`);
-		checkFile(path, `manualQa.artifactRefs[${index}].path`, opts);
-		return {
-			id: textField(ref["id"], `manualQa.artifactRefs[${index}].id`),
-			kind: kindField(ref["kind"], `manualQa.artifactRefs[${index}].kind`),
-			description: textField(ref["description"], `manualQa.artifactRefs[${index}].description`),
-			path,
-		};
+		return [];
+	}
+	return value.flatMap((item, index) => {
+		const prefix = `manualQa.artifactRefs[${index}]`;
+		const ref = section(item, prefix);
+		if (isPoisoned(prefix)) return [];
+		const pathField = `${prefix}.path`;
+		const idField = `${prefix}.id`;
+		const kindFieldName = `${prefix}.kind`;
+		const descriptionField = `${prefix}.description`;
+		const path = textField(ref["path"], pathField);
+		const id = textField(ref["id"], idField);
+		const kind = kindField(ref["kind"], kindFieldName);
+		if (isPoisoned(kindFieldName)) markPoisonedArtifactKind(id);
+		const description = textField(ref["description"], descriptionField);
+		checkFile(path, pathField, opts);
+		return [{ id, kind, description, path }];
 	});
 }
-
 export function referencedArtifacts(
 	value: unknown,
 	field: string,
 	byId: ReadonlyMap<string, UlwLoopManualQaArtifactRef>,
 ): readonly UlwLoopManualQaArtifactRef[] {
-	return stringArray(value, field).map((id) => {
+	const ids = stringArray(value, field);
+	if (isPoisoned(field)) return [];
+	return ids.flatMap((id) => {
 		const artifact = byId.get(id);
-		if (artifact === undefined) invalid(`${field} references unknown artifact ${id}.`, field);
-		return artifact;
+		if (artifact === undefined) {
+			invalid(`${field} references unknown artifact ${id}.`, field);
+			return [];
+		}
+		return [artifact];
 	});
 }

package/packages/omo-codex/plugin/components/ulw-loop/src/quality-gate-fields.ts

@@ -1,44 +1,97 @@
 import { UlwLoopError } from "./types.js";
 
 const PLACEHOLDER_PATTERN = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
+type QualityGateDefect = { readonly field: string; readonly message: string };
+type QualityGateCollector = {
+	readonly defects: QualityGateDefect[];
+	readonly poisonedFields: Set<string>;
+	readonly poisonedArtifactKinds: Set<string>;
+};
+let activeCollector: QualityGateCollector | undefined;
 
-export function invalid(message: string, field: string): never {
-	throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+/** A recorded defect poisons only its field; consumers skip dependent checks while preserving valid siblings and entry identity. */
+export function withQualityGateCollector<T>(operation: () => T): T {
+	const previous = activeCollector;
+	const collector: QualityGateCollector = { defects: [], poisonedFields: new Set(), poisonedArtifactKinds: new Set() };
+	activeCollector = collector;
+	try {
+		const result = operation();
+		if (collector.defects.length === 0) return result;
+		throwQualityGateDefects(collector.defects);
+	} finally {
+		activeCollector = previous;
+	}
 }
 
+export function throwQualityGateDefects(defects: readonly QualityGateDefect[]): never {
+	const uniqueDefects = [
+		...new Map(defects.map((defect) => [`${defect.field}\u0000${defect.message}`, defect])).values(),
+	];
+	const fields = uniqueDefects.slice(0, 25);
+	const truncated = uniqueDefects.length > fields.length;
+	const message = [
+		`Final quality gate has ${fields.length}${truncated ? "+" : ""} validation defects:`,
+		...fields.map((item) => `- ${item.field}: ${item.message}`),
+	].join("\n");
+	throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", {
+		details: { field: fields[0]?.field, fields, ...(truncated ? { truncated: true } : {}) },
+	});
+}
+export function invalid(message: string, field: string): undefined {
+	if (activeCollector === undefined)
+		throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+	activeCollector.defects.push({ field, message });
+	activeCollector.poisonedFields.add(field);
+	return undefined;
+}
+export function isPoisoned(field: string): boolean {
+	return activeCollector?.poisonedFields.has(field) ?? false;
+}
+export function poisonField(field: string): void {
+	activeCollector?.poisonedFields.add(field);
+}
+export function markPoisonedArtifactKind(id: string): void {
+	activeCollector?.poisonedArtifactKinds.add(id);
+}
+export function isPoisonedArtifactKind(id: string): boolean {
+	return activeCollector?.poisonedArtifactKinds.has(id) ?? false;
+}
 export function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
 export function section(value: unknown, field: string): Record<string, unknown> {
-	return isRecord(value) ? value : invalid(`Final quality gate is missing ${field} evidence.`, field);
+	if (isRecord(value)) return value;
+	invalid(`Final quality gate is missing ${field} evidence.`, field);
+	return {};
 }
-
 export function textField(value: unknown, field: string): string {
-	if (typeof value !== "string" || value.trim() === "")
+	if (typeof value !== "string" || value.trim() === "") {
 		invalid(`Final quality gate requires non-empty ${field}.`, field);
+		return "";
+	}
 	const trimmed = value.trim();
 	if (PLACEHOLDER_PATTERN.test(trimmed)) invalid(`Final quality gate rejects placeholder ${field}.`, field);
 	return trimmed;
 }
-
 export function numberField(value: unknown, field: string): number {
-	return typeof value === "number" && Number.isFinite(value)
-		? value
-		: invalid(`Final quality gate requires numeric ${field}.`, field);
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	invalid(`Final quality gate requires numeric ${field}.`, field);
+	return 0;
 }
-
 export function stringArray(value: unknown, field: string): readonly string[] {
-	if (!Array.isArray(value) || value.length === 0) return invalid(`Final quality gate requires ${field}.`, field);
+	if (!Array.isArray(value) || value.length === 0) {
+		invalid(`Final quality gate requires ${field}.`, field);
+		return [];
+	}
 	return value.map((item) => textField(item, field));
 }
-
 export function emptyBlockers(value: unknown, field: string): readonly [] {
 	if (Array.isArray(value) && value.length === 0) return [];
 	invalid(`${field} must be empty.`, field);
+	return [];
 }
-
 export function literal<T extends string | boolean>(value: unknown, expected: T, field: string): T {
 	if (value === expected) return expected;
 	invalid(`${field} must be ${String(expected)}.`, field);
+	return expected;
 }

package/packages/omo-codex/plugin/components/ulw-loop/src/quality-gate-verdicts.ts

@@ -1,13 +1,17 @@
 import { invalid, literal, textField } from "./quality-gate-fields.js";
 
 export function passedVerdict(value: unknown, field: string): "passed" {
-	if (value === "not_applicable") invalid(`${field} must not be not_applicable.`, field);
+	if (value === "not_applicable") {
+		invalid(`${field} must not be not_applicable.`, field);
+		return "passed";
+	}
 	return literal(value, "passed", field);
 }
 
 export function codeQualityStatusField(value: unknown, field: string): "CLEAR" | "WATCH" {
 	if (value === "CLEAR" || value === "WATCH") return value;
 	invalid(`${field} must be CLEAR or WATCH.`, field);
+	return "CLEAR";
 }
 
 export function adversarialVerdict(
@@ -20,4 +24,5 @@ export function adversarialVerdict(
 		return { verdict: "not_applicable", reason: textField(row["reason"], `${field}.reason`) };
 	}
 	invalid(`${field} must be passed or not_applicable with a reason.`, field);
+	return { verdict: "passed" };
 }

package/packages/omo-codex/plugin/components/ulw-loop/src/quality-gate.ts

@@ -1,4 +1,3 @@
-import { aggregateQualityGateDefects } from "./quality-gate-aggregate.js";
 import {
 	artifactCompatible,
 	artifactMap,
@@ -10,14 +9,17 @@ import {
 import {
 	emptyBlockers,
 	invalid,
+	isPoisoned,
+	isPoisonedArtifactKind,
 	literal,
 	numberField,
 	section,
 	stringArray,
 	textField,
+	withQualityGateCollector,
 } from "./quality-gate-fields.js";
 import { adversarialVerdict, codeQualityStatusField, passedVerdict } from "./quality-gate-verdicts.js";
-import { GATE_SECTION_BY_ACCEPTOR, REQUIRED_GATE_SECTIONS_BY_SURFACE, type UlwLoopToolkitSurface } from "./surface.js";
+import { GATE_SECTION_BY_ACCEPTOR, type UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopManualQaArtifactRef, UlwLoopQualityGate } from "./types.js";
 
 export {
@@ -40,6 +42,10 @@ export interface ValidateQualityGateOptions {
 }
 
 function reviewerRoleField(value: unknown, expected: string, field: string): string {
+	if (typeof value !== "string" || value.trim() === "") {
+		textField(value, field);
+		return expected;
+	}
 	const actual = textField(value, field);
 	if (actual !== expected) invalid(`${field} must be ${expected}.`, field);
 	return expected;
@@ -51,44 +57,51 @@ function reviewerAcceptorField(
 	sectionName: "manualQa" | "gateReview",
 ): string {
 	const field = `${sectionName}.by`;
-	const actual = textField(value, field);
 	const accepted = GATE_SECTION_BY_ACCEPTOR[surface][sectionName];
+	if (typeof value !== "string" || value.trim() === "") {
+		textField(value, field);
+		return accepted?.[0] ?? "";
+	}
+	const actual = textField(value, field);
 	if (accepted === undefined || !accepted.includes(actual))
 		invalid(`${field} must be one of ${accepted?.join(", ") ?? "the configured reviewers"}.`, field);
 	return actual;
 }
 
 export function validateQualityGate(input: unknown, opts?: ValidateQualityGateOptions): UlwLoopQualityGate {
+	return withQualityGateCollector(() => validateQualityGateUncollected(input, opts));
+}
+
+function validateQualityGateUncollected(input: unknown, opts?: ValidateQualityGateOptions): UlwLoopQualityGate {
 	const surface = opts?.reviewerSurface ?? "lazycodex";
-	aggregateQualityGateDefects(input, opts);
 	const gate = section(input, "qualityGate");
-	const requiredSections = REQUIRED_GATE_SECTIONS_BY_SURFACE[surface];
-	for (const sectionName of requiredSections) section(gate[sectionName], sectionName);
 	if (surface === "omo-senpi" && gate["codeReview"] !== undefined)
 		invalid("omo-senpi gate has no codeReview lane.", "codeReview");
 	const manualQa = section(gate["manualQa"], "manualQa");
 	const gateReview = section(gate["gateReview"], "gateReview");
 	const iteration = section(gate["iteration"], "iteration");
 	const coverage = section(gate["criteriaCoverage"], "criteriaCoverage");
+	const codeReview = surface === "lazycodex" ? section(gate["codeReview"], "codeReview") : {};
 	const manualQaBy = reviewerAcceptorField(manualQa["by"], surface, "manualQa");
 	const gateReviewBy = reviewerAcceptorField(gateReview["by"], surface, "gateReview");
-	if (surface === "lazycodex")
-		reviewerRoleField(section(gate["codeReview"], "codeReview")["by"], "lazycodex-code-reviewer", "codeReview.by");
+	const manualQaEvidence = textField(manualQa["evidence"], "manualQa.evidence");
+	const gateReviewEvidence = textField(gateReview["evidence"], "gateReview.evidence");
+	if (surface === "lazycodex") reviewerRoleField(codeReview?.["by"], "lazycodex-code-reviewer", "codeReview.by");
 	const totalCriteria = numberField(coverage["totalCriteria"], "criteriaCoverage.totalCriteria");
 	const passCount = numberField(coverage["passCount"], "criteriaCoverage.passCount");
-	if (passCount < totalCriteria)
+	if (!isPoisoned("criteriaCoverage.passCount") && passCount < totalCriteria)
 		invalid("criteriaCoverage.passCount must cover totalCriteria.", "criteriaCoverage.passCount");
 	const artifactRefs = parseArtifactRefs(manualQa["artifactRefs"], opts);
 	const byId = artifactMap(artifactRefs);
 	const surfaceEvidence = parseSurfaceEvidence(manualQa["surfaceEvidence"], byId);
 	const adversarialCases = parseAdversarialCases(manualQa["adversarialCases"], byId);
 	const gateReportPath = textField(gateReview["reportPath"], "gateReview.reportPath");
-	checkFile(gateReportPath, "gateReview.reportPath", opts);
+	if (!isPoisoned("gateReview.reportPath")) checkFile(gateReportPath, "gateReview.reportPath", opts);
 	const common = {
 		manualQa: {
 			by: manualQaBy,
 			status: literal(manualQa["status"], "passed", "manualQa.status"),
-			evidence: textField(manualQa["evidence"], "manualQa.evidence"),
+			evidence: manualQaEvidence,
 			surfaceEvidence,
 			adversarialCases,
 			artifactRefs,
@@ -97,7 +110,7 @@ export function validateQualityGate(input: unknown, opts?: ValidateQualityGateOp
 			by: gateReviewBy,
 			recommendation: literal(gateReview["recommendation"], "APPROVE", "gateReview.recommendation"),
 			reportPath: gateReportPath,
-			evidence: textField(gateReview["evidence"], "gateReview.evidence"),
+			evidence: gateReviewEvidence,
 			blockers: emptyBlockers(gateReview["blockers"], "gateReview.blockers"),
 		},
 		iteration: {
@@ -119,7 +132,6 @@ export function validateQualityGate(input: unknown, opts?: ValidateQualityGateOp
 		},
 	};
 	if (surface === "omo-senpi") return { surface, ...common };
-	const codeReview = section(gate["codeReview"], "codeReview");
 	const codeReportPath = textField(codeReview["reportPath"], "codeReview.reportPath");
 	checkFile(codeReportPath, "codeReview.reportPath", opts);
 	return {
@@ -140,10 +152,13 @@ function parseSurfaceEvidence(
 	value: unknown,
 	byId: ReadonlyMap<string, UlwLoopManualQaArtifactRef>,
 ): UlwLoopQualityGate["manualQa"]["surfaceEvidence"] {
-	if (!Array.isArray(value) || value.length === 0)
+	if (!Array.isArray(value) || value.length === 0) {
 		invalid("manualQa.surfaceEvidence must not be empty.", "manualQa.surfaceEvidence");
-	return value.map((item, index) => {
+		return [];
+	}
+	return value.flatMap((item, index) => {
 		const row = section(item, `manualQa.surfaceEvidence[${index}]`);
+		if (isPoisoned(`manualQa.surfaceEvidence[${index}]`)) return [];
 		const surface = surfaceField(row["surface"], `manualQa.surfaceEvidence[${index}].surface`);
 		const artifacts = referencedArtifacts(
 			row["artifactRefs"],
@@ -151,6 +166,7 @@ function parseSurfaceEvidence(
 			byId,
 		);
 		for (const artifact of artifacts) {
+			if (isPoisoned(`manualQa.surfaceEvidence[${index}].surface`) || isPoisonedArtifactKind(artifact.id)) continue;
 			if (!artifactCompatible(surface, artifact.kind)) {
 				invalid(
 					`manualQa.surfaceEvidence ${surface} artifact ${artifact.kind} is incompatible.`,
@@ -173,10 +189,13 @@ function parseAdversarialCases(
 	value: unknown,
 	byId: ReadonlyMap<string, UlwLoopManualQaArtifactRef>,
 ): UlwLoopQualityGate["manualQa"]["adversarialCases"] {
-	if (!Array.isArray(value) || value.length === 0)
+	if (!Array.isArray(value) || value.length === 0) {
 		invalid("manualQa.adversarialCases must not be empty.", "manualQa.adversarialCases");
-	return value.map((item, index) => {
+		return [];
+	}
+	return value.flatMap((item, index) => {
 		const row = section(item, `manualQa.adversarialCases[${index}]`);
+		if (isPoisoned(`manualQa.adversarialCases[${index}]`)) return [];
 		const artifacts = referencedArtifacts(
 			row["artifactRefs"],
 			`manualQa.adversarialCases[${index}].artifactRefs`,