oh-my-opencode 4.10.0 → 4.11.0

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

@@ -1,4 +1,4 @@
-import { codexGoalMode, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
+import { codexGoalMode, expectedCodexObjective, isEssentialCriterion, isFinalRunCompletionCandidate, } from "./goal-status.js";
 export function buildCodexGoalInstruction(args) {
     const mode = codexGoalMode(args.plan);
     const createGoal = buildCreateGoalPayload(args.plan, args.goal);
@@ -46,7 +46,7 @@ function modeConstraintLines(mode, isFinal) {
         "- If a different active or incomplete Codex goal exists, finish/checkpoint that goal before starting this ulw-loop.",
         isFinal
             ? "- This is the final story; update_goal is allowed only after the mandatory quality gate passes."
-            : "- This is not the final story: do not call update_goal yet; the aggregate Codex goal must remain active while later OMO stories remain.",
+            : "- This is not the final story: do not call update_goal mid-aggregate; checkpoint this OMO ledger story and continue the remaining stories. update_goal is reserved for the final story after the mandatory quality gate passes.",
     ];
 }
 function checkpointLines(plan, mode) {
@@ -68,22 +68,26 @@ function successCriteriaLines(criteria) {
 }
 function formatCriterionLine(criterion) {
     const remainingWork = criterion.status === "pending" ? " remaining work:" : "";
-    return `-${remainingWork} [${criterion.id}] (${criterion.userModel}) ${criterion.scenario} — expect: ${criterion.expectedEvidence} — status: ${criterion.status}`;
+    const marker = isEssentialCriterion(criterion) ? "essential" : "non-essential";
+    return `-${remainingWork} [${criterion.id}] [${marker}] (${criterion.userModel}) ${criterion.scenario} — expect: ${criterion.expectedEvidence} — status: ${criterion.status}`;
 }
 function finalSection(plan, goal, isFinal, aggregate) {
     if (!isFinal)
-        return "- This is not the final ulw-loop story; do not run the final ai-slop-cleaner/code-review gate yet.";
+        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);
     const blockerCommand = `omo 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 ulw-loop checkpoint${option} --goal-id ${goal.id} --status complete --evidence "<tests/files/PR evidence>" --codex-goal-json "<fresh complete get_goal JSON or path>" --quality-gate-json "<quality gate JSON or path>"`;
+    const checkpointCommand = `omo 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 ai-slop-cleaner on changed files even when it is a no-op, rerun verification, then run the code review (multi_agent_v1.spawn_agent(agent_type=\"codex-ultrawork-reviewer\", fork_context=false, ...); fall back to agent_type=\"worker\" with a scoped reviewer assignment if unavailable).",
-        "- If the final review is not APPROVE with architect status CLEAR, do not call update_goal. Record blocker work first:",
+        "- Run targeted verification for changed behavior.",
+        "- Confirm every manualQa artifact path exists and has non-zero size.",
+        "- Spawn final reviewers with fork_context=false: lazycodex-code-reviewer, lazycodex-qa-executor, and lazycodex-gate-reviewer. Include the original brief, goal objectives, desired user-visible outcome, diff, and evidence.",
+        "- Require clean codeReview, manualQa, gateReview, iteration, and criteriaCoverage. criteriaCoverage must summarize originalIntent, desiredOutcome, and userOutcomeReview; counts alone are not approval.",
+        "- If any reviewer is blocked/inconclusive or the quality gate is not clean, do not call update_goal. Record blocker work first:",
         `  ${blockerCommand}`,
         aggregate
-            ? '- If the final review is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint the aggregate story:'
-            : '- If the final review is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint:',
+            ? '- If the quality gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint the aggregate story:'
+            : '- If the quality gate is clean, call update_goal({status: "complete"}), call get_goal again, then checkpoint:',
         `  ${checkpointCommand}`,
     ]);
 }

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

@@ -5,6 +5,7 @@ export interface UlwLoopSuccessCriterion {
     readonly scenario: string;
     readonly userModel: UlwLoopSuccessCriterionUserModel;
     readonly expectedEvidence: string;
+    readonly essential?: boolean;
     capturedEvidence: string | null;
     status: UlwLoopCriterionStatus;
     capturedAt?: string;
@@ -56,20 +57,67 @@ export interface UlwLoopPlan {
     activeGoalId?: string;
     goals: UlwLoopItem[];
 }
+export type UlwLoopManualQaSurface = "cli" | "http" | "tmux" | "browser" | "gui" | "data";
+export type UlwLoopManualQaArtifactKind = "cli-transcript" | "log" | "screenshot" | "image" | "http-dump" | "data-diff";
+export interface UlwLoopManualQaArtifactRef {
+    readonly id: string;
+    readonly kind: UlwLoopManualQaArtifactKind;
+    readonly description: string;
+    readonly path: string;
+}
+export interface UlwLoopManualQaSurfaceEvidence {
+    readonly id: string;
+    readonly criterionRef: string;
+    readonly surface: UlwLoopManualQaSurface;
+    readonly invocation: string;
+    readonly verdict: "passed";
+    readonly artifactRefs: readonly string[];
+}
+export interface UlwLoopManualQaAdversarialCase {
+    readonly id: string;
+    readonly criterionRef: string;
+    readonly scenario: string;
+    readonly expectedBehavior: string;
+    readonly verdict: "passed";
+    readonly artifactRefs: readonly string[];
+}
 export interface UlwLoopQualityGate {
-    aiSlopCleaner: {
-        status: "passed";
-        evidence: string;
+    readonly codeReview: {
+        readonly by: string;
+        readonly recommendation: "APPROVE";
+        readonly codeQualityStatus: "CLEAR";
+        readonly reportPath: string;
+        readonly evidence: string;
+        readonly blockers: readonly [];
+    };
+    readonly manualQa: {
+        readonly by: string;
+        readonly status: "passed";
+        readonly evidence: string;
+        readonly surfaceEvidence: readonly UlwLoopManualQaSurfaceEvidence[];
+        readonly adversarialCases: readonly UlwLoopManualQaAdversarialCase[];
+        readonly artifactRefs: readonly UlwLoopManualQaArtifactRef[];
+    };
+    readonly gateReview: {
+        readonly by: string;
+        readonly recommendation: "APPROVE";
+        readonly reportPath: string;
+        readonly evidence: string;
+        readonly blockers: readonly [];
     };
-    verification: {
-        status: "passed";
-        commands: string[];
-        evidence: string;
+    readonly iteration: {
+        readonly fullRerun: true;
+        readonly status: "passed";
+        readonly rerunCommands: readonly string[];
+        readonly evidence: string;
     };
-    codeReview: {
-        recommendation: "APPROVE";
-        architectStatus: "CLEAR";
-        evidence: string;
+    readonly criteriaCoverage: {
+        readonly totalCriteria: number;
+        readonly passCount: number;
+        readonly originalIntent: string;
+        readonly desiredOutcome: string;
+        readonly userOutcomeReview: string;
+        readonly adversarialClassesCovered: readonly string[];
     };
 }
 export interface UlwLoopLedgerEntry {
@@ -83,7 +131,7 @@ export interface UlwLoopLedgerEntry {
     codexGoal?: unknown;
     evidence?: string;
     capturedEvidence?: string;
-    qualityGate?: UlwLoopQualityGate;
+    qualityGate?: unknown;
     steering?: UlwLoopSteeringAudit;
     before?: unknown;
     after?: unknown;

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

@@ -27,5 +27,8 @@ export declare function criteriaSummary(plan: UlwLoopPlan): {
     goalsWithUnresolvedCriteria: string[];
 };
 export declare function unresolvedCriteriaOf(goal: UlwLoopItem): UlwLoopSuccessCriterion[];
+export declare function unresolvedEssentialCriteriaOf(goal: UlwLoopItem): readonly UlwLoopSuccessCriterion[];
 export declare function requireAllCriteriaPass(goal: UlwLoopItem): void;
+export declare function requireAllPlanCriteriaPass(plan: UlwLoopPlan): void;
+export declare function requireEssentialCriteriaPass(goal: UlwLoopItem): void;
 export {};

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

@@ -1,8 +1,9 @@
-// biome-ignore-all format: keep this module under the mandated pure LOC budget.
-import { hasAllCriteriaPass } from "./goal-status.js";
+import { essentialCriteriaOf, hasAllCriteriaPass, hasEssentialCriteriaPass } from "./goal-status.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
 import { iso, UlwLoopError } from "./types.js";
-function ulwLoopFail(message, code, details) { throw new UlwLoopError(message, code, { details }); }
+function ulwLoopFail(message, code, details) {
+    throw new UlwLoopError(message, code, { details });
+}
 function ledgerKind(status) {
     switch (status) {
         case "pass":
@@ -21,9 +22,16 @@ function findGoal(plan, goalId) {
 }
 function findCriterion(goal, criterionId) {
     const criterion = goal.successCriteria.find((candidate) => candidate.id === criterionId);
-    return criterion ?? ulwLoopFail(`Success criterion not found: ${criterionId}.`, "ULW_LOOP_CRITERION_NOT_FOUND", { goalId: goal.id, criterionId });
+    return (criterion ??
+        ulwLoopFail(`Success criterion not found: ${criterionId}.`, "ULW_LOOP_CRITERION_NOT_FOUND", {
+            goalId: goal.id,
+            criterionId,
+        }));
+}
+function nonEmptyEvidence(evidence) {
+    const trimmed = evidence.trim();
+    return trimmed || ulwLoopFail("Evidence must be a non-empty string.", "ULW_LOOP_EVIDENCE_REQUIRED", {});
 }
-function nonEmptyEvidence(evidence) { const trimmed = evidence.trim(); return trimmed || ulwLoopFail("Evidence must be a non-empty string.", "ULW_LOOP_EVIDENCE_REQUIRED", {}); }
 export async function recordEvidence(repoRoot, args, scope) {
     return withUlwLoopMutationLock(repoRoot, scope, async () => {
         const plan = await readUlwLoopPlan(repoRoot, scope);
@@ -61,7 +69,12 @@ export async function markCriteriaPendingResetForGoal(repoRoot, goalId, scope) {
         const plan = await readUlwLoopPlan(repoRoot, scope);
         const goal = findGoal(plan, goalId);
         const now = iso();
-        const before = goal.successCriteria.map((criterion) => ({ id: criterion.id, status: criterion.status, capturedEvidence: criterion.capturedEvidence, capturedAt: criterion.capturedAt ?? null }));
+        const before = goal.successCriteria.map((criterion) => ({
+            id: criterion.id,
+            status: criterion.status,
+            capturedEvidence: criterion.capturedEvidence,
+            capturedAt: criterion.capturedAt ?? null,
+        }));
         for (const criterion of goal.successCriteria) {
             criterion.status = "pending";
             criterion.capturedEvidence = null;
@@ -71,7 +84,14 @@ export async function markCriteriaPendingResetForGoal(repoRoot, goalId, scope) {
         goal.updatedAt = now;
         plan.updatedAt = now;
         await writePlan(repoRoot, plan, scope);
-        await appendLedger(repoRoot, { at: now, kind: "criteria_revised", goalId, message: `Reset ${goal.successCriteria.length} criteria to pending.`, before, after: { resetCount: goal.successCriteria.length } }, scope);
+        await appendLedger(repoRoot, {
+            at: now,
+            kind: "criteria_revised",
+            goalId,
+            message: `Reset ${goal.successCriteria.length} criteria to pending.`,
+            before,
+            after: { resetCount: goal.successCriteria.length },
+        }, scope);
         return { plan, resetCount: goal.successCriteria.length };
     });
 }
@@ -101,7 +121,10 @@ export function criteriaSummary(plan) {
                 case "blocked":
                     blockedCount += 1;
                     break;
-                default: ulwLoopFail("Invalid criterion status.", "ULW_LOOP_CRITERION_STATUS_INVALID", { status: criterion.status });
+                default:
+                    ulwLoopFail("Invalid criterion status.", "ULW_LOOP_CRITERION_STATUS_INVALID", {
+                        status: criterion.status,
+                    });
             }
         }
         if (unresolved)
@@ -109,11 +132,45 @@ export function criteriaSummary(plan) {
     }
     return { totalCriteria, passCount, pendingCount, failCount, blockedCount, goalsWithUnresolvedCriteria };
 }
-export function unresolvedCriteriaOf(goal) { return goal.successCriteria.filter((criterion) => criterion.status !== "pass"); }
+export function unresolvedCriteriaOf(goal) {
+    return goal.successCriteria.filter((criterion) => criterion.status !== "pass");
+}
+export function unresolvedEssentialCriteriaOf(goal) {
+    const essentialCriteria = new Set(essentialCriteriaOf(goal).map((criterion) => criterion.id));
+    return goal.successCriteria.filter((criterion) => essentialCriteria.has(criterion.id) && criterion.status !== "pass");
+}
 export function requireAllCriteriaPass(goal) {
     if (hasAllCriteriaPass(goal))
         return;
     throw new UlwLoopError(`Goal ${goal.id} has unresolved success criteria.`, "ulw_loop_criteria_not_all_pass", {
-        details: { goalId: goal.id, unresolved: unresolvedCriteriaOf(goal).map((criterion) => ({ id: criterion.id, status: criterion.status })) },
+        details: {
+            goalId: goal.id,
+            unresolved: unresolvedCriteriaOf(goal).map((criterion) => ({ id: criterion.id, status: criterion.status })),
+        },
+    });
+}
+export function requireAllPlanCriteriaPass(plan) {
+    const unresolved = plan.goals.flatMap((goal) => unresolvedCriteriaOf(goal).map((criterion) => ({
+        goalId: goal.id,
+        id: criterion.id,
+        status: criterion.status,
+    })));
+    if (unresolved.length === 0)
+        return;
+    throw new UlwLoopError("Ulw-loop aggregate has unresolved success criteria.", "ulw_loop_criteria_not_all_pass", {
+        details: { unresolved },
+    });
+}
+export function requireEssentialCriteriaPass(goal) {
+    if (hasEssentialCriteriaPass(goal))
+        return;
+    throw new UlwLoopError(`Goal ${goal.id} has unresolved essential success criteria.`, "ulw_loop_criteria_not_all_pass", {
+        details: {
+            goalId: goal.id,
+            unresolved: unresolvedEssentialCriteriaOf(goal).map((criterion) => ({
+                id: criterion.id,
+                status: criterion.status,
+            })),
+        },
     });
 }

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

@@ -9,4 +9,7 @@ export declare function aggregateCodexObjective(plan: UlwLoopPlan): string;
 export declare function expectedCodexObjective(plan: UlwLoopPlan, goal: UlwLoopItem): string;
 export declare function compatibleCodexObjectives(plan: UlwLoopPlan): readonly string[];
 export declare function hasAllCriteriaPass(goal: UlwLoopItem): boolean;
+export declare function isEssentialCriterion(criterion: UlwLoopSuccessCriterion): boolean;
+export declare function essentialCriteriaOf(goal: UlwLoopItem): readonly UlwLoopSuccessCriterion[];
+export declare function hasEssentialCriteriaPass(goal: UlwLoopItem): boolean;
 export declare function firstUnresolvedCriterion(goal: UlwLoopItem): UlwLoopSuccessCriterion | undefined;

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

@@ -64,6 +64,20 @@ export function compatibleCodexObjectives(plan) {
 export function hasAllCriteriaPass(goal) {
     return goal.successCriteria.length > 0 && goal.successCriteria.every((criterion) => criterion.status === "pass");
 }
+export function isEssentialCriterion(criterion) {
+    return criterion.essential ?? true;
+}
+export function essentialCriteriaOf(goal) {
+    const explicit = goal.successCriteria.filter(isEssentialCriterion);
+    if (explicit.length > 0)
+        return explicit;
+    const happy = goal.successCriteria.find((criterion) => criterion.userModel === "happy");
+    return happy === undefined ? [] : [happy];
+}
+export function hasEssentialCriteriaPass(goal) {
+    const criteria = essentialCriteriaOf(goal);
+    return criteria.length > 0 && criteria.every((criterion) => criterion.status === "pass");
+}
 export function firstUnresolvedCriterion(goal) {
     return goal.successCriteria.find((criterion) => criterion.status !== "pass");
 }

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

@@ -1,5 +1,6 @@
 import { type UlwLoopScope } from "./paths.js";
-import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
+import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan } from "./types.js";
+export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
 export type UlwLoopPlanSummary = {
     readonly total: number;
     readonly pending: number;
@@ -18,11 +19,6 @@ export type UlwLoopPlanSummary = {
         readonly blocked: number;
     };
 };
-export declare function seedDefaultSuccessCriteria(goalIndex: number, objective: string): UlwLoopSuccessCriterion[];
-export declare function deriveGoalCandidates(brief: string): Array<{
-    title: string;
-    objective: string;
-}>;
 export declare function createUlwLoopPlan(repoRoot: string, args: {
     brief: string;
     codexGoalMode?: UlwLoopCodexGoalMode;

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

@@ -1,46 +1,24 @@
-// biome-ignore-all format: keep this port under the mandated pure LOC budget.
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
 import { aggregateCodexObjectiveForScope, isUlwLoopDone } from "./goal-status.js";
-import { ulwLoopBriefPath, ulwLoopBriefRelativePath, ulwLoopDir, ulwLoopGoalsPath, ulwLoopGoalsRelativePath, ulwLoopLedgerPath, ulwLoopLedgerRelativePath } from "./paths.js";
+import { ulwLoopBriefPath, ulwLoopBriefRelativePath, ulwLoopDir, ulwLoopGoalsPath, ulwLoopGoalsRelativePath, ulwLoopLedgerPath, ulwLoopLedgerRelativePath, } from "./paths.js";
+import { appendGoalToPlan, deriveGoalCandidates, makeGoal } from "./plan-goal-factory.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
 import { iso, UlwLoopError } from "./types.js";
-function cleanLine(line) { return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim(); }
-function normalizeObjective(value) { return value.replace(/\s+/g, " ").trim(); }
-function titleFromObjective(objective, fallback) { const firstLine = objective.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? fallback; return firstLine.length > 72 ? `${firstLine.slice(0, 69).trimEnd()}...` : firstLine; }
-function normalizeGoalId(title, index) { const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 36).replace(/-+$/g, ""); return `G${String(index + 1).padStart(3, "0")}${slug ? `-${slug}` : ""}`; }
-function assertNonEmpty(value, label) { const trimmed = value?.trim(); if (!trimmed)
-    throw new UlwLoopError(`Missing ${label}.`, "ULW_LOOP_ARGUMENT_MISSING"); return trimmed; }
-function truncateObjective(objective) { return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective; }
-export function seedDefaultSuccessCriteria(goalIndex, objective) {
-    const subject = truncateObjective(normalizeObjective(objective) || `Goal ${goalIndex + 1}`);
-    const rows = [
-        ["C001", "happy", `happy path for: ${subject}`, `Replace via revise_criterion with observable happy-path proof for goal ${goalIndex + 1}.`],
-        ["C002", "edge", "edge case (boundary/empty/malformed)", `Replace via revise_criterion with boundary or malformed-input proof for: ${subject}.`],
-        ["C003", "regression", "regression: adjacent surface still works", `Replace via revise_criterion with regression proof for neighboring behavior after: ${subject}.`],
-    ];
-    return rows.map(([id, userModel, scenario, expectedEvidence]) => ({ id, scenario, userModel, expectedEvidence, capturedEvidence: null, status: "pending" }));
+export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
+function isScheduleEligible(goal) {
+    return goal.steeringStatus !== "superseded" && goal.steeringStatus !== "blocked";
 }
-export function deriveGoalCandidates(brief) {
-    const bulletGoals = brief.split(/\r?\n/).map((line) => ({ original: line, cleaned: normalizeObjective(cleanLine(line)) })).filter(({ cleaned }) => cleaned.length > 0 && cleaned.length <= 1200).filter(({ original, cleaned }, index, all) => /^\s*(?:[-*+]\s+|\d+[.)]\s+)/.test(original) && all.findIndex((candidate) => candidate.cleaned === cleaned) === index).map(({ cleaned }) => cleaned);
-    const paragraphs = brief.split(/\n\s*\n/).map(normalizeObjective).filter((paragraph) => paragraph.length > 0 && !paragraph.startsWith("#"));
-    const selected = (bulletGoals.length > 0 ? bulletGoals : paragraphs).length > 0 ? (bulletGoals.length > 0 ? bulletGoals : paragraphs) : ["Complete the requested project objective."];
-    return selected.map((objective, index) => ({ title: titleFromObjective(objective, `Goal ${index + 1}`), objective }));
-}
-function makeGoal(title, objective, index, now) {
-    const cleanTitle = assertNonEmpty(title, "title");
-    const cleanObjective = assertNonEmpty(objective, "objective");
-    return { id: normalizeGoalId(cleanTitle, index), title: cleanTitle, objective: cleanObjective, status: "pending", successCriteria: seedDefaultSuccessCriteria(index, cleanObjective), attempt: 0, createdAt: now, updatedAt: now };
-}
-function appendGoalToPlan(plan, title, objective, now) {
-    const goal = makeGoal(title, objective, plan.goals.length, now);
-    plan.goals.push(goal);
-    plan.updatedAt = now;
-    return goal;
-}
-function isScheduleEligible(goal) { return goal.steeringStatus !== "superseded" && goal.steeringStatus !== "blocked"; }
 function clearGoalBlockerFields(goal) {
-    for (const key of ["blockedReason", "blockerSignature", "blockerOccurrenceCount", "requiredExternalDecision", "nonRetriable", "failedAt", "failureReason"])
+    for (const key of [
+        "blockedReason",
+        "blockerSignature",
+        "blockerOccurrenceCount",
+        "requiredExternalDecision",
+        "nonRetriable",
+        "failedAt",
+        "failureReason",
+    ])
         delete goal[key];
 }
 export async function createUlwLoopPlan(repoRoot, args, scope) {
@@ -53,7 +31,16 @@ export async function createUlwLoopPlan(repoRoot, args, scope) {
         }
         const now = iso();
         const goals = deriveGoalCandidates(args.brief).map((goal, index) => makeGoal(goal.title, goal.objective, index, now));
-        const plan = { version: 1, createdAt: now, updatedAt: now, briefPath: ulwLoopBriefRelativePath(scope), goalsPath: ulwLoopGoalsRelativePath(scope), ledgerPath: ulwLoopLedgerRelativePath(scope), codexGoalMode: args.codexGoalMode ?? "aggregate", goals };
+        const plan = {
+            version: 1,
+            createdAt: now,
+            updatedAt: now,
+            briefPath: ulwLoopBriefRelativePath(scope),
+            goalsPath: ulwLoopGoalsRelativePath(scope),
+            ledgerPath: ulwLoopLedgerRelativePath(scope),
+            codexGoalMode: args.codexGoalMode ?? "aggregate",
+            goals,
+        };
         if (plan.codexGoalMode === "aggregate")
             plan.codexObjective = aggregateCodexObjectiveForScope(scope);
         await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
@@ -94,7 +81,13 @@ export async function startNextUlwLoop(repoRoot, args = {}, scope) {
         if (!next && args.retryFailed) {
             next = plan.goals.find((goal) => goal.status === "failed" && !goal.nonRetriable && isScheduleEligible(goal));
             if (next)
-                await appendLedger(repoRoot, { at: now, kind: "goal_retried", goalId: next.id, status: "pending", ...(next.failureReason ? { message: next.failureReason } : {}) }, scope);
+                await appendLedger(repoRoot, {
+                    at: now,
+                    kind: "goal_retried",
+                    goalId: next.id,
+                    status: "pending",
+                    ...(next.failureReason ? { message: next.failureReason } : {}),
+                }, scope);
         }
         if (!next)
             return { done: true, plan };
@@ -113,5 +106,22 @@ export async function startNextUlwLoop(repoRoot, args = {}, scope) {
 export function summarizeUlwLoopPlan(plan) {
     const countStatus = (status) => plan.goals.filter((goal) => goal.status === status).length;
     const countCriteria = (status) => plan.goals.reduce((sum, goal) => sum + goal.successCriteria.filter((criterion) => criterion.status === status).length, 0);
-    return { total: plan.goals.length, pending: countStatus("pending"), in_progress: countStatus("in_progress"), complete: countStatus("complete"), failed: countStatus("failed"), blocked: countStatus("blocked"), review_blocked: countStatus("review_blocked"), needs_user_decision: countStatus("needs_user_decision"), superseded: plan.goals.filter((goal) => goal.steeringStatus === "superseded").length, criteria: { total: plan.goals.reduce((sum, goal) => sum + goal.successCriteria.length, 0), pass: countCriteria("pass"), pending: countCriteria("pending"), fail: countCriteria("fail"), blocked: countCriteria("blocked") } };
+    return {
+        total: plan.goals.length,
+        pending: countStatus("pending"),
+        in_progress: countStatus("in_progress"),
+        complete: countStatus("complete"),
+        failed: countStatus("failed"),
+        blocked: countStatus("blocked"),
+        review_blocked: countStatus("review_blocked"),
+        needs_user_decision: countStatus("needs_user_decision"),
+        superseded: plan.goals.filter((goal) => goal.steeringStatus === "superseded").length,
+        criteria: {
+            total: plan.goals.reduce((sum, goal) => sum + goal.successCriteria.length, 0),
+            pass: countCriteria("pass"),
+            pending: countCriteria("pending"),
+            fail: countCriteria("fail"),
+            blocked: countCriteria("blocked"),
+        },
+    };
 }

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

@@ -0,0 +1,8 @@
+import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
+export declare function seedDefaultSuccessCriteria(goalIndex: number, objective: string): UlwLoopSuccessCriterion[];
+export declare function deriveGoalCandidates(brief: string): Array<{
+    title: string;
+    objective: string;
+}>;
+export declare function makeGoal(title: string, objective: string, index: number, now: string): UlwLoopItem;
+export declare function appendGoalToPlan(plan: UlwLoopPlan, title: string, objective: string, now: string): UlwLoopItem;

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

@@ -0,0 +1,109 @@
+import { UlwLoopError } from "./types.js";
+function cleanLine(line) {
+    return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
+}
+function normalizeObjective(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+function titleFromObjective(objective, fallback) {
+    const firstLine = objective
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean) ?? fallback;
+    return firstLine.length > 72 ? `${firstLine.slice(0, 69).trimEnd()}...` : firstLine;
+}
+function normalizeGoalId(title, index) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 36)
+        .replace(/-+$/g, "");
+    return `G${String(index + 1).padStart(3, "0")}${slug ? `-${slug}` : ""}`;
+}
+function assertNonEmpty(value, label) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        throw new UlwLoopError(`Missing ${label}.`, "ULW_LOOP_ARGUMENT_MISSING");
+    return trimmed;
+}
+function truncateObjective(objective) {
+    return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective;
+}
+export function seedDefaultSuccessCriteria(goalIndex, objective) {
+    const subject = truncateObjective(normalizeObjective(objective) || `Goal ${goalIndex + 1}`);
+    const rows = [
+        [
+            "C001",
+            "happy",
+            `happy path for: ${subject}`,
+            `Replace via revise_criterion with observable happy-path proof for goal ${goalIndex + 1}.`,
+            true,
+        ],
+        [
+            "C002",
+            "edge",
+            "edge case (boundary/empty/malformed)",
+            `Replace via revise_criterion with boundary or malformed-input proof for: ${subject}.`,
+            true,
+        ],
+        [
+            "C003",
+            "regression",
+            "regression: adjacent surface still works",
+            `Replace via revise_criterion with regression proof for neighboring behavior after: ${subject}.`,
+            false,
+        ],
+    ];
+    return rows.map(([id, userModel, scenario, expectedEvidence, essential]) => ({
+        id,
+        scenario,
+        userModel,
+        expectedEvidence,
+        essential,
+        capturedEvidence: null,
+        status: "pending",
+    }));
+}
+export function deriveGoalCandidates(brief) {
+    const bulletGoals = brief
+        .split(/\r?\n/)
+        .map((line) => ({ original: line, cleaned: normalizeObjective(cleanLine(line)) }))
+        .filter(({ cleaned }) => cleaned.length > 0 && cleaned.length <= 1200)
+        .filter(({ original, cleaned }, index, all) => /^\s*(?:[-*+]\s+|\d+[.)]\s+)/.test(original) &&
+        all.findIndex((candidate) => candidate.cleaned === cleaned) === index)
+        .map(({ cleaned }) => cleaned);
+    const paragraphs = brief
+        .split(/\n\s*\n/)
+        .map(normalizeObjective)
+        .filter((paragraph) => paragraph.length > 0 && !paragraph.startsWith("#"));
+    const selected = (bulletGoals.length > 0 ? bulletGoals : paragraphs).length > 0
+        ? bulletGoals.length > 0
+            ? bulletGoals
+            : paragraphs
+        : ["Complete the requested project objective."];
+    return selected.map((objective, index) => ({
+        title: titleFromObjective(objective, `Goal ${index + 1}`),
+        objective,
+    }));
+}
+export function makeGoal(title, objective, index, now) {
+    const cleanTitle = assertNonEmpty(title, "title");
+    const cleanObjective = assertNonEmpty(objective, "objective");
+    return {
+        id: normalizeGoalId(cleanTitle, index),
+        title: cleanTitle,
+        objective: cleanObjective,
+        status: "pending",
+        successCriteria: seedDefaultSuccessCriteria(index, cleanObjective),
+        attempt: 0,
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export function appendGoalToPlan(plan, title, objective, now) {
+    const goal = makeGoal(title, objective, plan.goals.length, now);
+    plan.goals.push(goal);
+    plan.updatedAt = now;
+    return goal;
+}

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

@@ -0,0 +1,5 @@
+import type { UlwLoopItem, UlwLoopPlan } from "./types.js";
+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;

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

@@ -0,0 +1,41 @@
+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/;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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;
+}
+export function clearGoalBlockerFields(goal) {
+    for (const key of BLOCKER_FIELD_KEYS)
+        Reflect.deleteProperty(goal, key);
+}

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

@@ -0,0 +1,8 @@
+export declare function invalid(message: string, field: string): never;
+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;
+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;