oh-my-opencode 4.18.2 → 4.19.1

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

@@ -1,3 +1,4 @@
+// biome-ignore-all format: long agent-facing instruction strings are intentionally stable.
 import { codexGoalMode, expectedCodexObjective, isEssentialCriterion, isFinalRunCompletionCandidate, } from "./goal-status.js";
 export function buildCodexGoalInstruction(args) {
     const mode = codexGoalMode(args.plan);

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

@@ -12,5 +12,5 @@ export declare const ULW_LOOP_SUCCESS_CRITERION_USER_MODELS: readonly ["happy",
 export type UlwLoopSuccessCriterionUserModel = (typeof ULW_LOOP_SUCCESS_CRITERION_USER_MODELS)[number];
 export declare const ULW_LOOP_CRITERION_STATUSES: readonly ["pending", "pass", "fail", "blocked"];
 export type UlwLoopCriterionStatus = (typeof ULW_LOOP_CRITERION_STATUSES)[number];
-export declare const ULW_LOOP_LEDGER_EVENT_KINDS: readonly ["plan_created", "goal_started", "goal_resumed", "goal_completed", "goal_blocked", "goal_failed", "goal_needs_user_decision", "goal_retried", "aggregate_completed", "aggregate_objective_migrated", "goal_added", "steering_accepted", "steering_rejected", "final_review_failed", "goal_review_blocked", "evidence_captured", "criterion_failed", "criterion_blocked", "criteria_revised"];
+export declare const ULW_LOOP_LEDGER_EVENT_KINDS: readonly ["plan_created", "goal_started", "goal_resumed", "goal_completed", "goal_blocked", "goal_failed", "goal_needs_user_decision", "goal_retried", "aggregate_completed", "aggregate_objective_migrated", "goal_added", "steering_accepted", "steering_rejected", "final_review_failed", "goal_review_blocked", "evidence_captured", "criterion_failed", "criterion_blocked", "criteria_revised", "batch_closed", "batch_updated"];
 export type UlwLoopLedgerEventKind = (typeof ULW_LOOP_LEDGER_EVENT_KINDS)[number];

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

@@ -38,4 +38,6 @@ export const ULW_LOOP_LEDGER_EVENT_KINDS = [
     "criterion_failed",
     "criterion_blocked",
     "criteria_revised",
+    "batch_closed",
+    "batch_updated",
 ];

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

@@ -43,6 +43,11 @@ export interface UlwLoopAggregateCompletion {
     evidence: string;
     codexGoal?: unknown;
 }
+export interface UlwLoopValidationBatch {
+    readonly batchId: string;
+    readonly memberIds: readonly string[];
+    readonly finalGoalId: string;
+}
 export interface UlwLoopPlan {
     version: 1;
     evidenceLayoutVersion?: 2;
@@ -56,6 +61,7 @@ export interface UlwLoopPlan {
     codexObjectiveAliases?: string[];
     aggregateCompletion?: UlwLoopAggregateCompletion;
     activeGoalId?: string;
+    validationBatches?: readonly UlwLoopValidationBatch[];
     goals: UlwLoopItem[];
 }
 export type UlwLoopManualQaSurface = "cli" | "http" | "tmux" | "browser" | "gui" | "data";

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

@@ -3,6 +3,7 @@ import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCrit
 export declare const ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE: string;
 export declare function aggregateCodexObjectiveForScope(scope?: UlwLoopScope): string;
 export declare function codexGoalMode(plan: UlwLoopPlan): UlwLoopCodexGoalMode;
+export declare function isMemberResolved(goal: UlwLoopItem, plan: UlwLoopPlan): boolean;
 export declare function isUlwLoopDone(plan: UlwLoopPlan): boolean;
 export declare function isFinalRunCompletionCandidate(plan: UlwLoopPlan, goal: UlwLoopItem): boolean;
 export declare function aggregateCodexObjective(plan: UlwLoopPlan): string;

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

@@ -9,6 +9,9 @@ export function codexGoalMode(plan) {
 function isResolvedStatus(status) {
     return status === "complete";
 }
+export function isMemberResolved(goal, plan) {
+    return isResolvedStatus(goal.status) || isSupersededResolved(goal, plan);
+}
 function isSupersededResolved(goal, plan) {
     if (goal.steeringStatus !== "superseded")
         return false;

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

@@ -23,6 +23,7 @@ export declare function createUlwLoopPlan(repoRoot: string, args: {
     brief: string;
     codexGoalMode?: UlwLoopCodexGoalMode;
     force?: boolean;
+    validationBatchesJson?: string;
 }, scope?: UlwLoopScope): Promise<UlwLoopPlan>;
 export declare function addUlwLoopGoal(repoRoot: string, args: {
     title: string;

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

@@ -5,6 +5,7 @@ import { ulwLoopBriefPath, ulwLoopBriefRelativePath, ulwLoopDir, ulwLoopGoalsPat
 import { appendGoalToPlan, deriveGoalCandidates, makeGoal } from "./plan-goal-factory.js";
 import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
 import { iso, UlwLoopError } from "./types.js";
+import { parseValidationBatches } from "./validation-batch.js";
 export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
 function isScheduleEligible(goal) {
     return goal.steeringStatus !== "superseded" && goal.steeringStatus !== "blocked";
@@ -42,6 +43,9 @@ export async function createUlwLoopPlan(repoRoot, args, scope) {
             codexGoalMode: args.codexGoalMode ?? "aggregate",
             goals,
         };
+        const validationBatches = await parseValidationBatches(args.validationBatchesJson, goals);
+        if (validationBatches !== undefined)
+            plan.validationBatches = validationBatches;
         if (plan.codexGoalMode === "aggregate")
             plan.codexObjective = aggregateCodexObjectiveForScope(scope);
         await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });

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

@@ -5,6 +5,7 @@ export declare function withUlwLoopMutationLock<T>(repoRoot: string, scope: UlwL
 export declare function readUlwLoopPlan(repoRoot: string, scope?: UlwLoopScope): Promise<UlwLoopPlan>;
 export declare function writePlan(repoRoot: string, plan: UlwLoopPlan, scope?: UlwLoopScope): Promise<void>;
 export declare function appendLedger(repoRoot: string, entry: UlwLoopLedgerEntry, scope?: UlwLoopScope): Promise<void>;
+export declare function appendLedgerEntries(repoRoot: string, entries: readonly UlwLoopLedgerEntry[], scope?: UlwLoopScope): Promise<void>;
 export declare function readSteeringLedgerEntries(repoRoot: string, scope?: UlwLoopScope): Promise<UlwLoopLedgerEntry[]>;
 /**
  * First accepted steering entry matching an idempotency key/prompt signature.

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

@@ -14,7 +14,10 @@ function isLegacyEnumeratedAggregateObjective(objective) {
     return objective === LEGACY_OBJECTIVE || Boolean(objective?.startsWith(LEGACY_OBJECTIVE_PREFIX));
 }
 function isSteeringKind(value) {
-    return value === "steering_accepted" || value === "steering_rejected" || value === "criteria_revised";
+    return (value === "steering_accepted" ||
+        value === "steering_rejected" ||
+        value === "criteria_revised" ||
+        value === "batch_updated");
 }
 export async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn) {
     const scope = typeof scopeOrFn === "function" ? undefined : scopeOrFn;
@@ -76,8 +79,13 @@ export async function writePlan(repoRoot, plan, scope) {
     await rename(tmpPath, path);
 }
 export async function appendLedger(repoRoot, entry, scope) {
+    await appendLedgerEntries(repoRoot, [entry], scope);
+}
+export async function appendLedgerEntries(repoRoot, entries, scope) {
+    if (entries.length === 0)
+        return;
     await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
-    await appendFile(ulwLoopLedgerPath(repoRoot, scope), `${JSON.stringify(entry)}\n`, "utf8");
+    await appendFile(ulwLoopLedgerPath(repoRoot, scope), `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
 }
 /**
  * Streams raw ledger lines without materializing the file. Real ledgers reach

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

@@ -1,4 +1,4 @@
-import { literal, invalid, textField } from "./quality-gate-fields.js";
+import { invalid, literal, textField } from "./quality-gate-fields.js";
 export function passedVerdict(value, field) {
     if (value === "not_applicable")
         invalid(`${field} must not be not_applicable.`, field);

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

@@ -0,0 +1,15 @@
+import type { UlwLoopScope } from "./paths.js";
+import type { UlwLoopPlan, UlwLoopSteeringAudit, UlwLoopSteeringProposal } from "./types.js";
+export interface SteerUlwLoopBatchItemResult {
+    readonly accepted: boolean;
+    readonly deduped: boolean;
+    readonly audit: UlwLoopSteeringAudit;
+    readonly rejectedReasons: readonly string[];
+}
+export interface SteerUlwLoopBatchResult {
+    readonly plan: UlwLoopPlan;
+    readonly accepted: boolean;
+    readonly results: readonly SteerUlwLoopBatchItemResult[];
+    readonly rejectedReasons: readonly string[];
+}
+export declare function steerUlwLoopBatch(repoRoot: string, proposals: readonly UlwLoopSteeringProposal[], scope?: UlwLoopScope): Promise<SteerUlwLoopBatchResult>;

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

@@ -0,0 +1,84 @@
+import { appendLedger, appendLedgerEntries, findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { applySteeringMutation, validateUlwLoopSteeringProposal } from "./steering.js";
+import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "./steering-snapshot.js";
+import { iso } from "./types.js";
+import { batchUpdateLedgerEntry } from "./validation-batch.js";
+export async function steerUlwLoopBatch(repoRoot, proposals, scope) {
+    return withUlwLoopMutationLock(repoRoot, scope, async () => {
+        const plan = await readUlwLoopPlan(repoRoot, scope);
+        const prepared = await prepareBatch(repoRoot, plan, proposals, scope);
+        const failed = prepared.results.find((item) => !item.accepted);
+        if (failed !== undefined) {
+            const entry = rejectedLedgerEntry(prepared.results);
+            await appendLedger(repoRoot, entry, scope);
+            return rejected(plan, prepared.results, failed.rejectedReasons);
+        }
+        let next = plan;
+        for (const item of prepared.items)
+            if (item.kind === "fresh")
+                next = item.prepared.next;
+        const fresh = prepared.items.filter((item) => item.kind === "fresh");
+        if (fresh.length > 0) {
+            await writePlan(repoRoot, next, scope);
+            const entries = fresh.map((item) => ledgerEntry(item.prepared.proposal, item.prepared.audit, item.prepared.proposal.now?.toISOString() ?? iso()));
+            const batchEntry = batchUpdateLedgerEntry(plan, next, iso());
+            await appendLedgerEntries(repoRoot, batchEntry === null ? entries : [...entries, batchEntry], scope);
+        }
+        return { plan: next, accepted: true, results: prepared.results, rejectedReasons: [] };
+    });
+}
+async function prepareBatch(repoRoot, plan, proposals, scope) {
+    const items = [];
+    const results = [];
+    let current = plan;
+    for (const proposal of proposals) {
+        const key = proposal.idempotencyKey ?? proposal.promptSignature;
+        const prior = key === undefined ? undefined : await findAcceptedSteeringLedgerEntry(repoRoot, key, scope);
+        if (prior?.steering !== undefined) {
+            const result = { accepted: true, deduped: true, audit: { ...prior.steering, deduped: true }, rejectedReasons: [] };
+            items.push({ kind: "deduped", result });
+            results.push(result);
+            continue;
+        }
+        const audit = validateUlwLoopSteeringProposal(current, proposal);
+        if (!audit.invariant.accepted) {
+            const result = { accepted: false, deduped: false, audit, rejectedReasons: audit.invariant.rejectedReasons };
+            items.push({ kind: "deduped", result });
+            results.push(result);
+            continue;
+        }
+        const next = applySteeringMutation(current, proposal, audit);
+        const changed = changedGoalIdsBetween(current, next);
+        const finalAudit = { ...audit, before: buildSteeringPlanSnapshot(current, changed), after: buildSteeringPlanSnapshot(next, changed) };
+        const result = { accepted: true, deduped: false, audit: finalAudit, rejectedReasons: [] };
+        items.push({ kind: "fresh", prepared: { proposal, audit: finalAudit, before: current, next } });
+        results.push(result);
+        current = next;
+    }
+    return { items, results };
+}
+function rejected(plan, results, rejectedReasons) {
+    return { plan, accepted: false, results, rejectedReasons };
+}
+function rejectedLedgerEntry(results) {
+    const rejectedItems = results.map((result, index) => ({ result, index })).filter((item) => !item.result.accepted);
+    return { at: iso(), kind: "steering_rejected", message: rejectedItems.map((item) => `index ${item.index}: ${item.result.rejectedReasons.join(", ")}`).join("; ") };
+}
+function ledgerEntry(proposal, audit, at) {
+    const entry = {
+        at,
+        kind: proposal.kind === "revise_criterion" ? "criteria_revised" : "steering_accepted",
+        evidence: proposal.evidence,
+        message: proposal.rationale,
+        steering: audit,
+        mutationKind: proposal.kind,
+    };
+    const goalId = audit.targetGoalIds[0];
+    if (goalId !== undefined)
+        entry.goalId = goalId;
+    if (proposal.criterionId !== undefined)
+        entry.criterionId = proposal.criterionId;
+    if (proposal.idempotencyKey !== undefined)
+        entry.idempotencyKey = proposal.idempotencyKey;
+    return entry;
+}

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

@@ -0,0 +1,5 @@
+import type { UlwLoopItem, UlwLoopPlan, UlwLoopSteeringChildGoal, UlwLoopSteeringProposal } from "./types.js";
+export declare function makeGoal(plan: UlwLoopPlan, childGoal: UlwLoopSteeringChildGoal, evidence: string, now: string, offset: number): UlwLoopItem;
+export declare function reviseWording(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void;
+export declare function splitOrBlock(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void;
+export declare function reviseCriterion(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void;

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

@@ -0,0 +1,81 @@
+// biome-ignore-all format: compact extracted steering mutations stay below the pure LOC budget.
+import { seedDefaultSuccessCriteria } from "./plan-crud.js";
+import { ULW_LOOP_SUCCESS_CRITERION_USER_MODELS } from "./types.js";
+import { updateBatchesAfterSupersede } from "./validation-batch.js";
+const read = (value, key) => Object.entries(value).find(([name]) => name === key)?.[1];
+const isText = (value) => typeof value === "string" && value.trim().length > 0;
+const text = (value, key) => { const candidate = read(value, key); return isText(candidate) ? candidate.trim() : undefined; };
+const isModel = (value) => typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
+const after = (proposal) => { const candidate = read(proposal, "after"); return typeof candidate === "object" && candidate !== null && !Array.isArray(candidate) ? candidate : undefined; };
+const revised = (proposal, direct, nested) => text(proposal, direct) ?? text(after(proposal) ?? proposal, nested);
+const targets = (proposal) => proposal.targetGoalIds ?? [proposal.targetGoalId ?? text(proposal, "goalId") ?? ""].filter(Boolean);
+const child = (value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const title = text(value, "title");
+    const objective = text(value, "objective");
+    return title === undefined || objective === undefined ? null : { title, objective };
+};
+const children = (proposal) => {
+    const direct = proposal.childGoals;
+    if (direct !== undefined && direct.length > 0)
+        return direct;
+    const nested = after(proposal);
+    const fromAfter = nested === undefined ? undefined : read(nested, "children");
+    return Array.isArray(fromAfter) ? fromAfter.map(child).filter((item) => item !== null) : [];
+};
+const goal = (plan, id) => id === undefined ? undefined : plan.goals.find((item) => item.id === id);
+function nextId(plan, offset) {
+    const max = plan.goals.reduce((current, item) => { const digits = /^G(\d+)(?:-|$)/u.exec(item.id)?.[1]; return digits === undefined ? current : Math.max(current, Number(digits)); }, 0);
+    return `G${String(max + offset).padStart(3, "0")}`;
+}
+export function makeGoal(plan, childGoal, evidence, now, offset) {
+    const id = nextId(plan, offset);
+    const digits = /^G(\d+)/u.exec(id)?.[1];
+    const goalIndex = digits === undefined ? plan.goals.length + offset - 1 : Number(digits) - 1;
+    return { id, title: childGoal.title, objective: childGoal.objective, status: "pending", successCriteria: seedDefaultSuccessCriteria(goalIndex, childGoal.objective), attempt: 0, createdAt: now, updatedAt: now, evidence };
+}
+export function reviseWording(plan, proposal, now) {
+    const target = goal(plan, targets(proposal)[0]);
+    if (target === undefined)
+        return;
+    target.title = revised(proposal, "revisedTitle", "title") ?? target.title;
+    target.objective = revised(proposal, "revisedObjective", "objective") ?? target.objective;
+    target.steeringEvidence = proposal.evidence;
+    target.steeringRationale = proposal.rationale;
+    target.updatedAt = now;
+}
+export function splitOrBlock(plan, proposal, now) {
+    const target = goal(plan, targets(proposal)[0]);
+    if (target === undefined)
+        return;
+    const replacements = children(proposal).map((item, index) => makeGoal(plan, item, proposal.evidence, now, index + 1));
+    target.steeringEvidence = proposal.evidence;
+    target.steeringRationale = proposal.rationale;
+    target.updatedAt = now;
+    if (replacements.length === 0) {
+        target.status = "blocked";
+        target.steeringStatus = "blocked";
+        target.blockedReason = proposal.blockedReason ?? proposal.rationale;
+    }
+    else {
+        target.steeringStatus = "superseded";
+        target.supersededBy = replacements.map((item) => item.id);
+        for (const item of replacements)
+            item.supersedes = [target.id];
+        plan.goals.splice(plan.goals.indexOf(target) + 1, 0, ...replacements);
+        updateBatchesAfterSupersede(plan, target.id, replacements.map((item) => item.id));
+    }
+    if (plan.activeGoalId === target.id)
+        delete plan.activeGoalId;
+}
+export function reviseCriterion(plan, proposal, now) {
+    const target = goal(plan, targets(proposal)[0]);
+    const index = target?.successCriteria.findIndex((item) => item.id === proposal.criterionId) ?? -1;
+    const current = target?.successCriteria[index];
+    if (target === undefined || current === undefined)
+        return;
+    const model = read(proposal, "userModel");
+    target.successCriteria[index] = { ...current, scenario: text(proposal, "scenario") ?? current.scenario, expectedEvidence: text(proposal, "expectedEvidence") ?? current.expectedEvidence, userModel: isModel(model) ? model : current.userModel };
+    target.updatedAt = now;
+}

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

@@ -1,9 +1,10 @@
 // biome-ignore-all format: compact steering module must stay below the 240 pure-LOC budget
 import { isUlwLoopDone } from "./goal-status.js";
-import { seedDefaultSuccessCriteria } from "./plan-crud.js";
 import { appendLedger, findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { makeGoal, reviseCriterion, reviseWording, splitOrBlock } from "./steering-mutations.js";
 import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "./steering-snapshot.js";
 import { iso, ULW_LOOP_STEERING_MUTATION_KINDS, ULW_LOOP_SUCCESS_CRITERION_USER_MODELS } from "./types.js";
+import { batchUpdateLedgerEntry } from "./validation-batch.js";
 const SOURCES = ["user_prompt_submit", "finding", "cli"];
 const PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
 const isObject = (value) => typeof value === "object" && value !== null;
@@ -48,7 +49,6 @@ function childValues(proposal) {
     const fromAfter = nested === undefined ? undefined : read(nested, "children");
     return Array.isArray(fromAfter) ? fromAfter : [];
 }
-const children = (proposal) => childValues(proposal).map(child).filter((item) => item !== null);
 const pendingOrder = (proposal) => {
     const direct = texts(proposal, "pendingOrder");
     return direct.length > 0 ? direct : texts(after(proposal) ?? proposal, "pendingGoalIds");
@@ -163,19 +163,6 @@ function validateCriterion(plan, proposal, reasons) {
     if (model !== undefined && !isModel(model))
         reasons.push("invalid userModel");
 }
-function nextId(plan, offset) {
-    const max = plan.goals.reduce((current, item) => {
-        const digits = /^G(\d+)(?:-|$)/u.exec(item.id)?.[1];
-        return digits === undefined ? current : Math.max(current, Number(digits));
-    }, 0);
-    return `G${String(max + offset).padStart(3, "0")}`;
-}
-function makeGoal(plan, childGoal, evidence, now, offset) {
-    const id = nextId(plan, offset);
-    const digits = /^G(\d+)/u.exec(id)?.[1];
-    const goalIndex = digits === undefined ? plan.goals.length + offset - 1 : Number(digits) - 1;
-    return { id, title: childGoal.title, objective: childGoal.objective, status: "pending", successCriteria: seedDefaultSuccessCriteria(goalIndex, childGoal.objective), attempt: 0, createdAt: now, updatedAt: now, evidence };
-}
 export function applySteeringMutation(plan, proposal, audit) {
     const next = structuredClone(plan);
     if (!audit.invariant.accepted)
@@ -197,49 +184,6 @@ export function applySteeringMutation(plan, proposal, audit) {
         next.updatedAt = now;
     return next;
 }
-function reviseWording(plan, proposal, now) {
-    const target = goal(plan, targets(proposal)[0]);
-    if (target === undefined)
-        return;
-    target.title = revised(proposal, "revisedTitle", "title") ?? target.title;
-    target.objective = revised(proposal, "revisedObjective", "objective") ?? target.objective;
-    target.steeringEvidence = proposal.evidence;
-    target.steeringRationale = proposal.rationale;
-    target.updatedAt = now;
-}
-function splitOrBlock(plan, proposal, now) {
-    const target = goal(plan, targets(proposal)[0]);
-    if (target === undefined)
-        return;
-    const replacements = children(proposal).map((item, index) => makeGoal(plan, item, proposal.evidence, now, index + 1));
-    target.steeringEvidence = proposal.evidence;
-    target.steeringRationale = proposal.rationale;
-    target.updatedAt = now;
-    if (replacements.length === 0) {
-        target.status = "blocked";
-        target.steeringStatus = "blocked";
-        target.blockedReason = proposal.blockedReason ?? proposal.rationale;
-    }
-    else {
-        target.steeringStatus = "superseded";
-        target.supersededBy = replacements.map((item) => item.id);
-        for (const item of replacements)
-            item.supersedes = [target.id];
-        plan.goals.splice(plan.goals.indexOf(target) + 1, 0, ...replacements);
-    }
-    if (plan.activeGoalId === target.id)
-        delete plan.activeGoalId;
-}
-function reviseCriterion(plan, proposal, now) {
-    const target = goal(plan, targets(proposal)[0]);
-    const index = target?.successCriteria.findIndex((item) => item.id === proposal.criterionId) ?? -1;
-    const current = target?.successCriteria[index];
-    if (target === undefined || current === undefined)
-        return;
-    const model = read(proposal, "userModel");
-    target.successCriteria[index] = { ...current, scenario: text(proposal, "scenario") ?? current.scenario, expectedEvidence: text(proposal, "expectedEvidence") ?? current.expectedEvidence, userModel: isModel(model) ? model : current.userModel };
-    target.updatedAt = now;
-}
 function isProposal(value) {
     return isPlain(value) && isKind(read(value, "kind")) && isSource(read(value, "source")) && isText(read(value, "evidence")) && isText(read(value, "rationale"));
 }
@@ -277,9 +221,13 @@ export async function steerUlwLoop(repoRoot, proposal, scope) {
             finalAudit.before = buildSteeringPlanSnapshot(plan, changed);
             finalAudit.after = buildSteeringPlanSnapshot(next, changed);
         }
+        const at = proposal.now?.toISOString() ?? iso();
+        const batchEntry = accepted ? batchUpdateLedgerEntry(plan, next, at) : null;
         if (accepted)
             await writePlan(repoRoot, next, scope);
-        await appendLedger(repoRoot, ledgerEntry(proposal, finalAudit, proposal.now?.toISOString() ?? iso()), scope);
+        await appendLedger(repoRoot, ledgerEntry(proposal, finalAudit, at), scope);
+        if (batchEntry !== null)
+            await appendLedger(repoRoot, batchEntry, scope);
         return { plan: next, accepted, audit: finalAudit, rejectedReasons: audit.invariant.rejectedReasons, deduped: false };
     });
 }

package/packages/omo-codex/plugin/components/ulw-loop/dist/stop-resume-hook.js

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { isAbsolute, join } from "node:path";
+import { isAbsolute, join, resolve, sep } from "node:path";
 import { normalizeUlwLoopSessionId, ulwLoopDir } from "./paths.js";
 // Turn-death recovery only: Codex emits Stop when a turn ends, so a run that
 // dies mid-turn (crash, kill, context blowup before any Stop) never reaches
@@ -67,16 +67,24 @@ function isResumableStatus(status) {
 // a separate file — a ledger append would change the count and self-reset.
 function consumeResumeBudget(stateDir, goalId) {
     const ledgerLineCount = countLedgerLines(join(stateDir, "ledger.jsonl"));
-    const counterPath = join(stateDir, `auto-resume-${goalId}.json`);
+    const counterPath = resolve(stateDir, `auto-resume-${goalId}.json`);
+    const stuckPath = resolve(stateDir, `auto-resume-${goalId}.stuck`);
+    // goals.json is untrusted input: a crafted goal id (e.g. `../../x`) must
+    // never drive a write outside the session state dir. Deny the resume.
+    if (!isInsideDir(stateDir, counterPath) || !isInsideDir(stateDir, stuckPath))
+        return false;
     const previous = readCounter(counterPath);
     const count = previous !== null && previous.ledgerLineCount === ledgerLineCount ? previous.count : 0;
     if (count >= RESUME_CAP) {
-        writeFileSync(join(stateDir, `auto-resume-${goalId}.stuck`), `no ledger progress after ${count} resumes\n`);
+        writeFileSync(stuckPath, `no ledger progress after ${count} resumes\n`);
         return false;
     }
     writeFileSync(counterPath, JSON.stringify({ count: count + 1, ledgerLineCount }));
     return true;
 }
+function isInsideDir(dir, candidate) {
+    return candidate.startsWith(resolve(dir) + sep);
+}
 function renderResumeDirective(plan, goal, sessionId) {
     const normalized = normalizeUlwLoopSessionId(sessionId);
     const option = normalized !== null && plan.goalsPath.includes(`/${normalized}/`) ? ` --session-id ${normalized}` : "";
@@ -85,7 +93,7 @@ function renderResumeDirective(plan, goal, sessionId) {
         "The turn ended before the loop completed. Resume it now:",
         `1. Run \`omo ulw-loop status${option} --json\` to reload the plan, the active goal, and currentAttemptDir.`,
         "2. Continue the active goal's remaining success criteria, recording evidence with record-evidence.",
-        `3. Checkpoint through \`omo ulw-loop checkpoint${option}\` when the goal's criteria are proven.`,
+        `3. Checkpoint through \`omo ulw-loop checkpoint${option}\` when the goal's criteria are proven; a complete checkpoint prints the next goal instruction.`,
         "If the loop is genuinely blocked on the user, checkpoint the goal as blocked with the reason instead.",
     ].join("\n");
 }

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

@@ -0,0 +1,9 @@
+import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan, UlwLoopQualityGate, UlwLoopValidationBatch } from "./types.js";
+export declare function parseValidationBatches(input: string | undefined, goals: readonly UlwLoopItem[]): Promise<readonly UlwLoopValidationBatch[] | undefined>;
+export declare function updateBatchesAfterSupersede(plan: UlwLoopPlan, targetId: string, replacementIds: readonly string[]): void;
+export declare function batchUpdateLedgerEntry(before: UlwLoopPlan, after: UlwLoopPlan, at: string): UlwLoopLedgerEntry | null;
+export declare function batchOf(plan: UlwLoopPlan, goalId: string): UlwLoopValidationBatch | undefined;
+export declare function batchClosedBy(plan: UlwLoopPlan, goalId: string): UlwLoopValidationBatch | undefined;
+export declare function requireBatchFinalReady(plan: UlwLoopPlan, goal: UlwLoopItem): void;
+export declare function requireAllValidationBatchesClosed(plan: UlwLoopPlan, closingGoalId?: string): void;
+export declare function requireBatchGate(plan: UlwLoopPlan, goal: UlwLoopItem, gate: UlwLoopQualityGate): void;

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

@@ -0,0 +1,122 @@
+// biome-ignore-all format: compact validation-batch helpers stay below the pure LOC budget.
+import { readJsonInput } from "./cli-arg-parser.js";
+import { isMemberResolved } from "./goal-status.js";
+import { UlwLoopError } from "./types.js";
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function read(value, key) {
+    return Object.entries(value).find(([name]) => name === key)?.[1];
+}
+function text(value, key) {
+    const candidate = read(value, key);
+    return typeof candidate === "string" && candidate.trim().length > 0 ? candidate.trim() : undefined;
+}
+function strings(value, key) {
+    const candidate = read(value, key);
+    return Array.isArray(candidate) && candidate.every((item) => typeof item === "string" && item.trim().length > 0)
+        ? candidate.map((item) => item.trim())
+        : undefined;
+}
+export async function parseValidationBatches(input, goals) {
+    const raw = await readJsonInput(input);
+    if (raw === undefined)
+        return undefined;
+    if (!Array.isArray(raw))
+        fail("--validation-batch-json must be a JSON array.");
+    const batches = raw.map(batchFromObject);
+    validateBatches(batches, goals);
+    return batches;
+}
+function batchFromObject(value) {
+    if (!isObject(value))
+        fail("validation batch entries must be objects.");
+    const batchId = text(value, "batchId");
+    const memberIds = strings(value, "memberIds");
+    const finalGoalId = text(value, "finalGoalId");
+    if (batchId === undefined)
+        fail("validation batch requires batchId.");
+    if (memberIds === undefined || memberIds.length < 2)
+        fail("validation batch requires at least two memberIds.");
+    if (finalGoalId === undefined)
+        fail("validation batch requires finalGoalId.");
+    return { batchId, memberIds, finalGoalId };
+}
+function validateBatches(batches, goals) {
+    const goalIds = new Set(goals.map((goal) => goal.id));
+    const batchIds = new Set();
+    const members = new Set();
+    for (const batch of batches) {
+        if (batchIds.has(batch.batchId))
+            fail(`duplicate validation batch id: ${batch.batchId}.`);
+        batchIds.add(batch.batchId);
+        if (new Set(batch.memberIds).size !== batch.memberIds.length)
+            fail(`validation batch ${batch.batchId} has duplicate memberIds.`);
+        if (!batch.memberIds.includes(batch.finalGoalId))
+            fail(`validation batch ${batch.batchId} finalGoalId must be a member.`, "ULW_LOOP_VALIDATION_BATCH_FINAL_NOT_MEMBER");
+        for (const memberId of batch.memberIds) {
+            if (!goalIds.has(memberId))
+                fail(`validation batch ${batch.batchId} references unknown goal: ${memberId}.`, "ULW_LOOP_VALIDATION_BATCH_MEMBER_UNKNOWN");
+            if (members.has(memberId))
+                fail(`goal appears in multiple validation batches: ${memberId}.`, "ULW_LOOP_VALIDATION_BATCH_OVERLAP");
+            members.add(memberId);
+        }
+    }
+}
+export function updateBatchesAfterSupersede(plan, targetId, replacementIds) {
+    if (replacementIds.length === 0 || plan.validationBatches === undefined)
+        return;
+    plan.validationBatches = plan.validationBatches.map((batch) => {
+        if (!batch.memberIds.includes(targetId))
+            return batch;
+        const memberIds = batch.memberIds.flatMap((id) => (id === targetId ? [...replacementIds] : [id]));
+        const replacementFinalGoalId = replacementIds[replacementIds.length - 1] ?? batch.finalGoalId;
+        const finalGoalId = batch.finalGoalId === targetId ? replacementFinalGoalId : batch.finalGoalId;
+        return { batchId: batch.batchId, memberIds, finalGoalId };
+    });
+}
+export function batchUpdateLedgerEntry(before, after, at) {
+    if (JSON.stringify(before.validationBatches ?? []) === JSON.stringify(after.validationBatches ?? []))
+        return null;
+    return { at, kind: "batch_updated", before: before.validationBatches ?? [], after: after.validationBatches ?? [], message: "Validation batch membership updated after steering." };
+}
+export function batchOf(plan, goalId) {
+    return plan.validationBatches?.find((batch) => batch.memberIds.includes(goalId));
+}
+export function batchClosedBy(plan, goalId) {
+    const batch = batchOf(plan, goalId);
+    return batch?.finalGoalId === goalId ? batch : undefined;
+}
+export function requireBatchFinalReady(plan, goal) {
+    const batch = batchClosedBy(plan, goal.id);
+    if (batch === undefined)
+        return;
+    const open = batch.memberIds.filter((id) => id !== goal.id && !memberResolved(plan, id));
+    if (open.length > 0)
+        throw new UlwLoopError("Validation batch has unresolved members.", "ULW_LOOP_VALIDATION_BATCH_OPEN", { details: { batchId: batch.batchId, open } });
+}
+export function requireAllValidationBatchesClosed(plan, closingGoalId) {
+    const open = (plan.validationBatches ?? []).filter((batch) => batch.memberIds.some((id) => id !== closingGoalId && !memberResolved(plan, id)));
+    if (open.length > 0)
+        throw new UlwLoopError("Validation batches remain open.", "ULW_LOOP_VALIDATION_BATCH_OPEN", { details: { batchIds: open.map((batch) => batch.batchId) } });
+}
+export function requireBatchGate(plan, goal, gate) {
+    const batch = batchClosedBy(plan, goal.id);
+    if (batch === undefined)
+        return;
+    const members = batch.memberIds.map((id) => plan.goals.find((item) => item.id === id)).filter((item) => item !== undefined);
+    const pending = members.flatMap((member) => member.successCriteria.filter((criterion) => criterion.status !== "pass").map((criterion) => `${member.id}:${criterion.id}`));
+    if (pending.length > 0)
+        throw new UlwLoopError("Validation batch criteria remain pending.", "ULW_LOOP_VALIDATION_BATCH_CRITERIA_PENDING", { details: { batchId: batch.batchId, pending } });
+    const totalCriteria = members.reduce((sum, member) => sum + member.successCriteria.length, 0);
+    const passCount = members.reduce((sum, member) => sum + member.successCriteria.filter((criterion) => criterion.status === "pass").length, 0);
+    if (gate.criteriaCoverage.totalCriteria !== totalCriteria || gate.criteriaCoverage.passCount !== passCount)
+        throw new UlwLoopError("Validation batch gate coverage does not match member criteria.", "ULW_LOOP_VALIDATION_BATCH_GATE_MISMATCH", { details: { batchId: batch.batchId, expected: { totalCriteria, passCount }, actual: gate.criteriaCoverage } });
+}
+function memberResolved(plan, goalId) {
+    const goal = plan.goals.find((candidate) => candidate.id === goalId);
+    return goal !== undefined && isMemberResolved(goal, plan);
+}
+function fail(message, code = "ULW_LOOP_VALIDATION_BATCH_INVALID") {
+    throw new UlwLoopError(message, code);
+}

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

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