oh-my-opencode 4.10.0 → 4.11.0

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

@@ -0,0 +1,39 @@
+import { UlwLoopError } from "./types.js";
+const PLACEHOLDER_PATTERN = /^(?:placeholder|todo|tbd|n\/a|stub)$/i;
+export function invalid(message, field) {
+    throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+}
+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);
+}
+export function textField(value, field) {
+    if (typeof value !== "string" || value.trim() === "")
+        invalid(`Final quality gate requires non-empty ${field}.`, field);
+    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);
+}
+export function stringArray(value, field) {
+    if (!Array.isArray(value) || value.length === 0)
+        return invalid(`Final quality gate requires ${field}.`, field);
+    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);
+}
+export function literal(value, expected, field) {
+    if (value === expected)
+        return expected;
+    invalid(`${field} must be ${String(expected)}.`, field);
+}

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

@@ -1,6 +1,13 @@
-import type { UlwLoopItem, UlwLoopPlan, UlwLoopQualityGate } from "./types.js";
-export declare function validateQualityGate(input: unknown): UlwLoopQualityGate;
-export declare function normalizeBlockerEvidence(evidence: string): string;
-export declare function classifyExternalAuthorizationBlocker(evidence: string): string | null;
-export declare function sameBlockerOccurrences(plan: UlwLoopPlan, signature: string): number;
-export declare function clearGoalBlockerFields(goal: UlwLoopItem): void;
+import type { UlwLoopQualityGate } from "./types.js";
+export { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, normalizeBlockerEvidence, sameBlockerOccurrences, } from "./quality-gate-blockers.js";
+export interface QualityGateFs {
+    readonly existsSync: (path: string) => boolean;
+    readonly statSync: (path: string) => {
+        readonly size: number;
+    };
+}
+export interface ValidateQualityGateOptions {
+    readonly repoRoot: string;
+    readonly fs: QualityGateFs;
+}
+export declare function validateQualityGate(input: unknown, opts?: ValidateQualityGateOptions): UlwLoopQualityGate;

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

