lazycodex-ai 4.16.0 → 4.16.1

package/packages/omo-codex/plugin/components/ulw-loop/src/cli-steering.ts

@@ -73,7 +73,8 @@ function model(value: string | undefined): UlwLoopSuccessCriterionUserModel | un
 function neverKind(kind: never): never { return fail(`Unsupported steering kind: ${String(kind)}.`, "ULW_LOOP_STEERING_KIND_UNSUPPORTED", { kind }); }
 
 export async function parseSteeringProposal(argv: readonly string[]): Promise<CliSteeringProposal> {
-	const kind = parseSteeringKind(argv); const source = parseSteeringSource(argv); const base = { kind, source, evidence: required(argv, "--evidence"), rationale: required(argv, "--rationale") };
+	const kind = parseSteeringKind(argv); const source = parseSteeringSource(argv); const idempotencyKey = text(readValue(argv, "--idempotency-key"), "--idempotency-key");
+	const base = { kind, source, evidence: required(argv, "--evidence"), rationale: required(argv, "--rationale"), ...(idempotencyKey === undefined ? {} : { idempotencyKey }) };
 	switch (kind) {
 		case "add_subgoal": return normalizeSteeringProposal({ ...base, title: required(argv, "--title"), objective: required(argv, "--objective") });
 		case "split_subgoal": { const goalId = requiredGoal(argv); return normalizeSteeringProposal({ ...base, goalId, targetGoalId: goalId, childGoals: await children(argv, "--children", true) }); }

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

@@ -1,4 +1,6 @@
+import { createReadStream } from "node:fs";
 import { appendFile, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { createInterface } from "node:readline";
 
 import { aggregateCodexObjectiveForScope } from "./goal-status.js";
 import {
@@ -14,7 +16,7 @@ import { iso, ULW_LOOP_DIR, ULW_LOOP_GOALS, ULW_LOOP_LEDGER, UlwLoopError } from
 
 const LEGACY_OBJECTIVE_PREFIX = `Complete all ulw-loop stories in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}: `;
 const LEGACY_OBJECTIVE = `Complete all ulw-loop stories listed in ${ULW_LOOP_DIR}/${ULW_LOOP_GOALS}. Use ${ULW_LOOP_DIR}/${ULW_LOOP_LEDGER} as the durable audit trail.`;
-const locks = new Map<string, Promise<unknown>>();
+const locks = new Map<string, Promise<undefined>>();
 
 function hasCode(error: unknown, code: string): boolean {
 	return error instanceof Error && "code" in error && error.code === code;
@@ -43,12 +45,19 @@ export async function withUlwLoopMutationLock<T>(
 	const fn = typeof scopeOrFn === "function" ? scopeOrFn : maybeFn;
 	if (fn === undefined) throw new UlwLoopError("Missing ulw-loop mutation body.", "ULW_LOOP_LOCK_BODY_MISSING");
 	const lockKey = `${repoRoot}\0${ulwLoopRelativeDir(scope)}`;
-	const prior = locks.get(lockKey) ?? Promise.resolve();
+	const prior = locks.get(lockKey) ?? Promise.resolve(undefined);
 	const run = prior.then(fn, fn);
-	locks.set(
-		lockKey,
-		run.catch(() => undefined),
+	// The stored gate resolves to undefined so the map never retains fn's result
+	// (plans/audits), and it removes itself once no newer waiter replaced it —
+	// otherwise a long-lived host leaks one entry per (repo, scope) forever.
+	const gate: Promise<undefined> = run.then(
+		() => undefined,
+		() => undefined,
 	);
+	locks.set(lockKey, gate);
+	void gate.then(() => {
+		if (locks.get(lockKey) === gate) locks.delete(lockKey);
+	});
 	return run;
 }
 
@@ -107,18 +116,57 @@ export async function appendLedger(repoRoot: string, entry: UlwLoopLedgerEntry,
 	await appendFile(ulwLoopLedgerPath(repoRoot, scope), `${JSON.stringify(entry)}\n`, "utf8");
 }
 
-export async function readSteeringLedgerEntries(repoRoot: string, scope?: UlwLoopScope): Promise<UlwLoopLedgerEntry[]> {
-	let raw: string;
+/**
+ * Streams raw ledger lines without materializing the file. Real ledgers reach
+ * many MB (legacy entries embedded full-plan snapshots), so `readFile` here
+ * ballooned every steer/dedup path; line-at-a-time keeps memory O(longest line).
+ */
+async function* ledgerLines(repoRoot: string, scope?: UlwLoopScope): AsyncGenerator<string> {
+	const stream = createReadStream(ulwLoopLedgerPath(repoRoot, scope), { encoding: "utf8" });
+	const lines = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
 	try {
-		raw = await readFile(ulwLoopLedgerPath(repoRoot, scope), "utf8");
+		for await (const line of lines) {
+			if (line.trim().length > 0) yield line;
+		}
 	} catch (error) {
-		if (hasCode(error, "ENOENT")) return [];
-		throw error;
+		if (!hasCode(error, "ENOENT")) throw error;
+	} finally {
+		lines.close();
+		stream.destroy();
 	}
+}
+
+export async function readSteeringLedgerEntries(repoRoot: string, scope?: UlwLoopScope): Promise<UlwLoopLedgerEntry[]> {
 	const entries: UlwLoopLedgerEntry[] = [];
-	for (const line of raw.split(/\r?\n/).filter(Boolean)) {
+	for await (const line of ledgerLines(repoRoot, scope)) {
 		const entry: UlwLoopLedgerEntry = JSON.parse(line);
 		if (isSteeringKind(entry.kind)) entries.push(entry);
 	}
 	return entries;
 }
+
+/**
+ * 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 async function findAcceptedSteeringLedgerEntry(
+	repoRoot: string,
+	key: string,
+	scope?: UlwLoopScope,
+): Promise<UlwLoopLedgerEntry | undefined> {
+	const probe = JSON.stringify(key);
+	for await (const line of ledgerLines(repoRoot, scope)) {
+		if (!line.includes(probe)) continue;
+		const entry: UlwLoopLedgerEntry = JSON.parse(line);
+		if (!isSteeringKind(entry.kind)) continue;
+		if (entry.steering?.invariant.accepted !== true) continue;
+		if (
+			entry.idempotencyKey === key ||
+			entry.steering.idempotencyKey === key ||
+			entry.steering.promptSignature === key
+		)
+			return entry;
+	}
+	return undefined;
+}

package/packages/omo-codex/plugin/components/ulw-loop/src/steering-snapshot.ts

@@ -0,0 +1,38 @@
+import type { UlwLoopItem, UlwLoopPlan } from "./domain-types.js";
+import type { UlwLoopSteeringPlanSnapshot } from "./steering-types.js";
+
+/**
+ * Compact before/after snapshots for steering ledger entries.
+ *
+ * Ledger entries used to embed the FULL plan (every goal, criterion, and
+ * evidence string) twice per audit and twice more at the entry top level.
+ * That made each accepted steer O(plan size) on disk, so the ledger grew
+ * quadratically over a run, and every dedup scan re-hydrated all of it into
+ * memory. A snapshot instead records plan-level counters plus only the goals
+ * the mutation actually touched, keeping each entry O(changed goals).
+ */
+export function buildSteeringPlanSnapshot(
+	plan: UlwLoopPlan,
+	changedGoalIds: ReadonlySet<string>,
+): UlwLoopSteeringPlanSnapshot {
+	const snapshot: UlwLoopSteeringPlanSnapshot = {
+		updatedAt: plan.updatedAt,
+		goalCount: plan.goals.length,
+		goalIds: plan.goals.map((goal) => goal.id),
+		goals: plan.goals.filter((goal) => changedGoalIds.has(goal.id)),
+	};
+	return plan.activeGoalId === undefined ? snapshot : { ...snapshot, activeGoalId: plan.activeGoalId };
+}
+
+/** Ids of goals that differ between two plans, including added or removed goals. */
+export function changedGoalIdsBetween(before: UlwLoopPlan, after: UlwLoopPlan): Set<string> {
+	const beforeById = new Map<string, UlwLoopItem>(before.goals.map((goal) => [goal.id, goal]));
+	const changed = new Set<string>();
+	for (const goal of after.goals) {
+		const prior = beforeById.get(goal.id);
+		if (prior === undefined || JSON.stringify(prior) !== JSON.stringify(goal)) changed.add(goal.id);
+		beforeById.delete(goal.id);
+	}
+	for (const id of beforeById.keys()) changed.add(id);
+	return changed;
+}

package/packages/omo-codex/plugin/components/ulw-loop/src/steering-types.ts

@@ -1,5 +1,5 @@
 import type { UlwLoopSteeringMutationKind, UlwLoopSteeringSource } from "./constants.js";
-import type { UlwLoopPlan } from "./domain-types.js";
+import type { UlwLoopItem, UlwLoopPlan } from "./domain-types.js";
 
 export interface UlwLoopSteeringInvariantResult {
 	accepted: boolean;
@@ -44,13 +44,21 @@ export interface UlwLoopSteeringProposal {
 	now?: Date;
 }
 
+export interface UlwLoopSteeringPlanSnapshot {
+	readonly updatedAt: string;
+	readonly activeGoalId?: string;
+	readonly goalCount: number;
+	readonly goalIds: readonly string[];
+	readonly goals: readonly UlwLoopItem[];
+}
+
 export interface UlwLoopSteeringAudit {
 	kind: UlwLoopSteeringMutationKind;
 	source: UlwLoopSteeringSource;
 	targetGoalIds: string[];
 	criterionId?: string;
-	before?: unknown;
-	after?: unknown;
+	before?: UlwLoopSteeringPlanSnapshot;
+	after?: UlwLoopSteeringPlanSnapshot;
 	evidence: string;
 	rationale: string;
 	invariant: UlwLoopSteeringInvariantResult;

package/packages/omo-codex/plugin/components/ulw-loop/src/steering.ts

@@ -2,7 +2,8 @@
 import { isUlwLoopDone } from "./goal-status.js";
 import type { UlwLoopScope } from "./paths.js";
 import { seedDefaultSuccessCriteria } from "./plan-crud.js";
-import { appendLedger, readSteeringLedgerEntries, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { appendLedger, findAcceptedSteeringLedgerEntry, readUlwLoopPlan, withUlwLoopMutationLock, writePlan } from "./plan-io.js";
+import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "./steering-snapshot.js";
 import type {
 	SteerUlwLoopResult,
 	UlwLoopItem,
@@ -245,13 +246,22 @@ export async function steerUlwLoop(repoRoot: string, proposal: UlwLoopSteeringPr
 	return withUlwLoopMutationLock(repoRoot, scope, async () => {
 		const plan = await readUlwLoopPlan(repoRoot, scope);
 		const key = proposal.idempotencyKey ?? proposal.promptSignature;
-		const prior = key === undefined ? undefined : (await readSteeringLedgerEntries(repoRoot, scope)).find((entry) => entry.steering?.invariant.accepted === true && (entry.idempotencyKey === key || entry.steering.idempotencyKey === key || entry.steering.promptSignature === key));
-		if (prior?.steering !== undefined) return { plan, accepted: true, audit: { ...prior.steering, deduped: true }, rejectedReasons: [], deduped: true };
+		const prior = key === undefined ? undefined : await findAcceptedSteeringLedgerEntry(repoRoot, key, scope);
+		if (prior?.steering !== undefined) {
+			// Legacy entries embedded full-plan before/after snapshots; never
+			// re-surface those multi-MB payloads on the dedup path.
+			const { before: _before, after: _after, ...compactPrior } = prior.steering;
+			return { plan, accepted: true, audit: { ...compactPrior, deduped: true }, rejectedReasons: [], deduped: true };
+		}
 		const audit = validateUlwLoopSteeringProposal(plan, proposal);
 		const accepted = audit.invariant.accepted;
 		const next = accepted ? applySteeringMutation(plan, proposal, audit) : plan;
-		const finalAudit: UlwLoopSteeringAudit = { ...audit, before: plan };
-		if (accepted) finalAudit.after = next;
+		const finalAudit: UlwLoopSteeringAudit = { ...audit };
+		if (accepted) {
+			const changed = changedGoalIdsBetween(plan, next);
+			finalAudit.before = buildSteeringPlanSnapshot(plan, changed);
+			finalAudit.after = buildSteeringPlanSnapshot(next, changed);
+		}
 		if (accepted) await writePlan(repoRoot, next, scope);
 		await appendLedger(repoRoot, ledgerEntry(proposal, finalAudit, proposal.now?.toISOString() ?? iso()), scope);
 		return { plan: next, accepted, audit: finalAudit, rejectedReasons: audit.invariant.rejectedReasons, deduped: false };
@@ -264,7 +274,5 @@ function ledgerEntry(proposal: UlwLoopSteeringProposal, audit: UlwLoopSteeringAu
 	if (goalId !== undefined) entry.goalId = goalId;
 	if (proposal.criterionId !== undefined) entry.criterionId = proposal.criterionId;
 	if (proposal.idempotencyKey !== undefined) entry.idempotencyKey = proposal.idempotencyKey;
-	if (audit.before !== undefined) entry.before = audit.before;
-	if (audit.after !== undefined) entry.after = audit.after;
 	return entry;
 }

package/packages/omo-codex/plugin/components/ulw-loop/test/cli-create-goals.test.ts

@@ -169,4 +169,20 @@ describe("ulwLoopCommand create-goals", () => {
 
 		expect(await readFile(join(testDir, ".omo/ulw-loop/manual-456/goals.json"), "utf8")).toContain("Manual scoped");
 	});
+
+	it("#given a valueless --session-id #when creating goals #then it fails and writes no plan", async () => {
+		const code = await ulwLoopCommand(["create-goals", "--session-id", "--brief", "- Alpha"]);
+
+		expect(code).toBe(1);
+		expect(err.join("")).toContain("--session-id requires a non-empty value");
+		await expect(readFile(join(testDir, ".omo/ulw-loop/goals.json"), "utf8")).rejects.toThrow();
+	});
+
+	it("#given an empty --session-id= #when creating goals #then it fails and writes no plan", async () => {
+		const code = await ulwLoopCommand(["create-goals", "--session-id=", "--brief", "- Alpha"]);
+
+		expect(code).toBe(1);
+		expect(err.join("")).toContain("--session-id requires a non-empty value");
+		await expect(readFile(join(testDir, ".omo/ulw-loop/goals.json"), "utf8")).rejects.toThrow();
+	});
 });

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

@@ -1,16 +1,18 @@
-import { copyFile, mkdir, mkdtemp, readdir, readFile, writeFile } from "node:fs/promises";
+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 {
 	appendLedger,
+	findAcceptedSteeringLedgerEntry,
 	readSteeringLedgerEntries,
 	readUlwLoopPlan,
 	withUlwLoopMutationLock,
 	writePlan,
 } from "../src/plan-io.js";
-import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan } from "../src/types.js";
+import type { UlwLoopItem, UlwLoopLedgerEntry, UlwLoopPlan, UlwLoopSteeringAudit } from "../src/types.js";
 import { UlwLoopError } from "../src/types.js";
 
 const NOW = "2026-05-23T00:00:00.000Z";
@@ -51,6 +53,45 @@ function entry(kind: UlwLoopLedgerEntry["kind"], goalId = "G001"): UlwLoopLedger
 	return { at: NOW, kind, goalId };
 }
 
+function steeringAudit(overrides: Partial<UlwLoopSteeringAudit> = {}): UlwLoopSteeringAudit {
+	return {
+		kind: "revise_pending_wording",
+		source: "cli",
+		targetGoalIds: ["G001"],
+		evidence: "observed evidence",
+		rationale: "needed change",
+		invariant: {
+			accepted: true,
+			structuralInvariantAccepted: true,
+			evidenceBackedNecessity: true,
+			noEasierCompletion: true,
+			rejectedReasons: [],
+		},
+		...overrides,
+	};
+}
+
+function rejectedSteeringAudit(overrides: Partial<UlwLoopSteeringAudit> = {}): UlwLoopSteeringAudit {
+	return steeringAudit({
+		invariant: {
+			accepted: false,
+			structuralInvariantAccepted: false,
+			evidenceBackedNecessity: false,
+			noEasierCompletion: true,
+			rejectedReasons: ["missing evidence"],
+		},
+		...overrides,
+	});
+}
+
+function steeringEntry(
+	kind: UlwLoopLedgerEntry["kind"],
+	audit: UlwLoopSteeringAudit,
+	overrides: Partial<UlwLoopLedgerEntry> = {},
+): UlwLoopLedgerEntry {
+	return { at: NOW, kind, goalId: "G001", steering: audit, ...overrides };
+}
+
 async function makeRepo(): Promise<string> {
 	return mkdtemp(join(tmpdir(), "ug-io-"));
 }
@@ -209,6 +250,112 @@ describe("readSteeringLedgerEntries", () => {
 	});
 });
 
+describe("findAcceptedSteeringLedgerEntry", () => {
+	it.each([
+		[
+			"top-level idempotencyKey",
+			steeringEntry("steering_accepted", steeringAudit(), { idempotencyKey: "needle-key" }),
+		],
+		["steering.idempotencyKey", steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "needle-key" }))],
+		[
+			"steering.promptSignature",
+			steeringEntry("steering_accepted", steeringAudit({ promptSignature: "needle-key" })),
+		],
+	] as const)("finds an accepted entry by %s", async (_name, target) => {
+		// given
+		const repoRoot = await makeRepo();
+		await appendLedger(repoRoot, steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "other-key" })));
+		await appendLedger(repoRoot, target);
+
+		// when
+		const found = await findAcceptedSteeringLedgerEntry(repoRoot, "needle-key");
+
+		// then
+		expect(found).toEqual(target);
+	});
+
+	it("skips a rejected entry carrying the same key", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		await appendLedger(
+			repoRoot,
+			steeringEntry("steering_rejected", rejectedSteeringAudit({ idempotencyKey: "needle-key" })),
+		);
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("returns the accepted entry even when a rejected one with the same key precedes it", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const accepted = steeringEntry("steering_accepted", steeringAudit({ idempotencyKey: "needle-key" }));
+		await appendLedger(
+			repoRoot,
+			steeringEntry("steering_rejected", rejectedSteeringAudit({ idempotencyKey: "needle-key" })),
+		);
+		await appendLedger(repoRoot, accepted);
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toEqual(accepted);
+	});
+
+	it("returns undefined when the ledger file is missing", async () => {
+		// given
+		const repoRoot = await makeRepo();
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("ignores the key when it only appears in non-steering entries", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		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" });
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("ignores an accepted entry whose key only appears in evidence text", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		await appendLedger(repoRoot, steeringEntry("steering_accepted", steeringAudit({ evidence: "needle-key" })));
+
+		// when/then
+		await expect(findAcceptedSteeringLedgerEntry(repoRoot, "needle-key")).resolves.toBeUndefined();
+	});
+
+	it("finds the key inside a legacy entry embedding full before/after plans", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const bulkyGoals = Array.from({ length: 20 }, (_, index) =>
+			makeGoal({ id: `G${String(index + 1).padStart(3, "0")}`, objective: `evidence detail ${index} `.repeat(200) }),
+		);
+		const bulkyPlan = makePlan({ goals: bulkyGoals });
+		const legacyLine = JSON.stringify({
+			at: NOW,
+			kind: "steering_accepted",
+			goalId: "G001",
+			idempotencyKey: "needle-key",
+			before: bulkyPlan,
+			after: bulkyPlan,
+			steering: { ...steeringAudit({ idempotencyKey: "needle-key" }), before: bulkyPlan, after: bulkyPlan },
+		});
+		await mkdir(ulwLoopDir(repoRoot), { recursive: true });
+		await appendFile(ulwLoopLedgerPath(repoRoot), `${legacyLine}\n`, "utf8");
+
+		// when
+		const found = await findAcceptedSteeringLedgerEntry(repoRoot, "needle-key");
+
+		// then
+		expect(legacyLine.length).toBeGreaterThan(100_000);
+		expect(found?.kind).toBe("steering_accepted");
+		expect(found?.idempotencyKey).toBe("needle-key");
+	});
+});
+
 describe("withUlwLoopMutationLock", () => {
 	it("serializes concurrent invocations", async () => {
 		// given
@@ -236,4 +383,115 @@ describe("withUlwLoopMutationLock", () => {
 		expect(maxActive).toBe(1);
 		expect(await readFile(counterPath, "utf8")).toBe("3");
 	});
+
+	it("propagates the body rejection and keeps later calls working", async () => {
+		// given
+		const repoRoot = await makeRepo();
+
+		// when
+		const failure = withUlwLoopMutationLock(repoRoot, async () => {
+			throw new Error("body exploded");
+		});
+
+		// then
+		await expect(failure).rejects.toThrow("body exploded");
+		await expect(withUlwLoopMutationLock(repoRoot, async () => "recovered")).resolves.toBe("recovered");
+	});
+
+	it("still serializes a second batch after the first batch's gate settles", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		let active = 0;
+		let maxActive = 0;
+		const body = async (): Promise<void> => {
+			active += 1;
+			maxActive = Math.max(maxActive, active);
+			await tick();
+			active -= 1;
+		};
+
+		// when
+		await Promise.all([1, 2, 3].map(() => withUlwLoopMutationLock(repoRoot, body)));
+		await tick();
+		await Promise.all([1, 2].map(() => withUlwLoopMutationLock(repoRoot, body)));
+
+		// then
+		expect(maxActive).toBe(1);
+	});
+
+	it("keeps an in-flight successor locked when an earlier gate settles", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const events: string[] = [];
+		let releaseSecond = false;
+
+		// when
+		const first = withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("first");
+		});
+		const second = withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("second:start");
+			while (!releaseSecond) await tick();
+			events.push("second:end");
+		});
+		await first;
+		await tick();
+		const third = withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("third");
+		});
+		releaseSecond = true;
+		await Promise.all([second, third]);
+
+		// then
+		expect(events).toEqual(["first", "second:start", "second:end", "third"]);
+	});
+
+	it("does not serialize distinct repo roots against each other", async () => {
+		// given
+		const rootA = await makeRepo();
+		const rootB = await makeRepo();
+		const events: string[] = [];
+		let releaseA = false;
+
+		// when
+		const held = withUlwLoopMutationLock(rootA, async () => {
+			events.push("a:start");
+			while (!releaseA) await tick();
+			events.push("a:end");
+		});
+		await withUlwLoopMutationLock(rootB, async () => {
+			events.push("b");
+		});
+		releaseA = true;
+		await held;
+
+		// then
+		expect(events).toEqual(["a:start", "b", "a:end"]);
+	});
+
+	it("serializes per scope while distinct scopes stay independent", async () => {
+		// given
+		const repoRoot = await makeRepo();
+		const scoped = { sessionId: "session-a" };
+		const events: string[] = [];
+		let releaseScoped = false;
+
+		// when
+		const heldScoped = withUlwLoopMutationLock(repoRoot, scoped, async () => {
+			events.push("scoped-1:start");
+			while (!releaseScoped) await tick();
+			events.push("scoped-1:end");
+		});
+		const queuedScoped = withUlwLoopMutationLock(repoRoot, scoped, async () => {
+			events.push("scoped-2");
+		});
+		await withUlwLoopMutationLock(repoRoot, async () => {
+			events.push("root-scope");
+		});
+		releaseScoped = true;
+		await Promise.all([heldScoped, queuedScoped]);
+
+		// then
+		expect(events).toEqual(["scoped-1:start", "root-scope", "scoped-1:end", "scoped-2"]);
+	});
 });

