oh-my-opencode 5.0.0-beta.31 → 5.0.0-beta.32

package/packages/omo-codex/plugin/components/ulw-loop/dist/codex-goal-instruction.js

@@ -87,6 +87,8 @@ function finalSection(plan, goal, isFinal, aggregate, surface) {
     if (!isFinal)
         return "- This is not the final ulw-loop story; do not run the final reviewer/manual-QA/gate-review quality gate yet.";
     const option = sessionOption(plan);
+    if (surface === "omo-senpi")
+        return senpiFinalSection(plan, goal, aggregate);
     const blockerCommand = `omo-agent-toolkit ulw-loop record-review-blockers${option} --goal-id ${goal.id} --title "Resolve final code-review blockers" --objective "<blocker-resolution objective>" --evidence "<review findings>" --codex-goal-json "<active get_goal JSON or path>"`;
     const checkpointCommand = `omo-agent-toolkit ulw-loop checkpoint${option} --goal-id ${goal.id} --status complete --evidence "<targeted verification/manualQa/gateReview evidence>" --codex-goal-json "<fresh complete get_goal JSON or path>" --quality-gate-json "<quality gate JSON or path>"`;
     return joinLines([
@@ -106,6 +108,22 @@ function finalSection(plan, goal, isFinal, aggregate, surface) {
         `  ${checkpointCommand}`,
     ]);
 }
+function senpiFinalSection(plan, goal, aggregate) {
+    const option = sessionOption(plan);
+    const checkpointCommand = `omo-agent-toolkit ulw-loop checkpoint${option} --goal-id ${goal.id} --status complete --evidence "<manualQa/gateReview evidence>" --codex-goal-json "<fresh complete get_goal JSON or path>" --quality-gate-json "$(omo-agent-toolkit ulw-loop checkpoint${option} --print-template)"`;
+    return joinLines([
+        "Final story — run the single-reviewer quality gate before update_goal:",
+        "- Run manual QA yourself and write the non-empty artifact under currentAttemptDir; set manualQa.by to \"main-session\".",
+        '- Spawn exactly one gate reviewer with task(category: "deep").',
+        "- If that task fails with any model_unavailable failure, retry with category:unspecified-high, then category:unspecified-low.",
+        '- Set gateReview.by to the exact category:<name> literal used for the successful task.',
+        '- Build the gate JSON with omo-agent-toolkit ulw-loop checkpoint --print-template, then fill manualQa, gateReview, iteration, and criteriaCoverage.',
+        '- Require passed manualQa, approved gateReview, passed iteration, and complete criteriaCoverage before update_goal({status: "complete"}).',
+        aggregate
+            ? `- If the gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint the aggregate story: ${checkpointCommand}`
+            : `- If the gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint: ${checkpointCommand}`,
+    ]);
+}
 function sessionOption(plan) {
     const prefix = ".omo/ulw-loop/";
     const suffix = "/goals.json";

package/packages/omo-codex/plugin/components/ulw-loop/dist/codex-goal-snapshot.d.ts

@@ -24,3 +24,16 @@ export declare function parseCodexGoalSnapshot(value: unknown): CodexGoalSnapsho
 export declare function readCodexGoalSnapshotInput(raw: string | undefined, cwd?: string): Promise<CodexGoalSnapshot | null>;
 export declare function reconcileCodexGoalSnapshot(snapshot: CodexGoalSnapshot | null | undefined, options: ReconcileCodexGoalOptions): CodexGoalReconciliation;
 export declare function formatCodexGoalReconciliation(reconciliation: CodexGoalReconciliation): string;
+export interface CodexGoalMismatchRecovery {
+    readonly message: string;
+    readonly details: {
+        readonly expectedObjective: string;
+        readonly receivedObjective: string;
+    };
+}
+/**
+ * The reconciliation errors normalize whitespace for comparison, which makes the
+ * quoted objective unusable as a copy source. Recovery therefore carries the
+ * plan's `codexObjective` verbatim so the agent can paste it into `update_goal`.
+ */
+export declare function codexGoalMismatchRecovery(expectedObjective: string, snapshot: CodexGoalSnapshot | null | undefined): CodexGoalMismatchRecovery;

package/packages/omo-codex/plugin/components/ulw-loop/dist/codex-goal-snapshot.js

@@ -95,3 +95,17 @@ export function formatCodexGoalReconciliation(reconciliation) {
     const parts = [...reconciliation.errors, ...reconciliation.warnings];
     return parts.join(" ");
 }
+/**
+ * The reconciliation errors normalize whitespace for comparison, which makes the
+ * quoted objective unusable as a copy source. Recovery therefore carries the
+ * plan's `codexObjective` verbatim so the agent can paste it into `update_goal`.
+ */
+export function codexGoalMismatchRecovery(expectedObjective, snapshot) {
+    const receivedObjective = snapshot?.objective ?? "";
+    const message = [
+        "Recovery: the Codex goal objective must equal the plan's codexObjective exactly — copy the expected value below into update_goal and re-run get_goal.",
+        `expected codexObjective: ${expectedObjective}`,
+        `received objective: ${receivedObjective || "(none)"}`,
+    ].join("\n");
+    return { message, details: { expectedObjective, receivedObjective } };
+}

package/packages/omo-codex/plugin/components/ulw-loop/dist/domain-types.d.ts

@@ -89,15 +89,7 @@ export interface UlwLoopManualQaAdversarialCase {
     readonly reason?: string;
     readonly artifactRefs: readonly string[];
 }
-export interface UlwLoopQualityGate {
-    readonly codeReview: {
-        readonly by: string;
-        readonly recommendation: "APPROVE";
-        readonly codeQualityStatus: "CLEAR" | "WATCH";
-        readonly reportPath: string;
-        readonly evidence: string;
-        readonly blockers: readonly [];
-    };
+interface UlwLoopQualityGateCommon {
     readonly manualQa: {
         readonly by: string;
         readonly status: "passed";
@@ -128,6 +120,21 @@ export interface UlwLoopQualityGate {
         readonly adversarialClassesCovered: readonly string[];
     };
 }
+export interface UlwLoopQualityGateLazycodex extends UlwLoopQualityGateCommon {
+    readonly surface: "lazycodex";
+    readonly codeReview: {
+        readonly by: string;
+        readonly recommendation: "APPROVE";
+        readonly codeQualityStatus: "CLEAR" | "WATCH";
+        readonly reportPath: string;
+        readonly evidence: string;
+        readonly blockers: readonly [];
+    };
+}
+export interface UlwLoopQualityGateSenpi extends UlwLoopQualityGateCommon {
+    readonly surface: "omo-senpi";
+}
+export type UlwLoopQualityGate = UlwLoopQualityGateLazycodex | UlwLoopQualityGateSenpi;
 export interface UlwLoopLedgerEntry {
     at: string;
     kind: UlwLoopLedgerEventKind;
@@ -149,3 +156,4 @@ export interface UlwLoopLedgerEntry {
     blockerOccurrenceCount?: number;
     requiredExternalDecision?: string;
 }
+export {};

package/packages/omo-codex/plugin/components/ulw-loop/dist/plan-io.js

@@ -1,8 +1,9 @@
-import { createReadStream } from "node:fs";
+import { createReadStream, readdirSync } from "node:fs";
 import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { aggregateCodexObjectiveForScope } from "./goal-status.js";
 import { repoRelative, ulwLoopDir, ulwLoopGoalsPath, ulwLoopLedgerPath, ulwLoopRelativeDir, } from "./paths.js";
+import { planMissingRecovery } from "./plan-missing-recovery.js";
 import { iso, ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER, UlwLoopError } from "./types.js";
 const LEGACY_OBJECTIVE_PREFIX = `Complete all ulw-loop stories in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}: `;
 const LEGACY_OBJECTIVE = `Complete all ulw-loop stories listed in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}. Use ${ULW_LOOP_DIR}/${ULW_LOOP_LEDGER} as the durable audit trail.`;
@@ -47,7 +48,8 @@ export async function readUlwLoopPlan(repoRoot, scope) {
     catch (error) {
         if (!hasCode(error, "ENOENT"))
             throw error;
-        throw new UlwLoopError(`No ulw-loop plan found at ${repoRelative(path, repoRoot)}. Run \`omo-agent-toolkit ulw-loop create-goals ...\` first.`, "ULW_LOOP_PLAN_MISSING", { cause: error });
+        const recovery = planMissingRecovery(readSessionDirs(repoRoot));
+        throw new UlwLoopError(`No ulw-loop plan found at ${repoRelative(path, repoRoot)}.\n${recovery.message}`, "ULW_LOOP_PLAN_MISSING", { cause: error, ...(recovery.details === undefined ? {} : { details: recovery.details }) });
     }
     const parsed = JSON.parse(raw);
     if (parsed.version !== 1 || !Array.isArray(parsed.goals)) {
@@ -71,6 +73,19 @@ export async function readUlwLoopPlan(repoRoot, scope) {
     }
     return parsed;
 }
+// Session dirs are the only recovery hint that matters when a plan is missing: the
+// caller is almost always scoped to a session whose sibling actually holds the plan.
+function readSessionDirs(repoRoot) {
+    try {
+        return readdirSync(ulwLoopDir(repoRoot), { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
 export async function writePlan(repoRoot, plan, scope) {
     await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
     const path = ulwLoopGoalsPath(repoRoot, scope);

package/packages/omo-codex/plugin/components/ulw-loop/dist/plan-missing-recovery.d.ts

@@ -0,0 +1,13 @@
+export declare const ULW_LOOP_CREATE_GOALS_COMMAND = "omo-agent-toolkit ulw-loop create-goals --brief \"<brief>\" --json";
+export interface PlanMissingRecovery {
+    readonly message: string;
+    readonly details?: {
+        readonly existingSessionIds: readonly string[];
+    };
+}
+/**
+ * A missing plan is either "never bootstrapped" or "bootstrapped under a different
+ * session id"; the recovery text has to answer both without the caller guessing.
+ */
+export declare function planMissingRecovery(existingSessionIds: readonly string[]): PlanMissingRecovery;
+export declare function sessionIdRequiredMessage(flag: string): string;

package/packages/omo-codex/plugin/components/ulw-loop/dist/plan-missing-recovery.js

@@ -0,0 +1,19 @@
+export const ULW_LOOP_CREATE_GOALS_COMMAND = 'omo-agent-toolkit ulw-loop create-goals --brief "<brief>" --json';
+/**
+ * A missing plan is either "never bootstrapped" or "bootstrapped under a different
+ * session id"; the recovery text has to answer both without the caller guessing.
+ */
+export function planMissingRecovery(existingSessionIds) {
+    const lines = [`Recovery: bootstrap the plan with \`${ULW_LOOP_CREATE_GOALS_COMMAND}\`.`];
+    if (existingSessionIds.length === 0)
+        return { message: lines.join("\n") };
+    lines.push(`Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}. Re-run with \`--session-id <id>\` to target one of them.`);
+    return { message: lines.join("\n"), details: { existingSessionIds } };
+}
+export function sessionIdRequiredMessage(flag) {
+    return [
+        `${flag} requires a non-empty value.`,
+        "Recovery: subprocess, eval, and hook contexts do not inherit the ulw-loop session env (OMO_ULW_LOOP_SESSION_ID / CODEX_SESSION_ID / CODEX_THREAD_ID / PI_SESSION_ID),",
+        `so pass the scope explicitly: \`${flag} <id>\` (for example \`${flag} 01a05b8a-6763-7780-834f-319423b071ce\`).`,
+    ].join("\n");
+}

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

@@ -0,0 +1,2 @@
+import type { ValidateQualityGateOptions } from "./quality-gate.js";
+export declare function aggregateQualityGateDefects(input: unknown, opts: ValidateQualityGateOptions | undefined): void;

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

@@ -0,0 +1,53 @@
+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;
+}
+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 } : {}) },
+    });
+}

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

@@ -0,0 +1,9 @@
+import type { ValidateQualityGateOptions } from "./quality-gate.js";
+import type { UlwLoopManualQaArtifactKind, UlwLoopManualQaArtifactRef, UlwLoopManualQaSurface } from "./types.js";
+export declare function surfaceField(value: unknown, field: string): UlwLoopManualQaSurface;
+export declare function kindField(value: unknown, field: string): UlwLoopManualQaArtifactKind;
+export declare function artifactCompatible(surface: UlwLoopManualQaSurface, kind: UlwLoopManualQaArtifactKind): boolean;
+export declare function checkFile(path: string, field: string, opts?: ValidateQualityGateOptions): void;
+export declare function artifactMap(refs: readonly UlwLoopManualQaArtifactRef[]): Map<string, UlwLoopManualQaArtifactRef>;
+export declare function parseArtifactRefs(value: unknown, opts?: ValidateQualityGateOptions): readonly UlwLoopManualQaArtifactRef[];
+export declare function referencedArtifacts(value: unknown, field: string, byId: ReadonlyMap<string, UlwLoopManualQaArtifactRef>): readonly UlwLoopManualQaArtifactRef[];

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

@@ -0,0 +1,85 @@
+import { resolve } from "node:path";
+import { isWithinAttemptDir } from "./paths.js";
+import { invalid, section, stringArray, textField } from "./quality-gate-fields.js";
+export 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);
+}
+export 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);
+}
+export 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");
+    }
+}
+export function checkFile(path, field, opts) {
+    if (opts?.repoRoot === undefined || opts.fs === undefined)
+        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);
+    }
+}
+export 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);
+    }
+    return byId;
+}
+export 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 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;
+    });
+}

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

