lazycodex-ai 5.0.0-beta.62 → 5.0.0-beta.64

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

@@ -1,3 +1,4 @@
+import { criteriaFromInput, criterionId } from "./success-criteria-input.js";
 import { UlwLoopError } from "./types.js";
 function cleanLine(line) {
     return line.replace(/^\s*(?:[-*+]\s+|\d+[.)]\s+)/, "").trim();
@@ -30,40 +31,39 @@ function assertNonEmpty(value, label) {
 function truncateObjective(objective) {
     return objective.length > 80 ? `${objective.slice(0, 77).trimEnd()}...` : objective;
 }
-export function seedDefaultSuccessCriteria(goalIndex, objective) {
+// The placeholder must name the exact call that replaces it on the surface the plan is driven from,
+// so a goal seeded without criteria costs one documented call per criterion instead of a doc hunt.
+function replaceVia(goalId, id, surface) {
+    return surface === "omo-senpi"
+        ? `Replace via agentToolkit.steer({ kind: "revise_criterion", source: "finding", goalId: "${goalId}", criterionId: "${id}", scenario, expectedEvidence, evidence, rationale }) (or pass successCriteria to addGoal)`
+        : `Replace via omo-agent-toolkit ulw-loop steer --kind revise_criterion --goal-id ${goalId} --criterion-id ${id} --scenario "<scenario>" --expected-evidence "<proof>" --evidence "<why>" --rationale "<why>"`;
+}
+export function seedDefaultSuccessCriteria(goalIndex, objective, options = {}) {
     const subject = truncateObjective(normalizeObjective(objective) || `Goal ${goalIndex + 1}`);
+    const goalId = options.goalId ?? `G${String(goalIndex + 1).padStart(3, "0")}`;
+    const surface = options.surface ?? "lazycodex";
     const rows = [
+        ["happy", `happy path for: ${subject}`, `observable happy-path proof for goal ${goalIndex + 1}`, true],
+        ["edge", "edge case (boundary/empty/malformed)", `boundary or malformed-input proof for: ${subject}`, true],
         [
-            "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}.`,
+            `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",
-    }));
+    return rows.map(([userModel, scenario, proof, essential], index) => {
+        const id = criterionId(index);
+        return {
+            id,
+            scenario,
+            userModel,
+            expectedEvidence: `${replaceVia(goalId, id, surface)} with ${proof}.`,
+            essential,
+            capturedEvidence: null,
+            status: "pending",
+        };
+    });
 }
 export function deriveGoalCandidates(brief) {
     const bulletGoals = brief
@@ -87,22 +87,29 @@ export function deriveGoalCandidates(brief) {
         objective,
     }));
 }
-export function makeGoal(title, objective, index, now) {
+export function makeGoal(title, objective, index, now, options = {}) {
     const cleanTitle = assertNonEmpty(title, "title");
     const cleanObjective = assertNonEmpty(objective, "objective");
+    const id = normalizeGoalId(cleanTitle, index);
+    const successCriteria = options.successCriteria === undefined
+        ? seedDefaultSuccessCriteria(index, cleanObjective, {
+            goalId: id,
+            ...(options.surface === undefined ? {} : { surface: options.surface }),
+        })
+        : criteriaFromInput(options.successCriteria);
     return {
-        id: normalizeGoalId(cleanTitle, index),
+        id,
         title: cleanTitle,
         objective: cleanObjective,
         status: "pending",
-        successCriteria: seedDefaultSuccessCriteria(index, cleanObjective),
+        successCriteria,
         attempt: 0,
         createdAt: now,
         updatedAt: now,
     };
 }
-export function appendGoalToPlan(plan, title, objective, now) {
-    const goal = makeGoal(title, objective, plan.goals.length, now);
+export function appendGoalToPlan(plan, title, objective, now, options = {}) {
+    const goal = makeGoal(title, objective, plan.goals.length, now, options);
     plan.goals.push(goal);
     plan.updatedAt = now;
     return goal;

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

@@ -1,16 +1,18 @@
 import { type UlwLoopScope } from "./paths.js";
-import type { UlwLoopLedgerEntry, UlwLoopPlan } from "./types.js";
+import { type StateLockOptions } from "./state-lock.js";
+import { type UlwLoopLedgerEntry, type UlwLoopPlan } from "./types.js";
+export declare function readLedger(repoRoot: string, scope?: UlwLoopScope): UlwLoopLedgerEntry[];
+export { planExists } from "./plan-log.js";
+export declare function withMutationLockOptions<T>(options: StateLockOptions, fn: () => Promise<T>): Promise<T>;
+export declare function assertStateLockOwned(lockPath: string): void;
+export declare function migrationEntries(plan: UlwLoopPlan): readonly UlwLoopLedgerEntry[];
 export declare function withUlwLoopMutationLock<T>(repoRoot: string, fn: () => Promise<T>): Promise<T>;
-export declare function withUlwLoopMutationLock<T>(repoRoot: string, scope: UlwLoopScope | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function withUlwLoopMutationLock<T>(repoRoot: string, scope: UlwLoopScope | undefined, fn: () => Promise<T>, options?: StateLockOptions): Promise<T>;
+export declare function readUlwLoopPlanSync(repoRoot: string, scope?: UlwLoopScope): UlwLoopPlan;
 export declare function readUlwLoopPlan(repoRoot: string, scope?: UlwLoopScope): Promise<UlwLoopPlan>;
 export declare function listUlwLoopSessionIds(repoRoot: string): readonly string[];
 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.
- * A cheap substring probe on the raw line skips JSON.parse for the vast
- * majority of entries, so dedup stays flat even on legacy multi-MB ledgers.
- */
 export declare function findAcceptedSteeringLedgerEntry(repoRoot: string, key: string, scope?: UlwLoopScope): Promise<UlwLoopLedgerEntry | undefined>;

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

@@ -1,46 +1,88 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createReadStream, readdirSync } from "node:fs";
-import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { createInterface } from "node:readline";
+import { readdirSync } from "node:fs";
 import { aggregateCodexObjectiveForScope } from "./goal-status.js";
-import { repoRelative, ulwLoopDir, ulwLoopGoalsPath, ulwLoopLedgerPath, ulwLoopRelativeDir, ulwLoopStateLockPath, } from "./paths.js";
-import { planMissingRecovery } from "./plan-missing-recovery.js";
+import { readLedger as reconcileLedger } from "./ledger.js";
+import { repoRelative, ulwLoopDir, ulwLoopGoalsPath, ulwLoopRelativeDir, ulwLoopStateLockPath, } from "./paths.js";
+import { commit, materialize, materializeSync } from "./plan-commit.js";
+import { readOptional, reconcilePlan } from "./plan-log.js";
+import { planMissingError } from "./plan-missing-recovery.js";
 import { withStateLock } from "./state-lock.js";
-import { iso, ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER, UlwLoopError } from "./types.js";
+import { iso, ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER, UlwLoopError, } from "./types.js";
+export function readLedger(repoRoot, scope) {
+    const lockPath = ulwLoopStateLockPath(repoRoot, scope);
+    if (heldLocks.getStore()?.has(lockPath)) {
+        assertStateLockOwned(lockPath);
+        materializeSync(ulwLoopDir(repoRoot, scope));
+    }
+    return reconcileLedger(repoRoot, scope);
+}
+export { planExists } from "./plan-log.js";
 const LEGACY_OBJECTIVE_PREFIX = `Complete all ulw-loop stories in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}: `;
 const LEGACY_OBJECTIVE = `Complete all ulw-loop stories listed in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}. Use ${ULW_LOOP_DIR}/${ULW_LOOP_LEDGER} as the durable audit trail.`;
 const locks = new Map();
-// Tracks which state dirs the CURRENT async continuation holds, so a read nested
-// inside a locked mutation can tell itself apart from an unlocked read elsewhere
-// in the same process.
 const heldLocks = new AsyncLocalStorage();
-function hasCode(error, code) {
-    return error instanceof Error && "code" in error && error.code === code;
+const lockOptions = new AsyncLocalStorage();
+export function withMutationLockOptions(options, fn) {
+    return lockOptions.run(options, fn);
 }
-function isLegacyEnumeratedAggregateObjective(objective) {
-    return objective === LEGACY_OBJECTIVE || Boolean(objective?.startsWith(LEGACY_OBJECTIVE_PREFIX));
+function tokenAt(lockPath) {
+    const raw = readOptional(lockPath);
+    if (raw === undefined)
+        return undefined;
+    try {
+        const record = JSON.parse(raw);
+        return typeof record === "object" && record !== null && "token" in record && typeof record.token === "string"
+            ? record.token
+            : undefined;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
 }
-function isSteeringKind(value) {
-    return (value === "steering_accepted" ||
-        value === "steering_rejected" ||
-        value === "criteria_revised" ||
-        value === "batch_updated");
+export function assertStateLockOwned(lockPath) {
+    const context = heldLocks.getStore()?.get(lockPath);
+    if (context === undefined)
+        return;
+    if (tokenAt(lockPath) !== context.token)
+        throw new UlwLoopError("The ulw-loop mutation lock changed owners.", "ULW_LOOP_LOCK_LOST");
+}
+export function migrationEntries(plan) {
+    for (const context of heldLocks.getStore()?.values() ?? []) {
+        const entries = context.migrations.get(plan.goalsPath);
+        if (entries !== undefined) {
+            context.migrations.delete(plan.goalsPath);
+            return entries;
+        }
+    }
+    return [];
 }
-export async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn) {
+export async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn, options = {}) {
     const scope = typeof scopeOrFn === "function" ? undefined : scopeOrFn;
     const fn = typeof scopeOrFn === "function" ? scopeOrFn : maybeFn;
     if (fn === undefined)
         throw new UlwLoopError("Missing ulw-loop mutation body.", "ULW_LOOP_LOCK_BODY_MISSING");
     const lockKey = `${repoRoot}\0${ulwLoopRelativeDir(scope)}`;
     const lockPath = ulwLoopStateLockPath(repoRoot, scope);
-    // The promise chain orders callers inside this process; the file lock is what
-    // excludes every other process (each CLI invocation) touching the same state dir.
-    const locked = () => withStateLock(lockPath, () => heldLocks.run(new Set([...(heldLocks.getStore() ?? []), lockKey]), fn));
+    const locked = () => withStateLock(lockPath, async (token) => {
+        return heldLocks.run(new Map([...(heldLocks.getStore() ?? []), [lockPath, { token, migrations: new Map() }]]), async () => {
+            for (let attempt = 0;; attempt += 1) {
+                try {
+                    return await fn();
+                }
+                catch (error) {
+                    if (!(error instanceof UlwLoopError) || error.code !== "ULW_LOOP_PUBLISH_CONFLICT")
+                        throw error;
+                    assertStateLockOwned(lockPath);
+                    if (attempt !== 0)
+                        throw error;
+                }
+            }
+        });
+    }, { ...lockOptions.getStore(), ...options });
     const prior = locks.get(lockKey) ?? Promise.resolve(undefined);
     const run = prior.then(locked, locked);
-    // The stored gate resolves to undefined so the map never retains fn's result
-    // (plans/audits), and it removes itself once no newer waiter replaced it —
-    // otherwise a long-lived host leaks one entry per (repo, scope) forever.
     const gate = run.then(() => undefined, () => undefined);
     locks.set(lockKey, gate);
     void gate.then(() => {
@@ -49,47 +91,40 @@ export async function withUlwLoopMutationLock(repoRoot, scopeOrFn, maybeFn) {
     });
     return run;
 }
-export async function readUlwLoopPlan(repoRoot, scope) {
+export function readUlwLoopPlanSync(repoRoot, scope) {
     const path = ulwLoopGoalsPath(repoRoot, scope);
-    let raw;
-    try {
-        raw = await readFile(path, "utf8");
-    }
-    catch (error) {
-        if (!hasCode(error, "ENOENT"))
-            throw error;
-        const recovery = planMissingRecovery(listUlwLoopSessionIds(repoRoot));
-        throw new UlwLoopError(`No ulw-loop plan found at ${repoRelative(path, repoRoot)}.\n${recovery.message}`, "ULW_LOOP_PLAN_MISSING", { cause: error, ...(recovery.details === undefined ? {} : { details: recovery.details }) });
-    }
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== 1 || !Array.isArray(parsed.goals)) {
+    const parsed = reconcilePlan(ulwLoopDir(repoRoot, scope));
+    if (parsed === undefined)
+        throw planMissingError(repoRelative(path, repoRoot), listUlwLoopSessionIds(repoRoot));
+    if (parsed.version !== 1 || !Array.isArray(parsed.goals))
         throw new UlwLoopError(`Invalid ulw-loop plan at ${repoRelative(path, repoRoot)}.`, "ULW_LOOP_PLAN_INVALID");
-    }
     const previousObjective = parsed.codexObjective;
     if ((parsed.codexGoalMode ?? "per_story") === "aggregate" &&
-        isLegacyEnumeratedAggregateObjective(previousObjective)) {
-        if (!(heldLocks.getStore()?.has(`${repoRoot}\0${ulwLoopRelativeDir(scope)}`) ?? false)) {
-            // A read path (status/criteria) must not mutate state: mutating here runs
-            // unlocked and a second reader could write a partially-migrated plan.
-            throw new UlwLoopError(`The ulw-loop plan at ${repoRelative(path, repoRoot)} carries a legacy enumerated aggregate objective that must be migrated before reads continue. Run any state-mutating ulw-loop command once (e.g. \`record-evidence\`, \`steer\`, \`checkpoint\`) to migrate it under the state lock, then retry.`, "ULW_LOOP_MIGRATION_REQUIRED");
-        }
-        const now = iso();
+        previousObjective !== undefined &&
+        (previousObjective === LEGACY_OBJECTIVE || previousObjective.startsWith(LEGACY_OBJECTIVE_PREFIX))) {
         parsed.codexObjective = aggregateCodexObjectiveForScope(scope);
         parsed.codexObjectiveAliases = [...new Set([...(parsed.codexObjectiveAliases ?? []), previousObjective])];
-        parsed.updatedAt = now;
-        await writePlan(repoRoot, parsed, scope);
-        await appendLedger(repoRoot, {
-            at: now,
-            kind: "aggregate_objective_migrated",
-            message: "Migrated legacy enumerated aggregate Codex objective to the stable pointer objective.",
-            before: { codexObjective: previousObjective },
-            after: { codexObjective: parsed.codexObjective },
-        }, scope);
+        heldLocks
+            .getStore()
+            ?.get(ulwLoopStateLockPath(repoRoot, scope))
+            ?.migrations.set(parsed.goalsPath, [
+            {
+                at: iso(),
+                kind: "aggregate_objective_migrated",
+                before: { codexObjective: previousObjective },
+                after: { codexObjective: parsed.codexObjective },
+            },
+        ]);
     }
     return parsed;
 }
