lazycodex-ai 5.0.0-beta.46 → 5.0.0-beta.48

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

@@ -8,9 +8,11 @@ import { ulwLoopCommand } from "../src/cli-commands.js";
 import { writePlan } from "../src/plan-io.js";
 import { validateQualityGate } from "../src/quality-gate.js";
 import { goal, plan } from "./fixtures/checkpoint-builders.js";
+import { CLI_TEST_SCOPE, CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
 
 let repo: string;
 let output: string[];
+let originalOmoSessionId: string | undefined;
 
 beforeEach(async () => {
 	repo = await mkdtemp(join(tmpdir(), "ulw-template-"));
@@ -21,10 +23,14 @@ beforeEach(async () => {
 		return true;
 	});
 	delete process.env["OMO_AGENT_TOOLKIT_SURFACE"];
+	originalOmoSessionId = process.env["OMO_ULW_LOOP_SESSION_ID"];
+	process.env["OMO_ULW_LOOP_SESSION_ID"] = CLI_TEST_SESSION_ID;
 });
 
 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(repo, { recursive: true, force: true });
 });
 
@@ -54,6 +60,7 @@ describe("checkpoint --print-template", () => {
 				activeGoalId: "G001",
 				codexObjective: "Exact objective from goals.json",
 			}),
+			CLI_TEST_SCOPE,
 		);
 		process.env["OMO_AGENT_TOOLKIT_SURFACE"] = "omo-senpi";
 		const result = await run(["--print-template", "--goal-id", "G001", "--json"]);
@@ -86,6 +93,7 @@ describe("checkpoint --print-template", () => {
 				activeGoalId: "G001",
 				codexObjective: "Exact objective from goals.json",
 			}),
+			CLI_TEST_SCOPE,
 		);
 		process.env["OMO_AGENT_TOOLKIT_SURFACE"] = "omo-senpi";
 		const result = await run(["--print-template", "--goal-id", "G001", "--json"]);
