oh-my-opencode 4.18.2 → 4.19.1

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

@@ -0,0 +1,67 @@
+// biome-ignore-all format: compact CLI batch tests stay under the pure LOC budget.
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+
+import { ulwLoopCommand } from "../src/cli-commands.js";
+import { parseSteeringProposals } from "../src/cli-steering.js";
+import { ulwLoopGoalsPath } from "../src/paths.js";
+import { writePlan } from "../src/plan-io.js";
+import type { UlwLoopPlan } from "../src/types.js";
+
+const NOW = "2026-05-23T00:00:00.000Z";
+
+function plan(): 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: [] };
+}
+
+describe("parseSteeringProposals", () => {
+	it("#given proposals-json #when parsing steer args #then returns every proposal", async () => {
+		const proposals = await parseSteeringProposals([
+			"--proposals-json",
+			JSON.stringify([
+				{ kind: "annotate_ledger", evidence: "one", rationale: "because one" },
+				{ kind: "annotate_ledger", source: "cli", evidence: "two", rationale: "because two" },
+			]),
+		]);
+
+		expect(proposals).toHaveLength(2);
+		expect(proposals[0]).toMatchObject({ evidence: "one", source: "cli" });
+		expect(proposals[1]).toMatchObject({ evidence: "two" });
+	});
+
+	it("#given proposals-json path #when parsing steer args #then reads proposals from the file", async () => {
+		const repo = await mkdtemp(join(tmpdir(), "ug-cli-steer-batch-"));
+		const file = join(repo, "batch.json");
+		await writeFile(file, JSON.stringify([{ kind: "annotate_ledger", source: "cli", evidence: "file", rationale: "because file" }]), "utf8");
+
+		const proposals = await parseSteeringProposals(["--proposals-json", file]);
+
+		expect(proposals).toHaveLength(1);
+		expect(proposals[0]).toMatchObject({ evidence: "file" });
+	});
+
+	it("#given kind and proposals-json #when steering through CLI #then rejects conflict without mutation", async () => {
+		const repo = await mkdtemp(join(tmpdir(), "ug-cli-steer-batch-conflict-"));
+		const out: string[] = [];
+		try {
+			await writePlan(repo, plan());
+			const before = await readFile(ulwLoopGoalsPath(repo), "utf8");
+			vi.spyOn(process, "cwd").mockReturnValue(repo);
+			vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array): boolean => {
+				out.push(chunk.toString());
+				return true;
+			});
+			vi.spyOn(process.stderr, "write").mockImplementation((): boolean => true);
+
+			expect(await ulwLoopCommand(["steer", "--kind", "annotate_ledger", "--evidence", "flag", "--rationale", "flag", "--proposals-json", '[{"kind":"annotate_ledger","evidence":"batch","rationale":"batch"}]', "--json"])).toBe(1);
+
+			expect(JSON.parse(out.join(""))).toHaveProperty("error.code", "ULW_LOOP_STEERING_BATCH_CONFLICT");
+			expect(await readFile(ulwLoopGoalsPath(repo), "utf8")).toBe(before);
+		} finally {
+			vi.restoreAllMocks();
+			await rm(repo, { recursive: true, force: true });
+		}
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/cli-validation-batch.test.ts

@@ -0,0 +1,57 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ulwLoopCommand } from "../src/cli-commands.js";
+
+let testDir: string;
+let out: string[];
+
+beforeEach(async () => {
+	testDir = await mkdtemp(join(tmpdir(), "ug-cli-validation-batch-"));
+	out = [];
+	vi.spyOn(process, "cwd").mockReturnValue(testDir);
+	vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array): boolean => {
+		out.push(chunk.toString());
+		return true;
+	});
+	vi.spyOn(process.stderr, "write").mockImplementation((): boolean => true);
+});
+
+afterEach(async () => {
+	vi.restoreAllMocks();
+	await rm(testDir, { recursive: true, force: true });
+});
+
+describe("ulwLoopCommand create-goals validation batches", () => {
+	it("#given validation-batch-json #when creating goals #then JSON output includes validation batches", async () => {
+		expect(
+			await ulwLoopCommand([
+				"create-goals",
+				"--brief",
+				"- Goal alpha\n- Goal beta",
+				"--validation-batch-json",
+				'[{"batchId":"VB001","memberIds":["G001-goal-alpha","G002-goal-beta"],"finalGoalId":"G002-goal-beta"}]',
+				"--json",
+			]),
+		).toBe(0);
+
+		expect(JSON.parse(out.join(""))).toHaveProperty("plan.validationBatches.0.batchId", "VB001");
+	});
+
+	it("#given finalGoalId outside members #when creating goals from CLI #then exits one with the distinct code", async () => {
+		expect(
+			await ulwLoopCommand([
+				"create-goals",
+				"--brief",
+				"- Goal alpha\n- Goal beta\n- Goal gamma",
+				"--validation-batch-json",
+				'[{"batchId":"VB001","memberIds":["G001-goal-alpha","G002-goal-beta"],"finalGoalId":"G003-goal-gamma"}]',
+				"--json",
+			]),
+		).toBe(1);
+
+		expect(JSON.parse(out.join(""))).toHaveProperty("error.code", "ULW_LOOP_VALIDATION_BATCH_FINAL_NOT_MEMBER");
+	});
+});

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

