lazycodex-ai 5.0.0-beta.7 → 5.0.0-beta.71

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

@@ -0,0 +1,259 @@
+import { randomUUID } from "node:crypto";
+import { closeSync, ftruncateSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+import { UlwLoopError } from "./types.js";
+// O_EXCL establishes ownership. Async holders keep the fd open and refresh a
+// lease through that fd, never through the pathname: a reclaimed inode is invisible.
+// Sync/legacy holders are lease-less and only dead pids retire their records.
+// Expiry permits overlapping bodies; immutable revision publication fences them.
+// Reclaim's reread/unlink is not atomic. On Windows an open inode may not unlink:
+// treat that refusal as a live owner and fail closed. Release checks its token.
+export const ULW_LOOP_LOCK_TIMEOUT_CODE = "ULW_LOOP_LOCK_TIMEOUT";
+const DEFAULT_TIMEOUT_MS = 10_000;
+const DEFAULT_STALE_MS = 60_000;
+const DEFAULT_LEASE_MS = 30_000;
+const SLEEP_CELL = new Int32Array(new SharedArrayBuffer(4));
+const systemClock = {
+    now: Date.now,
+    schedule(fn, ms) {
+        const timer = setTimeout(fn, ms);
+        return {
+            unref: () => {
+                timer.unref();
+            },
+            cancel: () => clearTimeout(timer),
+        };
+    },
+};
+export async function withStateLock(lockPath, fn, options = {}) {
+    const holder = await acquireAsync(lockPath, options);
+    const clock = options.clock ?? systemClock;
+    let timer;
+    let heartbeatError;
+    const beat = () => {
+        try {
+            holder.record.leaseUntil = clock.now() + (options.leaseMs ?? DEFAULT_LEASE_MS);
+            writeRecord(holder);
+            schedule();
+        }
+        catch (error) {
+            heartbeatError = error;
+        }
+    };
+    const schedule = () => {
+        if (options.heartbeatMs === 0)
+            return;
+        timer = clock.schedule(beat, options.heartbeatMs ?? (options.leaseMs ?? DEFAULT_LEASE_MS) / 3);
+        timer.unref();
+    };
+    schedule();
+    try {
+        const result = await fn(holder.record.token);
+        if (heartbeatError !== undefined)
+            throw heartbeatError;
+        return result;
+    }
+    finally {
+        timer?.cancel();
+        closeSync(holder.fd);
+        release(lockPath, holder.record.token);
+    }
+}
+export function withStateLockSync(lockPath, fn, options = {}) {
+    const holder = acquireSync(lockPath, options);
+    try {
+        return fn();
+    }
+    finally {
+        closeSync(holder.fd);
+        release(lockPath, holder.record.token);
+    }
+}
+export function isStateLockTimeout(error) {
+    return error instanceof UlwLoopError && error.code === ULW_LOOP_LOCK_TIMEOUT_CODE;
+}
+async function acquireAsync(lockPath, options) {
+    const clock = options.clock ?? systemClock;
+    const deadline = clock.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    mkdirSync(dirname(lockPath), { recursive: true });
+    for (let attempt = 0;;) {
+        const outcome = attemptOnce(lockPath, options, clock.now(), options.leaseMs ?? DEFAULT_LEASE_MS);
+        if (outcome.kind === "acquired")
+            return outcome.holder;
+        if (outcome.kind === "retry")
+            continue;
+        if (clock.now() >= deadline)
+            throw lockTimeout(lockPath, options);
+        await new Promise((resolve) => clock.schedule(resolve, backoffMs(attempt)));
+        attempt += 1;
+    }
+}
+function acquireSync(lockPath, options) {
+    const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    mkdirSync(dirname(lockPath), { recursive: true });
+    for (let attempt = 0;;) {
+        const outcome = attemptOnce(lockPath, options, Date.now());
+        if (outcome.kind === "acquired")
+            return outcome.holder;
+        if (outcome.kind === "retry")
+            continue;
+        if (Date.now() >= deadline)
+            throw lockTimeout(lockPath, options);
+        Atomics.wait(SLEEP_CELL, 0, 0, backoffMs(attempt));
+        attempt += 1;
+    }
+}
+function attemptOnce(lockPath, options, now, leaseMs) {
+    try {
+        const holder = tryCreate(lockPath, now, leaseMs);
+        if (holder !== null)
+            return { kind: "acquired", holder };
+        const snapshot = readSnapshot(lockPath, now);
+        if (snapshot === null)
+            return { kind: "retry" };
+        const record = snapshot.record;
+        const stale = record === null
+            ? snapshot.ageMs > (options.staleMs ?? DEFAULT_STALE_MS)
+            : !isProcessAlive(record.pid) || (record.leaseUntil !== undefined && now > record.leaseUntil);
+        if (stale && reclaim(lockPath, snapshot.raw))
+            return { kind: "retry" };
+        return { kind: "wait" };
+    }
+    catch (error) {
+        if (hasCode(error, "EINTR"))
+            return { kind: "wait" };
+        throw error;
+    }
+}
+function writeRecord(holder) {
+    const buf = Buffer.from(JSON.stringify(holder.record));
+    ftruncateSync(holder.fd, 0);
+    let offset = 0;
+    while (offset < buf.length) {
+        const written = writeSync(holder.fd, buf, offset, buf.length - offset, offset);
+        if (written === 0)
+            throw new Error("State lock write made no progress.");
+        offset += written;
+    }
+}
+function tryCreate(lockPath, now, leaseMs) {
+    let fd;
+    try {
+        fd = openSync(lockPath, "wx");
+    }
+    catch (error) {
+        if (hasCode(error, "EEXIST"))
+            return null;
+        throw error;
+    }
+    const record = {
+        pid: process.pid,
+        createdAt: new Date(now).toISOString(),
+        token: randomUUID(),
+        ...(leaseMs === undefined ? {} : { leaseUntil: now + leaseMs }),
+    };
+    const holder = { fd, record };
+    try {
+        writeRecord(holder);
+    }
+    catch (error) {
+        closeSync(fd);
+        try {
+            unlinkSync(lockPath);
+        }
+        catch (cleanup) {
+            if (!hasCode(cleanup, "ENOENT"))
+                throw cleanup;
+        }
+        throw error;
+    }
+    return holder;
+}
+function readSnapshot(lockPath, now) {
+    try {
+        const raw = readFileSync(lockPath, "utf8");
+        return { raw, record: parseRecord(raw), ageMs: now - statSync(lockPath).mtimeMs };
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return null;
+        throw error;
+    }
+}
+function parseRecord(raw) {
+    try {
+        const record = JSON.parse(raw);
+        if (typeof record !== "object" || record === null)
+            return null;
+        if (!("pid" in record) || typeof record.pid !== "number" || !Number.isInteger(record.pid) || record.pid <= 0)
+            return null;
+        if (!("createdAt" in record) || typeof record.createdAt !== "string")
+            return null;
+        if (!("token" in record) || typeof record.token !== "string" || record.token.length === 0)
+            return null;
+        return {
+            pid: record.pid,
+            createdAt: record.createdAt,
+            token: record.token,
+            ...("leaseUntil" in record && typeof record.leaseUntil === "number" ? { leaseUntil: record.leaseUntil } : {}),
+        };
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return null;
+        throw error;
+    }
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (hasCode(error, "ESRCH"))
+            return false;
+        if (hasCode(error, "EPERM"))
+            return true;
+        throw error;
+    }
+}
+function reclaim(lockPath, expectedRaw) {
+    const current = readSnapshot(lockPath, Date.now());
+    if (current === null)
+        return true;
+    if (current.raw !== expectedRaw)
+        return false;
+    try {
+        unlinkSync(lockPath);
+    }
+    catch (error) {
+        if (hasCode(error, "EPERM") || hasCode(error, "EACCES"))
+            return false;
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+    return true;
+}
+function release(lockPath, token) {
+    if (readSnapshot(lockPath, Date.now())?.record?.token !== token)
+        return;
+    try {
+        unlinkSync(lockPath);
+    }
+    catch (error) {
+        if (!hasCode(error, "ENOENT"))
+            throw error;
+    }
+}
+function backoffMs(attempt) {
+    return Math.min(100, 5 * 2 ** attempt) + Math.random() * 5;
+}
+function lockTimeout(lockPath, options) {
+    const holder = readSnapshot(lockPath, Date.now())?.record;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const owner = holder == null ? "another process" : `pid ${holder.pid}`;
+    return new UlwLoopError(`ulw-loop state lock ${lockPath} is held by ${owner} for more than ${timeoutMs}ms. The lock owner is still alive. If a JS eval kernel was interrupted while writing, wait for its lease to expire (${options.leaseMs ?? DEFAULT_LEASE_MS} ms) or restart the owning senpi process; never delete a lock owned by a live process.`, ULW_LOOP_LOCK_TIMEOUT_CODE, { details: { lockPath, timeoutMs, ...(holder == null ? {} : { holderPid: holder.pid }) } });
+}
+function hasCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}

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

