lazycodex-ai 5.0.0-beta.7 → 5.0.0-beta.71

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

@@ -1,7 +1,7 @@
+import { existsSync } from "node:fs";
 import { appendFile, copyFile, mkdir, mkdtemp, readdir, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { setImmediate as tick } from "node:timers/promises";
 import { beforeEach, describe, expect, it } from "vitest";
 import { ulwLoopDir, ulwLoopGoalsPath, ulwLoopLedgerPath } from "../src/paths.js";
 import {
@@ -14,6 +14,7 @@ import {
 } from "../src/plan-io.js";
 import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan, UlwLoopSteeringAudit } from "../src/types.js";
 import { UlwLoopError } from "../src/types.js";
+import { barrier } from "./fixtures/barrier.js";
 
 const NOW = "2026-05-23T00:00:00.000Z";
 const STABLE_OBJECTIVE =
@@ -96,6 +97,12 @@ async function makeRepo(): Promise<string> {
 	return mkdtemp(join(tmpdir(), "ug-io-"));
 }
 
+async function makeLedgerRepo(): Promise<string> {
+	const root = await makeRepo();
+	await writePlan(root, makePlan());
+	return root;
+}
+
 async function writeRawPlan(repoRoot: string, plan: UlwLoopPlan): Promise<void> {
 	await mkdir(ulwLoopDir(repoRoot), { recursive: true });
 	await writeFile(ulwLoopGoalsPath(repoRoot), `${JSON.stringify(plan, null, 2)}\n`, "utf8");
@@ -135,13 +142,17 @@ describe("readUlwLoopPlan", () => {
 		expect(plan.goals[0]?.successCriteria).toHaveLength(3);
 	});
 
-	it("migrates legacy aggregate objective on read + writes aggregate_objective_migrated ledger entry + retains alias", async () => {
+	it("migrates legacy aggregate objective in memory and folds its audit into the enclosing commit", async () => {
 		// given
 		const legacyObjective = "Complete all ulw-loop stories in .omo/ulw-loop/goals.json: G001 Build auth service";
 		await writeRawPlan(repoRoot, makePlan({ codexObjective: legacyObjective }));
 
-		// when
-		const plan = await readUlwLoopPlan(repoRoot);
+		// when: read inside the mutation lock, the way every mutating command does
+		const plan = await withUlwLoopMutationLock(repoRoot, async () => {
+			const migrated = await readUlwLoopPlan(repoRoot);
+			await writePlan(repoRoot, migrated);
+			return migrated;
+		});
 
 		// then
 		expect(plan.codexObjective).toBe(STABLE_OBJECTIVE);
@@ -155,6 +166,34 @@ describe("readUlwLoopPlan", () => {
 			before: { codexObjective: legacyObjective },
 		});
 	});
+
+	it("readUlwLoopPlan migrates a legacy aggregate plan in memory outside the mutation lock without writing", async () => {
+		// given: the same legacy plan, but the read is not wrapped in withUlwLoopMutationLock
+		const legacyObjective = "Complete all ulw-loop stories in .omo/ulw-loop/goals.json: G001 Build auth service";
+		await writeRawPlan(repoRoot, makePlan({ codexObjective: legacyObjective }));
+
+		// when
+		const migrated = await readUlwLoopPlan(repoRoot);
+
+		// then: only the returned shape changes
+		expect(migrated.codexObjective).toBe(STABLE_OBJECTIVE);
+		expect(migrated.codexObjectiveAliases).toContain(legacyObjective);
+		const persisted = JSON.parse(await readFile(ulwLoopGoalsPath(repoRoot), "utf8"));
+		expect(persisted.codexObjective).toBe(legacyObjective);
+		expect(existsSync(ulwLoopLedgerPath(repoRoot))).toBe(false);
+	});
+
+	it("a read of an already-migrated plan outside the lock still succeeds", async () => {
+		// given
+		await writeRawPlan(repoRoot, makePlan({ codexObjective: STABLE_OBJECTIVE }));
+
+		// when
+		const plan = await readUlwLoopPlan(repoRoot);
+
+		// then
+		expect(plan.codexObjective).toBe(STABLE_OBJECTIVE);
+		expect(existsSync(ulwLoopLedgerPath(repoRoot))).toBe(false);
+	});
 });
 
 describe("writePlan", () => {
@@ -177,7 +216,8 @@ describe("writePlan", () => {
 		await writePlan(repoRoot, makePlan({ codexObjective: "first" }));
 
 		// when
-		await writePlan(repoRoot, makePlan({ codexObjective: "second" }));
+		const current = await readUlwLoopPlan(repoRoot);
+		await writePlan(repoRoot, { ...current, codexObjective: "second" });
 
 		// then
 		expect(JSON.parse(await readFile(ulwLoopGoalsPath(repoRoot), "utf8"))).toMatchObject({
@@ -189,7 +229,7 @@ describe("writePlan", () => {
 describe("appendLedger", () => {
 	it("appends a single JSONL line to ledger.jsonl", async () => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		const ledgerEntry = entry("goal_started");
 
 		// when
@@ -202,6 +242,7 @@ describe("appendLedger", () => {
 	it("creates ledger.jsonl if missing", async () => {
 		// given
 		const repoRoot = await makeRepo();
+		await writeRawPlan(repoRoot, makePlan());
 
 		// when
 		await appendLedger(repoRoot, entry("goal_completed"));
@@ -212,7 +253,7 @@ describe("appendLedger", () => {
 
 	it("preserves prior entries", async () => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		const first = entry("goal_started");
 		const second = entry("goal_completed");
 
@@ -228,7 +269,7 @@ describe("appendLedger", () => {
 describe("readSteeringLedgerEntries", () => {
 	it("returns only steering-related event kinds", async () => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		await appendLedger(repoRoot, entry("steering_accepted"));
 		await appendLedger(repoRoot, entry("goal_started"));
 		await appendLedger(repoRoot, entry("steering_rejected"));
@@ -263,7 +304,7 @@ describe("findAcceptedSteeringLedgerEntry", () => {
 		],
 	] as const)("finds an accepted entry by %s", async (_name, target) => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		await appendLedger(repoRoot, steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "other-key" })));
 		await appendLedger(repoRoot, target);
 
@@ -276,7 +317,7 @@ describe("findAcceptedSteeringLedgerEntry", () => {
 
 	it("skips a rejected entry carrying the same key", async () => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		await appendLedger(
 			repoRoot,
 			steeringEntry("steering_rejected", rejectedSteeringAudit({ idempotencyKey: "needle-key" })),
@@ -288,7 +329,7 @@ describe("findAcceptedSteeringLedgerEntry", () => {
 
 	it("returns the accepted entry even when a rejected one with the same key precedes it", async () => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		const accepted = steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "needle-key" }));
 		await appendLedger(
 			repoRoot,
@@ -310,7 +351,7 @@ describe("findAcceptedSteeringLedgerEntry", () => {
 
 	it("ignores the key when it only appears in non-steering entries", async () => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		await appendLedger(repoRoot, { at: NOW, kind: "goal_completed", goalId: "G001", idempotencyKey: "needle-key" });
 		await appendLedger(repoRoot, { at: NOW, kind: "evidence_captured", goalId: "G001", evidence: "needle-key" });
 
@@ -320,7 +361,7 @@ describe("findAcceptedSteeringLedgerEntry", () => {
 
 	it("ignores an accepted entry whose key only appears in evidence text", async () => {
 		// given
-		const repoRoot = await makeRepo();
+		const repoRoot = await makeLedgerRepo();
 		await appendLedger(repoRoot, steeringEntry("steering_accepted", steeringAudit({ evidence: "needle-key" })));
 
 		// when/then
@@ -406,13 +447,13 @@ describe("withUlwLoopMutationLock", () => {
 		const body = async (): Promise<void> => {
 			active += 1;
 			maxActive = Math.max(maxActive, active);
-			await tick();
+			await Promise.resolve();
 			active -= 1;
 		};
 
 		// when
 		await Promise.all([1, 2, 3].map(() => withUlwLoopMutationLock(repoRoot, body)));
-		await tick();
+		await Promise.resolve();
 		await Promise.all([1, 2].map(() => withUlwLoopMutationLock(repoRoot, body)));
 
 		// then
@@ -423,7 +464,8 @@ describe("withUlwLoopMutationLock", () => {
 		// given
 		const repoRoot = await makeRepo();
 		const events: string[] = [];
-		let releaseSecond = false;
+		const releaseSecond = barrier();
+		const enteredSecond = barrier();
 
 		// when
 		const first = withUlwLoopMutationLock(repoRoot, async () => {
@@ -431,15 +473,16 @@ describe("withUlwLoopMutationLock", () => {
 		});
 		const second = withUlwLoopMutationLock(repoRoot, async () => {
 			events.push("second:start");
-			while (!releaseSecond) await tick();
+			enteredSecond.resolve();
+			await releaseSecond.promise;
 			events.push("second:end");
 		});
 		await first;
-		await tick();
+		await enteredSecond.promise;
 		const third = withUlwLoopMutationLock(repoRoot, async () => {
 			events.push("third");
 		});
-		releaseSecond = true;
+		releaseSecond.resolve();
 		await Promise.all([second, third]);
 
 		// then
@@ -451,18 +494,21 @@ describe("withUlwLoopMutationLock", () => {
 		const rootA = await makeRepo();
 		const rootB = await makeRepo();
 		const events: string[] = [];
-		let releaseA = false;
+		const releaseA = barrier();
+		const enteredA = barrier();
 
 		// when
 		const held = withUlwLoopMutationLock(rootA, async () => {
 			events.push("a:start");
-			while (!releaseA) await tick();
+			enteredA.resolve();
+			await releaseA.promise;
 			events.push("a:end");
 		});
+		await enteredA.promise;
 		await withUlwLoopMutationLock(rootB, async () => {
 			events.push("b");
 		});
-		releaseA = true;
+		releaseA.resolve();
 		await held;
 
 		// then
@@ -474,21 +520,24 @@ describe("withUlwLoopMutationLock", () => {
 		const repoRoot = await makeRepo();
 		const scoped = { sessionId: "session-a" };
 		const events: string[] = [];
-		let releaseScoped = false;
+		const releaseScoped = barrier();
+		const enteredScoped = barrier();
 
 		// when
 		const heldScoped = withUlwLoopMutationLock(repoRoot, scoped, async () => {
 			events.push("scoped-1:start");
-			while (!releaseScoped) await tick();
+			enteredScoped.resolve();
+			await releaseScoped.promise;
 			events.push("scoped-1:end");
 		});
+		await enteredScoped.promise;
 		const queuedScoped = withUlwLoopMutationLock(repoRoot, scoped, async () => {
 			events.push("scoped-2");
 		});
 		await withUlwLoopMutationLock(repoRoot, async () => {
 			events.push("root-scope");
 		});
-		releaseScoped = true;
+		releaseScoped.resolve();
 		await Promise.all([heldScoped, queuedScoped]);
 
 		// then

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

@@ -0,0 +1,228 @@
+import { appendFileSync, existsSync, 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 { readLedger, readUlwLoopPlan } from "../src/plan-io.js";
+import { readNewestRecord } from "../src/plan-log.js";
+import { createAgentToolkit } from "../src/sdk.js";
+import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan } from "../src/types.js";
+import { goal } from "./fixtures/checkpoint-builders.js";
+
+// Reproduces #8328: a run created under the removed `omo_agent_toolkit` tool path published
+// `revisions/00000004.json` while the plan held one goal, then kept mutating goals.json and appending
+// ledger.jsonl lines DIRECTLY (no `revision`, no `id`) for goals the commit log never saw. The
+// agent-toolkit-sdk runtime then rebuilt the projection from the snapshot and every later goal vanished.
+const SESSION = "legacy-projection";
+const LEGACY_AT = "2026-09-16T01:00:00.000Z";
+let cwd: string;
+let dir: string;
+let legacyGoals: UlwLoopItem[];
+
+function toolkit() {
+	return createAgentToolkit({ cwd, sessionId: SESSION, surface: "omo-senpi" });
+}
+function ledgerLine(entry: UlwLoopLedgerEntry): string {
+	return `${JSON.stringify(entry)}\n`;
+}
+function goalsOnDisk(): UlwLoopPlan {
+	return JSON.parse(readFileSync(join(dir, "goals.json"), "utf8"));
+}
+async function seedSnapshotWithOneGoal(): Promise<void> {
+	const created = await toolkit().createGoals({ brief: "- alpha goal" });
+	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 alpha");
+	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");
+	// Two evidence captures on alpha -> revisions 3 and 4; the snapshot under test is 00000004.json.
+	for (const criterion of criteria.result.criteria.slice(0, 2)) {
+		const recorded = await toolkit().recordEvidence({
+			goalId,
+			criterionId: criterion.id,
+			status: "pass",
+			evidence: "alpha proof",
+		});
+		if (!recorded.ok) throw new Error("fixture could not record alpha evidence");
+	}
+}
+// The removed tool path rewrote goals.json wholesale (never stamping `revision`) and appended raw
+// ledger lines; this is that write, byte-shape included.
+function appendLegacyGoals(): void {
+	const plan = goalsOnDisk();
+	delete plan.revision;
+	legacyGoals = [
+		goal({
+			id: "G002-legacy-done",
+			title: "legacy done",
+			status: "complete",
+			completedAt: LEGACY_AT,
+			evidence: "legacy done proof",
+		}),
+		goal({ id: "G003-legacy-active", title: "legacy active", status: "in_progress", startedAt: LEGACY_AT }),
+		goal({ id: "G004-legacy-pending", title: "legacy pending", status: "pending", attempt: 0, successCriteria: [] }),
+	];
+	plan.goals.push(...legacyGoals);
+	plan.activeGoalId = "G003-legacy-active";
+	plan.updatedAt = LEGACY_AT;
+	writeFileSync(join(dir, "goals.json"), `${JSON.stringify(plan, null, 2)}\n`);
+	const entries: UlwLoopLedgerEntry[] = [
+		...legacyGoals.map((item) => ({
+			at: LEGACY_AT,
+			kind: "goal_added" as const,
+			goalId: item.id,
+			status: item.status,
+			message: item.title,
+		})),
+		{ at: LEGACY_AT, kind: "goal_started", goalId: "G002-legacy-done", status: "in_progress", message: "Attempt 1" },
+		{
+			at: LEGACY_AT,
+			kind: "evidence_captured",
+			goalId: "G002-legacy-done",
+			criterionId: "C001",
+			criterionStatus: "pass",
+			evidence: "C001 passed",
+		},
+		{
+			at: LEGACY_AT,
+			kind: "goal_completed",
+			goalId: "G002-legacy-done",
+			status: "complete",
+			evidence: "legacy done proof",
+		},
+		{
+			at: LEGACY_AT,
+			kind: "goal_started",
+			goalId: "G003-legacy-active",
+			status: "in_progress",
+			message: "Attempt 1",
+		},
+		{
+			at: LEGACY_AT,
+			kind: "evidence_captured",
+			goalId: "G003-legacy-active",
+			criterionId: "C001",
+			criterionStatus: "pass",
+			evidence: "C001 passed",
+		},
+	];
+	appendFileSync(join(dir, "ledger.jsonl"), entries.map(ledgerLine).join(""));
+}
+
+beforeEach(async () => {
+	cwd = await mkdtemp(join(tmpdir(), "ulw-legacy-projection-"));
+	dir = ulwLoopDir(cwd, { sessionId: SESSION });
+	await seedSnapshotWithOneGoal();
+	expect(readNewestRecord(dir)?.revision).toBe(4);
+	expect(readNewestRecord(dir)?.plan.goals).toHaveLength(1);
+	appendLegacyGoals();
+});
+afterEach(async () => {
+	await rm(cwd, { recursive: true, force: true });
+});
+
+describe("#given snapshot 4 holds one goal and the legacy tool path appended three goals with evidence afterwards", () => {
+	it("#when status rebuilds the projection #then every legacy goal, its evidence and its ledger events survive", async () => {
+		const status = await toolkit().status();
+
+		expect(status.ok).toBe(true);
+		if (!status.ok || status.operation !== "status") return;
+		expect(status.result.plan.goals.map((item) => item.id)).toEqual([
+			"G001-alpha-goal",
+			"G002-legacy-done",
+			"G003-legacy-active",
+			"G004-legacy-pending",
+		]);
+		const done = status.result.plan.goals.find((item) => item.id === "G002-legacy-done");
+		expect(done?.status).toBe("complete");
+		expect(done?.successCriteria.map((criterion) => criterion.capturedEvidence)).toEqual([
+			"C001 passed",
+			"C002 passed",
+			"C003 passed",
+		]);
+		expect(status.result.plan.activeGoalId).toBe("G003-legacy-active");
+		const ledger = readLedger(cwd, { sessionId: SESSION });
+		expect(ledger.filter((entry) => entry.kind === "goal_added").map((entry) => entry.goalId)).toEqual(
+			legacyGoals.map((item) => item.id),
+		);
+		expect(ledger.filter((entry) => entry.goalId === "G002-legacy-done").map((entry) => entry.kind)).toEqual([
+			"goal_added",
+			"goal_started",
+			"evidence_captured",
+			"goal_completed",
+		]);
+	});
+
+	it("#when evidence is recorded on a legacy goal #then it succeeds and publishes revision 5 holding all four goals", async () => {
+		const recorded = await toolkit().recordEvidence({
+			goalId: "G003-legacy-active",
+			criterionId: "C002",
+			status: "pass",
+			evidence: "recorded after the runtime switch",
+		});
+
+		expect(recorded.ok).toBe(true);
+		if (!recorded.ok) return;
+		const newest = readNewestRecord(dir);
+		expect(newest?.revision).toBe(5);
+		expect(existsSync(join(dir, "revisions", "00000005.json"))).toBe(true);
+		expect(newest?.plan.goals.map((item) => item.id)).toEqual([
+			"G001-alpha-goal",
+			"G002-legacy-done",
+			"G003-legacy-active",
+			"G004-legacy-pending",
+		]);
+		expect(newest?.plan.revision).toBe(5);
+		expect(goalsOnDisk().revision).toBe(5);
+		expect(goalsOnDisk().goals).toHaveLength(4);
+		// The legacy audit trail is still part of the reconciled ledger after the fold.
+		expect(
+			readLedger(cwd, { sessionId: SESSION }).some(
+				(entry) => entry.kind === "goal_completed" && entry.goalId === "G002-legacy-done",
+			),
+		).toBe(true);
+	});
+
+	it("#when a legacy goal is checkpointed complete #then the checkpoint succeeds and the next legacy goal is still there", async () => {
+		const closed = await toolkit().checkpoint({
+			goalId: "G003-legacy-active",
+			status: "complete",
+			evidence: "legacy goal closed after the runtime switch",
+		});
+
+		expect(closed.ok).toBe(true);
+		if (!closed.ok) return;
+		const plan = await readUlwLoopPlan(cwd, { sessionId: SESSION });
+		expect(plan.goals.find((item) => item.id === "G003-legacy-active")?.status).toBe("complete");
+		expect(plan.goals.find((item) => item.id === "G004-legacy-pending")?.status).toBe("pending");
+		expect(plan.goals).toHaveLength(4);
+	});
+});
+
+describe("#given the projection has already been truncated below what the ledger records", () => {
+	it("#when a locked operation would rewrite goals.json #then it refuses with ULW_LOOP_PROJECTION_TRUNCATED instead of dropping goals", async () => {
+		// The pre-fix runtime already rewrote goals.json from the one-goal snapshot; only ledger.jsonl still
+		// names the legacy goals.
+		const truncated = readNewestRecord(dir);
+		if (truncated === undefined) throw new Error("fixture lost its snapshot");
+		writeFileSync(join(dir, "goals.json"), `${JSON.stringify(truncated.plan, null, 2)}\n`);
+		const before = readFileSync(join(dir, "goals.json"), "utf8");
+
+		const recorded = await toolkit().recordEvidence({
+			goalId: "G001-alpha-goal",
+			criterionId: "C003",
+			status: "pass",
+			evidence: "must not be accepted on a truncated projection",
+		});
+
+		expect(recorded.ok).toBe(false);
+		if (recorded.ok) return;
+		expect(recorded.error.code).toBe("ULW_LOOP_PROJECTION_TRUNCATED");
+		expect(recorded.error.message).toContain("G002-legacy-done");
+		expect(readFileSync(join(dir, "goals.json"), "utf8")).toBe(before);
+		expect(readNewestRecord(dir)?.revision).toBe(4);
+	});
+});

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

@@ -0,0 +1,72 @@
+import { mkdirSync, rmSync, 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 { readNewestRecord, readRecords, reconcilePlan } from "../src/plan-log.js";
+import type { UlwLoopPlan } from "../src/types.js";
+
+let root: string;
+let dir: string;
+let base: UlwLoopPlan;
+const scope = { sessionId: "newest-record" };
+beforeEach(async () => {
+	root = await mkdtemp(join(tmpdir(), "ulw-newest-"));
+	dir = ulwLoopDir(root, scope);
+	base = await createUlwLoopPlan(root, { brief: "initial" }, scope);
+});
+afterEach(async () => {
+	await rm(root, { recursive: true, force: true });
+});
+// The names are deliberately mixed-width: lexicographically "000000010.json" sorts BEFORE "00000009.json",
+// so only numeric ordering of the parsed revision picks revision 10 as the newest record.
+function seedRecord(name: string, revision: number, brief: string): UlwLoopPlan {
+	const plan: UlwLoopPlan = { ...base, revision, brief };
+	mkdirSync(join(dir, "revisions"), { recursive: true });
+	writeFileSync(
+		join(dir, "revisions", name),
+		`${JSON.stringify({ version: 1, revision, plan, ledger: [{ at: "now", kind: "goal_added", revision, id: `${revision}-0` }] })}\n`,
+	);
+	return plan;
+}
+
+describe("#given a commit log whose newest record is the only one a plan read needs", () => {
+	it("#when the newest record is valid #then it wins over older records and a stale goals cache", async () => {
+		seedRecord("00000009.json", 9, "nine");
+		const newest = seedRecord("000000010.json", 10, "ten");
+
+		expect(base.revision).toBe(1);
+		expect(readNewestRecord(dir)?.revision).toBe(10);
+		expect(reconcilePlan(dir)).toEqual(newest);
+	});
+	it("#when the newest record is corrupt #then the newest valid older record wins", () => {
+		const older = seedRecord("00000009.json", 9, "nine");
+		writeFileSync(join(dir, "revisions", "000000010.json"), "{not json");
+
+		expect(readNewestRecord(dir)?.revision).toBe(9);
+		expect(reconcilePlan(dir)).toEqual(older);
+	});
+	it("#when an OLDER record is unreadable for a non-syntax reason #then the read stops at the newest record", () => {
+		const newest = seedRecord("000000010.json", 10, "ten");
+		rmSync(join(dir, "revisions", "00000001.json"));
+		mkdirSync(join(dir, "revisions", "00000001.json"));
+
+		expect(reconcilePlan(dir)).toEqual(newest);
+		expect(readNewestRecord(dir)).toEqual({
+			version: 1,
+			revision: 10,
+			plan: newest,
+			ledger: [{ at: "now", kind: "goal_added", revision: 10, id: "10-0" }],
+		});
+		expect(() => readRecords(dir)).toThrow(/EISDIR/);
+	});
+	it("#when the NEWEST record is unreadable for a non-syntax reason #then the error propagates", () => {
+		seedRecord("00000009.json", 9, "nine");
+		mkdirSync(join(dir, "revisions", "000000010.json"));
+
+		expect(() => readNewestRecord(dir)).toThrow(/EISDIR/);
+		expect(() => reconcilePlan(dir)).toThrow(/EISDIR/);
+	});
+});