lazycodex-ai 5.0.0-beta.6 → 5.0.0-beta.60

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

@@ -74,7 +74,7 @@ afterEach(async () => {
 
 describe("dist/cli.js entrypoint dispatch", () => {
 	it("#given no plan #when invoked with bare 'status --json' #then routes into ulw-loop instead of unknown command", async () => {
-		const result = await runCli(["status", "--json"]);
+		const result = await runCli(["status", "--session-id", "s1", "--json"]);
 
 		const combined = `${result.stdout}${result.stderr}`;
 		expect(combined).toContain("No ulw-loop plan found");
@@ -83,7 +83,7 @@ describe("dist/cli.js entrypoint dispatch", () => {
 	});
 
 	it("#given no plan #when invoked with legacy 'ulw-loop status --json' #then still routes into ulw-loop", async () => {
-		const result = await runCli(["ulw-loop", "status", "--json"]);
+		const result = await runCli(["ulw-loop", "status", "--session-id", "s1", "--json"]);
 
 		const combined = `${result.stdout}${result.stderr}`;
 		expect(combined).toContain("No ulw-loop plan found");
@@ -91,12 +91,46 @@ describe("dist/cli.js entrypoint dispatch", () => {
 		expect(result.code).toBe(1);
 	});
 
-	it("#given the top-level entrypoint #when invoked with 'help' #then prints usage and exits 0", async () => {
+	it("#given no session flag and no session env #when invoked with 'status --json' #then refuses the unscoped root instead of reading it", async () => {
+		const result = await runCli(["status", "--json"]);
+
+		expect(result.code).toBe(1);
+		expect(JSON.parse(result.stdout)).toMatchObject({
+			ok: false,
+			error: { code: "ULW_LOOP_SESSION_SCOPE_REQUIRED", details: { flag: "--session-id" } },
+		});
+	});
+
+	it("#given the top-level entrypoint #when invoked with 'help' #then prints the merged hook and subcommand usage and exits 0", async () => {
 		const result = await runCli(["help"]);
 
 		expect(result.code).toBe(0);
 		expect(result.stdout).toContain("Usage:");
-		expect(result.stdout).toContain("omo-agent-toolkit ulw-loop <subcommand>");
+		expect(result.stdout).toContain("hook user-prompt-submit");
+		expect(result.stdout).toContain("create-goals");
+		expect(result.stdout).toContain("complete-goals");
+		expect(result.stdout).toContain("record-review-blockers");
+		expect(result.stdout).not.toContain("for ulw-loop subcommands");
+	});
+
+	it("#given the staged router strips nothing #when invoked with 'ulw-loop help' #then prints the same merged help text", async () => {
+		const bare = await runCli(["help"]);
+		const nested = await runCli(["ulw-loop", "help"]);
+
+		expect(nested.code).toBe(0);
+		expect(nested.stdout.trim()).toBe(bare.stdout.trim());
+		expect(nested.stdout).toContain("hook user-prompt-submit");
+		expect(nested.stdout).toContain("record-review-blockers");
+		expect(nested.stdout).not.toContain("for ulw-loop subcommands");
+	});
+
+	it("#given a subcommand with required args #when invoked with 'create-goals --help' #then prints its usage and exits 0", async () => {
+		const result = await runCli(["create-goals", "--help"]);
+
+		expect(result.code).toBe(0);
+		expect(result.stdout).toContain("Usage:");
+		expect(result.stdout).toContain("create-goals");
+		expect(`${result.stdout}${result.stderr}`).not.toContain("Missing brief text");
 	});
 
 	it("#given a command outside the ulw-loop vocabulary #when invoked with 'frobnicate' #then fails as unknown command", async () => {

package/packages/omo-codex/plugin/components/ulw-loop/test/cli-json-errors.test.ts

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { ulwLoopCommand } from "../src/cli-commands.ts";
+import { CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
 
 let testDir: string;
 let out: string[];
@@ -22,6 +23,7 @@ beforeEach(async () => {
 	delete process.env["CODEX_SESSION_ID"];
 	delete process.env["CODEX_THREAD_ID"];
 	delete process.env["OMO_ULW_LOOP_SESSION_ID"];
+	process.env["OMO_ULW_LOOP_SESSION_ID"] = CLI_TEST_SESSION_ID;
 	vi.spyOn(process, "cwd").mockReturnValue(testDir);
 	vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array): boolean => {
 		out.push(chunk.toString());
@@ -76,6 +78,31 @@ describe("ulwLoopCommand --json error contract", () => {
 		expect(stdoutJson()).toMatchObject({ ok: false, error: { code: expect.any(String) } });
 	});
 
+	it("#given an invalid codex snapshot token #when checkpoint --json #then emits the stable typed error", async () => {
+		const code = await ulwLoopCommand([
+			"checkpoint",
+			"--json",
+			"--goal-id",
+			"G001",
+			"--status",
+			"complete",
+			"--evidence",
+			"proof",
+			"--codex-goal-json",
+			"not-json-not-a-path",
+		]);
+
+		expect(code).toBe(1);
+		expect(err.join("")).toBe("");
+		expect(stdoutJson()).toMatchObject({
+			ok: false,
+			error: {
+				code: "ULW_LOOP_CODEX_GOAL_JSON_INVALID",
+				message: expect.stringContaining("neither valid JSON nor a readable path"),
+			},
+		});
+	});
+
 	it("#given a malformed required flag #when --json #then surfaces the UlwLoopError code with details on stdout", async () => {
 		const code = await ulwLoopCommand(["criteria", "--json"]);
 

package/packages/omo-codex/plugin/components/ulw-loop/test/cli-scope-required.test.ts

@@ -0,0 +1,144 @@
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { ulwLoopCommand } from "../src/cli-commands.ts";
+import { ulwLoopAttemptEvidenceDir } from "../src/paths.ts";
+
+const SESSION_ENV_KEYS = ["OMO_ULW_LOOP_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "PI_SESSION_ID"] as const;
+const NOW = "2026-05-23T00:00:00.000Z";
+
+let testDir: string;
+let out: string[];
+let err: string[];
+let savedEnv: Record<string, string | undefined>;
+
+beforeEach(async () => {
+	testDir = await mkdtemp(join(tmpdir(), "ug-cli-scope-"));
+	out = [];
+	err = [];
+	savedEnv = {};
+	for (const key of SESSION_ENV_KEYS) {
+		savedEnv[key] = process.env[key];
+		delete process.env[key];
+	}
+	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((chunk: string | Uint8Array): boolean => {
+		err.push(chunk.toString());
+		return true;
+	});
+});
+
+afterEach(async () => {
+	vi.restoreAllMocks();
+	for (const key of SESSION_ENV_KEYS) {
+		const saved = savedEnv[key];
+		if (saved === undefined) delete process.env[key];
+		else process.env[key] = saved;
+	}
+	await rm(testDir, { recursive: true, force: true });
+});
+
+function stdoutJson(): Record<string, unknown> {
+	return JSON.parse(out.join(""));
+}
+
+async function writeLegacyRootPlan(): Promise<void> {
+	await mkdir(join(testDir, ".omo", "ulw-loop", "other-session"), { recursive: true });
+	await writeFile(
+		join(testDir, ".omo", "ulw-loop", "goals.json"),
+		JSON.stringify({
+			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("ulwLoopCommand session scope", () => {
+	describe("#given no --session-id and no session env", () => {
+		it("#when create-goals runs #then it refuses with ULW_LOOP_SESSION_SCOPE_REQUIRED and writes nothing", async () => {
+			const code = await ulwLoopCommand(["create-goals", "--brief", "- Goal A", "--json"]);
+
+			expect(code).toBe(1);
+			expect(err.join("")).toBe("");
+			expect(stdoutJson()).toMatchObject({
+				ok: false,
+				error: {
+					code: "ULW_LOOP_SESSION_SCOPE_REQUIRED",
+					details: { flag: "--session-id", existingSessionIds: [] },
+				},
+			});
+			expect(existsSync(join(testDir, ".omo"))).toBe(false);
+		});
+
+		it("#when a legacy root plan exists #then status does not read it and lists the real session ids", async () => {
+			await writeLegacyRootPlan();
+
+			const code = await ulwLoopCommand(["status", "--json"]);
+
+			expect(code).toBe(1);
+			expect(stdoutJson()).toMatchObject({
+				ok: false,
+				error: { code: "ULW_LOOP_SESSION_SCOPE_REQUIRED", details: { existingSessionIds: ["other-session"] } },
+			});
+			expect(out.join("")).not.toContain('"goals"');
+		});
+
+		it("#when the human-readable form is used #then the error explains the flag and the env keys", async () => {
+			const code = await ulwLoopCommand(["status"]);
+
+			expect(code).toBe(1);
+			expect(err.join("")).toContain("--session-id <id>");
+			expect(err.join("")).toContain("PI_SESSION_ID");
+		});
+
+		it("#when help is requested #then it prints usage without needing a scope", async () => {
+			expect(await ulwLoopCommand(["help"])).toBe(0);
+			expect(await ulwLoopCommand(["status", "--help"])).toBe(0);
+			expect(err.join("")).toBe("");
+		});
+	});
+
+	describe("#given a session env key", () => {
+		it("#when status runs #then the scope resolves to that session directory", async () => {
+			process.env["PI_SESSION_ID"] = "env-session";
+
+			const code = await ulwLoopCommand(["status", "--json"]);
+
+			expect(code).toBe(1);
+			expect(stdoutJson()).toMatchObject({
+				ok: false,
+				error: {
+					code: "ULW_LOOP_PLAN_MISSING",
+					message: expect.stringContaining(".omo/ulw-loop/env-session/goals.json"),
+				},
+			});
+		});
+	});
+});
+
+describe("ulwLoopAttemptEvidenceDir", () => {
+	it("#given no session scope #when resolving an attempt dir #then it refuses instead of inventing a placeholder", () => {
+		expect(() => ulwLoopAttemptEvidenceDir("G001", 1)).toThrow(
+			expect.objectContaining({ code: "ULW_LOOP_SESSION_SCOPE_REQUIRED" }),
+		);
+		expect(() => ulwLoopAttemptEvidenceDir("G001", 1, { sessionId: "  " })).toThrow(
+			expect.objectContaining({ code: "ULW_LOOP_SESSION_SCOPE_REQUIRED" }),
+		);
+	});
+
+	it("#given a session scope #when resolving an attempt dir #then it lives under that session", () => {
+		expect(ulwLoopAttemptEvidenceDir("G001", 2, { sessionId: "s1" })).toBe(".omo/evidence/ulw/s1/G001/a2");
+	});
+});

package/packages/omo-codex/plugin/components/ulw-loop/test/cli-status-next-actions.test.ts

@@ -0,0 +1,185 @@
+import { mkdir, 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";
+import { ulwLoopDir } from "../src/paths.js";
+import { writePlan } from "../src/plan-io.js";
+import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "../src/types.js";
+import { CLI_TEST_SCOPE, CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
+
+const NOW = "2026-05-23T00:00:00.000Z";
+const SESSION_ENV_KEYS = ["OMO_ULW_LOOP_SESSION_ID", "CODEX_SESSION_ID", "CODEX_THREAD_ID", "PI_SESSION_ID"] as const;
+
+let testDir: string;
+let out: string[];
+let err: string[];
+let savedEnv: Record<string, string | undefined>;
+
+beforeEach(async () => {
+	testDir = await mkdtemp(join(tmpdir(), "ug-status-next-"));
+	out = [];
+	err = [];
+	savedEnv = {};
+	for (const key of SESSION_ENV_KEYS) {
+		savedEnv[key] = process.env[key];
+		delete process.env[key];
+	}
+	process.env["OMO_ULW_LOOP_SESSION_ID"] = CLI_TEST_SESSION_ID;
+	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((chunk: string | Uint8Array): boolean => {
+		err.push(chunk.toString());
+		return true;
+	});
+});
+
+afterEach(async () => {
+	vi.restoreAllMocks();
+	for (const key of SESSION_ENV_KEYS) {
+		const saved = savedEnv[key];
+		if (saved === undefined) delete process.env[key];
+		else process.env[key] = saved;
+	}
+	await rm(testDir, { recursive: true, force: true });
+});
+
+function stdoutJson(): Record<string, unknown> {
+	return JSON.parse(out.join(""));
+}
+
+function nextActions(): readonly string[] {
+	const value = stdoutJson()["nextActions"];
+	if (!Array.isArray(value)) throw new Error(`expected nextActions array, got ${JSON.stringify(value)}`);
+	return value.map((entry) => String(entry));
+}
+
+function criterion(id: string, status: UlwLoopSuccessCriterion["status"]): UlwLoopSuccessCriterion {
+	return {
+		id,
+		scenario: `${id} scenario`,
+		userModel: "happy",
+		expectedEvidence: `${id} proof`,
+		capturedEvidence: status === "pass" ? `${id} passed` : null,
+		status,
+	};
+}
+
+function goal(overrides: Partial<UlwLoopItem> = {}): UlwLoopItem {
+	return {
+		id: "G001",
+		title: "Build auth",
+		objective: "Implement JWT auth endpoint",
+		status: "in_progress",
+		successCriteria: [criterion("C001", "pass")],
+		attempt: 1,
+		createdAt: NOW,
+		updatedAt: NOW,
+		...overrides,
+	};
+}
+
+function plan(goals: UlwLoopItem[], overrides: Partial<UlwLoopPlan> = {}): UlwLoopPlan {
+	const result: UlwLoopPlan = {
+		version: 1,
+		evidenceLayoutVersion: 2,
+		createdAt: NOW,
+		updatedAt: NOW,
+		briefPath: ".omo/ulw-loop/cli-test/brief.md",
+		goalsPath: ".omo/ulw-loop/cli-test/goals.json",
+		ledgerPath: ".omo/ulw-loop/cli-test/ledger.jsonl",
+		goals,
+	};
+	Object.assign(result, overrides);
+	return result;
+}
+
+function legacyLayoutPlan(goals: UlwLoopItem[], overrides: Partial<UlwLoopPlan> = {}): UlwLoopPlan {
+	const result = plan(goals, overrides);
+	delete result.evidenceLayoutVersion;
+	return result;
+}
+
+async function seed(seedPlan: UlwLoopPlan): Promise<void> {
+	await mkdir(ulwLoopDir(testDir, CLI_TEST_SCOPE), { recursive: true });
+	await writePlan(testDir, seedPlan, CLI_TEST_SCOPE);
+}
+
+describe("#given a plan with no goals", () => {
+	it("#when status --json #then nextActions points at create-goals", async () => {
+		await seed(plan([]));
+
+		expect(await ulwLoopCommand(["status", "--json"])).toBe(0);
+		expect(nextActions().join("\n")).toContain('omo-agent-toolkit ulw-loop create-goals --brief "<brief>" --json');
+	});
+});
+
+describe("#given an active goal with unresolved criteria", () => {
+	it("#when status --json #then nextActions names record-evidence with the remaining criterion ids", async () => {
+		await seed(
+			plan(
+				[
+					goal({
+						successCriteria: [criterion("C001", "pass"), criterion("C002", "pending"), criterion("C003", "fail")],
+					}),
+				],
+				{
+					activeGoalId: "G001",
+				},
+			),
+		);
+
+		expect(await ulwLoopCommand(["status", "--json"])).toBe(0);
+		const actions = nextActions().join("\n");
+		expect(actions).toContain("record-evidence");
+		expect(actions).toContain("C002");
+		expect(actions).toContain("C003");
+		expect(actions).not.toContain("C001");
+		expect(stdoutJson()).toHaveProperty("currentAttemptDir");
+	});
+});
+
+describe("#given the final story with every criterion passing", () => {
+	it("#when status --json #then nextActions tells the agent to complete the goal then print the template", async () => {
+		await seed(plan([goal({ successCriteria: [criterion("C001", "pass")] })], { activeGoalId: "G001" }));
+
+		expect(await ulwLoopCommand(["status", "--json"])).toBe(0);
+		const actions = nextActions().join("\n");
+		expect(actions).toContain("update_goal complete, then checkpoint --print-template");
+	});
+});
+
+describe("#given a review_blocked goal", () => {
+	it("#when status --json #then nextActions points at record-review-blockers", async () => {
+		await seed(plan([goal({ status: "review_blocked", successCriteria: [criterion("C001", "pass")] })]));
+
+		expect(await ulwLoopCommand(["status", "--json"])).toBe(0);
+		expect(nextActions().join("\n")).toContain("record-review-blockers");
+	});
+});
+
+describe("#given an evidence-layout v1 plan", () => {
+	it("#when status --json #then currentAttemptDir stays absent and nextActions explains the v1 layout", async () => {
+		await seed(legacyLayoutPlan([goal()], { activeGoalId: "G001" }));
+
+		expect(await ulwLoopCommand(["status", "--json"])).toBe(0);
+		expect(stdoutJson()).not.toHaveProperty("currentAttemptDir");
+		expect(nextActions().join("\n")).toContain("plan is evidence-layout v1; artifacts go under .omo/evidence/");
+	});
+});
+
+describe("#given a valueless --session-id in a subprocess context", () => {
+	it("#when any subcommand runs #then the error explains the missing session env and the flag usage", async () => {
+		expect(await ulwLoopCommand(["status", "--session-id", "--json"])).toBe(1);
+
+		const payload = stdoutJson();
+		expect(payload).toMatchObject({ ok: false, error: { code: "ULW_LOOP_SESSION_ID_REQUIRED" } });
+		const message = String((payload["error"] as Record<string, unknown>)["message"]);
+		expect(message).toContain("--session-id <id>");
+		expect(message).toContain("subprocess");
+	});
+});

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

@@ -9,6 +9,7 @@ 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";
+import { CLI_TEST_SCOPE } from "./fixtures/cli-session.js";
 
 const NOW = "2026-05-23T00:00:00.000Z";
 
@@ -45,9 +46,11 @@ describe("parseSteeringProposals", () => {
 	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[] = [];
+		const originalOmoSessionId = process.env["OMO_ULW_LOOP_SESSION_ID"];
 		try {
-			await writePlan(repo, plan());
-			const before = await readFile(ulwLoopGoalsPath(repo), "utf8");
+			process.env["OMO_ULW_LOOP_SESSION_ID"] = CLI_TEST_SCOPE.sessionId;
+			await writePlan(repo, plan(), CLI_TEST_SCOPE);
+			const before = await readFile(ulwLoopGoalsPath(repo, CLI_TEST_SCOPE), "utf8");
 			vi.spyOn(process, "cwd").mockReturnValue(repo);
 			vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array): boolean => {
 				out.push(chunk.toString());
@@ -58,8 +61,10 @@ describe("parseSteeringProposals", () => {
 			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);
+			expect(await readFile(ulwLoopGoalsPath(repo, CLI_TEST_SCOPE), "utf8")).toBe(before);
 		} finally {
+			if (originalOmoSessionId === undefined) delete process.env["OMO_ULW_LOOP_SESSION_ID"];
+			else process.env["OMO_ULW_LOOP_SESSION_ID"] = originalOmoSessionId;
 			vi.restoreAllMocks();
 			await rm(repo, { recursive: true, force: true });
 		}

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

@@ -4,13 +4,17 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { ulwLoopCommand } from "../src/cli-commands.js";
+import { CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
 
 let testDir: string;
 let out: string[];
+let originalOmoSessionId: string | undefined;
 
 beforeEach(async () => {
 	testDir = await mkdtemp(join(tmpdir(), "ug-cli-validation-batch-"));
 	out = [];
+	originalOmoSessionId = process.env["OMO_ULW_LOOP_SESSION_ID"];
+	process.env["OMO_ULW_LOOP_SESSION_ID"] = CLI_TEST_SESSION_ID;
 	vi.spyOn(process, "cwd").mockReturnValue(testDir);
 	vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array): boolean => {
 		out.push(chunk.toString());
@@ -21,6 +25,8 @@ beforeEach(async () => {
 
 afterEach(async () => {
 	vi.restoreAllMocks();
+	if (originalOmoSessionId === undefined) delete process.env["OMO_ULW_LOOP_SESSION_ID"];
+	else process.env["OMO_ULW_LOOP_SESSION_ID"] = originalOmoSessionId;
 	await rm(testDir, { recursive: true, force: true });
 });
 

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

@@ -6,6 +6,7 @@ import type { UlwLoopItem, UlwLoopPlan, UlwLoopSuccessCriterion } from "../src/t
 
 const NOW = "2026-05-23T00:00:00.000Z";
 const FINAL_REVIEW_ROLES = ["lazycodex-code-reviewer", "lazycodex-qa-executor", "lazycodex-gate-reviewer"] as const;
+const SENPI_REVIEW_ROLES = ["omo-senpi-code-reviewer", "omo-senpi-qa-executor", "omo-senpi-gate-reviewer"] as const;
 const QUALITY_GATE_SECTIONS = ["codeReview", "manualQa", "gateReview", "iteration", "criteriaCoverage"] as const;
 
 function makeCriterion(overrides: Partial<UlwLoopSuccessCriterion> = {}): UlwLoopSuccessCriterion {
@@ -94,6 +95,40 @@ describe("buildCodexGoalInstruction aggregate mode", () => {
 		expect(text).toContain("checkpoint");
 	});
 
+	it("#given a final story on the omo-senpi surface #when rendering instructions #then teaches the single-gate category chain", () => {
+		const { text } = buildCodexGoalInstruction({
+			plan: makePlan({ codexGoalMode: "aggregate" }),
+			goal: makeGoal(),
+			isFinal: true,
+			surface: "omo-senpi",
+		});
+
+		expectTextToContainAll(text, [
+			"main-session",
+			'category: "deep"',
+			"unspecified-high",
+			"unspecified-low",
+			"gateReview.by",
+			"category:<name>",
+			"--print-template",
+		]);
+		for (const role of [...FINAL_REVIEW_ROLES, ...SENPI_REVIEW_ROLES]) expect(text).not.toContain(role);
+		expect(text).toMatch(/model_unavailable/);
+		expect(text).not.toContain("attempted_chain");
+	});
+
+	it("#given a final story with the explicit lazycodex surface #when rendering instructions #then keeps the lazycodex reviewers", () => {
+		const { text } = buildCodexGoalInstruction({
+			plan: makePlan({ codexGoalMode: "aggregate" }),
+			goal: makeGoal(),
+			isFinal: true,
+			surface: "lazycodex",
+		});
+
+		expectTextToContainAll(text, FINAL_REVIEW_ROLES);
+		for (const role of SENPI_REVIEW_ROLES) expect(text).not.toContain(role);
+	});
+
 	it("#given a scoped plan #when rendering final commands #then includes the session id option", () => {
 		const { text } = buildCodexGoalInstruction({
 			plan: makePlan({
@@ -113,9 +148,9 @@ describe("buildCodexGoalInstruction aggregate mode", () => {
 
 describe("buildCodexGoalInstruction per_story mode", () => {
 	it("uses the goal's own objective for create_goal", () => {
-		const goal = makeGoal({ objective: "Build the auth service" });
+		const goal = makeGoal({ objective: "per-story-objective-sentinel" });
 		const { text } = buildCodexGoalInstruction({ plan: makePlan({ codexGoalMode: "per_story" }), goal });
-		expect(text).toContain("Build the auth service");
+		expect(text).toContain("per-story-objective-sentinel");
 	});
 });
 

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

@@ -24,6 +24,24 @@ describe("parseCodexGoalSnapshot", () => {
 		expect(snapshot.status).toBe("active");
 	});
 
+	it("reads the objective from a title-bearing ulw-loop status goal", () => {
+		// given
+		const payload = {
+			id: "G002-goal-2-senpi-repo-audit-determine-wh",
+			title: "Audit the Senpi repository",
+			status: "in_progress",
+			successCriteria: [],
+		};
+
+		// when
+		const snapshot = parseCodexGoalSnapshot(payload);
+
+		// then
+		expect(snapshot.available).toBe(true);
+		expect(snapshot.objective).toBe("Audit the Senpi repository");
+		expect(snapshot.status).toBe("active");
+	});
+
 	it("ignores remaining token budget fields from goal snapshots", () => {
 		// given
 		const payload = { goal: { objective: "X", status: "active" }, remainingTokens: 123 };
@@ -85,10 +103,10 @@ describe("readCodexGoalSnapshotInput", () => {
 
 	it("reads from sample fixture path", async () => {
 		// given
-		const filePath = join(process.cwd(), "test", "fixtures", "codex-goal-snapshot.json");
+		const filePath = new URL("./fixtures/codex-goal-snapshot.json", import.meta.url);
 
 		// when
-		const snapshot = await readCodexGoalSnapshotInput(filePath);
+		const snapshot = await readCodexGoalSnapshotInput(filePath.pathname);
 
 		// then
 		expect(snapshot?.available).toBe(true);
@@ -102,6 +120,15 @@ describe("readCodexGoalSnapshotInput", () => {
 });
 
 describe("reconcileCodexGoalSnapshot", () => {
+	it("preserves objective whitespace in driver advice while normalizing comparison", () => {
+		const expectedObjective = "  exact   objective\nwith spacing  ";
+		const result = reconcileCodexGoalSnapshot(
+			parseCodexGoalSnapshot({ goal: { objective: "different", status: "active" } }),
+			{ expectedObjective },
+		);
+
+		expect(result.warnings[0]).toContain(`expected "${expectedObjective}"`);
+	});
 	it("returns ok=true when snapshot matches expected", () => {
 		// when
 		const reconciliation = reconcileCodexGoalSnapshot(
@@ -114,7 +141,7 @@ describe("reconcileCodexGoalSnapshot", () => {
 		expect(reconciliation.errors).toHaveLength(0);
 	});
 
-	it("reports error when objective mismatches", () => {
+	it("reports warning when objective mismatches", () => {
 		// when
 		const reconciliation = reconcileCodexGoalSnapshot(
 			{ available: true, objective: "X", status: "active", raw: null },
@@ -122,20 +149,34 @@ describe("reconcileCodexGoalSnapshot", () => {
 		);
 
 		// then
-		expect(reconciliation.ok).toBe(false);
-		expect(reconciliation.errors.length).toBeGreaterThan(0);
+		expect(reconciliation.ok).toBe(true);
+		expect(reconciliation.errors).toHaveLength(0);
+		expect(reconciliation.warnings.join(" ")).toContain("driver_objective_differs");
 	});
 
-	it("reports error when status mismatches", () => {
+	it("accepts a parsable snapshot without objective as advisory", () => {
 		// when
 		const reconciliation = reconcileCodexGoalSnapshot(
-			{ available: true, objective: "X", status: "active", raw: null },
-			{ expectedObjective: "X", allowedStatuses: ["complete"] },
+			{ available: true, status: "active", raw: { goal: { status: "active" } } },
+			{ expectedObjective: "X" },
 		);
 
 		// then
-		expect(reconciliation.ok).toBe(false);
-		expect(reconciliation.errors.length).toBeGreaterThan(0);
+		expect(reconciliation.ok).toBe(true);
+		expect(reconciliation.errors).toHaveLength(0);
+	});
+
+	it("accepts limited driver statuses", () => {
+		// when
+		const reconciliation = reconcileCodexGoalSnapshot(
+			{ available: true, objective: "X", status: "budget_limited", raw: null },
+			{ expectedObjective: "X" },
+		);
+
+		// then
+		expect(reconciliation.ok).toBe(true);
+		expect(reconciliation.errors).toHaveLength(0);
+		expect(reconciliation.warnings.join(" ")).toContain("/goal resume");
 	});
 });
 
@@ -144,7 +185,7 @@ describe("formatCodexGoalReconciliation", () => {
 		// given
 		const reconciliation = reconcileCodexGoalSnapshot(
 			{ available: true, objective: "X", status: "active", raw: null },
-			{ expectedObjective: "Y", allowedStatuses: ["complete"] },
+			{ expectedObjective: "Y" },
 		);
 
 		// when