@@ -0,0 +1,7 @@
+import type { UlwLoopToolkitSurface } from "./surface.js";
+import type { UlwLoopPlan } from "./types.js";
+/**
+ * Status is the one call every agent already makes between steps, so it is
+ * also the cheapest place to answer "what now?" without a second round trip.
+ */
+export declare function statusNextActions(plan: UlwLoopPlan, surface?: UlwLoopToolkitSurface): readonly string[];

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

@@ -0,0 +1,41 @@
+import { hasAllCriteriaPass, isFinalRunCompletionCandidate } from "./goal-status.js";
+import { createGoalsAction } from "./plan-missing-recovery.js";
+/**
+ * Status is the one call every agent already makes between steps, so it is
+ * also the cheapest place to answer "what now?" without a second round trip.
+ */
+export function statusNextActions(plan, surface = "lazycodex") {
+    const actions = [];
+    const active = plan.goals.find((goal) => goal.id === plan.activeGoalId);
+    if (plan.goals.length === 0)
+        actions.push(`No goals yet: bootstrap with \`${createGoalsAction(surface)}\`.`);
+    else if (active !== undefined)
+        actions.push(...activeGoalActions(plan, active, surface));
+    for (const goal of plan.goals.filter((candidate) => candidate.status === "review_blocked"))
+        actions.push(surface === "omo-senpi"
+            ? `${goal.id} is review_blocked: capture the reviewer verdict with \`agentToolkit.recordReviewBlockers({ goalId: "${goal.id}", title: "<title>", objective: "<objective>", evidence: "<verdict>" })\`.`
+            : `${goal.id} is review_blocked: capture the reviewer verdict with \`omo-agent-toolkit ulw-loop record-review-blockers --goal-id ${goal.id} --title "<title>" --objective "<objective>" --evidence "<verdict>" --codex-goal-json '<get_goal json>'\`.`);
+    if (plan.evidenceLayoutVersion !== 2 || active === undefined)
+        actions.push("plan is evidence-layout v1; artifacts go under .omo/evidence/");
+    return actions;
+}
+function activeGoalActions(plan, active, surface) {
+    const unresolved = active.successCriteria.filter((criterion) => criterion.status !== "pass");
+    if (unresolved.length > 0)
+        return [
+            surface === "omo-senpi"
+                ? `${active.id} has ${unresolved.length} unresolved criterion(s) (${unresolved.map((criterion) => criterion.id).join(", ")}): record proof with \`agentToolkit.recordEvidence({ goalId: "${active.id}", criterionId: "<id>", status: "pass", evidence: "<observable proof>" })\`.`
+                : `${active.id} has ${unresolved.length} unresolved criterion(s) (${unresolved.map((criterion) => criterion.id).join(", ")}): record proof with \`omo-agent-toolkit ulw-loop record-evidence --goal-id ${active.id} --criterion-id <id> --status pass --evidence "<observable proof>"\`.`,
+        ];
+    if (hasAllCriteriaPass(active) && isFinalRunCompletionCandidate(plan, active))
+        return [
+            surface === "omo-senpi"
+                ? `${active.id} passes every criterion and is the final story: complete the driver goal, then call \`agentToolkit.checkpoint({ goalId: "${active.id}", printTemplate: true })\` to build the final quality gate. Use status().result.currentAttemptDir for all quality-gate artifacts.`
+                : `${active.id} passes every criterion and is the final story: update_goal complete, then checkpoint --print-template to build the final quality gate. Use status --json's currentAttemptDir for all quality-gate artifacts.`,
+        ];
+    return [
+        surface === "omo-senpi"
+            ? `${active.id} passes every criterion: close it with \`agentToolkit.checkpoint({ goalId: "${active.id}", status: "complete", evidence: "<proof>" })\`. Put quality-gate artifacts under status().result.currentAttemptDir.`
+            : `${active.id} passes every criterion: close it with \`omo-agent-toolkit ulw-loop checkpoint --goal-id ${active.id} --status complete --evidence "<proof>" --codex-goal-json '<get_goal json>'\`. Put quality-gate artifacts under the currentAttemptDir shown by status --json.`,
+    ];
+}

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

