lazycodex-ai 5.0.0-beta.9 → 5.0.0

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

@@ -0,0 +1,108 @@
+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 { assertProjectionComplete, 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);
+    assertProjectionComplete(plan, ledger);
+    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,6 +1,9 @@
 import { type UlwLoopScope } from "./paths.js";
+import type { SuccessCriterionInput } from "./success-criteria-input.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 { SuccessCriterionInput } from "./success-criteria-input.js";
 export type UlwLoopPlanSummary = {
     readonly total: number;
     readonly pending: number;
@@ -24,11 +27,12 @@ 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;
-}, scope?: UlwLoopScope): Promise<{
+    successCriteria?: readonly SuccessCriterionInput[];
+}, scope?: UlwLoopScope, surface?: UlwLoopToolkitSurface): Promise<{
     plan: UlwLoopPlan;
     goal: UlwLoopItem;
 }>;

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 goals = deriveGoalCandidates(args.brief).map((goal, index) => makeGoal(goal.title, goal.objective, index, now, { surface }));
         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,28 +59,39 @@ 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) {
+export async function addUlwLoopGoal(repoRoot, args, scope, surface = "lazycodex") {
     return withUlwLoopMutationLock(repoRoot, scope, async () => {
         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);
+        const goal = appendGoalToPlan(plan, args.title, args.objective, now, {
+            surface,
+            ...(args.successCriteria === undefined ? {} : { successCriteria: args.successCriteria }),
+        });
+        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 +104,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 +126,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-goal-factory.d.ts

@@ -1,8 +1,15 @@
+import { type SuccessCriterionInput } from "./success-criteria-input.js";
+import type { UlwLoopToolkitSurface } from "./surface.js";
 import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "./types.js";
-export declare function seedDefaultSuccessCriteria(goalIndex: number, objective: string): UlwLoopSuccessCriterion[];
+export interface GoalSeedOptions {
+    readonly goalId?: string;
+    readonly surface?: UlwLoopToolkitSurface;
+    readonly successCriteria?: readonly SuccessCriterionInput[];
+}
+export declare function seedDefaultSuccessCriteria(goalIndex: number, objective: string, options?: Pick<GoalSeedOptions, "goalId" | "surface">): UlwLoopSuccessCriterion[];
 export declare function deriveGoalCandidates(brief: string): Array<{
     title: string;
     objective: string;
 }>;
-export declare function makeGoal(title: string, objective: string, index: number, now: string): UlwLoopItem;
-export declare function appendGoalToPlan(plan: UlwLoopPlan, title: string, objective: string, now: string): UlwLoopItem;
+export declare function makeGoal(title: string, objective: string, index: number, now: string, options?: GoalSeedOptions): UlwLoopItem;
+export declare function appendGoalToPlan(plan: UlwLoopPlan, title: string, objective: string, now: string, options?: GoalSeedOptions): UlwLoopItem;

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,15 +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>;