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

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

@@ -50,6 +50,9 @@ export interface UlwLoopValidationBatch {
 }
 export interface UlwLoopPlan {
     version: 1;
+    revision?: number;
+    brief?: string;
+    ledgerResetRevision?: number;
     evidenceLayoutVersion?: 2;
     createdAt: string;
     updatedAt: string;
@@ -136,6 +139,8 @@ export interface UlwLoopQualityGateSenpi extends UlwLoopQualityGateCommon {
 }
 export type UlwLoopQualityGate = UlwLoopQualityGateLazycodex | UlwLoopQualityGateSenpi;
 export interface UlwLoopLedgerEntry {
+    revision?: number;
+    id?: string;
     at: string;
     kind: UlwLoopLedgerEventKind;
     goalId?: string;

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

@@ -1,5 +1,6 @@
 import { essentialCriteriaOf, hasAllCriteriaPass, hasEssentialCriteriaPass } from "./goal-status.js";
-import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { commit } from "./plan-commit.js";
+import { readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
 import { iso, UlwLoopError } from "./types.js";
 function ulwLoopFail(message, code, details) {
     throw new UlwLoopError(message, code, { details });
@@ -48,7 +49,6 @@ export async function recordEvidence(repoRoot, args, scope) {
             criterion.notes = args.notes;
         goal.updatedAt = capturedAt;
         plan.updatedAt = capturedAt;
-        await writePlan(repoRoot, plan, scope);
         const ledgerEntry = {
             at: capturedAt,
             kind,
@@ -60,7 +60,7 @@ export async function recordEvidence(repoRoot, args, scope) {
             before: { status: prevStatus },
             after: { goalId: goal.id, criterionId: criterion.id, status: args.status, evidence, capturedAt, prevStatus },
         };
-        await appendLedger(repoRoot, ledgerEntry, scope);
+        await commit(repoRoot, scope, { plan, entries: [ledgerEntry] });
         return { plan, goal, criterion, ledgerEntry };
     });
 }
@@ -83,15 +83,19 @@ export async function markCriteriaPendingResetForGoal(repoRoot, goalId, scope) {
         }
         goal.updatedAt = now;
         plan.updatedAt = now;
-        await writePlan(repoRoot, plan, scope);
-        await appendLedger(repoRoot, {
-            at: now,
-            kind: "criteria_revised",
-            goalId,
-            message: `Reset ${goal.successCriteria.length} criteria to pending.`,
-            before,
-            after: { resetCount: goal.successCriteria.length },
-        }, scope);
+        await commit(repoRoot, scope, {
+            plan,
+            entries: [
+                {
+                    at: now,
+                    kind: "criteria_revised",
+                    goalId,
+                    message: `Reset ${goal.successCriteria.length} criteria to pending.`,
+                    before,
+                    after: { resetCount: goal.successCriteria.length },
+                },
+            ],
+        });
         return { plan, resetCount: goal.successCriteria.length };
     });
 }

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

@@ -0,0 +1,4 @@
+import { type UlwLoopScope } from "./paths.js";
+import type { UlwLoopLedgerEntry } from "./types.js";
+export declare function readLedgerAt(dir: string): UlwLoopLedgerEntry[];
+export declare function readLedger(repoRoot: string, scope?: UlwLoopScope): UlwLoopLedgerEntry[];

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

@@ -0,0 +1,34 @@
+import { join } from "node:path";
+import { ulwLoopDir } from "./paths.js";
+import { readOptional, readRecords, reconcilePlan } from "./plan-log.js";
+export function readLedgerAt(dir) {
+    const entries = new Map();
+    const lines = (readOptional(join(dir, "ledger.jsonl")) ?? "").split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        if (line.trim().length === 0)
+            continue;
+        try {
+            const entry = JSON.parse(line);
+            entry.revision ??= 0;
+            entry.id ??= `legacy-${index + 1}`;
+            entries.set(entry.id, entry);
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+        }
+    }
+    for (const record of readRecords(dir))
+        for (const [seq, entry] of record.ledger.entries()) {
+            const id = entry.id ?? `${record.revision}-${seq}`;
+            entries.set(id, { ...entry, revision: record.revision, id });
+        }
+    const reset = reconcilePlan(dir)?.ledgerResetRevision ?? 0;
+    const sequence = (entry) => Number(entry.id?.split("-").at(-1) ?? 0);
+    return [...entries.values()]
+        .filter((entry) => (entry.revision ?? 0) >= reset)
+        .sort((a, b) => (a.revision ?? 0) - (b.revision ?? 0) || sequence(a) - sequence(b));
+}
+export function readLedger(repoRoot, scope) {
+    return readLedgerAt(ulwLoopDir(repoRoot, scope));
+}

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