@@ -96,7 +104,7 @@ describe("checkpoint --print-template", () => {
 		expect(result["codexGoalTemplate"]).toEqual({
 			goal: { objective: "Exact objective from goals.json", status: "complete" },
 		});
-		expect(result["attemptDir"]).toBe(".omo/evidence/ulw/session/G001/a2");
+		expect(result["attemptDir"]).toBe(".omo/evidence/ulw/cli-test/G001/a2");
 	});
 
 	it("#given an active v2 plan #when printed without any goal id #then targets the active goal", async () => {
@@ -107,12 +115,13 @@ describe("checkpoint --print-template", () => {
 				activeGoalId: "G001",
 				codexObjective: "Exact objective from goals.json",
 			}),
+			CLI_TEST_SCOPE,
 		);
 		process.env["OMO_AGENT_TOOLKIT_SURFACE"] = "omo-senpi";
 		const result = await run(["--print-template", "--json"]);
 		const gate = result["qualityGateTemplate"] as Record<string, unknown>;
 		expect(Object.keys(gate)).toEqual(["manualQa", "gateReview", "iteration", "criteriaCoverage"]);
-		expect(result["attemptDir"]).toBe(".omo/evidence/ulw/session/G001/a1");
+		expect(result["attemptDir"]).toBe(".omo/evidence/ulw/cli-test/G001/a1");
 	});
 
 	it("#given two goals #when printed with an explicit non-active goal id #then targets that goal's attempt dir", async () => {
@@ -123,13 +132,14 @@ describe("checkpoint --print-template", () => {
 				activeGoalId: "G001",
 				codexObjective: "Exact objective from goals.json",
 			}),
+			CLI_TEST_SCOPE,
 		);
 		const result = await run(["--print-template", "--goal-id", "G002", "--json"]);
-		expect(result["attemptDir"]).toBe(".omo/evidence/ulw/session/G002/a3");
+		expect(result["attemptDir"]).toBe(".omo/evidence/ulw/cli-test/G002/a3");
 	});
 
 	it("#given a v1 plan #when printed without status #then exits successfully and gives v1 guidance", async () => {
-		await writePlan(repo, plan([goal({ id: "G001" })]));
+		await writePlan(repo, plan([goal({ id: "G001" })]), CLI_TEST_SCOPE);
 		const result = await run(["--print-template", "--goal-id", "G001", "--json"]);
 		expect(result["guidance"]).toContain("evidence-layout v1");
 		expect(result).not.toHaveProperty("attemptDir");

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

@@ -4,7 +4,8 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { ulwLoopCommand } from "../src/cli-commands.js";
-import { ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE } from "../src/goal-status.js";
+import { aggregateCodexObjectiveForScope } from "../src/goal-status.js";
+import { CLI_TEST_SCOPE, CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
 
 let testDir: string;
 let out: string[];
@@ -15,6 +16,7 @@ beforeEach(async () => {
 	out = [];
 	originalOmoSessionId = process.env["OMO_ULW_LOOP_SESSION_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());
@@ -39,7 +41,7 @@ function stdoutJson(): Record<string, unknown> {
 }
 
 function codexSnapshot(): string {
-	return JSON.stringify({ goal: { objective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE, status: "active" } });
+	return JSON.stringify({ goal: { objective: aggregateCodexObjectiveForScope(CLI_TEST_SCOPE), status: "active" } });
 }
 
 async function passCriterion(criterionId: string): Promise<void> {

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

@@ -4,7 +4,8 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { ulwLoopCommand } from "../src/cli-commands.ts";
-import { ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE } from "../src/goal-status.js";
+import { aggregateCodexObjectiveForScope } from "../src/goal-status.js";
+import { CLI_TEST_SCOPE, CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
 import { QA_DIR, qualityGateJson } from "./fixtures/quality-gate-builder.js";
 
 let testDir: string;
@@ -24,6 +25,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());
@@ -56,7 +58,7 @@ function stdoutJson(): Record<string, unknown> {
 }
 
 function codexSnapshot(status: "active" | "complete" = "active"): string {
-	return JSON.stringify({ goal: { objective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE, status } });
+	return JSON.stringify({ goal: { objective: aggregateCodexObjectiveForScope(CLI_TEST_SCOPE), status } });
 }
 
 async function createPlan(brief = "- Goal A\n- Goal B"): Promise<Record<string, unknown>> {

package/packages/omo-codex/plugin/components/ulw-loop/test/cli-commands.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());

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

@@ -5,6 +5,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { ulwLoopCommand } from "../src/cli-commands.ts";
 import { ulwLoopLedgerPath } from "../src/paths.ts";
+import { CLI_TEST_SCOPE, CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
 
 let testDir: string;
 let out: string[];
@@ -21,6 +22,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());
@@ -48,7 +50,7 @@ function stdoutJson(): Record<string, unknown> {
 }
 
 async function ledgerKinds(): Promise<string[]> {
-	const raw = await readFile(ulwLoopLedgerPath(testDir), "utf8");
+	const raw = await readFile(ulwLoopLedgerPath(testDir, CLI_TEST_SCOPE), "utf8");
 	return raw
 		.split(/\r?\n/)
 		.filter(Boolean)

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

@@ -4,7 +4,8 @@ import { join } from "node:path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
 import { ulwLoopCommand } from "../src/cli-commands.ts";
-import { ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE } from "../src/goal-status.js";
+import { aggregateCodexObjectiveForScope } from "../src/goal-status.js";
+import { CLI_TEST_SCOPE, CLI_TEST_SESSION_ID } from "./fixtures/cli-session.js";
 import { qualityGateJson } from "./fixtures/quality-gate-builder.js";
 
 let testDir: string;
@@ -27,6 +28,7 @@ beforeEach(async () => {
 	delete process.env["CODEX_THREAD_ID"];
 	delete process.env["OMO_ULW_LOOP_SESSION_ID"];
 	delete process.env["PI_SESSION_ID"];
+	process.env["PI_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());
@@ -61,7 +63,7 @@ function stdoutJson(): Record<string, unknown> {
 }
 
 function codexSnapshot(status: "active" | "complete" = "active"): string {
-	return JSON.stringify({ goal: { objective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE, status } });
+	return JSON.stringify({ goal: { objective: aggregateCodexObjectiveForScope(CLI_TEST_SCOPE), status } });
 }
 
 async function qualityGate(): Promise<string> {
@@ -101,9 +103,9 @@ describe("ulwLoopCommand create-goals", () => {
 		const parsed = stdoutJson();
 		expect(parsed).toMatchObject({ ok: true });
 		expect(parsed).toHaveProperty("plan.goals.0.successCriteria.0.id", "C001");
-		expect(await readFile(join(testDir, ".omo/ulw-loop/brief.md"), "utf8")).toContain("Goal A");
-		expect(await readFile(join(testDir, ".omo/ulw-loop/goals.json"), "utf8")).toContain("successCriteria");
-		expect(await readFile(join(testDir, ".omo/ulw-loop/ledger.jsonl"), "utf8")).toContain("plan_created");
+		expect(await readFile(join(testDir, ".omo/ulw-loop/cli-test/brief.md"), "utf8")).toContain("Goal A");
+		expect(await readFile(join(testDir, ".omo/ulw-loop/cli-test/goals.json"), "utf8")).toContain("successCriteria");
+		expect(await readFile(join(testDir, ".omo/ulw-loop/cli-test/ledger.jsonl"), "utf8")).toContain("plan_created");
 	});
 
 	it("#given completed default aggregate #when creating another default plan #then guides to a fresh session", async () => {
@@ -142,7 +144,7 @@ describe("ulwLoopCommand create-goals", () => {
 
 		expect(await ulwLoopCommand(["status", "--json"])).toBe(0);
 
-		expect(stdoutJson()).toMatchObject({ currentAttemptDir: ".omo/evidence/ulw/session/G001-goal-a/a1" });
+		expect(stdoutJson()).toMatchObject({ currentAttemptDir: ".omo/evidence/ulw/cli-test/G001-goal-a/a1" });
 	});
 
 	it("#given two session ids #when creating goals #then writes isolated session-scoped plans", async () => {
@@ -212,7 +214,7 @@ describe("ulwLoopCommand create-goals", () => {
 
 		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();
+		await expect(readFile(join(testDir, ".omo/ulw-loop/cli-test/goals.json"), "utf8")).rejects.toThrow();
 	});
 
 	it("#given an empty --session-id= #when creating goals #then it fails and writes no plan", async () => {
@@ -220,6 +222,6 @@ describe("ulwLoopCommand create-goals", () => {
 
 		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();
+		await expect(readFile(join(testDir, ".omo/ulw-loop/cli-test/goals.json"), "utf8")).rejects.toThrow();
 	});
 });

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,6 +91,16 @@ describe("dist/cli.js entrypoint dispatch", () => {
 		expect(result.code).toBe(1);
 	});
 
+	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"]);
 

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());

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

@@ -7,6 +7,7 @@ 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;
@@ -25,6 +26,7 @@ beforeEach(async () => {
 		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());
@@ -87,9 +89,9 @@ function plan(goals: UlwLoopItem[], overrides: Partial<UlwLoopPlan> = {}): UlwLo
 		evidenceLayoutVersion: 2,
 		createdAt: NOW,
 		updatedAt: NOW,
-		briefPath: ".omo/ulw-loop/brief.md",
-		goalsPath: ".omo/ulw-loop/goals.json",
-		ledgerPath: ".omo/ulw-loop/ledger.jsonl",
+		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);
@@ -103,8 +105,8 @@ function legacyLayoutPlan(goals: UlwLoopItem[], overrides: Partial<UlwLoopPlan>
 }
 
 async function seed(seedPlan: UlwLoopPlan): Promise<void> {
-	await mkdir(ulwLoopDir(testDir), { recursive: true });
-	await writePlan(testDir, seedPlan);
+	await mkdir(ulwLoopDir(testDir, CLI_TEST_SCOPE), { recursive: true });
+	await writePlan(testDir, seedPlan, CLI_TEST_SCOPE);
 }
 
 describe("#given a plan with no goals", () => {

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/fixtures/cli-session.ts

@@ -0,0 +1,4 @@
+// Every CLI-level test runs inside one explicit session scope: the CLI refuses to
+// touch the unscoped .omo/ulw-loop root, so state and evidence live under this id.
+export const CLI_TEST_SESSION_ID = "cli-test";
+export const CLI_TEST_SCOPE = { sessionId: CLI_TEST_SESSION_ID } as const;

package/packages/omo-codex/plugin/components/ulw-loop/test/fixtures/quality-gate-builder.ts

@@ -2,9 +2,10 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
 import { reviewerRolesFor, type UlwLoopToolkitSurface } from "../../src/surface.js";
+import { CLI_TEST_SESSION_ID } from "./cli-session.js";
 
 // v2 evidence layout: artifacts must live inside the goal's current attempt dir
-export function qaDirFor(goalId: string, attempt = 1, sessionId = "session"): string {
+export function qaDirFor(goalId: string, attempt = 1, sessionId = CLI_TEST_SESSION_ID): string {
 	return `.omo/evidence/ulw/${sessionId}/${goalId}/a${attempt}`;
 }