oh-my-opencode 5.0.0-beta.8 → 5.0.0-beta.81

package/packages/omo-codex/plugin/components/ulw-loop/test/sdk-driver-states.test.ts

@@ -0,0 +1,174 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { readUlwLoopPlan } from "../src/plan-io.js";
+import { createAgentToolkit } from "../src/sdk.js";
+
+const workDirs: string[] = [];
+
+afterEach(async () => {
+	for (const dir of workDirs.splice(0)) await rm(dir, { recursive: true, force: true });
+});
+
+interface Seeded {
+	readonly cwd: string;
+	readonly sessionId: string;
+	readonly goalId: string;
+	readonly objective: string;
+}
+
+// One fixture shape for every driver state: a real plan whose first goal is ready to close, so the
+// only thing under test is what the driver snapshot does to the checkpoint.
+async function seed(sessionId: string, brief = "- alpha goal\n- beta goal"): Promise<Seeded> {
+	const cwd = await mkdtemp(join(tmpdir(), "ulw-driver-"));
+	workDirs.push(cwd);
+	const toolkit = createAgentToolkit({ cwd, sessionId, surface: "omo-senpi" });
+	const created = await toolkit.createGoals({ brief });
+	if (!created.ok) throw new Error("fixture could not create goals");
+	return passNextGoal(cwd, sessionId);
+}
+
+async function passNextGoal(cwd: string, sessionId: string): Promise<Seeded> {
+	const toolkit = createAgentToolkit({ cwd, sessionId, surface: "omo-senpi" });
+	const started = await toolkit.completeGoals({});
+	if (!started.ok || started.operation !== "complete-goals" || "done" in started.result)
+		throw new Error("fixture could not start a goal");
+	const goalId = started.result.goal.id;
+	const criteria = await toolkit.criteria({ goalId });
+	if (!criteria.ok || criteria.operation !== "criteria") throw new Error("fixture has no criteria");
+	for (const criterion of criteria.result.criteria) {
+		const recorded = await toolkit.recordEvidence({
+			goalId,
+			criterionId: criterion.id,
+			status: "pass",
+			evidence: "driver-state fixture proof",
+		});
+		if (!recorded.ok) throw new Error("fixture could not record evidence");
+	}
+	const plan = await readUlwLoopPlan(cwd, { sessionId });
+	return { cwd, sessionId, goalId, objective: plan.codexObjective ?? "" };
+}
+
+function warningsOf(result: object): readonly string[] {
+	return "warnings" in result && Array.isArray(result.warnings) ? result.warnings : [];
+}
+
+async function closeWith(seeded: Seeded, snapshot?: Record<string, unknown>) {
+	const toolkit = createAgentToolkit({ cwd: seeded.cwd, sessionId: seeded.sessionId, surface: "omo-senpi" });
+	return toolkit.checkpoint({
+		goalId: seeded.goalId,
+		status: "complete",
+		evidence: "driver-state checkpoint",
+		...(snapshot === undefined ? {} : { codexGoalJson: JSON.stringify(snapshot) }),
+	});
+}
+
+describe("SDK driver-goal states", () => {
+	describe("#given no driver snapshot", () => {
+		it("#when the goal is checkpointed #then it completes and advises creating the driver goal", async () => {
+			const seeded = await seed("driver-absent");
+
+			const closed = await closeWith(seeded);
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) expect(closed.nextActions.join(" ")).toContain("create_goal");
+		});
+	});
+
+	describe("#given an active driver carrying the plan objective", () => {
+		it("#when the goal is checkpointed #then it completes with no objective difference reported", async () => {
+			const seeded = await seed("driver-active");
+
+			const closed = await closeWith(seeded, { goal: { objective: seeded.objective, status: "active" } });
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) {
+				expect([...(closed.warnings ?? []), ...closed.nextActions].join(" ")).not.toContain(
+					"driver_objective_differs",
+				);
+			}
+		});
+	});
+
+	describe("#given a driver completed before the plan finished", () => {
+		it("#when the goal is checkpointed #then it completes and advises re-creating the driver", async () => {
+			const seeded = await seed("driver-early");
+
+			const closed = await closeWith(seeded, { goal: { objective: seeded.objective, status: "complete" } });
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) expect(closed.nextActions.join(" ")).toContain("create_goal");
+		});
+	});
+
+	describe("#given a driver the harness has limited", () => {
+		for (const status of ["paused", "usage_limited", "budget_limited"] as const) {
+			it(`#when the driver is ${status} #then the checkpoint still completes and advises resuming it`, async () => {
+				const seeded = await seed(`driver-${status}`);
+
+				const closed = await closeWith(seeded, { goal: { objective: seeded.objective, status } });
+
+				expect(closed.ok).toBe(true);
+				if (closed.ok) expect(closed.nextActions.join(" ")).toContain("/goal resume");
+			});
+		}
+	});
+
+	describe("#given a driver whose objective differs from the plan", () => {
+		it("#when the goal is checkpointed #then the difference is a warning, never a rejection and never a next action", async () => {
+			const seeded = await seed("driver-differs");
+
+			const closed = await closeWith(seeded, { goal: { objective: "a different objective", status: "active" } });
+
+			expect(closed.ok).toBe(true);
+			if (closed.ok) {
+				expect(warningsOf(closed.result).join(" ")).toContain("driver_objective_differs");
+				expect(closed.nextActions.join(" ")).not.toContain("driver_objective_differs");
+				expect(closed.nextActions.join(" ")).not.toContain("create_goal");
+			}
+		});
+
+		it("#when a later goal is checkpointed under the same driver #then the difference is acknowledged in the plan and not repeated", async () => {
+			const first = await seed("driver-differs-once", "- alpha goal\n- beta goal\n- gamma goal");
+			const driver = { goal: { objective: "  a different\n objective  ", status: "active" } };
+
+			const firstClose = await closeWith(first, driver);
+			const second = await passNextGoal(first.cwd, first.sessionId);
+			const secondClose = await closeWith(second, driver);
+
+			expect(firstClose.ok && secondClose.ok).toBe(true);
+			if (firstClose.ok && secondClose.ok) {
+				expect(warningsOf(firstClose.result).join(" ")).toContain("driver_objective_differs");
+				expect(warningsOf(secondClose.result)).toEqual([]);
+				expect(secondClose.nextActions).toEqual([]);
+			}
+			const plan = await readUlwLoopPlan(first.cwd, { sessionId: first.sessionId });
+			expect(plan.acknowledgedDriverObjectives).toEqual(["a different objective"]);
+		});
+	});
+
+	describe("#given snapshot input that is neither JSON nor a readable path", () => {
+		it("#when the goal is checkpointed #then the typed error is returned and the goal stays open", async () => {
+			const seeded = await seed("driver-malformed");
+
+			const closed = await closeWith(seeded);
+			expect(closed.ok).toBe(true);
+
+			const second = await seed("driver-malformed-2");
+			const toolkit = createAgentToolkit({ cwd: second.cwd, sessionId: second.sessionId, surface: "omo-senpi" });
+			const rejected = await toolkit.checkpoint({
+				goalId: second.goalId,
+				status: "complete",
+				evidence: "driver-state checkpoint",
+				codexGoalJson: "not json and not a path",
+			});
+
+			expect(rejected.ok).toBe(false);
+			if (!rejected.ok) expect(rejected.error.code).toBe("ULW_LOOP_CODEX_GOAL_JSON_INVALID");
+			const plan = await readUlwLoopPlan(second.cwd, { sessionId: second.sessionId });
+			expect(plan.goals.find((goal) => goal.id === second.goalId)?.status).not.toBe("complete");
+		});
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/sdk-dx.test.ts

@@ -0,0 +1,219 @@
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { readUlwLoopPlan } from "../src/plan-io.js";
+import { createAgentToolkit, ULW_LOOP_MANIFEST, type ULW_LOOP_OPERATIONS } from "../src/sdk.js";
+
+const workDirs: string[] = [];
+afterEach(async () => {
+	for (const dir of workDirs.splice(0)) await rm(dir, { recursive: true, force: true });
+});
+
+async function fixture(sessionId: string, surface: "omo-senpi" | "lazycodex" = "omo-senpi") {
+	const cwd = await mkdtemp(join(tmpdir(), "ulw-dx-"));
+	workDirs.push(cwd);
+	const toolkit = createAgentToolkit({ cwd, sessionId, surface });
+	const created = await toolkit.createGoals({ brief: "- alpha goal\n- beta goal" });
+	if (!created.ok) throw new Error("fixture could not create goals");
+	return { cwd, toolkit };
+}
+
+describe("help() is self-describing", () => {
+	it("#given the manifest #when read #then every operation carries its camelCase method, a description, and an args map", () => {
+		const methods: Record<(typeof ULW_LOOP_OPERATIONS)[number], string> = {
+			help: "help",
+			"create-goals": "createGoals",
+			status: "status",
+			"complete-goals": "completeGoals",
+			checkpoint: "checkpoint",
+			steer: "steer",
+			"add-goal": "addGoal",
+			criteria: "criteria",
+			"record-evidence": "recordEvidence",
+			"record-review-blockers": "recordReviewBlockers",
+		};
+		for (const operation of ULW_LOOP_MANIFEST.operations) {
+			expect(operation.method).toBe(methods[operation.name]);
+			expect(operation.description.length).toBeGreaterThan(20);
+			expect(typeof operation.args).toBe("object");
+		}
+		const record = ULW_LOOP_MANIFEST.operations.find((operation) => operation.name === "record-evidence");
+		expect(record?.args).toMatchObject({ goalId: "string", criterionId: "string", evidence: "string" });
+		expect(Object.keys(record?.args ?? {})).toEqual(expect.arrayContaining(["status", "notes", "artifacts"]));
+		const add = ULW_LOOP_MANIFEST.operations.find((operation) => operation.name === "add-goal");
+		expect(Object.keys(add?.args ?? {})).toEqual(expect.arrayContaining(["title", "objective", "successCriteria"]));
+		const steer = ULW_LOOP_MANIFEST.operations.find((operation) => operation.name === "steer");
+		expect(Object.keys(steer?.args ?? {})).toEqual(
+			expect.arrayContaining([
+				"kind",
+				"source",
+				"evidence",
+				"rationale",
+				"goalId",
+				"criterionId",
+				"scenario",
+				"expectedEvidence",
+			]),
+		);
+	});
+
+	it("#given a toolkit #when help() runs #then the result is the manifest", async () => {
+		const { toolkit } = await fixture("dx-help");
+		const help = await toolkit.help();
+		expect(help.ok).toBe(true);
+		if (help.ok) expect(help.result.operations.map((operation) => operation.method)).toContain("recordEvidence");
+	});
+});
+
+describe("addGoal accepts success criteria", () => {
+	it("#given explicit successCriteria #when the goal is added #then exactly those criteria persist with sequential ids", async () => {
+		const { cwd, toolkit } = await fixture("dx-add-criteria");
+		const added = await toolkit.addGoal({
+			title: "lane",
+			objective: "ship the lane",
+			successCriteria: [
+				{ scenario: "curl -i /health returns 200", expectedEvidence: "status line captured in health.log" },
+				{
+					scenario: "malformed body returns 400",
+					expectedEvidence: "curl transcript",
+					userModel: "edge",
+					essential: false,
+				},
+			],
+		});
+		expect(added.ok).toBe(true);
+		if (!added.ok) return;
+		expect(added.result.goal.successCriteria).toEqual([
+			expect.objectContaining({
+				id: "C001",
+				scenario: "curl -i /health returns 200",
+				expectedEvidence: "status line captured in health.log",
+				userModel: "happy",
+				essential: true,
+				status: "pending",
+			}),
+			expect.objectContaining({
+				id: "C002",
+				scenario: "malformed body returns 400",
+				userModel: "edge",
+				essential: false,
+				status: "pending",
+			}),
+		]);
+		const plan = await readUlwLoopPlan(cwd, { sessionId: "dx-add-criteria" });
+		expect(plan.goals.at(-1)?.successCriteria).toHaveLength(2);
+	});
+
+	it("#given invalid successCriteria #when the goal is added #then the call fails closed with ULW_LOOP_ARGUMENT_INVALID and nothing persists", async () => {
+		const { cwd, toolkit } = await fixture("dx-add-invalid");
+		const attempts = [
+			{ successCriteria: [] },
+			{ successCriteria: [{ scenario: "  ", expectedEvidence: "x" }] },
+			{ successCriteria: [{ scenario: "s", expectedEvidence: "" }] },
+			{ successCriteria: [{ scenario: "s", expectedEvidence: "e", userModel: "vibes" }] },
+		];
+		for (const attempt of attempts) {
+			const added = await toolkit.addGoal({
+				title: "lane",
+				objective: "ship the lane",
+				...(attempt as { successCriteria: never }),
+			});
+			expect(added.ok).toBe(false);
+			if (!added.ok) expect(added.error.code).toBe("ULW_LOOP_ARGUMENT_INVALID");
+		}
+		const plan = await readUlwLoopPlan(cwd, { sessionId: "dx-add-invalid" });
+		expect(plan.goals).toHaveLength(2);
+	});
+
+	it("#given no successCriteria #when the goal is added #then the placeholders name the exact surface call", async () => {
+		const senpi = await fixture("dx-add-placeholder", "omo-senpi");
+		const added = await senpi.toolkit.addGoal({ title: "lane", objective: "ship the lane" });
+		expect(added.ok).toBe(true);
+		if (!added.ok) return;
+		const placeholder = added.result.goal.successCriteria[0]?.expectedEvidence ?? "";
+		expect(placeholder).toContain('agentToolkit.steer({ kind: "revise_criterion"');
+		expect(placeholder).toContain(`goalId: "${added.result.goal.id}"`);
+		expect(placeholder).toContain('criterionId: "C001"');
+		expect(placeholder).toContain("successCriteria");
+		expect(placeholder).not.toContain("Replace via revise_criterion with");
+
+		const codex = await fixture("dx-add-placeholder-cli", "lazycodex");
+		const cliAdded = await codex.toolkit.addGoal({ title: "lane", objective: "ship the lane" });
+		expect(cliAdded.ok).toBe(true);
+		if (cliAdded.ok) {
+			expect(cliAdded.result.goal.successCriteria[0]?.expectedEvidence).toContain(
+				`omo-agent-toolkit ulw-loop steer --kind revise_criterion --goal-id ${cliAdded.result.goal.id} --criterion-id C001`,
+			);
+		}
+	});
+});
+
+describe("recordEvidence binds artifacts", () => {
+	it("#given existing artifact paths #when evidence is recorded #then repo-relative paths persist on the criterion and the ledger", async () => {
+		const { cwd, toolkit } = await fixture("dx-artifacts");
+		await mkdir(join(cwd, "evidence"), { recursive: true });
+		await writeFile(join(cwd, "evidence", "gate.log"), "exit 0\n");
+		const outside = join(await mkdtemp(join(tmpdir(), "ulw-dx-outside-")), "shot.png");
+		workDirs.push(join(outside, ".."));
+		await writeFile(outside, "png");
+		const started = await toolkit.completeGoals({});
+		if (!started.ok || started.operation !== "complete-goals" || "done" in started.result) throw new Error("fixture");
+		const goalId = started.result.goal.id;
+		const recorded = await toolkit.recordEvidence({
+			goalId,
+			criterionId: "C001",
+			status: "pass",
+			evidence: "gate green",
+			artifacts: ["evidence/gate.log", join(cwd, "evidence", "gate.log"), outside],
+		});
+		expect(recorded.ok).toBe(true);
+		if (!recorded.ok) return;
+		expect(recorded.result.criterion.artifacts).toEqual(["evidence/gate.log", outside]);
+		expect(recorded.result.ledgerEntry.artifacts).toEqual(["evidence/gate.log", outside]);
+		const ledger = (await readFile(join(cwd, ".omo", "ulw-loop", "dx-artifacts", "ledger.jsonl"), "utf8"))
+			.trim()
+			.split("\n");
+		expect(ledger.at(-1)).toContain('"artifacts":["evidence/gate.log"');
+	});
+
+	it("#given a missing artifact #when evidence is recorded #then it fails with ULW_LOOP_EVIDENCE_ARTIFACT_MISSING naming the path and records nothing", async () => {
+		const { cwd, toolkit } = await fixture("dx-artifact-missing");
+		const started = await toolkit.completeGoals({});
+		if (!started.ok || started.operation !== "complete-goals" || "done" in started.result) throw new Error("fixture");
+		const goalId = started.result.goal.id;
+		const recorded = await toolkit.recordEvidence({
+			goalId,
+			criterionId: "C001",
+			status: "pass",
+			evidence: "gate green",
+			artifacts: ["evidence/does-not-exist.log"],
+		});
+		expect(recorded.ok).toBe(false);
+		if (!recorded.ok) {
+			expect(recorded.error.code).toBe("ULW_LOOP_EVIDENCE_ARTIFACT_MISSING");
+			expect(recorded.error.message).toContain("evidence/does-not-exist.log");
+		}
+		const plan = await readUlwLoopPlan(cwd, { sessionId: "dx-artifact-missing" });
+		expect(plan.goals[0]?.successCriteria[0]?.status).toBe("pending");
+	});
+});
+
+describe("status() exposes a stable evidence root", () => {
+	it("#given a session-scoped plan #when status runs #then evidenceRoot is the plan-level directory beside the moving attempt dir", async () => {
+		const { toolkit } = await fixture("dx-evidence-root");
+		const before = await toolkit.status();
+		expect(before.ok).toBe(true);
+		if (before.ok) expect(before.result.evidenceRoot).toBe(".omo/evidence/ulw/dx-evidence-root");
+		await toolkit.completeGoals({});
+		const after = await toolkit.status();
+		expect(after.ok).toBe(true);
+		if (after.ok) {
+			expect(after.result.evidenceRoot).toBe(".omo/evidence/ulw/dx-evidence-root");
+			expect(after.result.currentAttemptDir).toMatch(
+				/^\.omo\/evidence\/ulw\/dx-evidence-root\/G001-alpha-goal\/a\d+$/,
+			);
+		}
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/sdk-session-context.test.ts

@@ -0,0 +1,169 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { ulwLoopLedgerPath, ulwLoopStateLockPath } from "../src/paths.js";
+import { createAgentToolkit } from "../src/sdk.js";
+
+const children: ChildProcess[] = [];
+const workDirs: string[] = [];
+
+afterEach(async () => {
+	for (const child of children.splice(0)) {
+		if (child.exitCode === null) child.kill("SIGKILL");
+	}
+	for (const dir of workDirs.splice(0)) await rm(dir, { recursive: true, force: true });
+});
+
+const HOLDER_SCRIPT = `
+const fs = require("node:fs");
+const path = require("node:path");
+const [lockPath, holdMs] = process.argv.slice(1);
+fs.mkdirSync(path.dirname(lockPath), { recursive: true });
+const fd = fs.openSync(lockPath, "wx");
+fs.writeSync(fd, JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString(), token: "holder-" + process.pid }));
+fs.closeSync(fd);
+process.stdout.write("HELD\\n");
+setTimeout(() => {
+	fs.writeFileSync(lockPath + ".released", "");
+	fs.unlinkSync(lockPath);
+}, Number(holdMs));
+`;
+
+async function makeWorkdir(): Promise<string> {
+	const dir = await mkdtemp(join(tmpdir(), "ulw-sdk-session-"));
+	workDirs.push(dir);
+	return dir;
+}
+
+function holdStateLock(lockPath: string, holdMs: number): Promise<{ readonly releasedMarker: string }> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(process.execPath, ["-e", HOLDER_SCRIPT, lockPath, String(holdMs)], {
+			stdio: ["ignore", "pipe", "inherit"],
+		});
+		children.push(child);
+		let output = "";
+		child.stdout.setEncoding("utf8");
+		child.stdout.on("data", (chunk: string) => {
+			output += chunk;
+			if (output.includes("HELD")) resolve({ releasedMarker: `${lockPath}.released` });
+		});
+		child.once("error", reject);
+	});
+}
+
+async function seedSession(
+	cwd: string,
+	sessionId: string,
+): Promise<{ readonly goalId: string; readonly criteria: readonly string[] }> {
+	const toolkit = createAgentToolkit({ cwd, sessionId, surface: "lazycodex" });
+	const created = await toolkit.createGoals({ brief: "Session context fixture" });
+	if (!created.ok) throw new Error("fixture could not create goals");
+	const started = await toolkit.completeGoals({});
+	if (!started.ok || started.operation !== "complete-goals" || "done" in started.result)
+		throw new Error("fixture could not start a goal");
+	const goalId = started.result.goal.id;
+	const criteria = await toolkit.criteria({ goalId });
+	if (!criteria.ok || criteria.operation !== "criteria") throw new Error("fixture has no criteria");
+	return { goalId, criteria: criteria.result.criteria.map((criterion) => criterion.id) };
+}
+
+describe("agent toolkit session context", () => {
+	describe("#given a session id that normalizes to null", () => {
+		it("#when an omo-senpi SDK context is created #then it rejects without creating session state", async () => {
+			const cwd = await makeWorkdir();
+
+			expect(() => createAgentToolkit({ cwd, sessionId: "../../x", surface: "omo-senpi" })).toThrowError(
+				expect.objectContaining({ code: "ULW_LOOP_SESSION_ID_INVALID" }),
+			);
+			expect(existsSync(join(cwd, ".omo", "ulw-loop"))).toBe(false);
+		});
+	});
+
+	describe("#given a blank session id", () => {
+		it("#when an SDK context is created #then it reports the required-id error", async () => {
+			const cwd = await makeWorkdir();
+
+			expect(() => createAgentToolkit({ cwd, sessionId: "   ", surface: "omo-senpi" })).toThrowError(
+				expect.objectContaining({ code: "ULW_LOOP_SESSION_ID_REQUIRED" }),
+			);
+		});
+	});
+
+	describe("#given a plan written under session A", () => {
+		it("#when session B reads through its own context #then the read fails closed instead of borrowing A", async () => {
+			const cwd = await makeWorkdir();
+			await seedSession(cwd, "session-a");
+
+			const foreign = createAgentToolkit({ cwd, sessionId: "session-b", surface: "lazycodex" });
+			const status = await foreign.status();
+
+			expect(status.ok).toBe(false);
+		});
+	});
+
+	describe("#given the session state lock held by another process", () => {
+		it("#when an SDK mutation runs #then it waits for that release before writing", async () => {
+			const cwd = await makeWorkdir();
+			const sessionId = "session-lock";
+			const seeded = await seedSession(cwd, sessionId);
+			const criterionId = seeded.criteria[0];
+			if (criterionId === undefined) throw new Error("fixture has no criterion");
+			const holder = await holdStateLock(ulwLoopStateLockPath(cwd, { sessionId }), 300);
+
+			const toolkit = createAgentToolkit({ cwd, sessionId, surface: "lazycodex" });
+			const recorded = await toolkit.recordEvidence({
+				goalId: seeded.goalId,
+				criterionId,
+				status: "pass",
+				evidence: "waited for the held lock",
+			});
+
+			expect(recorded.ok).toBe(true);
+			expect(existsSync(holder.releasedMarker)).toBe(true);
+		});
+	});
+
+	describe("#given two SDK instances bound to one session directory", () => {
+		it("#when both record evidence concurrently #then the ledger keeps both entries", async () => {
+			const cwd = await makeWorkdir();
+			const sessionId = "session-concurrent";
+			const seeded = await seedSession(cwd, sessionId);
+			const first = seeded.criteria[0];
+			const second = seeded.criteria[1];
+			if (first === undefined || second === undefined) throw new Error("fixture needs two criteria");
+
+			const results = await Promise.all([
+				createAgentToolkit({ cwd, sessionId, surface: "lazycodex" }).recordEvidence({
+					goalId: seeded.goalId,
+					criterionId: first,
+					status: "pass",
+					evidence: "first instance",
+				}),
+				createAgentToolkit({ cwd, sessionId, surface: "lazycodex" }).recordEvidence({
+					goalId: seeded.goalId,
+					criterionId: second,
+					status: "pass",
+					evidence: "second instance",
+				}),
+			]);
+
+			expect(results.every((result) => result.ok)).toBe(true);
+			const ledger = await readFile(ulwLoopLedgerPath(cwd, { sessionId }), "utf8");
+			const recorded = ledger
+				.split("\n")
+				.filter((line) => line.trim().length > 0)
+				.map((line): unknown => JSON.parse(line))
+				.filter((entry): entry is { readonly criterionId: string } => {
+					if (typeof entry !== "object" || entry === null || !("criterionId" in entry)) return false;
+					return typeof entry.criterionId === "string";
+				})
+				.map((entry) => entry.criterionId);
+			expect(recorded).toContain(first);
+			expect(recorded).toContain(second);
+		});
+	});
+});