@@ -1,123 +1,194 @@
-import { UlwLoopError } from "./types.js";
-const BLOCKER_FIELD_KEYS = "blocker blockerSignature blockerEvidence blockerOccurrences blockedAt".split(" ");
-const URL_PATTERN = /https?:\/\/\S+/g;
-const PUNCTUATION_PATTERN = /[`"'()[\]{}:,;]/g;
-const WHITESPACE_PATTERN = /\s+/g;
-const AUTH_PATTERN = /\b(auth\w*|credential\w*|token|permission\w*|scope\w*|access|unauthorized|forbidden|401|403)\b/;
-const MISSING_PATTERN = /\b(unset|missing|required|requires|without|omit\w*|not set|not available|no read packages|read packages)\b/;
-const GHCR_PATTERN = /\b(ghcr|github container registry|read packages|imagepullsecret|package api|anonymous|container image)\b/;
-const GHCR_401_PATTERN = /\b(401|unauthorized|anonymous pull|authentication required)\b/;
-const GHCR_403_PATTERN = /\b(403|forbidden|read packages|package api)\b/;
-const UNCONDITIONAL_APPROVAL_PATTERN = /\bUNCONDITIONAL\s+APPROVAL\b/i;
-function invalid(message, field) {
-    throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
+import { resolve } from "node:path";
+import { emptyBlockers, invalid, literal, numberField, section, stringArray, textField, } from "./quality-gate-fields.js";
+const REVIEWER_ROLES = {
+    codeReview: "lazycodex-code-reviewer",
+    manualQa: "lazycodex-qa-executor",
+    gateReview: "lazycodex-gate-reviewer",
+};
+export { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, normalizeBlockerEvidence, sameBlockerOccurrences, } from "./quality-gate-blockers.js";
+function reviewerRoleField(value, expected, field) {
+    const actual = textField(value, field);
+    if (actual !== expected)
+        invalid(`${field} must be ${expected}.`, field);
+    return expected;
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+function surfaceField(value, field) {
+    if (value === "cli" ||
+        value === "http" ||
+        value === "tmux" ||
+        value === "browser" ||
+        value === "gui" ||
+        value === "data")
+        return value;
+    invalid(`${field} must be a supported manual QA surface.`, field);
 }
-function section(value, field) {
-    return isRecord(value) ? value : invalid(`Final quality gate is missing ${field} evidence.`, field);
+function kindField(value, field) {
+    if (value === "cli-transcript" ||
+        value === "log" ||
+        value === "screenshot" ||
+        value === "image" ||
+        value === "http-dump" ||
+        value === "data-diff")
+        return value;
+    invalid(`${field} must be a supported artifact kind.`, field);
 }
-function nonEmptyString(value, field) {
-    return typeof value === "string" && value.trim() !== ""
-        ? value
-        : invalid(`Final quality gate requires non-empty ${field}.`, field);
+function passedVerdict(value, field) {
+    if (value === "not_applicable")
+        invalid(`${field} must not be not_applicable.`, field);
+    return literal(value, "passed", field);
 }
-function numberField(value, field) {
-    return typeof value === "number" && Number.isFinite(value)
-        ? value
-        : invalid(`Final quality gate requires numeric ${field}.`, field);
+function artifactCompatible(surface, kind) {
+    switch (surface) {
+        case "cli":
+        case "tmux":
+            return kind === "cli-transcript" || kind === "log";
+        case "http":
+            return kind === "http-dump";
+        case "browser":
+        case "gui":
+            return kind === "screenshot" || kind === "image";
+        case "data":
+            return kind === "data-diff";
+        default:
+            invalid("manualQa.surfaceEvidence has an unsupported surface.", "manualQa.surfaceEvidence.surface");
+    }
 }
-function stringArray(value, field) {
-    if (!Array.isArray(value) || value.length === 0)
-        return invalid(`Final quality gate requires ${field}.`, field);
-    return value.map((item) => nonEmptyString(item, field));
+function checkFile(path, field, opts) {
+    if (opts === undefined)
+        return;
+    const absolute = resolve(opts.repoRoot, path);
+    if (!opts.fs.existsSync(absolute))
+        invalid(`${field} must point to an existing artifact.`, field);
+    const stat = opts.fs.statSync(absolute);
+    if (stat.size <= 0)
+        invalid(`${field} must point to a non-empty artifact.`, field);
 }
-function normalizeReviewerField({ value, field, expectedValue, evidenceApproved, }) {
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed === "") {
-            if (evidenceApproved)
-                return expectedValue;
-            invalid(`${field} must be ${expectedValue} or codeReview.evidence should include UNCONDITIONAL APPROVAL.`, field);
-        }
-        if (trimmed === expectedValue)
-            return expectedValue;
-        invalid(`${field} must be ${expectedValue}.`, field);
+function artifactMap(refs) {
+    const byId = new Map();
+    for (const ref of refs) {
+        if (byId.has(ref.id))
+            invalid(`manualQa.artifactRefs contains duplicate ${ref.id}.`, "manualQa.artifactRefs");
+        byId.set(ref.id, ref);
     }
-    if (value === undefined) {
-        if (evidenceApproved)
-            return expectedValue;
-        invalid(`${field} must be ${expectedValue} or codeReview.evidence should include UNCONDITIONAL APPROVAL.`, field);
-    }
-    invalid(`${field} must be ${expectedValue}.`, field);
+    return byId;
+}
+function parseArtifactRefs(value, opts) {
+    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,
+        };
+    });
 }
-export function validateQualityGate(input) {
+function referencedArtifacts(value, field, byId) {
+    return stringArray(value, field).map((id) => {
+        const artifact = byId.get(id);
+        if (artifact === undefined)
+            invalid(`${field} references unknown artifact ${id}.`, field);
+        return artifact;
+    });
+}
+export function validateQualityGate(input, opts) {
     const gate = section(input, "qualityGate");
-    const cleaner = section(gate["aiSlopCleaner"], "aiSlopCleaner");
-    const verification = section(gate["verification"], "verification");
-    const review = section(gate["codeReview"], "codeReview");
+    const codeReview = section(gate["codeReview"], "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");
-    if (cleaner["status"] !== "passed")
-        invalid("aiSlopCleaner.status must be passed.", "aiSlopCleaner.status");
-    if (verification["status"] !== "passed")
-        invalid("verification.status must be passed.", "verification.status");
     const totalCriteria = numberField(coverage["totalCriteria"], "criteriaCoverage.totalCriteria");
     const passCount = numberField(coverage["passCount"], "criteriaCoverage.passCount");
     if (passCount < totalCriteria)
         invalid("criteriaCoverage.passCount must cover totalCriteria.", "criteriaCoverage.passCount");
-    const commands = stringArray(verification["commands"], "verification.commands");
-    const covered = stringArray(coverage["adversarialClassesCovered"], "criteriaCoverage.adversarialClassesCovered");
-    const cleanerEvidence = nonEmptyString(cleaner["evidence"], "aiSlopCleaner.evidence");
-    const verificationEvidence = nonEmptyString(verification["evidence"], "verification.evidence");
-    const reviewEvidence = nonEmptyString(review["evidence"], "codeReview.evidence");
-    const approvalEvidence = UNCONDITIONAL_APPROVAL_PATTERN.test(reviewEvidence);
-    const recommendation = normalizeReviewerField({
-        value: review["recommendation"],
-        field: "codeReview.recommendation",
-        expectedValue: "APPROVE",
-        evidenceApproved: approvalEvidence,
-    });
-    const architectStatus = normalizeReviewerField({
-        value: review["architectStatus"],
-        field: "codeReview.architectStatus",
-        expectedValue: "CLEAR",
-        evidenceApproved: approvalEvidence,
-    });
-    const result = {
-        aiSlopCleaner: { status: "passed", evidence: cleanerEvidence },
-        verification: { status: "passed", commands, evidence: verificationEvidence },
-        codeReview: { recommendation, architectStatus, evidence: reviewEvidence },
+    const artifactRefs = parseArtifactRefs(manualQa["artifactRefs"], opts);
+    const byId = artifactMap(artifactRefs);
+    const surfaceEvidence = parseSurfaceEvidence(manualQa["surfaceEvidence"], byId);
+    const adversarialCases = parseAdversarialCases(manualQa["adversarialCases"], byId);
+    const codeReportPath = textField(codeReview["reportPath"], "codeReview.reportPath");
+    const gateReportPath = textField(gateReview["reportPath"], "gateReview.reportPath");
+    checkFile(codeReportPath, "codeReview.reportPath", opts);
+    checkFile(gateReportPath, "gateReview.reportPath", opts);
+    return {
+        codeReview: {
+            by: reviewerRoleField(codeReview["by"], REVIEWER_ROLES.codeReview, "codeReview.by"),
+            recommendation: literal(codeReview["recommendation"], "APPROVE", "codeReview.recommendation"),
+            codeQualityStatus: literal(codeReview["codeQualityStatus"], "CLEAR", "codeReview.codeQualityStatus"),
+            reportPath: codeReportPath,
+            evidence: textField(codeReview["evidence"], "codeReview.evidence"),
+            blockers: emptyBlockers(codeReview["blockers"], "codeReview.blockers"),
+        },
+        manualQa: {
+            by: reviewerRoleField(manualQa["by"], REVIEWER_ROLES.manualQa, "manualQa.by"),
+            status: literal(manualQa["status"], "passed", "manualQa.status"),
+            evidence: textField(manualQa["evidence"], "manualQa.evidence"),
+            surfaceEvidence,
+            adversarialCases,
+            artifactRefs,
+        },
+        gateReview: {
+            by: reviewerRoleField(gateReview["by"], REVIEWER_ROLES.gateReview, "gateReview.by"),
+            recommendation: literal(gateReview["recommendation"], "APPROVE", "gateReview.recommendation"),
+            reportPath: gateReportPath,
+            evidence: textField(gateReview["evidence"], "gateReview.evidence"),
+            blockers: emptyBlockers(gateReview["blockers"], "gateReview.blockers"),
+        },
+        iteration: {
+            fullRerun: literal(iteration["fullRerun"], true, "iteration.fullRerun"),
+            status: literal(iteration["status"], "passed", "iteration.status"),
+            rerunCommands: stringArray(iteration["rerunCommands"], "iteration.rerunCommands"),
+            evidence: textField(iteration["evidence"], "iteration.evidence"),
+        },
+        criteriaCoverage: {
+            totalCriteria,
+            passCount,
+            originalIntent: textField(coverage["originalIntent"], "criteriaCoverage.originalIntent"),
+            desiredOutcome: textField(coverage["desiredOutcome"], "criteriaCoverage.desiredOutcome"),
+            userOutcomeReview: textField(coverage["userOutcomeReview"], "criteriaCoverage.userOutcomeReview"),
+            adversarialClassesCovered: stringArray(coverage["adversarialClassesCovered"], "criteriaCoverage.adversarialClassesCovered"),
+        },
     };
-    Object.assign(result, { criteriaCoverage: { totalCriteria, passCount, adversarialClassesCovered: covered } });
-    return result;
-}
-export function normalizeBlockerEvidence(evidence) {
-    const withoutUrls = evidence.toLowerCase().replace(URL_PATTERN, " ");
-    const withoutPunctuation = withoutUrls.replace(PUNCTUATION_PATTERN, " ");
-    return withoutPunctuation.replace(WHITESPACE_PATTERN, " ").trim();
-}
-export function classifyExternalAuthorizationBlocker(evidence) {
-    const normalized = normalizeBlockerEvidence(evidence);
-    if (!normalized || !AUTH_PATTERN.test(normalized) || !MISSING_PATTERN.test(normalized))
-        return null;
-    if (!GHCR_PATTERN.test(normalized))
-        return "EXTERNAL_AUTHORIZATION_REQUIRED";
-    const status401 = GHCR_401_PATTERN.test(normalized) ? "HTTP_401_ANONYMOUS" : null;
-    const status403 = GHCR_403_PATTERN.test(normalized) ? "HTTP_403_NO_READ_PACKAGES" : null;
-    const status = [status401, status403].filter((part) => part !== null).join("+");
-    return `GHCR_PULL_ACCESS:${status || "AUTHORIZATION_REQUIRED"}:GHCR_VISIBILITY_OR_CREDENTIAL_REQUIRED`;
 }
-function nestedBlockerSignature(goal) {
-    const blocker = Reflect.get(goal, "blocker");
-    const signature = isRecord(blocker) ? blocker["signature"] : null;
-    return typeof signature === "string" ? signature : null;
-}
-export function sameBlockerOccurrences(plan, signature) {
-    return plan.goals.filter((goal) => goal.blockerSignature === signature || nestedBlockerSignature(goal) === signature)
-        .length;
+function parseSurfaceEvidence(value, byId) {
+    if (!Array.isArray(value) || value.length === 0)
+        invalid("manualQa.surfaceEvidence must not be empty.", "manualQa.surfaceEvidence");
+    return value.map((item, index) => {
+        const row = section(item, `manualQa.surfaceEvidence[${index}]`);
+        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 (!artifactCompatible(surface, artifact.kind)) {
+                invalid(`manualQa.surfaceEvidence ${surface} artifact ${artifact.kind} is incompatible.`, "manualQa.surfaceEvidence");
+            }
+        }
+        return {
+            id: textField(row["id"], `manualQa.surfaceEvidence[${index}].id`),
+            criterionRef: textField(row["criterionRef"], `manualQa.surfaceEvidence[${index}].criterionRef`),
+            surface,
+            invocation: textField(row["invocation"], `manualQa.surfaceEvidence[${index}].invocation`),
+            verdict: passedVerdict(row["verdict"], `manualQa.surfaceEvidence[${index}].verdict`),
+            artifactRefs: artifacts.map((artifact) => artifact.id),
+        };
+    });
 }
-export function clearGoalBlockerFields(goal) {
-    for (const key of BLOCKER_FIELD_KEYS)
-        Reflect.deleteProperty(goal, key);
+function parseAdversarialCases(value, byId) {
+    if (!Array.isArray(value) || value.length === 0)
+        invalid("manualQa.adversarialCases must not be empty.", "manualQa.adversarialCases");
+    return value.map((item, index) => {
+        const row = section(item, `manualQa.adversarialCases[${index}]`);
+        const artifacts = referencedArtifacts(row["artifactRefs"], `manualQa.adversarialCases[${index}].artifactRefs`, byId);
+        return {
+            id: textField(row["id"], `manualQa.adversarialCases[${index}].id`),
+            criterionRef: textField(row["criterionRef"], `manualQa.adversarialCases[${index}].criterionRef`),
+            scenario: textField(row["scenario"], `manualQa.adversarialCases[${index}].scenario`),
+            expectedBehavior: textField(row["expectedBehavior"], `manualQa.adversarialCases[${index}].expectedBehavior`),
+            verdict: passedVerdict(row["verdict"], `manualQa.adversarialCases[${index}].verdict`),
+            artifactRefs: artifacts.map((artifact) => artifact.id),
+        };
+    });
 }

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",
 						"timeout": 10,
-						"statusMessage": "LazyCodex(4.10.0): Checking Ulw-Loop Steering"
+						"statusMessage": "LazyCodex(4.11.0): Checking Ulw-Loop Steering"
 					}
 				]
 			}
@@ -20,7 +20,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "LazyCodex(4.10.0): Enforcing Unlimited Ulw-Loop Budget"
+						"statusMessage": "LazyCodex(4.11.0): Enforcing Unlimited Ulw-Loop Budget"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-ulw-loop",
-	"version": "4.10.0",
+	"version": "4.11.0",
 	"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

@@ -161,38 +161,38 @@ Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures a
    - BLOCKED: `omo ulw-loop record-evidence --goal-id <id> --criterion-id <id> --status blocked --evidence "<observable>" --notes "<safety/blocker/leftover-state>" --json`
 9. If actual does not match expected, diagnose, respawn the right-sized worker with the failure context to fix minimally, and rerun the SAME criterion (including a fresh cleanup).
 10. After 3 same-criterion failures, exit the goal with diagnosis.
-11. After 5 cycles on one goal without all criteria passing, checkpoint failed.
+11. After 5 cycles on one goal without required criteria passing, checkpoint failed.
 12. Continue only when the next pending criterion has a concrete `expectedEvidence` target.
 
 ### Goal Completion
-1. Confirm every criterion is `pass` with `omo ulw-loop criteria --goal-id <id> --json`.
+1. Non-final aggregate goal: confirm every `essential` criterion is `pass`; non-essential criteria may remain pending. Final aggregate goal: confirm every criterion across the whole plan is `pass`.
 2. Call `get_goal` for a fresh snapshot.
 3. Run `omo ulw-loop checkpoint --goal-id <id> --status complete --evidence "<criteria evidence summary>" --codex-goal-json <snapshot> --json`.
 4. If blocked or failed, checkpoint with `--status blocked` or `--status failed` and include diagnosis evidence.
 5. If this is the final goal, run the final quality gate first and pass `--quality-gate-json`.
 
 ## Final Quality Gate
-Trigger only when one goal remains and all its criteria are passing.
+Trigger only for the final aggregate goal after every criterion in every goal is `pass`.
 1. Run targeted verification for changed behavior.
-2. Run `ai-slop-cleaner` on changed files. If no relevant edits exist, record a passed no-op cleaner report.
-3. Rerun verification after cleanup.
-4. HEAVY tier — or any goal you are unsure is sound — spawns a rigorous reviewer with `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous final verification reviewer. DELIVERABLE: approve or cite blockers. SCOPE: <changed files and goal>. VERIFY: inspect diff and verification evidence.","fork_context":false})`. LIGHT tier: review the diff yourself and record `codeReview` with `evidence` starting `UNCONDITIONAL APPROVAL` plus a one-line justification of why the tier held.
-5. Clean review means `codeReview.recommendation == "APPROVE"` and `codeReview.architectStatus == "CLEAR"`.
-6. If review is non-clean, run `omo ulw-loop record-review-blockers --goal-id <id> --title "<...>" --objective "<...>" --evidence "<review findings>" --codex-goal-json <snapshot> --json`.
-7. If clean, checkpoint final completion:
+2. Run Manual-QA for every criterion; confirm each artifact exists and is non-empty.
+3. Spawn final reviewers with `fork_context: false`: code review, QA review, gate review. Include original brief, goals, desired outcome, and diff.
+4. Treat timeout, missing deliverable, ack-only, `BLOCKED:`, or inconclusive review as a blocker. Fix, rerun affected verification/Manual-QA, and repeat review.
+5. If review remains blocked, run `omo ulw-loop record-review-blockers --goal-id <id> --title "<...>" --objective "<...>" --evidence "<review findings>" --codex-goal-json <snapshot> --json`.
+6. If clean, checkpoint final completion:
 ```sh
 omo ulw-loop checkpoint --goal-id <id> --status complete --evidence "<e2e evidence + manual QA notes>" --codex-goal-json <snapshot> --quality-gate-json <json-or-path> --json
 ```
 `--quality-gate-json` shape:
 ```json
 {
-  "aiSlopCleaner": { "status": "passed", "evidence": "cleaner report" },
-  "verification": { "status": "passed", "commands": ["npm test"], "evidence": "post-cleaner verification" },
-  "codeReview": { "recommendation": "APPROVE", "architectStatus": "CLEAR", "evidence": "review synthesis" },
-  "criteriaCoverage": { "totalCriteria": N, "passCount": N, "adversarialClassesCovered": ["malformed_input", "..."] }
+  "codeReview":{"by":"lazycodex-code-reviewer","recommendation":"APPROVE","codeQualityStatus":"CLEAR","reportPath":"packages/omo-codex/plugin/components/ulw-loop/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 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":"packages/omo-codex/plugin/components/ulw-loop/test/fixtures/artifacts/cli-pass.txt"},{"id":"artifact-cli-reject","kind":"log","description":"Reject log artifact.","path":"packages/omo-codex/plugin/components/ulw-loop/test/fixtures/artifacts/rejection.txt"},{"id":"artifact-data-diff","kind":"data-diff","description":"Data diff artifact.","path":"packages/omo-codex/plugin/components/ulw-loop/test/fixtures/artifacts/data-diff.txt"}]},
+  "gateReview":{"by":"lazycodex-gate-reviewer","recommendation":"APPROVE","reportPath":"packages/omo-codex/plugin/components/ulw-loop/test/fixtures/artifacts/gate-review.md","evidence":"Gate review passed.","blockers":[]},
+  "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"]}
 }
 ```
-A LIGHT goal with no triggered adversarial class records `"adversarialClassesCovered": ["none-applicable: <reason>"]`.
+Artifacts must be non-empty; counts alone fail. LIGHT without adversarial class records `"adversarialClassesCovered": ["none-applicable: <reason>"]`.
 
 ## Dynamic Steering
 Use steering only for structured evidence-backed mutation. Reject natural-language steering requests.
@@ -214,7 +214,7 @@ Structured prompt directives accepted: `OMO_ULW_LOOP_STEER: { ... }`, `omo.ulw-l
 1. NEVER call `update_goal` mid-aggregate; only on final story after the quality gate passes.
 2. NEVER call `create_goal` when `get_goal` shows a different active goal.
 3. NEVER mark `criterion.status == "pass"` without captured observable evidence in `record-evidence`.
-4. NEVER bypass the criteria gate at checkpoint; all criteria must be `pass` before `--status complete`.
+4. NEVER bypass the criteria gate: non-final aggregate completion requires all essential criteria; final aggregate completion requires all criteria across the whole plan.
 5. Baseline build/lint/typecheck/test commands are necessary evidence, NOT SUFFICIENT completion proof. Criteria coverage with observable evidence is the gate.
 6. Treat `.omo/ulw-loop/ledger.jsonl` as the durable audit trail; checkpoint after every success or failure.
 7. Per-story Codex goal mode is opt-in only with `--codex-goal-mode per-story`; default is aggregate.
@@ -228,9 +228,9 @@ Structured prompt directives accepted: `OMO_ULW_LOOP_STEER: { ... }`, `omo.ulw-l
 15. Every verified work unit that touched git-tracked files must leave either an atomic `git-master`-style commit hash or explicit no-commit blocker evidence before the next unit starts.
 
 ## Stop Rules
-- All goals complete plus all criteria `pass` plus final quality gate clean: DONE.
+- All goals complete plus every plan criterion `pass` plus final quality gate clean: DONE.
 - 3x same criterion failure: checkpoint failed, surface diagnosis.
-- 5 cycles on one goal without all-pass: checkpoint failed, surface.
+- 5 cycles on one goal without required criteria passing: checkpoint failed, surface.
 - Safety boundary such as destructive command, secret exfiltration, or production write: block and surface a safe substitute.
 - Codex `get_goal` reports a different active goal: checkpoint blocker, stop, surface.
 - Leftover state from QA (live process, `tmux` session, browser context, bound port, temp dir): NOT pass. Clean up, append the receipt, then continue.

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

@@ -0,0 +1,100 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+import { codexGoalMode, isFinalRunCompletionCandidate } from "./goal-status.js";
+import { type UlwLoopScope, ulwLoopBriefPath } from "./paths.js";
+import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
+import { ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER } from "./types.js";
+
+function normalizeObjective(value: string): string {
+	return value.replace(/\s+/g, " ").trim();
+}
+
+function textMentionsUlwLoopPlanArtifact(value: string | undefined): boolean {
+	const normalized = (value ?? "").toLowerCase();
+	return (
+		normalized.includes(ULW_LOOP_DIR.toLowerCase()) ||
+		normalized.includes(ULW_LOOP_GOALS.toLowerCase()) ||
+		normalized.includes(ULW_LOOP_LEDGER.toLowerCase())
+	);
+}
+
+function textMentionsGoalId(value: string | undefined, goalId: string): boolean {
+	return (value ?? "").toLowerCase().includes(goalId.toLowerCase());
+}
+
+function textHasCompletionValidationEvidence(value: string | undefined): boolean {
+	const normalized = (value ?? "").toLowerCase();
+	const done =
+		/\b(?:planned work|implementation|deliverables?|scope|task|work)\b/.test(normalized) &&
+		/\b(?:done|complete|completed|finished|shipped)\b/.test(normalized);
+	const verified =
+		/\b(?:validation|verification|tests?|build|lint|review|quality gate|code-review)\b/.test(normalized) &&
+		/\b(?:passed|complete|completed|clean|green|approve|approved|clear)\b/.test(normalized);
+	return done && verified;
+}
+
+async function snapshotObjectiveMapsToUlwLoopPlan(
+	repoRoot: string,
+	snapshotObjective: string,
+	scope?: UlwLoopScope,
+): Promise<boolean> {
+	const actual = normalizeObjective(snapshotObjective).toLowerCase();
+	if (textMentionsUlwLoopPlanArtifact(actual)) return true;
+	if (actual.length < 24 || !existsSync(ulwLoopBriefPath(repoRoot, scope))) return false;
+	try {
+		const brief = normalizeObjective(await readFile(ulwLoopBriefPath(repoRoot, scope), "utf8")).toLowerCase();
+		return brief.length >= 24 && (brief.includes(actual) || actual.includes(brief));
+	} catch (error) {
+		if (error instanceof Error) return false;
+		throw error;
+	}
+}
+
+export async function canReconcileCompletedTaskScopedAggregateSnapshot(
+	repoRoot: string,
+	plan: UlwLoopPlan,
+	goal: UlwLoopItem,
+	snapshotObjective: string,
+	evidence: string,
+	scope?: UlwLoopScope,
+): Promise<boolean> {
+	if (codexGoalMode(plan) !== "aggregate") return false;
+	if (goal.status !== "in_progress" || plan.activeGoalId !== goal.id) return false;
+	if (isFinalRunCompletionCandidate(plan, goal)) {
+		return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
+	}
+	if (!textMentionsUlwLoopPlanArtifact(evidence) || !textMentionsGoalId(evidence, goal.id)) return false;
+	if (!textHasCompletionValidationEvidence(evidence)) return false;
+	return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
+}
+
+export async function canReconcileActiveFinalTaskScopedAggregateSnapshot(
+	repoRoot: string,
+	plan: UlwLoopPlan,
+	goal: UlwLoopItem,
+	snapshotObjective: string,
+	evidence: string,
+	scope?: UlwLoopScope,
+): Promise<boolean> {
+	if (codexGoalMode(plan) !== "aggregate") return false;
+	if (goal.status !== "in_progress" || plan.activeGoalId !== goal.id) return false;
+	if (!isFinalRunCompletionCandidate(plan, goal)) return false;
+	if (!textHasCompletionValidationEvidence(evidence)) return false;
+	return snapshotObjectiveMapsToUlwLoopPlan(repoRoot, snapshotObjective, scope);
+}
+
+function buildCompletedLegacyGoalRemediation(goal: UlwLoopItem): string {
+	return [
+		"If get_goal returns a different completed legacy/thread objective, do not repeat --status complete in this thread.",
+		`Record a non-terminal blocker with: omo ulw-loop checkpoint --goal-id ${goal.id} --status blocked --evidence "<completed legacy Codex goal blocks create_goal in this thread>" --codex-goal-json "<different completed get_goal JSON or path>".`,
+		"Then continue only from a Codex goal context with no active/completed conflicting goal, in the same repo/worktree, and create the intended goal there.",
+	].join(" ");
+}
+
+export function buildTaskScopedAggregateReconciliationHint(goal: UlwLoopItem, final: boolean): string {
+	if (final) {
+		return ` Final task-scoped aggregate reconciliation requires the checkpoint goal to be the active in-progress final OMO goal and the completed get_goal objective to map to the ulw-loop brief or artifact. ${buildCompletedLegacyGoalRemediation(goal)}`;
+	}
+	return ` Completed task-scoped aggregate reconciliation requires the checkpoint goal to be the active in-progress OMO goal, evidence that names that active OMO goal id, names .omo/ulw-loop/goals.json or ledger.jsonl, includes completed implementation plus validation/review evidence, and a get_goal objective that maps to the ulw-loop brief/artifact. ${buildCompletedLegacyGoalRemediation(goal)}`;
+}