@@ -1,5 +1,5 @@
 import { UlwLoopError } from "./types.js";
-const PLACEHOLDER_PATTERN = /^(?:placeholder|todo|tbd|n\/a|stub)$/i;
+const PLACEHOLDER_PATTERN = /^(?:<replace:[^>]+>|placeholder|todo|tbd|n\/a|stub)$/i;
 export function invalid(message, field) {
     throw new UlwLoopError(message, "ULW_LOOP_QUALITY_GATE_INVALID", { details: { field } });
 }

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

@@ -1,8 +1,8 @@
-import { resolve } from "node:path";
-import { isWithinAttemptDir } from "./paths.js";
+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 { adversarialVerdict, codeQualityStatusField, passedVerdict } from "./quality-gate-verdicts.js";
-import { reviewerRolesFor } from "./surface.js";
+import { GATE_SECTION_BY_ACCEPTOR, REQUIRED_GATE_SECTIONS_BY_SURFACE } from "./surface.js";
 export { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, normalizeBlockerEvidence, sameBlockerOccurrences, } from "./quality-gate-blockers.js";
 function reviewerRoleField(value, expected, field) {
     const actual = textField(value, field);
@@ -10,96 +10,31 @@ function reviewerRoleField(value, expected, field) {
         invalid(`${field} must be ${expected}.`, field);
     return expected;
 }
-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 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 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 checkFile(path, field, opts) {
-    if (opts?.repoRoot === undefined || opts.fs === undefined)
-        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);
-    }
-}
-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);
-    }
-    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,
-        };
-    });
-}
-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;
-    });
+function reviewerAcceptorField(value, surface, sectionName) {
+    const field = `${sectionName}.by`;
+    const actual = textField(value, field);
+    const accepted = GATE_SECTION_BY_ACCEPTOR[surface][sectionName];
+    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) {
-    const reviewerRoles = reviewerRolesFor(opts?.reviewerSurface ?? "lazycodex");
+    const surface = opts?.reviewerSurface ?? "lazycodex";
+    aggregateQualityGateDefects(input, opts);
     const gate = section(input, "qualityGate");
-    const codeReview = section(gate["codeReview"], "codeReview");
+    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 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 totalCriteria = numberField(coverage["totalCriteria"], "criteriaCoverage.totalCriteria");
     const passCount = numberField(coverage["passCount"], "criteriaCoverage.passCount");
     if (passCount < totalCriteria)
@@ -108,21 +43,11 @@ export function validateQualityGate(input, 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"], reviewerRoles.codeReview, "codeReview.by"),
-            recommendation: literal(codeReview["recommendation"], "APPROVE", "codeReview.recommendation"),
-            codeQualityStatus: codeQualityStatusField(codeReview["codeQualityStatus"], "codeReview.codeQualityStatus"),
-            reportPath: codeReportPath,
-            evidence: textField(codeReview["evidence"], "codeReview.evidence"),
-            blockers: emptyBlockers(codeReview["blockers"], "codeReview.blockers"),
-        },
+    const common = {
         manualQa: {
-            by: reviewerRoleField(manualQa["by"], reviewerRoles.manualQa, "manualQa.by"),
+            by: manualQaBy,
             status: literal(manualQa["status"], "passed", "manualQa.status"),
             evidence: textField(manualQa["evidence"], "manualQa.evidence"),
             surfaceEvidence,
@@ -130,7 +55,7 @@ export function validateQualityGate(input, opts) {
             artifactRefs,
         },
         gateReview: {
-            by: reviewerRoleField(gateReview["by"], reviewerRoles.gateReview, "gateReview.by"),
+            by: gateReviewBy,
             recommendation: literal(gateReview["recommendation"], "APPROVE", "gateReview.recommendation"),
             reportPath: gateReportPath,
             evidence: textField(gateReview["evidence"], "gateReview.evidence"),
@@ -151,6 +76,23 @@ export function validateQualityGate(input, opts) {
             adversarialClassesCovered: stringArray(coverage["adversarialClassesCovered"], "criteriaCoverage.adversarialClassesCovered"),
         },
     };
+    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 {
+        surface,
+        ...common,
+        codeReview: {
+            by: "lazycodex-code-reviewer",
+            recommendation: literal(codeReview["recommendation"], "APPROVE", "codeReview.recommendation"),
+            codeQualityStatus: codeQualityStatusField(codeReview["codeQualityStatus"], "codeReview.codeQualityStatus"),
+            reportPath: codeReportPath,
+            evidence: textField(codeReview["evidence"], "codeReview.evidence"),
+            blockers: emptyBlockers(codeReview["blockers"], "codeReview.blockers"),
+        },
+    };
 }
 function parseSurfaceEvidence(value, byId) {
     if (!Array.isArray(value) || value.length === 0)

package/packages/omo-codex/plugin/components/ulw-loop/dist/review-blockers.js

@@ -1,4 +1,5 @@
 // biome-ignore-all format: compact port must stay within the requested pure LOC budget.
+import { codexSnapshotMismatchError } from "./checkpoint-reconciliation.js";
 import { readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot } from "./codex-goal-snapshot.js";
 import { codexGoalMode, compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
 import { seedDefaultSuccessCriteria } from "./plan-crud.js";
@@ -42,9 +43,10 @@ export async function recordFinalReviewBlockers(repoRoot, args, scope) {
             ulwLoopError(`${goal.id} is not final.`, "ulw_loop_not_final_story");
         const snapshot = await readCodexGoalSnapshotInput(args.codexGoalJson, repoRoot);
         const aggregate = codexGoalMode(plan) === "aggregate";
-        const reconciliation = reconcileCodexGoalSnapshot(snapshot, { expectedObjective: expectedCodexObjective(plan, goal), ...(aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {}), allowedStatuses: ["active"], requireSnapshot: true, requireComplete: false });
+        const expected = expectedCodexObjective(plan, goal);
+        const reconciliation = reconcileCodexGoalSnapshot(snapshot, { expectedObjective: expected, ...(aggregate ? { acceptedObjectives: compatibleCodexObjectives(plan) } : {}), allowedStatuses: ["active"], requireSnapshot: true, requireComplete: false });
         if (!reconciliation.ok)
-            ulwLoopError(reconciliation.errors.join(" "), "ulw_loop_codex_snapshot_mismatch");
+            throw codexSnapshotMismatchError({ reconciliation, snapshot, expectedObjective: expected });
         const now = iso();
         for (const field of BLOCKER_FIELDS)
             Reflect.deleteProperty(goal, field);