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

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

@@ -1,2 +1,7 @@
 import type { ValidateQualityGateOptions } 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 declare function aggregateQualityGateDefects(input: unknown, opts: ValidateQualityGateOptions | undefined): void;

package/packages/omo-codex/plugin/components/ulw-loop/dist/quality-gate-aggregate.js

@@ -1,53 +1,9 @@
-import { resolve } from "node:path";
-import { isRecord } from "./quality-gate-fields.js";
-import { UlwLoopError } from "./types.js";
-const PLACEHOLDER = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
-function add(defects, field, message) {
-    defects.push({ field, message });
-}
-function text(value, field, defects) {
-    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, field, defects) {
-    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, opts) {
-    if (!isRecord(input))
-        return;
-    const defects = [];
-    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/dist/quality-gate-artifacts.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { isWithinAttemptDir } from "./paths.js";
-import { invalid, section, stringArray, textField } from "./quality-gate-fields.js";
+import { invalid, isPoisoned, markPoisonedArtifactKind, section, stringArray, textField, } from "./quality-gate-fields.js";
 export function surfaceField(value, field) {
     if (value === "cli" ||
         value === "http" ||
@@ -10,6 +10,7 @@ export function surfaceField(value, field) {
         value === "data")
         return value;
     invalid(`${field} must be a supported manual QA surface.`, field);
+    return "cli";
 }
 export function kindField(value, field) {
     if (value === "cli-transcript" ||
@@ -20,6 +21,7 @@ export function kindField(value, field) {
         value === "data-diff")
         return value;
     invalid(`${field} must be a supported artifact kind.`, field);
+    return "log";
 }
 export function artifactCompatible(surface, kind) {
     switch (surface) {
@@ -35,21 +37,22 @@ export function artifactCompatible(surface, kind) {
             return kind === "data-diff";
         default:
             invalid("manualQa.surfaceEvidence has an unsupported surface.", "manualQa.surfaceEvidence.surface");
+            return false;
     }
 }
 export function checkFile(path, field, opts) {
-    if (opts?.repoRoot === undefined || opts.fs === undefined)
+    if (opts?.repoRoot === undefined || opts.fs === undefined || isPoisoned(field))
         return;
     const absolute = resolve(opts.repoRoot, path);
-    if (!opts.fs.existsSync(absolute))
+    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 && 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.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) {
     const byId = new Map();
@@ -61,25 +64,39 @@ export function artifactMap(refs) {
     return byId;
 }
 export function parseArtifactRefs(value, opts) {
-    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, field, byId) {
-    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)
+        if (artifact === undefined) {
             invalid(`${field} references unknown artifact ${id}.`, field);
-        return artifact;
+            return [];
+        }
+        return [artifact];
     });
 }

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

@@ -1,4 +1,15 @@
-export declare function invalid(message: string, field: string): never;
+type QualityGateDefect = {
+    readonly field: string;
+    readonly message: string;
+};
+/** A recorded defect poisons only its field; consumers skip dependent checks while preserving valid siblings and entry identity. */
+export declare function withQualityGateCollector<T>(operation: () => T): T;
+export declare function throwQualityGateDefects(defects: readonly QualityGateDefect[]): never;
+export declare function invalid(message: string, field: string): undefined;
+export declare function isPoisoned(field: string): boolean;
+export declare function poisonField(field: string): void;
+export declare function markPoisonedArtifactKind(id: string): void;
+export declare function isPoisonedArtifactKind(id: string): boolean;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
 export declare function section(value: unknown, field: string): Record<string, unknown>;
 export declare function textField(value: unknown, field: string): string;
@@ -6,3 +17,4 @@ export declare function numberField(value: unknown, field: string): number;
 export declare function stringArray(value: unknown, field: string): readonly string[];
 export declare function emptyBlockers(value: unknown, field: string): readonly [];
 export declare function literal<T extends string | boolean>(value: unknown, expected: T, field: string): T;
+export {};

package/packages/omo-codex/plugin/components/ulw-loop/dist/quality-gate-fields.js

@@ -1,39 +1,95 @@
 import { UlwLoopError } from "./types.js";
 const PLACEHOLDER_PATTERN = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
+let activeCollector;
+/** A recorded defect poisons only its field; consumers skip dependent checks while preserving valid siblings and entry identity. */
+export function withQualityGateCollector(operation) {
+    const previous = activeCollector;
+    const collector = { 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) {
+    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, field) {
-    throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+    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) {
+    return activeCollector?.poisonedFields.has(field) ?? false;
+}
+export function poisonField(field) {
+    activeCollector?.poisonedFields.add(field);
+}
+export function markPoisonedArtifactKind(id) {
+    activeCollector?.poisonedArtifactKinds.add(id);
+}
+export function isPoisonedArtifactKind(id) {
+    return activeCollector?.poisonedArtifactKinds.has(id) ?? false;
 }
 export function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export function section(value, field) {
-    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, field) {
-    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, field) {
-    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, field) {
-    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, field) {
     if (Array.isArray(value) && value.length === 0)
         return [];
     invalid(`${field} must be empty.`, field);
+    return [];
 }
 export function literal(value, expected, field) {
     if (value === expected)
         return expected;
     invalid(`${field} must be ${String(expected)}.`, field);
+    return expected;
 }

package/packages/omo-codex/plugin/components/ulw-loop/dist/quality-gate-verdicts.js

@@ -1,13 +1,16 @@
 import { invalid, literal, textField } from "./quality-gate-fields.js";
 export function passedVerdict(value, field) {
-    if (value === "not_applicable")
+    if (value === "not_applicable") {
         invalid(`${field} must not be not_applicable.`, field);
+        return "passed";
+    }
     return literal(value, "passed", field);
 }
 export function codeQualityStatusField(value, field) {
     if (value === "CLEAR" || value === "WATCH")
         return value;
     invalid(`${field} must be CLEAR or WATCH.`, field);
+    return "CLEAR";
 }
 export function adversarialVerdict(row, field) {
     const value = row["verdict"];
@@ -17,4 +20,5 @@ export function adversarialVerdict(row, field) {
         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/dist/quality-gate.js

@@ -1,10 +1,13 @@
-import { aggregateQualityGateDefects } from "./quality-gate-aggregate.js";
 import { artifactCompatible, artifactMap, checkFile, parseArtifactRefs, referencedArtifacts, surfaceField, } from "./quality-gate-artifacts.js";
-import { emptyBlockers, invalid, literal, numberField, section, stringArray, textField, } from "./quality-gate-fields.js";
+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 } from "./surface.js";
+import { GATE_SECTION_BY_ACCEPTOR } from "./surface.js";
 export { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, normalizeBlockerEvidence, sameBlockerOccurrences, } from "./quality-gate-blockers.js";
 function reviewerRoleField(value, expected, field) {
+    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);
@@ -12,44 +15,51 @@ function reviewerRoleField(value, expected, field) {
 }
 function reviewerAcceptorField(value, surface, sectionName) {
     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, opts) {
+    return withQualityGateCollector(() => validateQualityGateUncollected(input, opts));
+}
+function validateQualityGateUncollected(input, opts) {
     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");
+    const manualQaEvidence = textField(manualQa["evidence"], "manualQa.evidence");
+    const gateReviewEvidence = textField(gateReview["evidence"], "gateReview.evidence");
     if (surface === "lazycodex")
-        reviewerRoleField(section(gate["codeReview"], "codeReview")["by"], "lazycodex-code-reviewer", "codeReview.by");
+        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,
@@ -58,7 +68,7 @@ export function validateQualityGate(input, opts) {
             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: {
@@ -78,7 +88,6 @@ export function validateQualityGate(input, opts) {
     };
     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 {
@@ -95,13 +104,19 @@ export function validateQualityGate(input, opts) {
     };
 }
 function parseSurfaceEvidence(value, byId) {
-    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"], `manualQa.surfaceEvidence[${index}].artifactRefs`, 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.`, "manualQa.surfaceEvidence");
             }
@@ -117,10 +132,14 @@ function parseSurfaceEvidence(value, byId) {
     });
 }
 function parseAdversarialCases(value, byId) {
-    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`, byId);
         const verdictInfo = adversarialVerdict(row, `manualQa.adversarialCases[${index}]`);
         return {

package/packages/omo-codex/plugin/components/ulw-loop/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit --with-ultrawork",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.33) Checking Ulw-Loop Steering"
+						"statusMessage": "(OmO 5.0.0-beta.35) Checking Ulw-Loop Steering"
 					}
 				]
 			}
@@ -20,7 +20,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.33) Enforcing Unlimited Ulw-Loop Budget"
+						"statusMessage": "(OmO 5.0.0-beta.35) Enforcing Unlimited Ulw-Loop Budget"
 					}
 				]
 			},
@@ -31,7 +31,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use-spawn",
 						"timeout": 5,
-						"statusMessage": "(OmO 5.0.0-beta.33) Guarding Ulw-Loop Spawns"
+						"statusMessage": "(OmO 5.0.0-beta.35) Guarding Ulw-Loop Spawns"
 					}
 				]
 			}
@@ -43,7 +43,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook stop",
 						"timeout": 10,
-						"statusMessage": "(OmO 5.0.0-beta.33) Checking Ulw-Loop Resume"
+						"statusMessage": "(OmO 5.0.0-beta.35) Checking Ulw-Loop Resume"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/ulw-loop/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-ulw-loop",
-	"version": "5.0.0-beta.33",
+	"version": "5.0.0-beta.35",
 	"description": "Codex plugin: durable repo-native multi-goal orchestration with embedded success criteria and observable evidence audit.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/ulw-loop/skills/ulw-loop/references/full-workflow.md

@@ -190,6 +190,7 @@ omo-agent-toolkit ulw-loop record-evidence --goal-id <g> --criterion-id <c> --st
 # Then use the harness update_goal tool with status complete.
 omo-agent-toolkit ulw-loop checkpoint --goal-id <g> --print-template --json
 # Fill the printed template: replace every placeholder and use real artifact paths under currentAttemptDir.
+# codex-goal-json.goal.objective must equal the plan's codexObjective verbatim.
 omo-agent-toolkit ulw-loop checkpoint --goal-id <g> --status complete --evidence "..." --codex-goal-json <path> --quality-gate-json <path>
 omo-agent-toolkit ulw-loop complete-goals
 ```
@@ -214,7 +215,7 @@ omo-agent-toolkit ulw-loop checkpoint --goal-id <id> --status complete --evidenc
 {
   "codeReview":{"by":"lazycodex-code-reviewer","recommendation":"APPROVE","codeQualityStatus":"CLEAR","reportPath":"test/fixtures/artifacts/code-review.md","evidence":"Diff review passed.","blockers":[]},
   "manualQa":{"by":"lazycodex-qa-executor","status":"passed","evidence":"CLI and data surfaces passed.","surfaceEvidence":[{"id":"surface-cli-pass","criterionRef":"C1","surface":"cli","invocation":"omo-agent-toolkit ulw-loop checkpoint --quality-gate-json sample-quality-gate.json --json","verdict":"passed","artifactRefs":["artifact-cli-pass"]},{"id":"surface-data-pass","criterionRef":"C2","surface":"data","invocation":"diff -u before-ledger.json after-ledger.json","verdict":"passed","artifactRefs":["artifact-data-diff"]}],"adversarialCases":[{"id":"adv-malformed-input","criterionRef":"C3","scenario":"malformed gate input omits manual QA evidence","expectedBehavior":"validator rejects ULW_LOOP_QUALITY_GATE_INVALID","verdict":"passed","artifactRefs":["artifact-cli-reject"]}],"artifactRefs":[{"id":"artifact-cli-pass","kind":"cli-transcript","description":"CLI pass artifact.","path":"test/fixtures/artifacts/cli-pass.txt"},{"id":"artifact-cli-reject","kind":"log","description":"Reject log artifact.","path":"test/fixtures/artifacts/rejection.txt"},{"id":"artifact-data-diff","kind":"data-diff","description":"Data diff artifact.","path":"test/fixtures/artifacts/data-diff.txt"}]},
-  "gateReview":{"by":"lazycodex-gate-reviewer","recommendation":"APPROVE","reportPath":"test/fixtures/artifacts/gate-review.md","evidence":"Gate review passed.","blockers":[]},
+  "gateReview":{"by":"lazycodex-gate-reviewer","recommendation":"APPROVE","reportPath":"test/fixtures/artifacts/gate-review.md","evidence":"Gate review passed.","blockers":[],"notes":[]},
   "iteration":{"fullRerun":true,"status":"passed","rerunCommands":["bunx vitest run packages/omo-codex/plugin/components/ulw-loop/test/quality-gate-doc.test.ts"],"evidence":"Focused rerun passed."},
   "criteriaCoverage":{"totalCriteria":3,"passCount":3,"originalIntent":"User wanted artifact-backed completion.","desiredOutcome":"Behavior ships with review and QA evidence.","userOutcomeReview":"Result matches brief and goals.","adversarialClassesCovered":["malformed_input","stale_state"]}
 }

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

@@ -0,0 +1,81 @@
+import {
+	canReconcileActiveFinalTaskScopedAggregateSnapshot,
+	canReconcileCompletedTaskScopedAggregateSnapshot,
+	codexSnapshotMismatchError,
+} from "./checkpoint-reconciliation.js";
+import { readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot } from "./codex-goal-snapshot.js";
+import {
+	codexGoalMode,
+	compatibleCodexObjectives,
+	expectedCodexObjective,
+	isFinalRunCompletionCandidate,
+} from "./goal-status.js";
+import type { UlwLoopScope } from "./paths.js";
+import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
+import { UlwLoopError } from "./types.js";
+
+function normalizeObjective(value: string): string {
+	return value.replace(/\s+/g, " ").trim();
+}
+
+export async function validateCheckpointCodexGoal(input: {
+	readonly repoRoot: string;
+	readonly plan: UlwLoopPlan;
+	readonly goal: UlwLoopItem;
+	readonly raw: string | undefined;
+	readonly evidence: string;
+	readonly scope?: UlwLoopScope;
+}): Promise<unknown> {
+	const aggregate = codexGoalMode(input.plan) === "aggregate";
+	const final = isFinalRunCompletionCandidate(input.plan, input.goal);
+	const snapshot = await readCodexGoalSnapshotInput(input.raw, input.repoRoot);
+	const expectedObjective = expectedCodexObjective(input.plan, input.goal);
+	const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
+		expectedObjective,
+		...(aggregate ? { acceptedObjectives: compatibleCodexObjectives(input.plan) } : {}),
+		allowedStatuses: aggregate ? (final ? ["complete"] : ["active"]) : ["complete"],
+		requireSnapshot: true,
+		requireComplete: !aggregate || final,
+	});
+	if (reconciliation.ok) return reconciliation.snapshot.raw;
+	const objective = snapshot?.objective;
+	const mismatchedTaskObjective =
+		snapshot?.available === true &&
+		objective !== undefined &&
+		normalizeObjective(objective) !== normalizeObjective(expectedObjective);
+	const completedTaskScoped =
+		mismatchedTaskObjective &&
+		snapshot.status === "complete" &&
+		(await canReconcileCompletedTaskScopedAggregateSnapshot(
+			input.repoRoot,
+			input.plan,
+			input.goal,
+			objective,
+			input.evidence,
+			input.scope,
+		));
+	const activeFinalTaskScoped =
+		mismatchedTaskObjective &&
+		snapshot.status === "active" &&
+		(await canReconcileActiveFinalTaskScopedAggregateSnapshot(
+			input.repoRoot,
+			input.plan,
+			input.goal,
+			objective,
+			input.evidence,
+			input.scope,
+		));
+	if (completedTaskScoped || activeFinalTaskScoped) return reconciliation.snapshot.raw;
+	throw codexSnapshotMismatchError({
+		reconciliation,
+		snapshot,
+		expectedObjective,
+		taskScopedHint: { goal: input.goal, aggregate, final },
+	});
+}
+
+export function combineCheckpointValidationErrors(codexError: UlwLoopError, gateError: UlwLoopError): UlwLoopError {
+	return new UlwLoopError(`${codexError.message}\n${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
+		details: { ...(codexError.details ?? {}), ...(gateError.details ?? {}) },
+	});
+}

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

@@ -16,6 +16,12 @@ export interface CodexSnapshotMismatchInput {
 	readonly taskScopedHint?: { readonly goal: UlwLoopItem; readonly aggregate: boolean; readonly final: boolean };
 }
 
+export function combineCheckpointValidationErrors(codexError: UlwLoopError, gateError: UlwLoopError): UlwLoopError {
+	return new UlwLoopError(`${codexError.message}\n${gateError.message}`, "ULW_LOOP_QUALITY_GATE_INVALID", {
+		details: { ...(codexError.details ?? {}), ...(gateError.details ?? {}) },
+	});
+}
+
 export function codexSnapshotMismatchError(input: CodexSnapshotMismatchInput): UlwLoopError {
 	const { reconciliation, snapshot, taskScopedHint } = input;
 	const hint =