@@ -1,4 +1,5 @@
-import { appendLedger, appendLedgerEntries, findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { commit } from "./plan-commit.js";
+import { findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
 import { applySteeringMutation, validateUlwLoopSteeringProposal } from "./steering.js";
 import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "./steering-snapshot.js";
 import { iso } from "./types.js";
@@ -10,7 +11,7 @@ export async function steerUlwLoopBatch(repoRoot, proposals, scope) {
         const failed = prepared.results.find((item) => !item.accepted);
         if (failed !== undefined) {
             const entry = rejectedLedgerEntry(prepared.results);
-            await appendLedger(repoRoot, entry, scope);
+            await commit(repoRoot, scope, { plan, entries: [entry] });
             return rejected(plan, prepared.results, failed.rejectedReasons);
         }
         let next = plan;
@@ -19,10 +20,9 @@ export async function steerUlwLoopBatch(repoRoot, proposals, scope) {
                 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);
+            await commit(repoRoot, scope, { plan: next, entries: batchEntry === null ? entries : [...entries, batchEntry] });
         }
         return { plan: next, accepted: true, results: prepared.results, rejectedReasons: [] };
     });

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

@@ -1,5 +1,6 @@
+import type { UlwLoopToolkitSurface } from "./surface.js";
 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 makeGoal(plan: UlwLoopPlan, childGoal: UlwLoopSteeringChildGoal, evidence: string, now: string, offset: number, surface?: UlwLoopToolkitSurface): 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 splitOrBlock(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string, surface?: UlwLoopToolkitSurface): void;
 export declare function reviseCriterion(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, now: string): void;

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

