oh-my-opencode 5.0.0-beta.31 → 5.0.0-beta.32

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

@@ -0,0 +1,183 @@
+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";
+
+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];
+	}
+	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/brief.md",
+		goalsPath: ".omo/ulw-loop/goals.json",
+		ledgerPath: ".omo/ulw-loop/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), { recursive: true });
+	await writePlan(testDir, seedPlan);
+}
+
+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/codex-goal-instruction.test.ts

@@ -95,7 +95,7 @@ describe("buildCodexGoalInstruction aggregate mode", () => {
 		expect(text).toContain("checkpoint");
 	});
 
-	it("#given a final story on the omo-senpi surface #when rendering instructions #then names the omo-senpi reviewers only", () => {
+	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(),
@@ -103,8 +103,18 @@ describe("buildCodexGoalInstruction aggregate mode", () => {
 			surface: "omo-senpi",
 		});
 
-		expectTextToContainAll(text, SENPI_REVIEW_ROLES);
-		for (const role of FINAL_REVIEW_ROLES) expect(text).not.toContain(role);
+		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", () => {

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

@@ -0,0 +1,105 @@
+import { mkdir, mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { checkpointUlwLoop } from "../src/checkpoint.js";
+import { ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE } from "../src/goal-status.js";
+import { ulwLoopDir } from "../src/paths.js";
+import { readUlwLoopPlan } from "../src/plan-io.js";
+import { recordFinalReviewBlockers } from "../src/review-blockers.js";
+import { UlwLoopError } from "../src/types.js";
+import { goal, passGoal, plan, repoWith, snapshot } from "./fixtures/checkpoint-builders.js";
+
+async function captureError(action: () => Promise<unknown>): Promise<UlwLoopError> {
+	try {
+		await action();
+	} catch (error) {
+		expect(error).toBeInstanceOf(UlwLoopError);
+		if (error instanceof UlwLoopError) return error;
+		throw error;
+	}
+	throw new Error("Expected UlwLoopError");
+}
+
+describe("#given a codex goal snapshot whose objective differs from the plan", () => {
+	it("#when checkpoint reconciles it #then the mismatch carries the verbatim expected and received objectives", async () => {
+		const repo = await repoWith(plan([passGoal("G001"), goal({ id: "G002", status: "pending" })]));
+
+		const error = await captureError(() =>
+			checkpointUlwLoop(repo, {
+				goalId: "G001",
+				status: "complete",
+				evidence: "work complete and validation passed",
+				codexGoalJson: snapshot("active", "wrong objective"),
+			}),
+		);
+
+		expect(error.code).toBe("ulw_loop_codex_snapshot_mismatch");
+		expect(error.details).toMatchObject({
+			expectedObjective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE,
+			receivedObjective: "wrong objective",
+		});
+		expect(error.message).toContain(
+			"objective must equal the plan's codexObjective exactly — copy the expected value below",
+		);
+		expect(error.message).toContain(ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE);
+	});
+
+	it("#when record-review-blockers reconciles it #then the same guided payload is emitted", async () => {
+		const repo = await repoWith(
+			plan([passGoal("G001", { status: "complete" }), goal({ id: "G002", status: "in_progress" })]),
+		);
+
+		const error = await captureError(() =>
+			recordFinalReviewBlockers(repo, {
+				goalId: "G002",
+				title: "Resolve final review blockers",
+				objective: "Address the BLOCK findings",
+				evidence: "review verdict: REQUEST_CHANGES",
+				codexGoalJson: JSON.stringify({ goal: { objective: "stale objective", status: "active" } }),
+			}),
+		);
+
+		expect(error.code).toBe("ulw_loop_codex_snapshot_mismatch");
+		expect(error.details).toMatchObject({
+			expectedObjective: ULW_LOOP_AGGREGATE_CODEX_OBJECTIVE,
+			receivedObjective: "stale objective",
+		});
+		expect(error.message).toContain(
+			"objective must equal the plan's codexObjective exactly — copy the expected value below",
+		);
+	});
+});
+
+describe("#given no ulw-loop plan on disk", () => {
+	it("#when the plan is read #then the error names the exact create-goals bootstrap command", async () => {
+		const repo = await mkdtemp(join(tmpdir(), "ug-guided-plan-"));
+
+		const error = await captureError(() => readUlwLoopPlan(repo));
+
+		expect(error.code).toBe("ULW_LOOP_PLAN_MISSING");
+		expect(error.message).toContain('omo-agent-toolkit ulw-loop create-goals --brief "<brief>" --json');
+	});
+
+	it("#when sibling session dirs exist #then the error lists the existing session ids", async () => {
+		const repo = await mkdtemp(join(tmpdir(), "ug-guided-plan-"));
+		await mkdir(join(ulwLoopDir(repo), "session-alpha"), { recursive: true });
+		await mkdir(join(ulwLoopDir(repo), "session-beta"), { recursive: true });
+
+		const error = await captureError(() => readUlwLoopPlan(repo, { sessionId: "session-gamma" }));
+
+		expect(error.code).toBe("ULW_LOOP_PLAN_MISSING");
+		expect(error.message).toContain("session-alpha");
+		expect(error.message).toContain("session-beta");
+		expect(error.details).toMatchObject({ existingSessionIds: ["session-alpha", "session-beta"] });
+	});
+
+	it("#when no session dirs exist #then the error lists no session ids", async () => {
+		const repo = await mkdtemp(join(tmpdir(), "ug-guided-plan-"));
+
+		const error = await captureError(() => readUlwLoopPlan(repo, { sessionId: "session-gamma" }));
+
+		expect(error.details?.["existingSessionIds"]).toBeUndefined();
+	});
+});

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

@@ -0,0 +1,101 @@
+import { existsSync, statSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { validateQualityGate } from "../src/quality-gate.js";
+import { UlwLoopError } from "../src/types.js";
+
+const opts = { repoRoot: process.cwd(), fs: { existsSync, statSync }, reviewerSurface: "omo-senpi" as const };
+
+describe("aggregated quality gate validation", () => {
+	it("#given four independent defects #when validating #then reports all defects in one error", () => {
+		const gate = {
+			manualQa: {
+				by: "main-session",
+				status: "passed",
+				evidence: "placeholder",
+				surfaceEvidence: [],
+				adversarialCases: [],
+				artifactRefs: [
+					{ id: "missing", kind: "cli-transcript", description: "artifact", path: "does-not-exist.txt" },
+				],
+			},
+			gateReview: {
+				by: "category:deep",
+				recommendation: "REJECT",
+				reportPath: "test/fixtures/artifacts/gate-review.md",
+				blockers: [],
+			},
+			iteration: { fullRerun: true, status: "passed", rerunCommands: ["test"], evidence: "rerun" },
+			criteriaCoverage: {
+				totalCriteria: 1,
+				passCount: 1,
+				originalIntent: "intent",
+				desiredOutcome: "outcome",
+				userOutcomeReview: "review",
+				adversarialClassesCovered: ["none"],
+			},
+		};
+		try {
+			validateQualityGate(gate, opts);
+			throw new Error("expected validation failure");
+		} catch (error) {
+			expect(error).toBeInstanceOf(UlwLoopError);
+			if (!(error instanceof UlwLoopError)) throw error;
+			expect(error.code).toBe("ULW_LOOP_QUALITY_GATE_INVALID");
+			expect(error.details?.["field"]).toBe("manualQa.evidence");
+			expect(error.details?.["fields"]).toEqual(
+				expect.arrayContaining([
+					{ field: "manualQa.evidence", message: expect.stringContaining("placeholder") },
+					{ field: "gateReview.evidence", message: expect.stringContaining("non-empty") },
+					{ field: "gateReview.recommendation", message: expect.stringContaining("APPROVE") },
+					{ field: "manualQa.artifactRefs[0].path", message: expect.stringContaining("existing") },
+				]),
+			);
+		}
+	});
+
+	it("#given more than twenty-five defects #when validating #then caps the list and flags truncation", () => {
+		const refs = Array.from({ length: 30 }, (_, index) => ({
+			id: `ref-${index}`,
+			kind: "cli-transcript",
+			description: "artifact",
+			path: `does-not-exist-${index}.txt`,
+		}));
+		const gate = {
+			manualQa: {
+				by: "main-session",
+				status: "passed",
+				evidence: "real evidence",
+				surfaceEvidence: [],
+				adversarialCases: [],
+				artifactRefs: refs,
+			},
+			gateReview: {
+				by: "category:deep",
+				recommendation: "APPROVE",
+				reportPath: "test/fixtures/artifacts/gate-review.md",
+				evidence: "gate evidence",
+				blockers: [],
+			},
+			iteration: { fullRerun: true, status: "passed", rerunCommands: ["test"], evidence: "rerun" },
+			criteriaCoverage: {
+				totalCriteria: 1,
+				passCount: 1,
+				originalIntent: "intent",
+				desiredOutcome: "outcome",
+				userOutcomeReview: "review",
+				adversarialClassesCovered: ["none"],
+			},
+		};
+		try {
+			validateQualityGate(gate, opts);
+			throw new Error("expected validation failure");
+		} catch (error) {
+			expect(error).toBeInstanceOf(UlwLoopError);
+			if (!(error instanceof UlwLoopError)) throw error;
+			const fields = error.details?.["fields"];
+			expect(Array.isArray(fields) && fields.length).toBe(25);
+			expect(error.details?.["truncated"]).toBe(true);
+			expect(error.message).toContain("25+");
+		}
+	});
+});

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

@@ -85,18 +85,20 @@ function qualityGateError(input: unknown, surface?: "lazycodex" | "omo-senpi"):
 	throw new Error("Expected UlwLoopError");
 }
 
-function senpiGate(): Record<string, unknown> {
-	return gateWith({
-		codeReview: { ...BASE_GATE.codeReview, by: "omo-senpi-code-reviewer" },
-		manualQa: { ...BASE_GATE.manualQa, by: "omo-senpi-qa-executor" },
-		gateReview: { ...BASE_GATE.gateReview, by: "omo-senpi-gate-reviewer" },
+function senpiGate(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+	const { codeReview: _codeReview, ...withoutCodeReview } = BASE_GATE;
+	return {
+		...withoutCodeReview,
+		manualQa: { ...BASE_GATE.manualQa, by: "main-session" },
+		gateReview: { ...BASE_GATE.gateReview, by: "category:deep" },
 		criteriaCoverage: {
 			...BASE_GATE.criteriaCoverage,
 			originalIntent: "User wanted the senpi surface to accept honest reviewer attribution.",
 			desiredOutcome: "A gate naming the omo-senpi reviewers validates on the omo-senpi surface.",
 			userOutcomeReview: "The senpi-surface gate passed with truthful reviewer identities.",
 		},
-	});
+		...overrides,
+	};
 }
 
 describe("validateQualityGate reviewer roles", () => {
@@ -124,29 +126,28 @@ describe("validateQualityGate reviewer roles", () => {
 		expect(() => validateQualityGate(senpiGate(), { reviewerSurface: "omo-senpi" })).not.toThrow();
 	});
 
-	it("#given lazycodex identities #when validated on the omo-senpi surface #then each role names the omo-senpi identity", () => {
+	it("#given a codeReview lane #when validated on the omo-senpi surface #then it is rejected", () => {
 		const error = qualityGateError(gateWith({}), "omo-senpi");
 		expect(error.code).toBe("ULW_LOOP_QUALITY_GATE_INVALID");
-		expect(error.message).toContain("omo-senpi-code-reviewer");
+		expect(error.message).toContain("no codeReview lane");
 	});
 
-	it("#given omo-senpi identities #when validated on the default lazycodex surface #then the gate is rejected", () => {
+	it("#given a four-section senpi gate #when validated on the default lazycodex surface #then codeReview is required", () => {
 		const error = qualityGateError(senpiGate());
 		expect(error.code).toBe("ULW_LOOP_QUALITY_GATE_INVALID");
-		expect(error.message).toContain("lazycodex-code-reviewer");
+		expect(error.message).toContain("codeReview");
 	});
 
 	it("#given swapped omo-senpi reviewer roles #when validated on the omo-senpi surface #then section-specific roles are enforced", () => {
-		const swapped = gateWith({
-			codeReview: { ...BASE_GATE.codeReview, by: "omo-senpi-qa-executor" },
-			manualQa: { ...BASE_GATE.manualQa, by: "omo-senpi-qa-executor" },
-			gateReview: { ...BASE_GATE.gateReview, by: "omo-senpi-gate-reviewer" },
+		const swapped = senpiGate({
+			manualQa: { ...BASE_GATE.manualQa, by: "category:deep" },
+			gateReview: { ...BASE_GATE.gateReview, by: "main-session" },
 		});
 
 		const error = qualityGateError(swapped, "omo-senpi");
 
 		expect(error.code).toBe("ULW_LOOP_QUALITY_GATE_INVALID");
-		expect(error.message).toContain("codeReview.by");
+		expect(error.message).toContain("manualQa.by");
 	});
 
 	it("#given swapped LazyCodex reviewer roles #when validated #then section-specific roles are enforced", () => {

package/packages/omo-codex/plugin/components/ulw-loop/test/quality-gate-senpi-surface.test.ts

@@ -0,0 +1,131 @@
+import { readFile } from "node:fs/promises";
+
+import { describe, expect, it } from "vitest";
+
+import { validateQualityGate } from "../src/quality-gate.js";
+import { UlwLoopError } from "../src/types.js";
+
+const COMMON = {
+	manualQa: {
+		status: "passed",
+		evidence: "Ran senpi manual QA with artifact-backed evidence.",
+		surfaceEvidence: [
+			{
+				id: "surface-cli-pass",
+				criterionRef: "C1",
+				surface: "cli",
+				invocation: "omo-agent-toolkit ulw-loop checkpoint --status complete",
+				verdict: "passed",
+				artifactRefs: ["artifact-cli-pass"],
+			},
+		],
+		adversarialCases: [
+			{
+				id: "adv-role",
+				criterionRef: "C2",
+				scenario: "a reviewer role is invalid",
+				expectedBehavior: "the gate rejects the invalid role",
+				verdict: "passed",
+				artifactRefs: ["artifact-cli-pass"],
+			},
+		],
+		artifactRefs: [
+			{
+				id: "artifact-cli-pass",
+				kind: "cli-transcript",
+				description: "CLI transcript for valid checkpoint.",
+				path: "cli-pass.txt",
+			},
+		],
+	},
+	iteration: {
+		fullRerun: true,
+		status: "passed",
+		rerunCommands: ["bunx vitest run"],
+		evidence: "Focused tests passed.",
+	},
+	criteriaCoverage: {
+		totalCriteria: 2,
+		passCount: 2,
+		originalIntent: "User wanted a valid senpi quality gate.",
+		desiredOutcome: "The senpi gate accepts its four required lanes.",
+		userOutcomeReview: "The requested senpi outcome is covered.",
+		adversarialClassesCovered: ["role_mismatch"],
+	},
+} as const;
+
+function senpiGate(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+	return {
+		...COMMON,
+		manualQa: { ...COMMON.manualQa, by: "main-session" },
+		gateReview: {
+			by: "category:deep",
+			recommendation: "APPROVE",
+			reportPath: "gate-review.md",
+			evidence: "Verified the senpi gate.",
+			blockers: [],
+		},
+		...overrides,
+	};
+}
+
+function section(input: Record<string, unknown>, key: string): Record<string, unknown> {
+	const value = input[key];
+	if (typeof value !== "object" || value === null || Array.isArray(value))
+		throw new Error(`missing object section: ${key}`);
+	return value as Record<string, unknown>;
+}
+
+function errorFor(input: unknown): UlwLoopError {
+	try {
+		validateQualityGate(input, { reviewerSurface: "omo-senpi" });
+	} catch (error) {
+		if (error instanceof UlwLoopError) return error;
+		throw error;
+	}
+	throw new Error("Expected quality gate validation to fail");
+}
+
+describe("validateQualityGate omo-senpi surface", () => {
+	it("#given a four-section senpi gate #when validated #then it accepts main-session manual QA and category:deep review", () => {
+		expect(() => validateQualityGate(senpiGate(), { reviewerSurface: "omo-senpi" })).not.toThrow();
+	});
+
+	it("#given a senpi gate with codeReview #when validated #then it rejects the forbidden codeReview lane", () => {
+		const error = errorFor(senpiGate({ codeReview: { by: "anything" } }));
+		expect(error.details?.["field"]).toContain("codeReview");
+		expect(error.message).toContain("omo-senpi gate has no codeReview lane");
+	});
+
+	it.each(["category:deep", "category:unspecified-high", "category:unspecified-low"])(
+		"#given gateReview.by %s #when validated on senpi #then it accepts the category role",
+		(by) => {
+			expect(() =>
+				validateQualityGate(senpiGate({ gateReview: { ...section(senpiGate(), "gateReview"), by } }), {
+					reviewerSurface: "omo-senpi",
+				}),
+			).not.toThrow();
+		},
+	);
+
+	it.each(["omo-senpi-gate-reviewer", "lazycodex-gate-reviewer", "arbitrary"])(
+		"#given gateReview.by %s #when validated on senpi #then it rejects the non-category role",
+		(by) => {
+			const error = errorFor(senpiGate({ gateReview: { ...section(senpiGate(), "gateReview"), by } }));
+			expect(error.message).toContain("gateReview.by");
+		},
+	);
+
+	it.each(["omo-senpi-qa-executor", "lazycodex-qa-executor", "arbitrary"])(
+		"#given manualQa.by %s #when validated on senpi #then it rejects the non-main-session role",
+		(by) => {
+			const error = errorFor(senpiGate({ manualQa: { ...COMMON.manualQa, by } }));
+			expect(error.message).toContain("manualQa.by");
+		},
+	);
+
+	it("#given the existing lazycodex fixture #when validated on the default surface #then it remains valid", async () => {
+		const raw = await readFile(new URL("./fixtures/sample-quality-gate.json", import.meta.url), "utf8");
+		expect(() => validateQualityGate(JSON.parse(raw))).not.toThrow();
+	});
+});

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

@@ -111,7 +111,10 @@ describe("validateQualityGate", () => {
 			"gateReview",
 			"iteration",
 			"manualQa",
+			"surface",
 		]);
+		expect("codeReview" in gate).toBe(true);
+		if (!("codeReview" in gate)) throw new Error("expected lazycodex codeReview section");
 		expect(gate.codeReview.codeQualityStatus).toBe("CLEAR");
 		expect(gate).toMatchObject({
 			criteriaCoverage: { totalCriteria: 9, passCount: 9, userOutcomeReview: expect.stringContaining("user") },
@@ -127,6 +130,8 @@ describe("validateQualityGate", () => {
 		const gate = validateQualityGate(parsed, FS_OPTS);
 
 		// then
+		expect("codeReview" in gate).toBe(true);
+		if (!("codeReview" in gate)) throw new Error("expected lazycodex codeReview section");
 		expect(gate.codeReview.recommendation).toBe("APPROVE");
 		expect(gate.manualQa.artifactRefs).toHaveLength(5);
 	});