package/packages/omo-codex/plugin/components/ulw-loop/test/steering-snapshot.test.ts

@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import { buildSteeringPlanSnapshot, changedGoalIdsBetween } from "../src/steering-snapshot.js";
+import type { UlwLoopItem, UlwLoopPlan } from "../src/types.js";
+
+const NOW = "2026-05-23T00:00:00.000Z";
+
+function goal(id: string, overrides: Partial<UlwLoopItem> = {}): UlwLoopItem {
+	return {
+		id,
+		title: `Goal ${id}`,
+		objective: `Objective for ${id}`,
+		status: "pending",
+		successCriteria: [],
+		attempt: 0,
+		createdAt: NOW,
+		updatedAt: NOW,
+		...overrides,
+	};
+}
+
+function plan(goals: UlwLoopItem[], overrides: Partial<UlwLoopPlan> = {}): UlwLoopPlan {
+	return {
+		version: 1,
+		createdAt: NOW,
+		updatedAt: NOW,
+		briefPath: ".omo/ulw-loop/brief.md",
+		goalsPath: ".omo/ulw-loop/goals.json",
+		ledgerPath: ".omo/ulw-loop/ledger.jsonl",
+		goals,
+		...overrides,
+	};
+}
+
+describe("changedGoalIdsBetween", () => {
+	it.each([
+		{
+			name: "added goal",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001"), goal("G002"), goal("G003")],
+			expected: ["G003"],
+		},
+		{
+			name: "removed goal",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001")],
+			expected: ["G002"],
+		},
+		{
+			name: "mutated goal",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001"), goal("G002", { title: "Rewritten" })],
+			expected: ["G002"],
+		},
+		{
+			name: "reordered-only goals",
+			before: [goal("G001"), goal("G002"), goal("G003")],
+			after: [goal("G003"), goal("G001"), goal("G002")],
+			expected: [],
+		},
+		{
+			name: "identical plans",
+			before: [goal("G001"), goal("G002")],
+			after: [goal("G001"), goal("G002")],
+			expected: [],
+		},
+		{
+			name: "add + remove + mutate at once",
+			before: [goal("G001"), goal("G002"), goal("G003")],
+			after: [goal("G001", { status: "blocked" }), goal("G003"), goal("G004")],
+			expected: ["G001", "G002", "G004"],
+		},
+	])("detects $name", ({ before, after, expected }) => {
+		// when
+		const changed = changedGoalIdsBetween(plan(before), plan(after));
+
+		// then
+		expect([...changed].sort()).toEqual(expected);
+	});
+});
+
+describe("buildSteeringPlanSnapshot", () => {
+	it("includes only changed goals while keeping full goalIds order and goalCount", () => {
+		// given
+		const goals = [goal("G001"), goal("G002"), goal("G003"), goal("G004")];
+		const source = plan(goals);
+
+		// when
+		const snapshot = buildSteeringPlanSnapshot(source, new Set(["G003"]));
+
+		// then
+		expect(snapshot.goals.map((item) => item.id)).toEqual(["G003"]);
+		expect(snapshot.goals[0]).toEqual(goals[2]);
+		expect(snapshot.goalIds).toEqual(["G001", "G002", "G003", "G004"]);
+		expect(snapshot.goalCount).toBe(4);
+		expect(snapshot.updatedAt).toBe(NOW);
+	});
+
+	it("omits the activeGoalId key entirely when the plan has none", () => {
+		// when
+		const snapshot = buildSteeringPlanSnapshot(plan([goal("G001")]), new Set(["G001"]));
+
+		// then
+		expect("activeGoalId" in snapshot).toBe(false);
+	});
+
+	it("carries activeGoalId when the plan has one", () => {
+		// when
+		const snapshot = buildSteeringPlanSnapshot(plan([goal("G001")], { activeGoalId: "G001" }), new Set());
+
+		// then
+		expect(snapshot.activeGoalId).toBe("G001");
+	});
+
+	it("keeps plan order for changed goals regardless of set insertion order", () => {
+		// given
+		const source = plan([goal("G001"), goal("G002"), goal("G003")]);
+
+		// when
+		const snapshot = buildSteeringPlanSnapshot(source, new Set(["G003", "G001"]));
+
+		// then
+		expect(snapshot.goals.map((item) => item.id)).toEqual(["G001", "G003"]);
+	});
+});