@@ -29,11 +29,11 @@ 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) {
+export function makeGoal(plan, childGoal, evidence, now, offset, surface = "lazycodex") {
     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 };
+    return { id, title: childGoal.title, objective: childGoal.objective, status: "pending", successCriteria: seedDefaultSuccessCriteria(goalIndex, childGoal.objective, { goalId: id, surface }), attempt: 0, createdAt: now, updatedAt: now, evidence };
 }
 export function reviseWording(plan, proposal, now) {
     const target = goal(plan, targets(proposal)[0]);
@@ -45,11 +45,11 @@ export function reviseWording(plan, proposal, now) {
     target.steeringRationale = proposal.rationale;
     target.updatedAt = now;
 }
-export function splitOrBlock(plan, proposal, now) {
+export function splitOrBlock(plan, proposal, now, surface = "lazycodex") {
     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));
+    const replacements = children(proposal).map((item, index) => makeGoal(plan, item, proposal.evidence, now, index + 1, surface));
     target.steeringEvidence = proposal.evidence;
     target.steeringRationale = proposal.rationale;
     target.updatedAt = now;

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

@@ -1,4 +1,4 @@
-import type { UlwLoopSteeringMutationKind, UlwLoopSteeringSource } from "./constants.js";
+import type { UlwLoopSteeringMutationKind, UlwLoopSteeringSource, UlwLoopSuccessCriterionUserModel } from "./constants.js";
 import type { UlwLoopItem, UlwLoopPlan } from "./domain-types.js";
 export interface UlwLoopSteeringInvariantResult {
     accepted: boolean;
@@ -21,9 +21,17 @@ export interface UlwLoopSteeringAfterPayload {
 export interface UlwLoopSteeringProposal {
     kind: UlwLoopSteeringMutationKind;
     source: UlwLoopSteeringSource;
+    /** Alias of `targetGoalId`; the SDK documentation uses `goalId` like every other operation. */
+    goalId?: string;
     targetGoalId?: string;
     targetGoalIds?: string[];
     criterionId?: string;
+    /** `revise_criterion` payload: the replacement scenario text. */
+    scenario?: string;
+    /** `revise_criterion` payload: the replacement observable-proof text. */
+    expectedEvidence?: string;
+    /** `revise_criterion` payload: the replacement user model. */
+    userModel?: UlwLoopSuccessCriterionUserModel;
     evidence: string;
     rationale: string;
     title?: string;

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

@@ -1,6 +1,7 @@
 import type { UlwLoopScope } from "./paths.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { SteerUlwLoopResult, UlwLoopPlan, UlwLoopSteeringAudit, UlwLoopSteeringProposal } from "./types.js";
 export declare function validateUlwLoopSteeringProposal(plan: UlwLoopPlan, proposal: unknown): UlwLoopSteeringAudit;
-export declare function applySteeringMutation(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, audit: UlwLoopSteeringAudit): UlwLoopPlan;
+export declare function applySteeringMutation(plan: UlwLoopPlan, proposal: UlwLoopSteeringProposal, audit: UlwLoopSteeringAudit, surface?: UlwLoopToolkitSurface): UlwLoopPlan;
 export declare function parseUlwLoopSteeringDirective(text: string): UlwLoopSteeringProposal | null;
-export declare function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringProposal, scope?: UlwLoopScope): Promise<SteerUlwLoopResult>;
+export declare function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringProposal, scope?: UlwLoopScope, surface?: UlwLoopToolkitSurface): Promise<SteerUlwLoopResult>;

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

@@ -1,12 +1,13 @@
 // biome-ignore-all format: compact steering module must stay below the 240 pure-LOC budget
 import { isUlwLoopDone } from "./goal-status.js";
-import { appendLedger, findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { commit } from "./plan-commit.js";
+import { findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock } 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 PROTECTED = new Set(["aggregateCompletion", "codexObjective", "codexObjectiveAliases", "acknowledgedDriverObjectives", "originalConstraints", "qualityGate", "status", "completedAt", "completionStatus"]);
 const isObject = (value) => typeof value === "object" && value !== null;
 const isPlain = (value) => isObject(value) && !Array.isArray(value);
 const read = (value, key) => Object.entries(value).find(([name]) => name === key)?.[1];
@@ -163,13 +164,13 @@ function validateCriterion(plan, proposal, reasons) {
     if (model !== undefined && !isModel(model))
         reasons.push("invalid userModel");
 }
-export function applySteeringMutation(plan, proposal, audit) {
+export function applySteeringMutation(plan, proposal, audit, surface = "lazycodex") {
     const next = structuredClone(plan);
     if (!audit.invariant.accepted)
         return next;
     const now = proposal.now?.toISOString() ?? iso();
     if (proposal.kind === "add_subgoal")
-        next.goals.push(makeGoal(next, { title: proposal.title ?? "", objective: proposal.objective ?? "" }, proposal.evidence, now, 1));
+        next.goals.push(makeGoal(next, { title: proposal.title ?? "", objective: proposal.objective ?? "" }, proposal.evidence, now, 1, surface));
     if (proposal.kind === "reorder_pending") {
         const order = pendingOrder(proposal);
         next.goals = [...order.map((id) => goal(next, id)).filter((item) => item !== undefined), ...next.goals.filter((item) => !order.includes(item.id))];
@@ -177,7 +178,7 @@ export function applySteeringMutation(plan, proposal, audit) {
     if (proposal.kind === "revise_pending_wording")
         reviseWording(next, proposal, now);
     if (proposal.kind === "split_subgoal" || proposal.kind === "mark_blocked_superseded")
-        splitOrBlock(next, proposal, now);
+        splitOrBlock(next, proposal, now, surface);
     if (proposal.kind === "revise_criterion")
         reviseCriterion(next, proposal, now);
     if (proposal.kind !== "annotate_ledger")
@@ -201,7 +202,7 @@ export function parseUlwLoopSteeringDirective(text) {
         throw error;
     }
 }
-export async function steerUlwLoop(repoRoot, proposal, scope) {
+export async function steerUlwLoop(repoRoot, proposal, scope, surface = "lazycodex") {
     return withUlwLoopMutationLock(repoRoot, scope, async () => {
         const plan = await readUlwLoopPlan(repoRoot, scope);
         const key = proposal.idempotencyKey ?? proposal.promptSignature;
@@ -214,7 +215,7 @@ export async function steerUlwLoop(repoRoot, proposal, scope) {
         }
         const audit = validateUlwLoopSteeringProposal(plan, proposal);
         const accepted = audit.invariant.accepted;
-        const next = accepted ? applySteeringMutation(plan, proposal, audit) : plan;
+        const next = accepted ? applySteeringMutation(plan, proposal, audit, surface) : plan;
         const finalAudit = { ...audit };
         if (accepted) {
             const changed = changedGoalIdsBetween(plan, next);
@@ -223,11 +224,10 @@ export async function steerUlwLoop(repoRoot, proposal, scope) {
         }
         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, at), scope);
+        const entries = [ledgerEntry(proposal, finalAudit, at)];
         if (batchEntry !== null)
-            await appendLedger(repoRoot, batchEntry, scope);
+            entries.push(batchEntry);
+        await commit(repoRoot, scope, { plan: next, entries });
         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,11 +1,14 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, resolve, sep } from "node:path";
-import { normalizeUlwLoopSessionId, ulwLoopDir } from "./paths.js";
+import { readLedgerAt } from "./ledger.js";
+import { normalizeUlwLoopSessionId, ulwLoopDir, ulwLoopStateLockPath } from "./paths.js";
+import { readUlwLoopPlanSync } from "./plan-io.js";
+import { isStateLockTimeout, withStateLockSync } from "./state-lock.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
 // this handler. Mid-turn stalls are out of scope by design.
 const RESUME_CAP = 2;
-// Mirrors start-work-continuation's context-pressure bail-out: injecting a
+// Mirrors ulw-execute-continuation's context-pressure bail-out: injecting a
 // resume directive into an already-overflowing context makes things worse.
 const CONTEXT_PRESSURE_MARKERS = [
     "context compacted",
@@ -24,14 +27,15 @@ export function runStopResumeHook(input) {
         return "";
     if (boulderContinuationWillFire(payload.cwd, payload.session_id))
         return "";
-    const stateDir = ulwLoopDir(payload.cwd, { sessionId: payload.session_id });
-    const plan = readPlan(join(stateDir, "goals.json"));
+    const scope = { sessionId: payload.session_id };
+    const stateDir = ulwLoopDir(payload.cwd, scope);
+    const plan = readPlan(payload.cwd, payload.session_id);
     if (plan === null || plan.aggregateCompletion?.status === "complete")
         return "";
     const goal = resumableGoal(plan);
     if (goal === undefined)
         return "";
-    if (!consumeResumeBudget(stateDir, goal.id))
+    if (!consumeResumeBudgetLocked(ulwLoopStateLockPath(payload.cwd, scope), stateDir, goal.id))
         return "";
     const output = {
         decision: "block",
@@ -62,11 +66,22 @@ function resumableGoal(plan) {
 function isResumableStatus(status) {
     return status === "pending" || status === "in_progress";
 }
-// Two-strike cap keyed on ledger movement: an unchanged ledger.jsonl line
-// count across resumes means the loop is not progressing. The stuck marker is
-// a separate file — a ledger append would change the count and self-reset.
+// A resume is a budgeted side effect; when the session lock cannot be taken the
+// hook stays silent (fail closed) instead of charging the counter unlocked.
+function consumeResumeBudgetLocked(lockPath, stateDir, goalId) {
+    try {
+        return withStateLockSync(lockPath, () => consumeResumeBudget(stateDir, goalId));
+    }
+    catch (error) {
+        if (isStateLockTimeout(error))
+            return false;
+        throw error;
+    }
+}
+// Hook budget counters are exempt from plan/audit commits. Count reconciled
+// entries, not cache lines: a writer dying after link still made progress.
 function consumeResumeBudget(stateDir, goalId) {
-    const ledgerLineCount = countLedgerLines(join(stateDir, "ledger.jsonl"));
+    const ledgerLineCount = readLedgerAt(stateDir).length;
     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
@@ -97,9 +112,9 @@ function renderResumeDirective(plan, goal, sessionId) {
         "If the loop is genuinely blocked on the user, checkpoint the goal as blocked with the reason instead.",
     ].join("\n");
 }
-function readPlan(goalsPath) {
+function readPlan(repoRoot, sessionId) {
     try {
-        return JSON.parse(readFileSync(goalsPath, "utf8"));
+        return readUlwLoopPlanSync(repoRoot, { sessionId });
     }
     catch (error) {
         if (error instanceof Error)
@@ -107,16 +122,6 @@ function readPlan(goalsPath) {
         throw error;
     }
 }
-function countLedgerLines(ledgerPath) {
-    try {
-        return readFileSync(ledgerPath, "utf8").split("\n").filter(Boolean).length;
-    }
-    catch (error) {
-        if (error instanceof Error)
-            return 0;
-        throw error;
-    }
-}
 function readCounter(counterPath) {
     try {
         if (!existsSync(counterPath))
@@ -132,7 +137,7 @@ function readCounter(counterPath) {
         throw error;
     }
 }
-// Local ~10-LOC approximation of start-work-continuation's boulder check (no
+// Local ~10-LOC approximation of ulw-execute-continuation's boulder check (no
 // cross-component import allowed): any continuable work for this session means
 // that hook owns the Stop event, so this one stays silent.
 function boulderContinuationWillFire(cwd, sessionId) {
@@ -167,7 +172,7 @@ function transcriptShowsContextPressure(transcriptPath) {
         throw error;
     }
 }
-// start-work-continuation owns an active Boulder plan until its final gate marks
+// ulw-execute-continuation owns an active Boulder plan until its final gate marks
 // the work complete, including the zero-remaining checklist state.
 function boulderPlanHasChecklist(cwd, entry) {
     const activePlan = entry["active_plan"];

package/packages/omo-codex/plugin/components/ulw-loop/dist/success-criteria-input.d.ts

@@ -0,0 +1,9 @@
+import type { UlwLoopSuccessCriterion, UlwLoopSuccessCriterionUserModel } from "./types.js";
+export interface SuccessCriterionInput {
+    readonly scenario: string;
+    readonly expectedEvidence: string;
+    readonly userModel?: UlwLoopSuccessCriterionUserModel;
+    readonly essential?: boolean;
+}
+export declare function criterionId(index: number): string;
+export declare function criteriaFromInput(input: readonly unknown[]): UlwLoopSuccessCriterion[];

package/packages/omo-codex/plugin/components/ulw-loop/dist/success-criteria-input.js

@@ -0,0 +1,41 @@
+import { ULW_LOOP_SUCCESS_CRITERION_USER_MODELS, UlwLoopError } from "./types.js";
+function invalid(message, details) {
+    throw new UlwLoopError(`Invalid successCriteria: ${message}`, "ULW_LOOP_ARGUMENT_INVALID", { details });
+}
+function isUserModel(value) {
+    return typeof value === "string" && ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.some((model) => model === value);
+}
+function requireText(value, field, index) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    return trimmed || invalid(`entry ${index + 1} needs a non-empty ${field}.`, { index, field });
+}
+export function criterionId(index) {
+    return `C${String(index + 1).padStart(3, "0")}`;
+}
+export function criteriaFromInput(input) {
+    if (input.length === 0)
+        invalid("provide at least one criterion or omit the field for placeholders.", { count: 0 });
+    return input.map((entry, index) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return invalid(`entry ${index + 1} must be an object.`, { index });
+        const record = { ...entry };
+        const userModel = record["userModel"] ?? "happy";
+        if (!isUserModel(userModel))
+            return invalid(`entry ${index + 1} userModel must be one of ${ULW_LOOP_SUCCESS_CRITERION_USER_MODELS.join(", ")}.`, {
+                index,
+                userModel: String(userModel),
+            });
+        const essential = record["essential"];
+        if (essential !== undefined && typeof essential !== "boolean")
+            return invalid(`entry ${index + 1} essential must be a boolean.`, { index });
+        return {
+            id: criterionId(index),
+            scenario: requireText(record["scenario"], "scenario", index),
+            userModel,
+            expectedEvidence: requireText(record["expectedEvidence"], "expectedEvidence", index),
+            essential: essential ?? true,
+            capturedEvidence: null,
+            status: "pending",
+        };
+    });
+}