@@ -0,0 +1,19 @@
+import { type UlwLoopScope } from "./paths.js";
+import { type UlwLoopLedgerEntry, type UlwLoopPlan } from "./types.js";
+interface CommitHooks {
+    readonly beforeMutation?: () => void | Promise<void>;
+    readonly beforeCommit?: () => void | Promise<void>;
+    readonly afterCommit?: () => void | Promise<void>;
+    readonly link?: (source: string, destination: string) => void;
+    readonly writeView?: (path: string, content: string) => Promise<void>;
+}
+export declare function withCommitHooks<T>(value: CommitHooks, fn: () => Promise<T>): Promise<T>;
+export declare function beforePlanMutation(): Promise<void>;
+export declare function writeViewFile(path: string, content: string): Promise<void>;
+export declare function commit(repoRoot: string, scope: UlwLoopScope | undefined, mutation: {
+    readonly plan: UlwLoopPlan;
+    readonly entries: readonly UlwLoopLedgerEntry[];
+}): Promise<void>;
+export declare function materializeSync(dir: string): void;
+export declare function materialize(dir: string): Promise<void>;
+export {};

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

@@ -0,0 +1,107 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { linkSync, mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readLedgerAt } from "./ledger.js";
+import { ulwLoopDir, ulwLoopStateLockPath } from "./paths.js";
+import { assertStateLockOwned, migrationEntries } from "./plan-io.js";
+import { hasCode, readOptional, readRecords, reconcilePlan } from "./plan-log.js";
+import { UlwLoopError } from "./types.js";
+const hooks = new AsyncLocalStorage();
+export function withCommitHooks(value, fn) {
+    return hooks.run(value, fn);
+}
+export async function beforePlanMutation() {
+    await hooks.getStore()?.beforeMutation?.();
+}
+export async function writeViewFile(path, content) {
+    await (hooks.getStore()?.writeView ?? writeFile)(path, content);
+}
+// link is the sole commit point; no copy fallback (Node copyFile is not atomic).
+// A resumed zombie can publish first, but never overwrite an existing revision.
+// Logical audit order is (revision, sequence), not materialization completion time.
+export async function commit(repoRoot, scope, mutation) {
+    const { plan } = mutation;
+    const dir = ulwLoopDir(repoRoot, scope);
+    assertStateLockOwned(ulwLoopStateLockPath(repoRoot, scope));
+    await hooks.getStore()?.beforeCommit?.();
+    const next = (plan.revision ?? 0) + 1;
+    const brief = plan.brief ?? readOptional(join(dir, "brief.md")) ?? "";
+    const entries = [...migrationEntries(plan), ...mutation.entries].map((entry, seq) => ({
+        ...entry,
+        revision: next,
+        id: `${next}-${seq}`,
+    }));
+    const record = {
+        version: 1,
+        revision: next,
+        plan: { ...plan, revision: next, brief },
+        ledger: entries,
+    };
+    mkdirSync(join(dir, "revisions"), { recursive: true });
+    mkdirSync(join(dir, "tmp"), { recursive: true });
+    const temp = join(dir, "tmp", `${process.pid}-${randomUUID()}.json`);
+    try {
+        writeFileSync(temp, `${JSON.stringify(record)}\n`, { flag: "wx" });
+        try {
+            (hooks.getStore()?.link ?? linkSync)(temp, join(dir, "revisions", `${String(next).padStart(8, "0")}.json`));
+        }
+        catch (error) {
+            if (hasCode(error, "EEXIST"))
+                throw new UlwLoopError("Another writer published the read revision.", "ULW_LOOP_PUBLISH_CONFLICT", {
+                    cause: error,
+                });
+            if (["EPERM", "ENOTSUP", "EXDEV"].some((code) => hasCode(error, code)))
+                throw new UlwLoopError("Immutable ulw-loop publication requires atomic hard links.", "ULW_LOOP_PUBLISH_UNSUPPORTED_FS", { cause: error });
+            throw error;
+        }
+    }
+    finally {
+        rmSync(temp, { force: true });
+    }
+    plan.revision = next;
+    plan.brief = brief;
+    for (const [index, entry] of mutation.entries.entries())
+        Object.assign(entry, entries[index + entries.length - mutation.entries.length]);
+    await hooks.getStore()?.afterCommit?.();
+    await materialize(dir);
+}
+function viewContents(dir) {
+    const plan = reconcilePlan(dir);
+    if (plan === undefined || readRecords(dir).length === 0)
+        return [];
+    const ledger = readLedgerAt(dir);
+    const views = [
+        ["goals.json", `${JSON.stringify(plan, null, 2)}\n`],
+        ["ledger.jsonl", ledger.length === 0 ? "" : `${ledger.map((entry) => JSON.stringify(entry)).join("\n")}\n`],
+        ["brief.md", plan.brief ?? readOptional(join(dir, "brief.md")) ?? ""],
+    ];
+    return views.filter(([name, content]) => readOptional(join(dir, name)) !== content);
+}
+export function materializeSync(dir) {
+    for (const [name, content] of viewContents(dir)) {
+        mkdirSync(join(dir, "tmp"), { recursive: true });
+        const temp = join(dir, "tmp", `${process.pid}-${randomUUID()}-${name}`);
+        try {
+            writeFileSync(temp, content, { flag: "wx" });
+            renameSync(temp, join(dir, name));
+        }
+        finally {
+            rmSync(temp, { force: true });
+        }
+    }
+}
+export async function materialize(dir) {
+    for (const [name, content] of viewContents(dir)) {
+        mkdirSync(join(dir, "tmp"), { recursive: true });
+        const temp = join(dir, "tmp", `${process.pid}-${randomUUID()}-${name}`);
+        try {
+            await writeViewFile(temp, content);
+            await rename(temp, join(dir, name));
+        }
+        finally {
+            rmSync(temp, { force: true });
+        }
+    }
+}

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