-// Session dirs are the only recovery hint that matters when a plan or a scope is
-// missing: the caller is almost always meant to target one of these siblings.
+export async function readUlwLoopPlan(repoRoot, scope) {
+    if (heldLocks.getStore()?.has(ulwLoopStateLockPath(repoRoot, scope))) {
+        assertStateLockOwned(ulwLoopStateLockPath(repoRoot, scope));
+        await materialize(ulwLoopDir(repoRoot, scope));
+    }
+    return readUlwLoopPlanSync(repoRoot, scope);
+}
 export function listUlwLoopSessionIds(repoRoot) {
     try {
         return readdirSync(ulwLoopDir(repoRoot), { withFileTypes: true })
@@ -102,72 +137,28 @@ export function listUlwLoopSessionIds(repoRoot) {
     }
 }
 export async function writePlan(repoRoot, plan, scope) {
-    await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
-    const path = ulwLoopGoalsPath(repoRoot, scope);
-    const tmpPath = `${path}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tmpPath, `${JSON.stringify(plan, null, 2)}\n`, "utf8");
-    await rename(tmpPath, path);
+    await commit(repoRoot, scope, { plan, entries: [] });
 }
 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), `${entries.map((entry) => JSON.stringify(entry)).join("\n")}\n`, "utf8");
+    if (entries.length > 0)
+        await commit(repoRoot, scope, { plan: await readUlwLoopPlan(repoRoot, scope), entries });
 }
-/**
- * Streams raw ledger lines without materializing the file. Real ledgers reach
- * many MB (legacy entries embedded full-plan snapshots), so `readFile` here
- * ballooned every steer/dedup path; line-at-a-time keeps memory O(longest line).
- */
-async function* ledgerLines(repoRoot, scope) {
-    const stream = createReadStream(ulwLoopLedgerPath(repoRoot, scope), { encoding: "utf8" });
-    const lines = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
-    try {
-        for await (const line of lines) {
-            if (line.trim().length > 0)
-                yield line;
-        }
-    }
-    catch (error) {
-        if (!hasCode(error, "ENOENT"))
-            throw error;
-    }
-    finally {
-        lines.close();
-        stream.destroy();
-    }
+function isSteeringKind(value) {
+    return (value === "steering_accepted" ||
+        value === "steering_rejected" ||
+        value === "criteria_revised" ||
+        value === "batch_updated");
 }
 export async function readSteeringLedgerEntries(repoRoot, scope) {
-    const entries = [];
-    for await (const line of ledgerLines(repoRoot, scope)) {
-        const entry = JSON.parse(line);
-        if (isSteeringKind(entry.kind))
-            entries.push(entry);
-    }
-    return entries;
+    return readLedger(repoRoot, scope).filter((entry) => isSteeringKind(entry.kind));
 }
-/**
- * First accepted steering entry matching an idempotency key/prompt signature.
- * A cheap substring probe on the raw line skips JSON.parse for the vast
- * majority of entries, so dedup stays flat even on legacy multi-MB ledgers.
- */
 export async function findAcceptedSteeringLedgerEntry(repoRoot, key, scope) {
-    const probe = JSON.stringify(key);
-    for await (const line of ledgerLines(repoRoot, scope)) {
-        if (!line.includes(probe))
-            continue;
-        const entry = JSON.parse(line);
-        if (!isSteeringKind(entry.kind))
-            continue;
-        if (entry.steering?.invariant.accepted !== true)
-            continue;
-        if (entry.idempotencyKey === key ||
+    return readLedger(repoRoot, scope).find((entry) => isSteeringKind(entry.kind) &&
+        entry.steering?.invariant.accepted === true &&
+        (entry.idempotencyKey === key ||
             entry.steering.idempotencyKey === key ||
-            entry.steering.promptSignature === key)
-            return entry;
-    }
-    return undefined;
+            entry.steering.promptSignature === key));
 }

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

@@ -0,0 +1,15 @@
+import { type UlwLoopScope } from "./paths.js";
+import type { UlwLoopLedgerEntry, UlwLoopPlan } from "./types.js";
+export interface PlanCommitRecord {
+    readonly version: 1;
+    readonly revision: number;
+    readonly plan: UlwLoopPlan;
+    readonly ledger: readonly UlwLoopLedgerEntry[];
+}
+export declare function hasCode(error: unknown, code: string): boolean;
+export declare function readOptional(path: string): string | undefined;
+export declare function logNames(dir: string): string[];
+export declare function readRecords(dir: string): PlanCommitRecord[];
+export declare function readNewestRecord(dir: string): PlanCommitRecord | undefined;
+export declare function reconcilePlan(dir: string): UlwLoopPlan | undefined;
+export declare function planExists(repoRoot: string, scope?: UlwLoopScope): boolean;

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

@@ -0,0 +1,86 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ulwLoopDir } from "./paths.js";
+export function hasCode(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
+}
+export function readOptional(path) {
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return undefined;
+        throw error;
+    }
+}
+export function logNames(dir) {
+    try {
+        return readdirSync(join(dir, "revisions"))
+            .filter((name) => /^\d{8,}\.json$/.test(name))
+            .sort();
+    }
+    catch (error) {
+        if (hasCode(error, "ENOENT"))
+            return [];
+        throw error;
+    }
+}
+function readRecord(dir, name) {
+    try {
+        const record = JSON.parse(readFileSync(join(dir, "revisions", name), "utf8"));
+        return record.version === 1 &&
+            Number.isInteger(record.revision) &&
+            record.plan?.version === 1 &&
+            Array.isArray(record.plan.goals) &&
+            Array.isArray(record.ledger)
+            ? record
+            : undefined;
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        return undefined;
+    }
+}
+// Only the audit trail needs every record; plan reads use readNewestRecord.
+export function readRecords(dir) {
+    const records = [];
+    for (const name of logNames(dir)) {
+        const record = readRecord(dir, name);
+        if (record !== undefined)
+            records.push(record);
+    }
+    return records.sort((a, b) => a.revision - b.revision);
+}
+// Every ulw-loop status probe reads the plan, each record embeds a full plan copy, and records are never
+// deleted - so a plan read parses the newest record only, newest first, and stops there. Names are ordered
+// by their parsed revision because a wider zero-padding would break lexicographic order.
+export function readNewestRecord(dir) {
+    const names = logNames(dir).sort((a, b) => Number.parseInt(b, 10) - Number.parseInt(a, 10));
+    for (const name of names) {
+        const record = readRecord(dir, name);
+        if (record !== undefined)
+            return record;
+    }
+    return undefined;
+}
+export function reconcilePlan(dir) {
+    const raw = readOptional(join(dir, "goals.json"));
+    let cached;
+    if (raw !== undefined) {
+        try {
+            cached = JSON.parse(raw);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+        }
+    }
+    const latest = readNewestRecord(dir);
+    return latest !== undefined && latest.revision >= (cached?.revision ?? 0) ? latest.plan : cached;
+}
+export function planExists(repoRoot, scope) {
+    const dir = ulwLoopDir(repoRoot, scope);
+    return existsSync(join(dir, "goals.json")) || logNames(dir).length > 0;
+}

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

@@ -1,4 +1,7 @@
+import { UlwLoopError } from "./runtime.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 export declare const ULW_LOOP_CREATE_GOALS_COMMAND = "omo-agent-toolkit ulw-loop create-goals --brief \"<brief>\" --json";
+export declare function createGoalsAction(surface: UlwLoopToolkitSurface): string;
 export interface PlanMissingRecovery {
     readonly message: string;
     readonly details?: {
@@ -9,6 +12,7 @@ export interface PlanMissingRecovery {
  * A missing plan is either "never bootstrapped" or "bootstrapped under a different
  * session id"; the recovery text has to answer both without the caller guessing.
  */
-export declare function planMissingRecovery(existingSessionIds: readonly string[]): PlanMissingRecovery;
+export declare function planMissingRecovery(existingSessionIds: readonly string[], surface?: UlwLoopToolkitSurface): PlanMissingRecovery;
+export declare function planMissingError(planPath: string, existingSessionIds: readonly string[], surface?: UlwLoopToolkitSurface): UlwLoopError;
 export declare function sessionScopeRequiredMessage(flag: string, existingSessionIds: readonly string[]): string;
 export declare function sessionIdRequiredMessage(flag: string): string;

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

@@ -1,15 +1,27 @@
+import { UlwLoopError } from "./runtime.js";
 export const ULW_LOOP_CREATE_GOALS_COMMAND = 'omo-agent-toolkit ulw-loop create-goals --brief "<brief>" --json';
+export function createGoalsAction(surface) {
+    return surface === "omo-senpi" ? 'agentToolkit.createGoals({ brief: "<brief>" })' : ULW_LOOP_CREATE_GOALS_COMMAND;
+}
 /**
  * A missing plan is either "never bootstrapped" or "bootstrapped under a different
  * session id"; the recovery text has to answer both without the caller guessing.
  */
-export function planMissingRecovery(existingSessionIds) {
-    const lines = [`Recovery: bootstrap the plan with \`${ULW_LOOP_CREATE_GOALS_COMMAND}\`.`];
+export function planMissingRecovery(existingSessionIds, surface = "lazycodex") {
+    const lines = [`Recovery: bootstrap the plan with \`${createGoalsAction(surface)}\`.`];
     if (existingSessionIds.length === 0)
         return { message: lines.join("\n") };
-    lines.push(`Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}. Re-run with \`--session-id <id>\` to target one of them.`);
+    lines.push(surface === "omo-senpi"
+        ? `Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}. The SDK is bound to the current session; resume the owning session to target its plan.`
+        : `Existing ulw-loop session ids under .omo/ulw-loop/: ${existingSessionIds.join(", ")}. Re-run with \`--session-id <id>\` to target one of them.`);
     return { message: lines.join("\n"), details: { existingSessionIds } };
 }
+export function planMissingError(planPath, existingSessionIds, surface = "lazycodex") {
+    const recovery = planMissingRecovery(existingSessionIds, surface);
+    return new UlwLoopError(`No ulw-loop plan found at ${planPath}.\n${recovery.message}`, "ULW_LOOP_PLAN_MISSING", {
+        ...(recovery.details === undefined ? {} : { details: recovery.details }),
+    });
+}
 export function sessionScopeRequiredMessage(flag, existingSessionIds) {
     const lines = [
         "No ulw-loop session scope: neither the session env (OMO_ULW_LOOP_SESSION_ID / CODEX_SESSION_ID / CODEX_THREAD_ID / PI_SESSION_ID) nor the flag names this run, and the shared .omo/ulw-loop root is never used implicitly because every session in this directory would read and overwrite it.",

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

@@ -1,8 +1,10 @@
 // biome-ignore-all format: compact port must stay within the requested pure LOC budget.
 import { CodexGoalSnapshotError, formatCodexGoalReconciliation, readCodexGoalSnapshotInput, reconcileCodexGoalSnapshot, } from "./codex-goal-snapshot.js";
+import { acknowledgeDriverObjective, acknowledgedDriverObjectives } from "./driver-objective-ack.js";
 import { compatibleCodexObjectives, expectedCodexObjective, isFinalRunCompletionCandidate } from "./goal-status.js";
+import { commit } from "./plan-commit.js";
 import { seedDefaultSuccessCriteria } from "./plan-crud.js";
-import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
 import { iso, UlwLoopError } from "./types.js";
 const BLOCKER_FIELDS = "blockedReason blockerSignature blockerOccurrenceCount requiredExternalDecision nonRetriable failedAt failureReason completedAt blocker blockerEvidence blockerOccurrences blockedAt".split(" ");
 function ulwLoopError(message, code) {
@@ -17,12 +19,13 @@ function nextGoalId(plan) {
 }
 function appendBlockerGoal(plan, args, now) {
     const index = plan.goals.length;
+    const id = nextGoalId(plan);
     const goal = {
-        id: nextGoalId(plan),
+        id,
         title: args.title,
         objective: args.objective,
         status: "pending",
-        successCriteria: seedDefaultSuccessCriteria(index, args.objective),
+        successCriteria: seedDefaultSuccessCriteria(index, args.objective, { goalId: id }),
         attempt: 0,
         createdAt: now,
         updatedAt: now,
@@ -44,9 +47,11 @@ export async function recordFinalReviewBlockers(repoRoot, args, scope) {
         const reconciliation = reconcileCodexGoalSnapshot(snapshot, {
             expectedObjective: expectedCodexObjective(plan, goal),
             acceptedObjectives: compatibleCodexObjectives(plan),
+            acknowledgedObjectives: acknowledgedDriverObjectives(plan),
         });
         if (!reconciliation.ok)
             throw new CodexGoalSnapshotError(formatCodexGoalReconciliation(reconciliation));
+        acknowledgeDriverObjective(plan, reconciliation.unacknowledgedObjective);
         const now = iso();
         for (const field of BLOCKER_FIELDS)
             Reflect.deleteProperty(goal, field);
@@ -64,16 +69,14 @@ export async function recordFinalReviewBlockers(repoRoot, args, scope) {
         const summaryEntry = { at: now, kind: "goal_review_blocked", goalId: goal.id, status: goal.status, evidence: args.evidence, codexGoal, message: `Review blockers recorded; appended ${newGoal.id}.` };
         Reflect.set(summaryEntry, "kind", "blocker_recorded");
         const ledgerEntries = [blockedEntry, addedEntry, summaryEntry];
-        await writePlan(repoRoot, plan, scope);
-        for (const entry of ledgerEntries)
-            await appendLedger(repoRoot, entry, scope);
+        await commit(repoRoot, scope, { plan, entries: ledgerEntries });
         return {
             plan,
             blockedGoal: goal,
             newGoal,
             ledgerEntries,
-            nextActions: reconciliation.warnings,
-            warnings: reconciliation.warnings.filter((warning) => warning.startsWith("driver_objective_differs")),
+            nextActions: reconciliation.nextActions,
+            warnings: reconciliation.warnings,
         };
     });
 }