lazycodex-ai 5.0.0-beta.9 → 5.0.0

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

@@ -1,13 +1,140 @@
-import { writeFile } from "node:fs/promises";
-import { describe, expect, it } from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 
 import { checkpointUlwLoop } from "../src/checkpoint.js";
-import { ulwLoopBriefPath } from "../src/paths.js";
-import { startNextUlwLoop } from "../src/plan-crud.js";
 import { criterion, expectCode, goal, passGoal, plan, repoWith, snapshot } from "./fixtures/checkpoint-builders.js";
 import { MISSING_ARTIFACT_PATH, qualityGateJson } from "./fixtures/quality-gate-builder.js";
 
+function requiredSection(gate: Record<string, Record<string, unknown>>, key: string): Record<string, unknown> {
+	const section = gate[key];
+	if (section === undefined) throw new Error(`missing gate section: ${key}`);
+	return section;
+}
+
+describe("checkpointUlwLoop final story surface resolution", () => {
+	beforeEach(() => {
+		delete process.env["OMO_AGENT_TOOLKIT_SURFACE"];
+	});
+
+	afterEach(() => {
+		delete process.env["OMO_AGENT_TOOLKIT_SURFACE"];
+	});
+
+	it("#given the omo-senpi surface #when the gate omits codeReview #then the final story completes", async () => {
+		process.env["OMO_AGENT_TOOLKIT_SURFACE"] = "omo-senpi";
+		const repo = await repoWith(
+			plan([passGoal("G001", { status: "complete" }), passGoal("G002")], { activeGoalId: "G002" }),
+		);
+		const gate = JSON.parse(await qualityGateJson(repo, undefined, "G001-finished", "omo-senpi")) as Record<
+			string,
+			Record<string, unknown>
+		>;
+		delete gate["codeReview"];
+		requiredSection(gate, "manualQa")["by"] = "main-session";
+		requiredSection(gate, "gateReview")["by"] = "category:deep";
+
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G002",
+			status: "complete",
+			evidence: "final work complete and validation passed",
+			codexGoalJson: snapshot("complete"),
+			qualityGateJson: JSON.stringify(gate),
+		});
+
+		expect(result.aggregateCompletion?.status).toBe("complete");
+		expect(result.plan.aggregateCompletion?.status).toBe("complete");
+	});
+
+	it("#given the same codeReview-free gate #when the surface is lazycodex #then the final story completes", async () => {
+		const repo = await repoWith(
+			plan([passGoal("G001", { status: "complete" }), passGoal("G002")], { activeGoalId: "G002" }),
+		);
+		const gate = JSON.parse(await qualityGateJson(repo, undefined, "G001-finished", "omo-senpi")) as Record<
+			string,
+			Record<string, unknown>
+		>;
+		delete gate["codeReview"];
+		requiredSection(gate, "manualQa")["by"] = "main-session";
+		requiredSection(gate, "gateReview")["by"] = "category:deep";
+
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G002",
+			status: "complete",
+			evidence: "final work complete and validation passed",
+			codexGoalJson: snapshot("complete"),
+			qualityGateJson: JSON.stringify(gate),
+		});
+
+		expect(result.aggregateCompletion?.status).toBe("complete");
+		expect(result.plan.aggregateCompletion?.status).toBe("complete");
+	});
+
+	it("#given the omo-senpi surface #when the gate includes codeReview #then the final story is rejected", async () => {
+		process.env["OMO_AGENT_TOOLKIT_SURFACE"] = "omo-senpi";
+		const repo = await repoWith(
+			plan([passGoal("G001", { status: "complete" }), passGoal("G002")], { activeGoalId: "G002" }),
+		);
+		const gateJson = await qualityGateJson(repo, undefined, "G001-finished", "omo-senpi");
+
+		await expectCode(
+			() =>
+				checkpointUlwLoop(repo, {
+					goalId: "G002",
+					status: "complete",
+					evidence: "final work complete and validation passed",
+					codexGoalJson: snapshot("complete"),
+					qualityGateJson: gateJson,
+				}),
+			"ULW_LOOP_QUALITY_GATE_INVALID",
+		);
+	});
+
+	it("#given the omo-senpi surface #when the gate names lazycodex reviewers #then the final story is rejected", async () => {
+		process.env["OMO_AGENT_TOOLKIT_SURFACE"] = "omo-senpi";
+		const repo = await repoWith(
+			plan([passGoal("G001", { status: "complete" }), passGoal("G002")], { activeGoalId: "G002" }),
+		);
+		const gateJson = await qualityGateJson(repo);
+
+		await expectCode(
+			() =>
+				checkpointUlwLoop(repo, {
+					goalId: "G002",
+					status: "complete",
+					evidence: "final work complete and validation passed",
+					codexGoalJson: snapshot("complete"),
+					qualityGateJson: gateJson,
+				}),
+			"ULW_LOOP_QUALITY_GATE_INVALID",
+		);
+	});
+});
+
 describe("checkpointUlwLoop final story", () => {
+	it("#given a mismatched codex objective and multiple gate defects #when completing the final checkpoint #then reports both validation domains", async () => {
+		const repo = await repoWith(
+			plan([passGoal("G001", { status: "complete" }), passGoal("G002")], { activeGoalId: "G002" }),
+		);
+		const gate = JSON.parse(await qualityGateJson(repo)) as Record<string, Record<string, unknown>>;
+		const manualQa = requiredSection(gate, "manualQa");
+		manualQa["surfaceEvidence"] = [];
+		requiredSection(gate, "gateReview")["recommendation"] = "REJECT";
+
+		try {
+			await checkpointUlwLoop(repo, {
+				goalId: "G002",
+				status: "complete",
+				evidence: "final work complete and validation passed",
+				codexGoalJson: snapshot("complete", "wrong objective"),
+				qualityGateJson: JSON.stringify(gate),
+			});
+			throw new Error("expected validation failure");
+		} catch (error) {
+			expect(error).toBeInstanceOf(Error);
+			if (!(error instanceof Error)) throw error;
+			expect(error.message).toContain("manualQa.surfaceEvidence");
+			expect(error.message).toContain("gateReview.recommendation");
+		}
+	});
 	it("requires quality-gate-json for the final goal complete", async () => {
 		const repo = await repoWith(
 			plan([passGoal("G001", { status: "complete" }), passGoal("G002")], { activeGoalId: "G002" }),
@@ -85,84 +212,6 @@ describe("checkpointUlwLoop final story", () => {
 		);
 	});
 
-	it("ACCEPTS complete when task-scoped completed Codex objective maps to the ulw-loop brief", async () => {
-		const taskObjective = "Fix ulw-loop objective mismatch and install local ulw";
-		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), `${taskObjective}\n`, "utf8");
-
-		const result = await checkpointUlwLoop(repo, {
-			goalId: "G001",
-			status: "complete",
-			evidence: "final implementation complete and quality gate passed",
-			codexGoalJson: snapshot("complete", taskObjective),
-			qualityGateJson: await qualityGateJson(repo),
-		});
-
-		expect(result.aggregateCompletion?.status).toBe("complete");
-		expect(result.ledgerEntry.kind).toBe("aggregate_completed");
-	});
-
-	it("ACCEPTS complete when active task-scoped Codex objective maps to the ulw-loop brief", async () => {
-		const taskObjective = "Create only research artifacts with source evidence";
-		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), `${taskObjective}\n`, "utf8");
-
-		const result = await checkpointUlwLoop(repo, {
-			goalId: "G001",
-			status: "complete",
-			evidence: "final implementation complete and quality gate passed",
-			codexGoalJson: snapshot("active", taskObjective),
-			qualityGateJson: await qualityGateJson(repo),
-		});
-
-		expect(result.aggregateCompletion?.status).toBe("complete");
-		expect(result.ledgerEntry.kind).toBe("aggregate_completed");
-	});
-
-	it("explains final task-scoped objective mapping when completed Codex objective is unrelated", async () => {
-		const repo = await repoWith(plan([passGoal("G001")], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), "Fix ulw-loop objective mismatch and install local ulw\n", "utf8");
-
-		await expect(
-			checkpointUlwLoop(repo, {
-				goalId: "G001",
-				status: "complete",
-				evidence: "final implementation complete and quality gate passed",
-				codexGoalJson: snapshot("complete", "unrelated completed task"),
-				qualityGateJson: await qualityGateJson(repo),
-			}),
-		).rejects.toThrow("Final task-scoped aggregate reconciliation");
-	});
-
-	it("keeps aggregate open when non-final task-scoped Codex completion maps to the brief", async () => {
-		const taskObjective = "Implement first accepted story";
-		const first = goal({
-			id: "G001",
-			status: "in_progress",
-			successCriteria: [
-				criterion("C001", "pass", { essential: true }),
-				criterion("C002", "pending", { essential: false }),
-			],
-		});
-		const second = goal({ id: "G002", status: "pending", objective: "Implement second accepted story" });
-		const repo = await repoWith(plan([first, second], { activeGoalId: "G001" }));
-		await writeFile(ulwLoopBriefPath(repo), `${taskObjective}\n`, "utf8");
-
-		const result = await checkpointUlwLoop(repo, {
-			goalId: "G001",
-			status: "complete",
-			evidence: "G001 updated .omo/ulw-loop/goals.json after implementation completed and validation passed",
-			codexGoalJson: snapshot("complete", taskObjective),
-			qualityGateJson: await qualityGateJson(repo),
-		});
-		const next = await startNextUlwLoop(repo);
-
-		expect(result.aggregateCompletion).toBeUndefined();
-		expect(result.plan.aggregateCompletion).toBeUndefined();
-		expect(result.ledgerEntry.kind).toBe("goal_completed");
-		expect(next).toMatchObject({ goal: { id: "G002", status: "in_progress" } });
-	});
-
 	it("requires all criteria for per-story completion", async () => {
 		const current = goal({
 			successCriteria: [

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

@@ -0,0 +1,147 @@
+import { existsSync, statSync } from "node:fs";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+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-"));
+	output = [];
+	vi.spyOn(process, "cwd").mockReturnValue(repo);
+	vi.spyOn(process.stdout, "write").mockImplementation((chunk: string | Uint8Array): boolean => {
+		output.push(chunk.toString());
+		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 });
+});
+
+async function run(args: string[]): Promise<Record<string, unknown>> {
+	const code = await ulwLoopCommand(["checkpoint", ...args]);
+	expect(code).toBe(0);
+	return JSON.parse(output.join(""));
+}
+
+function fillTemplate(value: unknown): unknown {
+	if (typeof value === "string") {
+		return value.replace(/<replace:[^>]+>/g, "plausible evidence");
+	}
+	if (Array.isArray(value)) return value.map(fillTemplate);
+	if (value !== null && typeof value === "object") {
+		return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, fillTemplate(item)]));
+	}
+	return value;
+}
+
+describe("checkpoint --print-template", () => {
+	it("#given a printed template #when every placeholder is filled #then the quality gate validates", async () => {
+		await writePlan(
+			repo,
+			plan([goal({ id: "G001", attempt: 2 })], {
+				evidenceLayoutVersion: 2,
+				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"]);
+		const template = fillTemplate(result["qualityGateTemplate"]) as Record<string, unknown>;
+		const paths = [
+			...((template["manualQa"] as Record<string, unknown>)["artifactRefs"] as Array<Record<string, unknown>>),
+		];
+		await Promise.all(
+			[
+				...paths.map((artifact) => String(artifact["path"])),
+				String((template["gateReview"] as Record<string, unknown>)["reportPath"]),
+			].map(async (path) => {
+				const absolute = resolve(repo, path);
+				await mkdir(resolve(absolute, ".."), { recursive: true });
+				await writeFile(absolute, "evidence");
+			}),
+		);
+		const validated = validateQualityGate(template, {
+			repoRoot: repo,
+			fs: { existsSync, statSync },
+			reviewerSurface: "omo-senpi",
+		});
+		expect(validated.gateReview.recommendation).toBe("APPROVE");
+	});
+	it("#given an active senpi v2 plan #when printed with only goal-id #then emits the senpi gate skeleton", async () => {
+		await writePlan(
+			repo,
+			plan([goal({ id: "G001", attempt: 2 })], {
+				evidenceLayoutVersion: 2,
+				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"]);
+		const gate = result["qualityGateTemplate"] as Record<string, unknown>;
+		expect(Object.keys(gate)).toEqual(["manualQa", "gateReview", "iteration", "criteriaCoverage"]);
+		expect((gate["manualQa"] as Record<string, unknown>)["by"]).toBe("main-session");
+		expect((gate["gateReview"] as Record<string, unknown>)["by"]).toBe("category:deep-high");
+		expect(result["codexGoalTemplate"]).toEqual({
+			goal: { objective: "Exact objective from goals.json", status: "complete" },
+		});
+		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 () => {
+		await writePlan(
+			repo,
+			plan([goal({ id: "G001", attempt: 1 })], {
+				evidenceLayoutVersion: 2,
+				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/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 () => {
+		await writePlan(
+			repo,
+			plan([goal({ id: "G001", attempt: 1 }), goal({ id: "G002", attempt: 3 })], {
+				evidenceLayoutVersion: 2,
+				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/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" })]), 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/checkpoint.test.ts

@@ -127,33 +127,27 @@ describe("checkpointUlwLoop reconciliation (status=complete)", () => {
 		).resolves.toMatchObject({ goal: { status: "complete" } });
 	});
 
-	it("throws on mismatched objective", async () => {
+	it("warns when objective mismatches", async () => {
 		const repo = await repoWith(plan([passGoal("G001"), goal({ id: "G002", status: "pending" })]));
 
-		await expectCode(
-			() =>
-				checkpointUlwLoop(repo, {
-					goalId: "G001",
-					status: "complete",
-					evidence: "work complete and validation passed",
-					codexGoalJson: snapshot("active", "wrong objective"),
-				}),
-			"ulw_loop_codex_snapshot_mismatch",
-		);
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G001",
+			status: "complete",
+			evidence: "work complete and validation passed",
+			codexGoalJson: snapshot("active", "wrong objective"),
+		});
+		expect(result.warnings.join(" ")).toContain("driver_objective_differs");
 	});
 
-	it("throws on mismatched status (snapshot complete when expected active)", async () => {
+	it("advises create_goal when the driver closed early", async () => {
 		const repo = await repoWith(plan([passGoal("G001"), goal({ id: "G002", status: "pending" })]));
 
-		await expectCode(
-			() =>
-				checkpointUlwLoop(repo, {
-					goalId: "G001",
-					status: "complete",
-					evidence: "work complete and validation passed",
-					codexGoalJson: snapshot("complete"),
-				}),
-			"ulw_loop_codex_snapshot_mismatch",
-		);
+		const result = await checkpointUlwLoop(repo, {
+			goalId: "G001",
+			status: "complete",
+			evidence: "work complete and validation passed",
+			codexGoalJson: snapshot("complete"),
+		});
+		expect(result.nextActions.join(" ")).toContain("create_goal");
 	});
 });

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>> {
@@ -126,6 +128,33 @@ describe("ulwLoopCommand checkpoint", () => {
 		expect(stdoutJson()).toHaveProperty("goal.status", "complete");
 	});
 
+	it("#given a complete checkpoint with an objective difference #when invoked with JSON #then exposes driver advice and warning", async () => {
+		await createPlan();
+		await passCriterion("G001-goal-a", "C001");
+		await passCriterion("G001-goal-a", "C002");
+		await passCriterion("G001-goal-a", "C003");
+
+		expect(
+			await ulwLoopCommand([
+				"checkpoint",
+				"--goal-id",
+				"G001-goal-a",
+				"--status",
+				"complete",
+				"--evidence",
+				"implementation done and validation passed",
+				"--codex-goal-json",
+				JSON.stringify({ goal: { objective: "different driver", status: "budget_limited" } }),
+				"--json",
+			]),
+		).toBe(0);
+		const result = stdoutJson();
+		expect(result).toMatchObject({ ok: true });
+		expect(result).toHaveProperty("nextActions");
+		expect(JSON.stringify(result)).toContain("driver_objective_differs");
+		expect(JSON.stringify(result)).toContain("/goal resume");
+	});
+
 	it("ACCEPTS when all criteria pass", async () => {
 		await createPlan();
 		await passCriterion("G001-goal-a", "C001");

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;
@@ -13,6 +14,7 @@ let err: string[];
 let originalCodexSessionId: string | undefined;
 let originalCodexThreadId: string | undefined;
 let originalOmoSessionId: string | undefined;
+let originalPiSessionId: string | undefined;
 
 beforeEach(async () => {
 	testDir = await mkdtemp(join(tmpdir(), "ug-cli-create-goals-"));
@@ -21,9 +23,12 @@ beforeEach(async () => {
 	originalCodexSessionId = process.env["CODEX_SESSION_ID"];
 	originalCodexThreadId = process.env["CODEX_THREAD_ID"];
 	originalOmoSessionId = process.env["OMO_ULW_LOOP_SESSION_ID"];
+	originalPiSessionId = process.env["PI_SESSION_ID"];
 	delete process.env["CODEX_SESSION_ID"];
 	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());
@@ -43,6 +48,8 @@ afterEach(async () => {
 	else process.env["CODEX_THREAD_ID"] = originalCodexThreadId;
 	if (originalOmoSessionId === undefined) delete process.env["OMO_ULW_LOOP_SESSION_ID"];
 	else process.env["OMO_ULW_LOOP_SESSION_ID"] = originalOmoSessionId;
+	if (originalPiSessionId === undefined) delete process.env["PI_SESSION_ID"];
+	else process.env["PI_SESSION_ID"] = originalPiSessionId;
 	await rm(testDir, { recursive: true, force: true });
 });
 
@@ -56,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> {
@@ -96,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 () => {
@@ -137,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 () => {
@@ -182,12 +189,32 @@ describe("ulwLoopCommand create-goals", () => {
 		expect(await readFile(join(testDir, ".omo/ulw-loop/manual-456/goals.json"), "utf8")).toContain("Manual scoped");
 	});
 
+	it("#given two Senpi sessions in one cwd #when each reads ulw-loop state #then only the owner sees its run", async () => {
+		process.env["PI_SESSION_ID"] = "session-A";
+		expect(await ulwLoopCommand(["create-goals", "--brief", "- Session A run", "--json"])).toBe(0);
+		resetOutput();
+
+		process.env["PI_SESSION_ID"] = "session-B";
+		expect(await ulwLoopCommand(["status", "--json"])).toBe(1);
+		expect(stdoutJson()).toMatchObject({ ok: false, error: { code: "ULW_LOOP_PLAN_MISSING" } });
+		resetOutput();
+
+		process.env["PI_SESSION_ID"] = "session-A";
+		expect(await ulwLoopCommand(["status", "--json"])).toBe(0);
+		expect(stdoutJson()).toMatchObject({
+			plan: {
+				goalsPath: ".omo/ulw-loop/session-A/goals.json",
+				goals: [{ title: "Session A run" }],
+			},
+		});
+	});
+
 	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();
+		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 () => {
@@ -195,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();
 	});
 });