oh-my-opencode 5.0.0-beta.4 → 5.0.0-beta.42

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

@@ -1,3 +1,4 @@
+import { type UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
 export interface CodexCreateGoalPayload {
     readonly objective: string;
@@ -10,4 +11,5 @@ export declare function buildCodexGoalInstruction(args: {
     readonly plan: UlwLoopPlan;
     readonly goal: UlwLoopItem;
     readonly isFinal?: boolean;
+    readonly surface?: UlwLoopToolkitSurface;
 }): UlwLoopGoalInstruction;

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

@@ -1,15 +1,17 @@
 // biome-ignore-all format: long agent-facing instruction strings are intentionally stable.
 import { codexGoalMode, expectedCodexObjective, isEssentialCriterion, isFinalRunCompletionCandidate, } from "./goal-status.js";
+import { resolveToolkitSurface, reviewerRolesFor } from "./surface.js";
 export function buildCodexGoalInstruction(args) {
     const mode = codexGoalMode(args.plan);
     const createGoal = buildCreateGoalPayload(args.plan, args.goal);
     const isFinal = args.isFinal ?? isFinalRunCompletionCandidate(args.plan, args.goal);
-    return { text: buildText(mode, args.plan, args.goal, createGoal, isFinal), json: createGoal };
+    const surface = args.surface ?? resolveToolkitSurface();
+    return { text: buildText(mode, args.plan, args.goal, createGoal, isFinal, surface), json: createGoal };
 }
 function buildCreateGoalPayload(plan, goal) {
     return { objective: expectedCodexObjective(plan, goal) };
 }
-function buildText(mode, plan, goal, createGoal, isFinal) {
+function buildText(mode, plan, goal, createGoal, isFinal, surface) {
     return joinLines([
         mode === "aggregate" ? "UlwLoop aggregate-goal handoff" : "UlwLoop active-goal handoff",
         `Mode: ${mode}`,
@@ -26,7 +28,7 @@ function buildText(mode, plan, goal, createGoal, isFinal) {
         "- Goals are unlimited. Do not add numeric limits.",
         ...modeConstraintLines(mode, isFinal),
         ...evidenceLayoutLines(plan),
-        finalSection(plan, goal, isFinal, mode === "aggregate"),
+        finalSection(plan, goal, isFinal, mode === "aggregate", surface),
         ...checkpointLines(plan, mode),
         "",
         "create_goal payload:",
@@ -80,18 +82,21 @@ function evidenceLayoutLines(plan) {
         "- Evidence layout v2: write every artifact for the active goal (QA matrix, review reports, receipts) under the current attempt directory — read currentAttemptDir from `omo-agent-toolkit ulw-loop status --json` (.omo/evidence/ulw/<session>/<goalId>/a<attempt>). The final checkpoint rejects quality-gate artifacts outside that directory.",
     ];
 }
-function finalSection(plan, goal, isFinal, aggregate) {
+function finalSection(plan, goal, isFinal, aggregate, surface) {
+    const roles = reviewerRolesFor(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([
         "Final story — run mandatory quality gate before update_goal:",
         "- Run targeted verification for changed behavior.",
         "- Confirm every manualQa artifact path exists and has non-zero size.",
-        "- First spawn lazycodex-code-reviewer and lazycodex-qa-executor in parallel (fork_context: false on the v1 surface; fork_turns: \"none\" on v2). Include the original brief, goal objectives, desired user-visible outcome, diff, and evidence; wait for BOTH to return and confirm their report artifacts exist on disk (code-review report + manualQa matrix).",
-        "- Only then spawn lazycodex-gate-reviewer (same fork settings), passing those artifact paths.",
+        `- First spawn ${roles.codeReview} and ${roles.manualQa} in parallel (fork_context: false on the v1 surface; fork_turns: "none" on v2). Include the original brief, goal objectives, desired user-visible outcome, diff, and evidence; wait for BOTH to return and confirm their report artifacts exist on disk (code-review report + manualQa matrix).`,
+        `- Only then spawn ${roles.gateReview} (same fork settings), passing those artifact paths.`,
         "- Require clean codeReview, manualQa, gateReview, iteration, and criteriaCoverage. criteriaCoverage must summarize originalIntent, desiredOutcome, and userOutcomeReview; counts alone are not approval.",
         "- On a reviewer REJECT, fix only the cited blockers, rerun the affected verification/Manual-QA, and re-review the delta at most TWICE; if blockers remain, record them and surface to the user.",
         "- If codeQualityStatus is WATCH, include the WATCH notes verbatim in your final user-facing message.",
@@ -103,6 +108,22 @@ function finalSection(plan, goal, isFinal, aggregate) {
         `  ${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

@@ -31,7 +31,7 @@ export function parseCodexGoalSnapshot(value) {
         return { available: false, raw: value };
     }
     const goal = safeObject(goalValue);
-    const objective = safeString(goal["objective"] ?? goal["goal"] ?? goal["description"] ?? root["objective"]);
+    const objective = safeString(goal["objective"] ?? goal["goal"] ?? goal["description"] ?? goal["title"] ?? root["objective"] ?? root["title"]);
     const status = normalizeStatus(goal["status"] ?? root["status"]);
     return {
         available: Boolean(objective || status !== "unknown"),
@@ -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/paths.js

@@ -1,6 +1,6 @@
 import { isAbsolute, join, relative, sep } from "node:path";
 import { ULW_LOOP_BRIEF, ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER } from "./types.js";
-const SESSION_ENV_KEYS = ["OMO_ULW_LOOP_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID"];
+const SESSION_ENV_KEYS = ["OMO_ULW_LOOP_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "PI_SESSION_ID"];
 export function normalizeUlwLoopSessionId(sessionId) {
     const trimmed = sessionId?.trim();
     if (!trimmed)

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,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

@@ -0,0 +1,9 @@
+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) {
+    validateQualityGate(input, opts);
+}

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

@@ -0,0 +1,12 @@
+import type { ValidateQualityGateOptions } from "./quality-gate.js";
+import type { UlwLoopManualQaArtifactKind, UlwLoopManualQaArtifactRef, UlwLoopManualQaSurface } from "./types.js";
+export declare const SUPPORTED_SURFACES: readonly UlwLoopManualQaSurface[];
+export declare const SUPPORTED_KINDS: readonly UlwLoopManualQaArtifactKind[];
+export declare function surfaceField(value: unknown, field: string): UlwLoopManualQaSurface;
+export declare function kindField(value: unknown, field: string): UlwLoopManualQaArtifactKind;
+export declare function compatibleKindsFor(surface: UlwLoopManualQaSurface): readonly 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,104 @@
+import { resolve } from "node:path";
+import { isWithinAttemptDir } from "./paths.js";
+import { invalid, isPoisoned, markPoisonedArtifactKind, section, stringArray, textField, } from "./quality-gate-fields.js";
+export const SUPPORTED_SURFACES = ["cli", "http", "tmux", "browser", "gui", "data"];
+export const SUPPORTED_KINDS = [
+    "cli-transcript",
+    "log",
+    "screenshot",
+    "image",
+    "http-dump",
+    "data-diff",
+];
+const COMPATIBLE_KINDS = {
+    cli: ["cli-transcript", "log"],
+    tmux: ["cli-transcript", "log"],
+    http: ["http-dump"],
+    browser: ["screenshot", "image"],
+    gui: ["screenshot", "image"],
+    data: ["data-diff"],
+};
+function isSupportedSurface(value) {
+    return SUPPORTED_SURFACES.some((surface) => surface === value);
+}
+function isSupportedKind(value) {
+    return SUPPORTED_KINDS.some((kind) => kind === value);
+}
+export function surfaceField(value, field) {
+    if (isSupportedSurface(value))
+        return value;
+    invalid(`${field} must be a supported manual QA surface (${SUPPORTED_SURFACES.join(", ")}).`, field);
+    return "cli";
+}
+export function kindField(value, field) {
+    if (isSupportedKind(value))
+        return value;
+    invalid(`${field} must be a supported artifact kind (${SUPPORTED_KINDS.join(", ")}); review/QA reports belong in codeReview.reportPath or gateReview.reportPath, not artifactRefs.`, field);
+    return "log";
+}
+export function compatibleKindsFor(surface) {
+    return COMPATIBLE_KINDS[surface];
+}
+export function artifactCompatible(surface, kind) {
+    return compatibleKindsFor(surface).includes(kind);
+}
+export function checkFile(path, field, opts) {
+    if (opts?.repoRoot === undefined || opts.fs === undefined || isPoisoned(field))
+        return;
+    const absolute = resolve(opts.repoRoot, path);
+    if (!opts.fs.existsSync(absolute)) {
+        invalid(`${field} must point to an existing artifact.`, field);
+        return;
+    }
+    if (opts.fs.statSync(absolute).size <= 0)
+        invalid(`${field} must point to a non-empty artifact.`, field);
+    if (opts.currentAttemptDir !== undefined &&
+        !isWithinAttemptDir(absolute, resolve(opts.repoRoot, opts.currentAttemptDir)))
+        invalid(`${field} (${path}) must point to an artifact from the current attempt (${opts.currentAttemptDir}).`, field);
+}
+export function artifactMap(refs) {
+    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 [];
+    }
+    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) {
+    const ids = stringArray(value, field);
+    if (isPoisoned(field))
+        return [];
+    return ids.flatMap((id) => {
+        const artifact = byId.get(id);
+        if (artifact === undefined) {
+            invalid(`${field} references unknown artifact ${id}.`, field);
+            return [];
+        }
+        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 = /^(?:placeholder|todo|tbd|n\/a|stub)$/i;
+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.d.ts

@@ -1,3 +1,4 @@
+import { type UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopQualityGate } from "./types.js";
 export { classifyExternalAuthorizationBlocker, clearGoalBlockerFields, normalizeBlockerEvidence, sameBlockerOccurrences, } from "./quality-gate-blockers.js";
 export interface QualityGateFs {
@@ -7,8 +8,9 @@ export interface QualityGateFs {
     };
 }
 export interface ValidateQualityGateOptions {
-    readonly repoRoot: string;
-    readonly fs: QualityGateFs;
+    readonly repoRoot?: string;
+    readonly fs?: QualityGateFs;
     readonly currentAttemptDir?: string;
+    readonly reviewerSurface?: UlwLoopToolkitSurface;
 }
 export declare function validateQualityGate(input: unknown, opts?: ValidateQualityGateOptions): UlwLoopQualityGate;