@@ -1,4 +1,5 @@
 import { type UlwLoopScope } from "./paths.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopCodexGoalMode, UlwLoopItem, UlwLoopPlan } from "./types.js";
 export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
 export type UlwLoopPlanSummary = {
@@ -24,7 +25,7 @@ export declare function createUlwLoopPlan(repoRoot: string, args: {
     codexGoalMode?: UlwLoopCodexGoalMode;
     force?: boolean;
     validationBatchesJson?: string;
-}, scope?: UlwLoopScope): Promise<UlwLoopPlan>;
+}, scope?: UlwLoopScope, surface?: UlwLoopToolkitSurface): Promise<UlwLoopPlan>;
 export declare function addUlwLoopGoal(repoRoot: string, args: {
     title: string;
     objective: string;

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

@@ -1,9 +1,8 @@
-import { existsSync } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
 import { aggregateCodexObjectiveForScope, isUlwLoopDone } from "./goal-status.js";
-import { ulwLoopBriefPath, ulwLoopBriefRelativePath, ulwLoopDir, ulwLoopGoalsPath, ulwLoopGoalsRelativePath, ulwLoopLedgerPath, ulwLoopLedgerRelativePath, } from "./paths.js";
+import { ulwLoopBriefRelativePath, ulwLoopGoalsRelativePath, ulwLoopLedgerRelativePath, } from "./paths.js";
+import { beforePlanMutation, commit } from "./plan-commit.js";
 import { appendGoalToPlan, deriveGoalCandidates, makeGoal } from "./plan-goal-factory.js";
-import { appendLedger, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { planExists, readUlwLoopPlan, withUlwLoopMutationLock } from "./plan-io.js";
 import { iso, UlwLoopError } from "./types.js";
 import { parseValidationBatches } from "./validation-batch.js";
 export { deriveGoalCandidates, seedDefaultSuccessCriteria } from "./plan-goal-factory.js";
@@ -22,18 +21,30 @@ function clearGoalBlockerFields(goal) {
     ])
         delete goal[key];
 }
-export async function createUlwLoopPlan(repoRoot, args, scope) {
+export async function createUlwLoopPlan(repoRoot, args, scope, surface = "lazycodex") {
     return withUlwLoopMutationLock(repoRoot, scope, async () => {
-        if (!args.force && existsSync(ulwLoopGoalsPath(repoRoot, scope))) {
-            const existing = await readUlwLoopPlan(repoRoot, scope);
+        let existing;
+        if (planExists(repoRoot, scope)) {
+            try {
+                existing = await readUlwLoopPlan(repoRoot, scope);
+            }
+            catch (error) {
+                if (!args.force)
+                    throw error;
+            }
+        }
+        if (!args.force && existing !== undefined) {
             if (isUlwLoopDone(existing))
-                throw completedPlanExistsError(scope);
+                throw completedPlanExistsError(scope, surface);
             throw new UlwLoopError(`Refusing to overwrite existing ${ulwLoopGoalsRelativePath(scope)}; pass --force to recreate it.`, "ULW_LOOP_PLAN_EXISTS");
         }
         const now = iso();
         const goals = deriveGoalCandidates(args.brief).map((goal, index) => makeGoal(goal.title, goal.objective, index, now));
         const plan = {
             version: 1,
+            revision: existing?.revision ?? 0,
+            ledgerResetRevision: (existing?.revision ?? 0) + 1,
+            brief: args.brief.endsWith("\n") ? args.brief : `${args.brief}\n`,
             evidenceLayoutVersion: 2,
             createdAt: now,
             updatedAt: now,
@@ -48,19 +59,25 @@ export async function createUlwLoopPlan(repoRoot, args, scope) {
             plan.validationBatches = validationBatches;
         if (plan.codexGoalMode === "aggregate")
             plan.codexObjective = aggregateCodexObjectiveForScope(scope);
-        await mkdir(ulwLoopDir(repoRoot, scope), { recursive: true });
-        await writeFile(ulwLoopBriefPath(repoRoot, scope), args.brief.endsWith("\n") ? args.brief : `${args.brief}\n`, "utf8");
-        await writePlan(repoRoot, plan, scope);
-        await writeFile(ulwLoopLedgerPath(repoRoot, scope), "", "utf8");
-        await appendLedger(repoRoot, { at: now, kind: "plan_created", message: `${goals.length} goal(s) created` }, scope);
+        await beforePlanMutation();
+        await commit(repoRoot, scope, {
+            plan,
+            entries: [{ at: now, kind: "plan_created", message: `${goals.length} goal(s) created` }],
+        });
         return plan;
     });
 }
-function completedPlanExistsError(scope) {
+function completedPlanExistsError(scope, surface) {
     return new UlwLoopError([
         `Existing ulw-loop aggregate is already complete at ${ulwLoopGoalsRelativePath(scope)}.`,
-        "Start a new run with `omo-agent-toolkit ulw-loop create-goals --session-id <new-id> ...` to isolate fresh state.",
-        "Use --force only when you intentionally want to overwrite the completed evidence.",
+        ...(surface === "omo-senpi"
+            ? [
+                "Start a new run under a fresh session id (a new senpi session) or call agentToolkit.createGoals({ brief, force: true }) to recreate.",
+            ]
+            : [
+                "Start a new run with `omo-agent-toolkit ulw-loop create-goals --session-id <new-id> ...` to isolate fresh state.",
+                "Use --force only when you intentionally want to overwrite the completed evidence.",
+            ]),
     ].join(" "), "ULW_LOOP_PLAN_EXISTS_COMPLETE");
 }
 export async function addUlwLoopGoal(repoRoot, args, scope) {
@@ -68,8 +85,10 @@ export async function addUlwLoopGoal(repoRoot, args, scope) {
         const plan = await readUlwLoopPlan(repoRoot, scope);
         const now = iso();
         const goal = appendGoalToPlan(plan, args.title, args.objective, now);
-        await writePlan(repoRoot, plan, scope);
-        await appendLedger(repoRoot, { at: now, kind: "goal_added", goalId: goal.id, status: goal.status, message: goal.title }, scope);
+        await commit(repoRoot, scope, {
+            plan,
+            entries: [{ at: now, kind: "goal_added", goalId: goal.id, status: goal.status, message: goal.title }],
+        });
         return { plan, goal };
     });
 }
@@ -82,17 +101,18 @@ export async function startNextUlwLoop(repoRoot, args = {}, scope) {
         const existing = plan.goals.find((goal) => goal.status === "in_progress" && isScheduleEligible(goal));
         if (existing)
             return { plan, goal: existing, resumed: true };
+        const entries = [];
         let next = plan.goals.find((goal) => goal.status === "pending" && isScheduleEligible(goal));
         if (!next && args.retryFailed) {
             next = plan.goals.find((goal) => goal.status === "failed" && !goal.nonRetriable && isScheduleEligible(goal));
             if (next)
-                await appendLedger(repoRoot, {
+                entries.push({
                     at: now,
                     kind: "goal_retried",
                     goalId: next.id,
                     status: "pending",
                     ...(next.failureReason ? { message: next.failureReason } : {}),
-                }, scope);
+                });
         }
         if (!next)
             return { done: true, plan };
@@ -103,8 +123,14 @@ export async function startNextUlwLoop(repoRoot, args = {}, scope) {
         next.updatedAt = now;
         plan.activeGoalId = next.id;
         plan.updatedAt = now;
-        await writePlan(repoRoot, plan, scope);
-        await appendLedger(repoRoot, { at: now, kind: "goal_started", goalId: next.id, status: next.status, message: `Attempt ${next.attempt}` }, scope);
+        entries.push({
+            at: now,
+            kind: "goal_started",
+            goalId: next.id,
+            status: next.status,
+            message: `Attempt ${next.attempt}`,
+        });
+        await commit(repoRoot, scope, { plan, entries });
         return { plan, goal: next, resumed: false };
     });
 }

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