@@ -1,3 +1,4 @@
+// biome-ignore-all format: compact path tests predate this change.
 import { join, posix, win32 } from "node:path";
 
 import { describe, expect, it } from "vitest";

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

@@ -0,0 +1,152 @@
+// biome-ignore-all format: compact steering batch tests stay under the pure LOC budget.
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+
+import type { CliSteeringProposal } from "../src/cli-steering.js";
+import { readSteeringLedgerEntries, readUlwLoopPlan, writePlan } from "../src/plan-io.js";
+import { steerUlwLoopBatch } from "../src/steering-batch.js";
+import type { UlwLoopItem, UlwLoopPlan, UlwLoopSteeringProposal } from "../src/types.js";
+
+const appendFileCalls = vi.hoisted(() => vi.fn());
+vi.mock("node:fs/promises", async (importOriginal) => {
+	const actual = await importOriginal<typeof import("node:fs/promises")>();
+	appendFileCalls.mockImplementation(actual.appendFile);
+	return { ...actual, appendFile: appendFileCalls };
+});
+
+const NOW = "2026-05-23T00:00:00.000Z";
+
+function goal(id: string): UlwLoopItem {
+	return {
+		id,
+		title: id,
+		objective: `Do ${id}`,
+		status: "pending",
+		successCriteria: [],
+		attempt: 0,
+		createdAt: NOW,
+		updatedAt: NOW,
+	};
+}
+
+function plan(): 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: [goal("G001"), goal("G002")],
+	};
+}
+
+function proposal(overrides: Partial<UlwLoopSteeringProposal> = {}): UlwLoopSteeringProposal {
+	return {
+		kind: "add_subgoal",
+		source: "cli",
+		evidence: "observable evidence",
+		rationale: "necessary plan refinement",
+		title: "New goal",
+		objective: "Do the new goal",
+		...overrides,
+	};
+}
+
+async function repoWithPlan(): Promise<string> {
+	const repo = await mkdtemp(join(tmpdir(), "ug-steer-batch-"));
+	await writePlan(repo, plan());
+	return repo;
+}
+
+describe("steerUlwLoopBatch", () => {
+	it("#given two valid proposals #when applied as a batch #then both mutations commit", async () => {
+		const repo = await repoWithPlan();
+
+		const result = await steerUlwLoopBatch(repo, [
+			proposal({ idempotencyKey: "b1" }),
+			proposal({ kind: "revise_pending_wording", targetGoalId: "G001", revisedTitle: "Revised", idempotencyKey: "b2" }),
+		]);
+
+		expect(result.accepted).toBe(true);
+		expect(result.results).toHaveLength(2);
+		expect((await readUlwLoopPlan(repo)).goals.map((item) => item.title)).toContain("Revised");
+		expect((await readSteeringLedgerEntries(repo)).filter((entry) => entry.kind === "steering_accepted")).toHaveLength(2);
+	});
+
+	it("#given rejected proposals #when applied as a batch #then one rejection audit lists every rejected index", async () => {
+		const repo = await repoWithPlan();
+		const before = JSON.stringify(await readUlwLoopPlan(repo));
+
+		const result = await steerUlwLoopBatch(repo, [proposal({ idempotencyKey: "ok" }), proposal({ kind: "reorder_pending", pendingOrder: ["missing"] }), proposal({ evidence: "" })]);
+
+		expect(result.accepted).toBe(false);
+		expect(JSON.stringify(await readUlwLoopPlan(repo))).toBe(before);
+		expect((await readUlwLoopPlan(repo)).goals).toHaveLength(2);
+		const entries = await readSteeringLedgerEntries(repo);
+		expect(entries.filter((entry) => entry.kind === "steering_accepted")).toHaveLength(0);
+		expect(entries.filter((entry) => entry.kind === "steering_rejected")).toHaveLength(1);
+		expect(entries.find((entry) => entry.kind === "steering_rejected")?.message).toContain("index 1:");
+		expect(entries.find((entry) => entry.kind === "steering_rejected")?.message).toContain("index 2:");
+	});
+
+	it("#given a batch member split in proposals-json #when applied #then updates validation batch membership", async () => {
+		const repo = await repoWithPlan();
+		const seed = await readUlwLoopPlan(repo);
+		await writePlan(repo, { ...seed, validationBatches: [{ batchId: "VB001", memberIds: ["G001", "G002"], finalGoalId: "G002" }] });
+
+		const result = await steerUlwLoopBatch(repo, [
+			proposal({
+				kind: "split_subgoal",
+				targetGoalId: "G001",
+				childGoals: [{ title: "Child", objective: "Do child" }],
+			}),
+		]);
+
+		expect(result.plan.validationBatches).toEqual([{ batchId: "VB001", memberIds: ["G003", "G002"], finalGoalId: "G002" }]);
+		expect((await readSteeringLedgerEntries(repo)).at(-1)).toMatchObject({ kind: "batch_updated" });
+	});
+
+	it("#given a prior idempotency key #when batched with a fresh proposal #then dedupes one and applies the other", async () => {
+		const repo = await repoWithPlan();
+		await steerUlwLoopBatch(repo, [proposal({ idempotencyKey: "same" })]);
+
+		const result = await steerUlwLoopBatch(repo, [proposal({ idempotencyKey: "same" }), proposal({ idempotencyKey: "fresh" })]);
+
+		expect(result.accepted).toBe(true);
+		expect(result.results.map((item) => item.deduped)).toEqual([true, false]);
+		expect((await readUlwLoopPlan(repo)).goals).toHaveLength(4);
+	});
+
+	it("#given mixed fresh and deduped proposals #when accepted and replayed #then one append records all fresh audits and replay records none", async () => {
+		const repo = await repoWithPlan();
+		const seeded = await readUlwLoopPlan(repo);
+		seeded.goals[0]?.successCriteria.push({ id: "C001", scenario: "old", expectedEvidence: "proof", userModel: "edge", status: "pending", capturedEvidence: null });
+		await writePlan(repo, { ...seeded, validationBatches: [{ batchId: "VB001", memberIds: ["G001", "G002"], finalGoalId: "G002" }] });
+		await steerUlwLoopBatch(repo, [proposal({ idempotencyKey: "dedupe-me" })]);
+		appendFileCalls.mockClear();
+
+		const revise = { ...proposal({ kind: "revise_criterion", targetGoalId: "G001", criterionId: "C001", idempotencyKey: "revise-c1" }), scenario: "new" } satisfies CliSteeringProposal;
+		const batch = [
+			proposal({ idempotencyKey: "dedupe-me" }),
+			revise,
+			proposal({ kind: "split_subgoal", targetGoalId: "G002", childGoals: [{ title: "Child", objective: "Do child" }], idempotencyKey: "split-g2" }),
+		];
+		const result = await steerUlwLoopBatch(repo, batch);
+
+		expect(result.accepted).toBe(true);
+		expect(result.results.map((item) => item.deduped)).toEqual([true, false, false]);
+		expect(appendFileCalls).toHaveBeenCalledTimes(1);
+		expect((await readSteeringLedgerEntries(repo)).map((entry) => entry.kind).slice(-3)).toEqual(["criteria_revised", "steering_accepted", "batch_updated"]);
+		const after = JSON.stringify(await readUlwLoopPlan(repo));
+		appendFileCalls.mockClear();
+
+		const replay = await steerUlwLoopBatch(repo, batch);
+
+		expect(replay.results.map((item) => item.deduped)).toEqual([true, true, true]);
+		expect(JSON.stringify(await readUlwLoopPlan(repo))).toBe(after);
+		expect(appendFileCalls).not.toHaveBeenCalled();
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/stop-resume-hook.test.ts

@@ -179,6 +179,35 @@ describe("runStopResumeHook", () => {
 		expect(JSON.parse(output).reason).toContain("--session-id s1");
 	});
 
+	it("#given a goal id with path traversal #when the hook runs #then nothing is written outside the state dir and the resume is denied", () => {
+		writeGoals([pendingGoal("../../../escaped-marker")]);
+		const outsideDir = join(workDir, ".omo", "ulw-loop");
+		const sentinel = join(outsideDir, "escaped-marker.json");
+		writeFileSync(sentinel, "sentinel\n");
+
+		const output = runStopResumeHook(stopPayload());
+
+		expect(output).toBe("");
+		expect(readFileSync(sentinel, "utf8")).toBe("sentinel\n");
+		expect(existsSync(join(outsideDir, "escaped-marker.stuck"))).toBe(false);
+		expect(existsSync(join(outsideDir, "auto-resume-escaped-marker.json"))).toBe(false);
+	});
+
+	it("#given a normal goal id #when the hook runs past the cap #then the counter and stuck marker are written inside the state dir", () => {
+		writeGoals([pendingGoal("goal-abc")]);
+
+		runStopResumeHook(stopPayload());
+		runStopResumeHook(stopPayload());
+		const third = runStopResumeHook(stopPayload());
+
+		expect(third).toBe("");
+		const counter = JSON.parse(readFileSync(join(sessionDir(), "auto-resume-goal-abc.json"), "utf8"));
+		expect(counter.count).toBe(2);
+		expect(readFileSync(join(sessionDir(), "auto-resume-goal-abc.stuck"), "utf8")).toBe(
+			"no ledger progress after 2 resumes\n",
+		);
+	});
+
 	it("#given ledger movement between stops #when the hook fires again #then the cap resets", () => {
 		writeGoals([pendingGoal()]);
 

package/packages/omo-codex/plugin/components/ulw-loop/test/validation-batch-checkpoint.test.ts

@@ -0,0 +1,147 @@
+// biome-ignore-all format: compact validation-batch checkpoint tests stay under the pure LOC budget.
+import { describe, expect, it } from "vitest";
+
+import { checkpointUlwLoop } from "../src/checkpoint.js";
+import { readUlwLoopPlan } from "../src/plan-io.js";
+import { criterion, expectCode, goal, plan, repoWith, snapshot } from "./fixtures/checkpoint-builders.js";
+import { qualityGateJson } from "./fixtures/quality-gate-builder.js";
+
+const batch = { batchId: "VB001", memberIds: ["G001", "G002"], finalGoalId: "G002" };
+
+describe("validation-batch checkpoint enforcement", () => {
+	it("#given an open batch member #when completing the batch final goal #then rejects with batch open", async () => {
+		const repo = await repoWith(
+			plan([
+				goal({ id: "G001", status: "pending" }),
+				goal({ id: "G002", status: "in_progress" }),
+				goal({ id: "G003", status: "pending" }),
+			], { validationBatches: [batch] }),
+		);
+
+		await expectCode(
+			() =>
+				checkpointUlwLoop(repo, {
+					goalId: "G002",
+					status: "complete",
+					evidence: "batch final implementation done",
+					codexGoalJson: snapshot("active"),
+					qualityGateJson: "{}",
+				}),
+			"ULW_LOOP_VALIDATION_BATCH_OPEN",
+		);
+	});
+
+	it("#given complete members but no gate #when completing the batch final goal #then requires a batch gate", async () => {
+		const repo = await repoWith(
+			plan([
+				goal({ id: "G001", status: "complete" }),
+				goal({ id: "G002", status: "in_progress" }),
+				goal({ id: "G003", status: "pending" }),
+			], { validationBatches: [batch] }),
+		);
+
+		await expectCode(
+			() =>
+				checkpointUlwLoop(repo, {
+					goalId: "G002",
+					status: "complete",
+					evidence: "batch final implementation done",
+					codexGoalJson: snapshot("active"),
+				}),
+			"ULW_LOOP_VALIDATION_BATCH_GATE_REQUIRED",
+		);
+	});
+
+	it("#given a member criterion pending #when the batch gate is present #then rejects pending criteria", async () => {
+		const repo = await repoWith(
+			plan([
+				goal({ id: "G001", status: "complete", successCriteria: [criterion("C001", "pass"), criterion("C002", "pending")] }),
+				goal({ id: "G002", status: "in_progress", successCriteria: [criterion("C001", "pass"), criterion("C002", "pass")] }),
+				goal({ id: "G003", status: "pending" }),
+			], { validationBatches: [batch] }),
+		);
+
+		const gateJson = await qualityGateJson(repo, undefined, "G002");
+		await expectCode(
+			() =>
+				checkpointUlwLoop(repo, {
+					goalId: "G002",
+					status: "complete",
+					evidence: "batch final implementation done",
+					codexGoalJson: snapshot("active"),
+					qualityGateJson: gateJson,
+				}),
+			"ULW_LOOP_VALIDATION_BATCH_CRITERIA_PENDING",
+		);
+	});
+
+	it("#given all member criteria pass #when coverage counts mismatch #then rejects the gate", async () => {
+		const repo = await repoWith(
+			plan([
+				goal({ id: "G001", status: "complete", successCriteria: [criterion("C001", "pass"), criterion("C002", "pass")] }),
+				goal({ id: "G002", status: "in_progress", successCriteria: [criterion("C001", "pass"), criterion("C002", "pass")] }),
+				goal({ id: "G003", status: "pending" }),
+			], { validationBatches: [batch] }),
+		);
+
+		const gateJson = await qualityGateJson(repo, undefined, "G002");
+		await expectCode(
+			() =>
+				checkpointUlwLoop(repo, {
+					goalId: "G002",
+					status: "complete",
+					evidence: "batch final implementation done",
+					codexGoalJson: snapshot("active"),
+					qualityGateJson: gateJson,
+				}),
+			"ULW_LOOP_VALIDATION_BATCH_GATE_MISMATCH",
+		);
+	});
+
+	it("#given batch-final goal is also run-final #when completing it #then closes batch and aggregate", async () => {
+		const repo = await repoWith(
+			plan([
+				goal({ id: "G001", status: "complete", successCriteria: [criterion("C001", "pass")] }),
+				goal({ id: "G002", status: "complete", successCriteria: [criterion("C001", "pass")] }),
+				goal({ id: "G003", status: "in_progress", successCriteria: [criterion("C001", "pass")] }),
+			], { validationBatches: [{ batchId: "VB002", memberIds: ["G002", "G003"], finalGoalId: "G003" }] }),
+		);
+
+		const gate = JSON.parse(await qualityGateJson(repo, undefined, "G003"));
+		gate.criteriaCoverage.totalCriteria = 2;
+		gate.criteriaCoverage.passCount = 2;
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G003",
+			status: "complete",
+			evidence: "batch final is also aggregate final",
+			codexGoalJson: snapshot("complete"),
+			qualityGateJson: JSON.stringify(gate),
+		});
+
+		expect(result.aggregateCompletion?.status).toBe("complete");
+		expect((await readUlwLoopPlan(repo)).goals.find((item) => item.id === "G003")?.status).toBe("complete");
+	});
+
+	it("#given all batch checks pass #when completing final member #then appends batch closed", async () => {
+		const repo = await repoWith(
+			plan([
+				goal({ id: "G001", status: "complete", successCriteria: [criterion("C001", "pass")] }),
+				goal({ id: "G002", status: "in_progress", successCriteria: [criterion("C001", "pass")] }),
+				goal({ id: "G003", status: "pending" }),
+			], { validationBatches: [batch] }),
+		);
+
+		const gate = JSON.parse(await qualityGateJson(repo, undefined, "G002"));
+		gate.criteriaCoverage.totalCriteria = 2;
+		gate.criteriaCoverage.passCount = 2;
+		await checkpointUlwLoop(repo, {
+			goalId: "G002",
+			status: "complete",
+			evidence: "batch final implementation done",
+			codexGoalJson: snapshot("active"),
+			qualityGateJson: JSON.stringify(gate),
+		});
+
+		expect((await readUlwLoopPlan(repo)).goals.find((item) => item.id === "G002")?.status).toBe("complete");
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/validation-batch.test.ts

@@ -0,0 +1,73 @@
+// biome-ignore-all format: compact validation-batch tests stay under the pure LOC budget.
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { createUlwLoopPlan } from "../src/plan-crud.js";
+
+async function repo(): Promise<string> {
+	return mkdtemp(join(tmpdir(), "ug-validation-batch-"));
+}
+
+describe("createUlwLoopPlan validation batches", () => {
+	it("#given a valid validation batch #when creating goals #then stores it on the plan", async () => {
+		const plan = await createUlwLoopPlan(await repo(), {
+			brief: "- Goal alpha\n- Goal beta\n- Goal gamma",
+			validationBatchesJson: '[{"batchId":"VB001","memberIds":["G001-goal-alpha","G002-goal-beta"],"finalGoalId":"G002-goal-beta"}]',
+		});
+
+		expect(plan.validationBatches).toEqual([
+			{ batchId: "VB001", memberIds: ["G001-goal-alpha", "G002-goal-beta"], finalGoalId: "G002-goal-beta" },
+		]);
+	});
+
+	it("#given an unknown member id #when creating goals #then rejects with the member-unknown code", async () => {
+		await expect(
+			createUlwLoopPlan(await repo(), {
+				brief: "- Goal alpha\n- Goal beta",
+				validationBatchesJson: '[{"batchId":"VB001","memberIds":["G001-goal-alpha","missing"],"finalGoalId":"G001-goal-alpha"}]',
+			}),
+		).rejects.toMatchObject({ code: "ULW_LOOP_VALIDATION_BATCH_MEMBER_UNKNOWN" });
+	});
+
+	it("#given a final id outside members #when creating goals #then rejects with the final-not-member code", async () => {
+		await expect(
+			createUlwLoopPlan(await repo(), {
+				brief: "- Goal alpha\n- Goal beta\n- Goal gamma",
+				validationBatchesJson: '[{"batchId":"VB001","memberIds":["G001-goal-alpha","G002-goal-beta"],"finalGoalId":"G003-goal-gamma"}]',
+			}),
+		).rejects.toMatchObject({ code: "ULW_LOOP_VALIDATION_BATCH_FINAL_NOT_MEMBER" });
+	});
+
+	it("#given overlapping validation batches #when creating goals #then rejects with the overlap code", async () => {
+		await expect(
+			createUlwLoopPlan(await repo(), {
+				brief: "- Goal alpha\n- Goal beta\n- Goal gamma",
+				validationBatchesJson: '[{"batchId":"VB001","memberIds":["G001-goal-alpha","G002-goal-beta"],"finalGoalId":"G002-goal-beta"},{"batchId":"VB002","memberIds":["G002-goal-beta","G003-goal-gamma"],"finalGoalId":"G003-goal-gamma"}]',
+			}),
+		).rejects.toMatchObject({ code: "ULW_LOOP_VALIDATION_BATCH_OVERLAP" });
+	});
+
+	it("#given duplicate members #when creating goals #then retains the structural invalid code", async () => {
+		await expect(
+			createUlwLoopPlan(await repo(), {
+				brief: "- Goal alpha\n- Goal beta",
+				validationBatchesJson: '[{"batchId":"VB001","memberIds":["G001-goal-alpha","G001-goal-alpha"],"finalGoalId":"G001-goal-alpha"}]',
+			}),
+		).rejects.toMatchObject({ code: "ULW_LOOP_VALIDATION_BATCH_INVALID" });
+	});
+
+	it("#given a validation batch file #when creating goals #then reads the batch JSON from disk", async () => {
+		const root = await repo();
+		const file = join(root, "batches.json");
+		await import("node:fs/promises").then((fs) => fs.writeFile(file, '[{"batchId":"VB001","memberIds":["G001-goal-alpha","G002-goal-beta"],"finalGoalId":"G002-goal-beta"}]', "utf8"));
+
+		const plan = await createUlwLoopPlan(root, {
+			brief: "- Goal alpha\n- Goal beta",
+			validationBatchesJson: file,
+		});
+
+		expect(JSON.parse(await readFile(join(root, ".omo/ulw-loop/goals.json"), "utf8"))).toHaveProperty("validationBatches", plan.validationBatches);
+	});
+});

package/packages/omo-codex/plugin/hooks/post-compact-resetting-git-bash-mcp-reminder.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/git-bash/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.2) Resetting Git Bash MCP Reminder",
+						"statusMessage": "(OmO 4.19.1) Resetting Git Bash MCP Reminder",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\git-bash\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-compact-resetting-lsp-diagnostics-cache.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.2) Resetting LSP Diagnostics Cache",
+						"statusMessage": "(OmO 4.19.1) Resetting LSP Diagnostics Cache",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\lsp\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-compact-resetting-project-rule-cache.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/rules/dist/cli.js\" hook post-compact",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.2) Resetting Project Rule Cache",
+						"statusMessage": "(OmO 4.19.1) Resetting Project Rule Cache",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\rules\\dist\\cli.js\" hook post-compact"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-codegraph-init-guidance.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/codegraph/dist/cli.js\" hook post-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.2) Checking CodeGraph Init Guidance",
+						"statusMessage": "(OmO 4.19.1) Checking CodeGraph Init Guidance",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\codegraph\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-comments.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/comment-checker/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "(OmO 4.18.2) Checking Comments",
+						"statusMessage": "(OmO 4.19.1) Checking Comments",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\comment-checker\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-lsp-diagnostics.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "(OmO 4.18.2) Checking LSP Diagnostics",
+						"statusMessage": "(OmO 4.19.1) Checking LSP Diagnostics",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\lsp\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/post-tool-use-checking-thread-title-hygiene.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/teammode/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.2) Checking Thread Title Hygiene",
+						"statusMessage": "(OmO 4.19.1) Checking Thread Title Hygiene",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\teammode\\dist\\cli.js\" hook post-tool-use"
 					}
 				]

package/packages/omo-codex/plugin/hooks/post-tool-use-matching-project-rules.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/rules/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.18.2) Matching Project Rules",
+						"statusMessage": "(OmO 4.19.1) Matching Project Rules",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\rules\\dist\\cli.js\" hook post-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/pre-tool-use-enforcing-unlimited-goal-budget.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/ulw-loop/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.2) Enforcing Unlimited Goal Budget",
+						"statusMessage": "(OmO 4.19.1) Enforcing Unlimited Goal Budget",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\ulw-loop\\dist\\cli.js\" hook pre-tool-use"
 					}
 				],

package/packages/omo-codex/plugin/hooks/pre-tool-use-guarding-ulw-loop-spawns.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/ulw-loop/dist/cli.js\" hook pre-tool-use-spawn",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.2) Guarding Ulw-Loop Spawns",
+						"statusMessage": "(OmO 4.19.1) Guarding Ulw-Loop Spawns",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\ulw-loop\\dist\\cli.js\" hook pre-tool-use-spawn"
 					}
 				]

package/packages/omo-codex/plugin/hooks/pre-tool-use-recommending-git-bash-mcp.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/git-bash/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.18.2) Recommending Git Bash MCP",
+						"statusMessage": "(OmO 4.19.1) Recommending Git Bash MCP",
 						"commandWindows": "powershell -NoProfile -ExecutionPolicy Bypass -File \"${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1\" \"${PLUGIN_ROOT}\\components\\git-bash\\dist\\cli.js\" hook pre-tool-use"
 					}
 				],