lazycodex-ai 5.0.0-beta.9 → 5.0.0

package/packages/omo-codex/plugin/components/ulw-loop/test/plan-commit-log.test.ts

@@ -0,0 +1,252 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { ulwLoopDir } from "../src/paths.js";
+import { createUlwLoopPlan } from "../src/plan-crud.js";
+import * as io from "../src/plan-io.js";
+import { childWriter, cleanupWriters } from "./fixtures/commit-child.js";
+import { seedCrash } from "./fixtures/commit-crash.js";
+import { leaseClock } from "./fixtures/lease-clock.js";
+
+let root: string;
+let dir: string;
+const scope = { sessionId: "commit-log" };
+beforeEach(async () => {
+	root = await mkdtemp(join(tmpdir(), "ulw-commit-"));
+	dir = ulwLoopDir(root, scope);
+});
+afterEach(async () => {
+	await cleanupWriters();
+	await rm(root, { recursive: true, force: true });
+});
+function snapshot() {
+	return Object.fromEntries(
+		["goals.json", "ledger.jsonl", "brief.md"].map((name) => [
+			name,
+			existsSync(join(dir, name)) ? readFileSync(join(dir, name), "utf8") : null,
+		]),
+	);
+}
+
+describe("#given an immutable plan and audit log", () => {
+	it("#when (7a) a writer dies after publishing #then reads reconcile without writes and locked reads repair views", async () => {
+		const next = await seedCrash(root, scope, false);
+		const before = snapshot();
+		expect(await io.readUlwLoopPlan(root, scope)).toEqual(next);
+		expect(io.readLedger(root, scope).at(-1)?.id).toBe(`${next.revision}-0`);
+		expect(snapshot()).toEqual(before);
+		await io.withUlwLoopMutationLock(root, scope, () => io.readUlwLoopPlan(root, scope));
+		expect(JSON.parse(readFileSync(join(dir, "goals.json"), "utf8"))).toEqual(next);
+		expect(readFileSync(join(dir, "brief.md"), "utf8")).toBe(next.brief);
+	});
+	it("#when (7b) first creation has no goals cache #then existence and reads use the log", async () => {
+		const next = await seedCrash(root, scope, true);
+		expect(io.planExists(root, scope)).toBe(true);
+		expect(await io.readUlwLoopPlan(root, scope)).toEqual(next);
+	});
+	it("#when (8) a legacy plan first commits #then revision zero and legacy ledger and brief survive", async () => {
+		const plan = await createUlwLoopPlan(root, { brief: "legacy" }, scope);
+		delete plan.revision;
+		delete plan.brief;
+		delete plan.ledgerResetRevision;
+		await rm(join(dir, "revisions"), { recursive: true, force: true });
+		writeFileSync(join(dir, "goals.json"), JSON.stringify(plan));
+		writeFileSync(join(dir, "ledger.jsonl"), '{"at":"legacy","kind":"goal_started"}\n{"torn":');
+		expect(io.readLedger(root, scope)[0]).toMatchObject({ revision: 0, id: "legacy-1" });
+		const { commit } = await import("../src/plan-commit.js");
+		await io.withUlwLoopMutationLock(root, scope, async () => {
+			const legacy = await io.readUlwLoopPlan(root, scope);
+			await commit(root, scope, { plan: legacy, entries: [] });
+		});
+		expect(readdirSync(join(dir, "revisions"))).toEqual(["00000001.json"]);
+		expect(io.readLedger(root, scope)[0]?.id).toBe("legacy-1");
+		expect(readFileSync(join(dir, "brief.md"), "utf8")).toBe("legacy\n");
+	});
+	it("#when (9) force recreation succeeds #then the reset is a new revision with filtered views", async () => {
+		const first = await createUlwLoopPlan(root, { brief: "old" }, scope);
+		const next = await createUlwLoopPlan(root, { brief: "new", force: true }, scope);
+		expect(next.revision).toBe((first.revision ?? 0) + 1);
+		expect(next.ledgerResetRevision).toBe(next.revision);
+		expect(io.readLedger(root, scope)).toHaveLength(1);
+		expect(readFileSync(join(dir, "brief.md"), "utf8")).toBe(next.brief);
+		expect(readdirSync(join(dir, "revisions"))).toHaveLength(2);
+	});
+	it("#when (12) hard links are unsupported #then publication fails closed without a record or view changes", async () => {
+		await createUlwLoopPlan(root, { brief: "old" }, scope);
+		const before = snapshot();
+		const { withCommitHooks, commit } = await import("../src/plan-commit.js");
+		await expect(
+			withCommitHooks(
+				{
+					link: () => {
+						throw Object.assign(new Error("unsupported"), { code: "EPERM" });
+					},
+				},
+				() =>
+					io.withUlwLoopMutationLock(root, scope, async () => {
+						const plan = await io.readUlwLoopPlan(root, scope);
+						plan.brief = "forbidden";
+						await commit(root, scope, { plan, entries: [] });
+					}),
+			),
+		).rejects.toMatchObject({ code: "ULW_LOOP_PUBLISH_UNSUPPORTED_FS" });
+		expect(snapshot()).toEqual(before);
+		expect(readdirSync(join(dir, "revisions"))).toHaveLength(1);
+	});
+});
+
+describe("#given paused writers in separate processes", () => {
+	it.each(["write", "force"])(
+		"#when (5)/(9) B wins %s after A's precheck #then A loses without publishing or changing views",
+		async (mode) => {
+			await createUlwLoopPlan(root, { brief: "initial" }, scope);
+			const { withCommitHooks, commit } = await import("../src/plan-commit.js");
+			let successor: ReturnType<typeof snapshot> | undefined;
+			let writes = 0;
+			const clock = leaseClock();
+			await expect(
+				withCommitHooks(
+					{
+						beforeCommit: async () => {
+							clock.advance(201);
+							const writer = childWriter(root, mode, clock.now());
+							expect(await writer.exited).toBe(0);
+							successor = snapshot();
+						},
+						writeView: async () => {
+							writes += 1;
+							throw new Error("loser wrote a view");
+						},
+					},
+					() =>
+						io.withUlwLoopMutationLock(
+							root,
+							scope,
+							async () => {
+								const plan = await io.readUlwLoopPlan(root, scope);
+								plan.brief = "A\n";
+								await commit(root, scope, { plan, entries: [{ at: "A", kind: "goal_added", message: "A" }] });
+							},
+							{ clock, leaseMs: 200, heartbeatMs: 0 },
+						),
+				),
+			).rejects.toMatchObject({ code: "ULW_LOOP_LOCK_LOST" });
+			expect(writes).toBe(0);
+			expect(snapshot()).toEqual(successor);
+			const published = JSON.parse(readFileSync(join(dir, "revisions", "00000002.json"), "utf8"));
+			expect(published.plan).toEqual(await io.readUlwLoopPlan(root, scope));
+			expect(published.ledger).toHaveLength(1);
+			expect(io.readLedger(root, scope).at(-1)).toEqual(published.ledger[0]);
+			expect(published.ledger[0].kind).toBe(mode === "force" ? "plan_created" : "goal_added");
+			expect(io.readLedger(root, scope).some((entry) => entry.message === "A")).toBe(false);
+			expect(readdirSync(join(dir, "revisions"))).toEqual(["00000001.json", "00000002.json"]);
+		},
+	);
+	it("#when (6) A wins before the valid holder B #then B retries once from A's revision", async () => {
+		await createUlwLoopPlan(root, { brief: "initial" }, scope);
+		const { withCommitHooks, commit } = await import("../src/plan-commit.js");
+		let writer: ReturnType<typeof childWriter> | undefined;
+		const clock = leaseClock();
+		await withCommitHooks(
+			{
+				beforeCommit: async () => {
+					clock.advance(201);
+					writer = childWriter(root, "mirror", clock.now());
+					await writer.wait("before");
+				},
+			},
+			() =>
+				io.withUlwLoopMutationLock(
+					root,
+					scope,
+					async () => {
+						const plan = await io.readUlwLoopPlan(root, scope);
+						plan.codexObjective = "A";
+						await commit(root, scope, { plan, entries: [{ at: "A", kind: "goal_added", message: "A" }] });
+					},
+					{ clock, leaseMs: 200, heartbeatMs: 0 },
+				),
+		);
+		if (writer === undefined) throw new Error("B not started");
+		writer.child.send("resume");
+		expect(await writer.exited).toBe(0);
+		expect((await io.readUlwLoopPlan(root, scope)).codexObjective).toBe("A|B");
+		expect(
+			io
+				.readLedger(root, scope)
+				.slice(-2)
+				.map((entry) => entry.message),
+		).toEqual(["A", "B"]);
+		expect(readdirSync(join(dir, "revisions"))).toHaveLength(3);
+	});
+	it("#when (7c) a child dies after an acknowledged partial temp write #then every public view remains complete", async () => {
+		await createUlwLoopPlan(root, { brief: "initial" }, scope);
+		const before = snapshot();
+		const writer = childWriter(root, "partial");
+		await writer.wait("partial");
+		writer.child.kill("SIGKILL");
+		await writer.exited;
+		const after = snapshot();
+		const published = JSON.parse(readFileSync(join(dir, "revisions", "00000002.json"), "utf8"));
+		expect([before["goals.json"], `${JSON.stringify(published.plan, null, 2)}\n`]).toContain(after["goals.json"]);
+		expect([before["brief.md"], published.plan.brief]).toContain(after["brief.md"]);
+		expect(after["ledger.jsonl"]).toBe(before["ledger.jsonl"]);
+		for (const line of readFileSync(join(dir, "ledger.jsonl"), "utf8").trim().split("\n"))
+			expect(() => JSON.parse(line)).not.toThrow();
+		expect(io.readLedger(root, scope).at(-1)?.message).toBe("B");
+	});
+	it.each(["accepted", "rejected"])(
+		"#when (11) %s steering dies after link #then its audit survives and accepted retries dedupe",
+		async (mode) => {
+			const original = await createUlwLoopPlan(root, { brief: "initial" }, scope);
+			const writer = childWriter(root, mode);
+			await writer.wait("linked");
+			writer.child.kill("SIGKILL");
+			await writer.exited;
+			expect(io.readLedger(root, scope).at(-1)?.kind).toBe(`steering_${mode}`);
+			const prior = await io.findAcceptedSteeringLedgerEntry(root, "crash-key", scope);
+			if (mode === "rejected") {
+				expect(prior).toBeUndefined();
+				expect(await io.readUlwLoopPlan(root, scope)).toEqual({ ...original, revision: 2 });
+			} else {
+				const { steerUlwLoop } = await import("../src/steering.js");
+				const result = await steerUlwLoop(
+					root,
+					{
+						kind: "annotate_ledger",
+						source: "cli",
+						evidence: "observed",
+						rationale: "audit",
+						idempotencyKey: "crash-key",
+					},
+					scope,
+				);
+				expect(result.deduped).toBe(true);
+				expect(io.readLedger(root, scope)).toHaveLength(2);
+				expect(readdirSync(join(dir, "revisions"))).toHaveLength(2);
+			}
+		},
+	);
+	it("#when (10) retry fails before commit #then no goal_retried audit escapes", async () => {
+		const { startNextUlwLoop } = await import("../src/plan-crud.js");
+		const plan = await createUlwLoopPlan(root, { brief: "initial" }, scope);
+		const { commit, withCommitHooks } = await import("../src/plan-commit.js");
+		for (const goal of plan.goals) goal.status = "failed";
+		await commit(root, scope, { plan, entries: [] });
+		const before = snapshot();
+		await expect(
+			withCommitHooks(
+				{
+					beforeCommit: () => {
+						throw new Error("stop before commit");
+					},
+				},
+				() => startNextUlwLoop(root, { retryFailed: true }, scope),
+			),
+		).rejects.toThrow("stop before commit");
+		expect(snapshot()).toEqual(before);
+		expect(io.readLedger(root, scope).some((entry) => entry.kind === "goal_retried")).toBe(false);
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/plan-commit-recovery.test.ts

@@ -0,0 +1,190 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { PreToolUsePayload } from "../src/codex-hook.js";
+import { ulwLoopDir } from "../src/paths.js";
+import { commit, materialize, withCommitHooks } from "../src/plan-commit.js";
+import { createUlwLoopPlan } from "../src/plan-crud.js";
+import {
+	planExists,
+	readLedger,
+	readUlwLoopPlan,
+	withMutationLockOptions,
+	withUlwLoopMutationLock,
+} from "../src/plan-io.js";
+import { applySpawnBudgetGuards } from "../src/spawn-guard.js";
+import { runStopResumeHook } from "../src/stop-resume-hook.js";
+import { childWriter, cleanupWriters } from "./fixtures/commit-child.js";
+import { leaseClock } from "./fixtures/lease-clock.js";
+
+let root: string;
+let dir: string;
+const scope = { sessionId: "commit-log" };
+beforeEach(async () => {
+	root = await mkdtemp(join(tmpdir(), "ulw-recovery-"));
+	dir = ulwLoopDir(root, scope);
+});
+afterEach(async () => {
+	await cleanupWriters();
+	vi.unstubAllEnvs();
+	await rm(root, { recursive: true, force: true });
+});
+function signal() {
+	let resolve: () => void = () => {
+		throw new Error("signal not initialized");
+	};
+	const promise = new Promise<void>((done, reject) => {
+		const timeout = setTimeout(() => reject(new Error("signal timed out")), 5_000);
+		resolve = () => {
+			clearTimeout(timeout);
+			done();
+		};
+	});
+	return { promise, resolve };
+}
+function views() {
+	return ["goals.json", "ledger.jsonl", "brief.md"].map((name) => readFileSync(join(dir, name), "utf8"));
+}
+describe("#given crash recovery through public surfaces", () => {
+	it("#when (7b) only revision one exists #then both hooks and existence gates use it", async () => {
+		const plan = await createUlwLoopPlan(root, { brief: "unfinished" }, scope);
+		for (const name of ["goals.json", "ledger.jsonl", "brief.md"]) await rm(join(dir, name));
+		expect(readdirSync(join(dir, "revisions"))).toEqual(["00000001.json"]);
+		expect(planExists(root, scope)).toBe(true);
+		expect((await readUlwLoopPlan(root, scope)).revision).toBe(1);
+		const payload = {
+			session_id: scope.sessionId,
+			turn_id: "turn",
+			cwd: root,
+			model: "test",
+			permission_mode: "default",
+		};
+		const stop = {
+			...payload,
+			hook_event_name: "Stop",
+			transcript_path: join(root, "transcript"),
+			stop_hook_active: false,
+		};
+		expect(JSON.parse(runStopResumeHook(stop)).decision).toBe("block");
+		expect(JSON.parse(readFileSync(join(dir, `auto-resume-${plan.goals[0]?.id}.json`), "utf8")).ledgerLineCount).toBe(
+			1,
+		);
+		vi.stubEnv("OMO_SPAWN_FANOUT_LIMIT", "1");
+		vi.stubEnv("PLUGIN_DATA", join(root, "plugin-data"));
+		const spawn: PreToolUsePayload = {
+			...payload,
+			hook_event_name: "PreToolUse",
+			transcript_path: null,
+			tool_name: "spawn_agent",
+			tool_use_id: "tool",
+			tool_input: {},
+		};
+		expect(applySpawnBudgetGuards(spawn)).toBe("");
+		expect(JSON.parse(applySpawnBudgetGuards(spawn)).hookSpecificOutput.permissionDecision).toBe("deny");
+	});
+	it("#when (7c) two materializers overlap #then every public inode is complete even if a view regresses", async () => {
+		const plan = await createUlwLoopPlan(root, { brief: "old" }, scope);
+		const old = views();
+		await withCommitHooks(
+			{
+				afterCommit: () => {
+					throw new Error("crash");
+				},
+			},
+			() =>
+				commit(root, scope, {
+					plan: { ...plan, brief: "middle\n" },
+					entries: [{ at: "middle", kind: "goal_added" }],
+				}),
+		).catch((error: unknown) => {
+			expect(error).toBeInstanceOf(Error);
+		});
+		const middleViews = [
+			`${JSON.stringify(await readUlwLoopPlan(root, scope), null, 2)}\n`,
+			`${readLedger(root, scope)
+				.map((entry) => JSON.stringify(entry))
+				.join("\n")}\n`,
+			"middle\n",
+		];
+		const partial = signal();
+		const resume = signal();
+		const first = withCommitHooks(
+			{
+				writeView: async (path, content) => {
+					if (path.endsWith("ledger.jsonl")) {
+						await writeFile(path, content.slice(0, 5));
+						partial.resolve();
+						await resume.promise;
+					}
+					await writeFile(path, content);
+				},
+			},
+			() => materialize(dir),
+		);
+		await partial.promise;
+		expect(readFileSync(join(dir, "ledger.jsonl"), "utf8")).toBe(old[1]);
+		const latest = await readUlwLoopPlan(root, scope);
+		await commit(root, scope, { plan: { ...latest, brief: "new\n" }, entries: [{ at: "new", kind: "goal_added" }] });
+		const newViews = views();
+		resume.resolve();
+		await first;
+		const final = views();
+		expect(() => JSON.parse(final[0] ?? "")).not.toThrow();
+		for (const line of (final[1] ?? "").trim().split("\n")) expect(() => JSON.parse(line)).not.toThrow();
+		for (const [index, content] of final.entries()) expect([middleViews[index], newViews[index]]).toContain(content);
+		expect(
+			readLedger(root, scope)
+				.map((entry) => entry.at)
+				.slice(-2),
+		).toEqual(["middle", "new"]);
+	});
+	it("#when (9) a force-recreator loses before its first possible view write #then its successor stays untouched", async () => {
+		await createUlwLoopPlan(root, { brief: "old" }, scope);
+		let successor: string[] = [];
+		let writes = 0;
+		const clock = leaseClock();
+		await expect(
+			withCommitHooks(
+				{
+					beforeMutation: async () => {
+						clock.advance(201);
+						const writer = childWriter(root, "force", clock.now());
+						expect(await writer.exited).toBe(0);
+						successor = views();
+					},
+					writeView: async (path, content) => {
+						writes += 1;
+						await writeFile(path, content);
+					},
+				},
+				() =>
+					withMutationLockOptions({ clock, leaseMs: 200, heartbeatMs: 0 }, () =>
+						createUlwLoopPlan(root, { brief: "A", force: true }, scope),
+					),
+			),
+		).rejects.toMatchObject({ code: "ULW_LOOP_LOCK_LOST" });
+		expect(writes).toBe(0);
+		expect(views()).toEqual(successor);
+		expect(readLedger(root, scope)).toHaveLength(1);
+	});
+	it("#when a locked ledger-only read follows a crash #then all views are repaired without another revision", async () => {
+		const plan = await createUlwLoopPlan(root, { brief: "old" }, scope);
+		await expect(
+			withCommitHooks(
+				{
+					afterCommit: () => {
+						throw new Error("crash");
+					},
+				},
+				() => commit(root, scope, { plan: { ...plan, brief: "new\n" }, entries: [] }),
+			),
+		).rejects.toThrow("crash");
+		await withUlwLoopMutationLock(root, scope, async () => {
+			expect(readLedger(root, scope)).toHaveLength(1);
+		});
+		expect(readFileSync(join(dir, "brief.md"), "utf8")).toBe("new\n");
+		expect(readdirSync(join(dir, "revisions"))).toHaveLength(2);
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/plan-io-cross-process.test.ts

@@ -0,0 +1,106 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import type { UlwLoopPlan } from "../src/types.ts";
+
+type EvidenceModule = typeof import("../src/evidence.ts");
+
+const NOW = "2026-09-07T00:00:00.000Z";
+const SCOPE = { sessionId: "s1" } as const;
+const CRITERIA = ["C001", "C002", "C003"] as const;
+
+let repoRoot: string;
+
+beforeEach(async () => {
+	repoRoot = await mkdtemp(join(tmpdir(), "ulw-cross-process-"));
+	await mkdir(join(repoRoot, ".omo", "ulw-loop", "s1"), { recursive: true });
+	await writeFile(join(repoRoot, ".omo", "ulw-loop", "s1", "goals.json"), `${JSON.stringify(plan(), null, 2)}\n`);
+	await writeFile(join(repoRoot, ".omo", "ulw-loop", "s1", "ledger.jsonl"), "");
+});
+
+afterEach(async () => {
+	vi.resetModules();
+	await rm(repoRoot, { recursive: true, force: true });
+});
+
+function plan(): UlwLoopPlan {
+	return {
+		version: 1,
+		evidenceLayoutVersion: 2,
+		createdAt: NOW,
+		updatedAt: NOW,
+		briefPath: ".omo/ulw-loop/s1/brief.md",
+		goalsPath: ".omo/ulw-loop/s1/goals.json",
+		ledgerPath: ".omo/ulw-loop/s1/ledger.jsonl",
+		codexGoalMode: "aggregate",
+		activeGoalId: "G001",
+		goals: [
+			{
+				id: "G001",
+				title: "Goal one",
+				objective: "Goal one",
+				status: "in_progress",
+				attempt: 1,
+				createdAt: NOW,
+				updatedAt: NOW,
+				successCriteria: CRITERIA.map((id) => ({
+					id,
+					scenario: `scenario ${id}`,
+					userModel: "happy",
+					expectedEvidence: "evidence",
+					essential: true,
+					capturedEvidence: null,
+					status: "pending",
+				})),
+			},
+		],
+	};
+}
+
+// Each isolated import evaluates plan-io again, so every instance owns a fresh
+// in-process promise chain: the same situation as separate CLI processes
+// sharing one state directory.
+async function loadIsolatedEvidenceModule(): Promise<EvidenceModule> {
+	vi.resetModules();
+	return await import("../src/evidence.ts");
+}
+
+async function readPlanFile(): Promise<UlwLoopPlan> {
+	return JSON.parse(await readFile(join(repoRoot, ".omo", "ulw-loop", "s1", "goals.json"), "utf8"));
+}
+
+async function readLedgerKinds(): Promise<readonly string[]> {
+	const raw = await readFile(join(repoRoot, ".omo", "ulw-loop", "s1", "ledger.jsonl"), "utf8");
+	return raw
+		.split("\n")
+		.filter((line) => line.trim().length > 0)
+		.map((line) => JSON.parse(line).kind);
+}
+
+describe("record-evidence across independent module instances", () => {
+	describe("#given three evidence writers that share only the state directory", () => {
+		it("#when they record different criteria concurrently #then every criterion lands in goals.json", async () => {
+			const writers: { readonly criterionId: string; readonly module: EvidenceModule }[] = [];
+			for (const criterionId of CRITERIA) {
+				writers.push({ criterionId, module: await loadIsolatedEvidenceModule() });
+			}
+
+			await Promise.all(
+				writers.map(({ criterionId, module }) =>
+					module.recordEvidence(
+						repoRoot,
+						{ goalId: "G001", criterionId, status: "pass", evidence: `proof ${criterionId}` },
+						SCOPE,
+					),
+				),
+			);
+
+			const persisted = await readPlanFile();
+			const statuses = persisted.goals[0]?.successCriteria.map((criterion) => criterion.status);
+			expect(statuses).toEqual(["pass", "pass", "pass"]);
+			expect(await readLedgerKinds()).toEqual(["evidence_captured", "evidence_captured", "evidence_captured"]);
+		});
+	});
+});