lazycodex-ai 5.0.0-beta.4 → 5.0.0-beta.40

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

@@ -24,9 +24,7 @@ type ShellResult = {
 };
 
 function bootstrapScriptFrom(text: string): string {
-	const heading = text.indexOf("### 1. Create goals from the brief");
-	expect(heading).toBeGreaterThanOrEqual(0);
-	const blockStart = text.indexOf("```sh\n", heading);
+	const blockStart = text.indexOf("```sh\n");
 	expect(blockStart).toBeGreaterThanOrEqual(0);
 	const codeStart = blockStart + "```sh\n".length;
 	const blockEnd = text.indexOf("\n```", codeStart);
@@ -90,7 +88,8 @@ describe("hooks/hooks.json", () => {
 		const hooks = await readJson("hooks/hooks.json") as Record<string, unknown>;
 		const events = (hooks["hooks"] as Record<string, unknown>)["UserPromptSubmit"] as readonly Record<string, unknown>[];
 		expect(events.length).toBeGreaterThan(0);
-		const command = ((events[0]?.["hooks"] as readonly Record<string, unknown>[])[0]?.["command"]) as string;
+		const command = (events[0]?.["hooks"] as readonly Record<string, unknown>[] | undefined)?.[0]?.["command"];
+		expect(command).toEqual(expect.any(String));
 		expect(command).toContain(`$${"{PLUGIN_ROOT}"}`);
 		expect(command).toContain("dist/cli.js");
 		expect(command).toContain("hook user-prompt-submit");
@@ -129,9 +128,7 @@ describe("skills/ulw-loop/SKILL.md", () => {
 		const text = await readText("skills/ulw-loop/agents/openai.yaml");
 
 		expect(text).toContain('display_name: "(OmO) ulw-loop"');
-		expect(text).not.toContain("ulw-loop / ulw-loop");
 		expect(text).toContain('short_description: "Goal-like ultrawork loop for systematic decomposition"');
-		expect(text).toContain("Use $ulw-loop");
 	});
 
 	it("#given Codex dollar hinting #when querying ulw-loop #then ulw-loop remains discoverable as an alias", async () => {
@@ -172,7 +169,7 @@ describe("skills/ulw-loop/SKILL.md", () => {
 				].join("\n"),
 			);
 
-			const result = await runShell(`${bootstrap}\n\"$ULW_LOOP_NODE\" \"$ULW_LOOP_CLI\" ulw-loop status --json`, {
+			const result = await runShell(`${bootstrap}\n"$ULW_LOOP_NODE" "$ULW_LOOP_CLI" ulw-loop status --json`, {
 				...process.env,
 				CODEX_HOME: codexHome,
 				HOME: home,
@@ -181,7 +178,6 @@ describe("skills/ulw-loop/SKILL.md", () => {
 
 			expect(result.code).toBe(0);
 			expect(result.stdout).toContain('"source":"cached-ulw-loop"');
-			expect(result.stderr).not.toContain("unknown command");
 		} finally {
 			await rm(root, { recursive: true, force: true });
 		}
@@ -189,27 +185,7 @@ describe("skills/ulw-loop/SKILL.md", () => {
 
 });
 
-describe("source LOC budget", () => {
-	it("every source file stays at or under 250 pure LOC", async () => {
-		const files = [
-			"src/types.ts", "src/paths.ts", "src/plan-io.ts", "src/plan-crud.ts", "src/goal-status.ts",
-			"src/evidence.ts", "src/quality-gate.ts", "src/quality-gate-verdicts.ts", "src/checkpoint.ts", "src/review-blockers.ts",
-			"src/stop-resume-hook.ts", "src/spawn-guard.ts",
-			"src/steering.ts", "src/codex-goal-instruction.ts", "src/codex-goal-snapshot.ts", "src/codex-hook.ts",
-			"src/cli.ts", "src/cli-arg-parser.ts", "src/cli-output.ts", "src/cli-steering.ts", "src/cli-commands.ts",
-		];
-		for (const file of files) {
-			const text = await readText(file);
-			const pure = text.split("\n").filter((line) => {
-				const trimmed = line.trim();
-				return trimmed.length > 0 && !trimmed.startsWith("//");
-			}).length;
-			expect(pure, `${file} pure LOC`).toBeLessThanOrEqual(250);
-		}
-	});
-});
-
-describe("README implementation contract", () => {
+	describe("README implementation contract", () => {
 	it("#given the README #when subcommands are inspected #then every implemented CLI subcommand is documented", async () => {
 		const readme = await readText("README.md");
 
@@ -218,14 +194,6 @@ describe("README implementation contract", () => {
 		}
 	});
 
-	it("#given the README #when stale scaffold language is checked #then it is absent", async () => {
-		const readme = await readText("README.md");
-
-		expect(readme).not.toMatch(/scaffold only/i);
-		expect(readme).not.toMatch(/Wave 1/i);
-		expect(readme).not.toMatch(/lands in later waves/i);
-	});
-
 	it("#given the README #when hooks are described #then both hook channels are documented", async () => {
 		const readme = await readText("README.md");
 

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

@@ -7,6 +7,7 @@ import {
 	isWithinAttemptDir,
 	normalizeUlwLoopSessionId,
 	repoRelative,
+	resolveUlwLoopSessionIdFromEnv,
 	ulwLoopBriefPath,
 	ulwLoopDir,
 	ulwLoopGoalsPath,
@@ -25,6 +26,14 @@ describe("ulwLoopDir(repo)", () => {
 	});
 });
 
+describe("resolveUlwLoopSessionIdFromEnv", () => {
+	it("#given a Senpi session env #when resolving scope #then uses the current Pi session id", () => {
+		expect(resolveUlwLoopSessionIdFromEnv({ PI_SESSION_ID: "01a00baf-feed-7f4d-a4a9-b8345c67cf72" })).toBe(
+			"01a00baf-feed-7f4d-a4a9-b8345c67cf72",
+		);
+	});
+});
+
 describe("ulw-loop*Path helpers", () => {
 	it("compose artifact filenames under ulwLoopDir", () => {
 		// when/then

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

@@ -0,0 +1,258 @@
+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 basics", () => {
+	it("#given rejected recommendation, empty surface evidence, and invalid artifact kind #when validating #then reports all three defects", () => {
+		const gate = {
+			manualQa: {
+				by: "main-session",
+				status: "passed",
+				evidence: "qa evidence",
+				surfaceEvidence: [],
+				adversarialCases: [
+					{
+						id: "adv",
+						criterionRef: "C001",
+						scenario: "scenario",
+						expectedBehavior: "reject",
+						verdict: "passed",
+						artifactRefs: [],
+					},
+				],
+				artifactRefs: [
+					{
+						id: "artifact",
+						kind: "invalid-kind",
+						description: "artifact",
+						path: "test/fixtures/artifacts/cli-pass.txt",
+					},
+				],
+			},
+			gateReview: {
+				by: "category:deep",
+				recommendation: "REJECT",
+				evidence: "gate evidence",
+				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, { reviewerSurface: "omo-senpi" });
+			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.map((item) => item["field"]) : []).toEqual(
+				expect.arrayContaining([
+					"gateReview.recommendation",
+					"manualQa.surfaceEvidence",
+					"manualQa.artifactRefs[0].kind",
+				]),
+			);
+		}
+	});
+
+	it("#given an empty existing artifact and another defect #when validating #then reports both defects", () => {
+		const gate = {
+			manualQa: {
+				by: "main-session",
+				status: "passed",
+				evidence: "qa evidence",
+				surfaceEvidence: [
+					{
+						id: "surface",
+						criterionRef: "C001",
+						surface: "cli",
+						invocation: "run",
+						verdict: "passed",
+						artifactRefs: ["empty"],
+					},
+				],
+				adversarialCases: [
+					{
+						id: "adv",
+						criterionRef: "C001",
+						scenario: "scenario",
+						expectedBehavior: "reject",
+						verdict: "passed",
+						artifactRefs: [],
+					},
+				],
+				artifactRefs: [{ id: "empty", kind: "cli-transcript", description: "empty", path: "empty.txt" }],
+			},
+			gateReview: {
+				by: "category:deep",
+				recommendation: "REJECT",
+				evidence: "gate evidence",
+				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, {
+				repoRoot: process.cwd(),
+				reviewerSurface: "omo-senpi",
+				fs: {
+					existsSync: (path) => path.endsWith("empty.txt") || path.endsWith("gate-review.md"),
+					statSync: () => ({ size: 0 }),
+				},
+			});
+			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.map((item) => item["field"]) : []).toEqual(
+				expect.arrayContaining(["manualQa.artifactRefs[0].path", "gateReview.recommendation"]),
+			);
+		}
+	});
+	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 missing required fields #when validating #then reports each field in one error", () => {
+		const gate = {
+			manualQa: { evidence: "qa", artifactRefs: [] },
+			gateReview: { by: "invalid", recommendation: "REJECT", evidence: "", reportPath: "", blockers: ["blocker"] },
+			iteration: { fullRerun: false, status: "failed", rerunCommands: [], evidence: "" },
+			criteriaCoverage: {
+				totalCriteria: "bad",
+				passCount: 0,
+				originalIntent: "",
+				desiredOutcome: "",
+				userOutcomeReview: "",
+				adversarialClassesCovered: [],
+			},
+		};
+		expect(() => validateQualityGate(gate, { reviewerSurface: "omo-senpi" })).toThrow(/gateReview\.by/);
+		try {
+			validateQualityGate(gate, { reviewerSurface: "omo-senpi" });
+		} catch (error) {
+			expect(error).toBeInstanceOf(UlwLoopError);
+			if (!(error instanceof UlwLoopError)) throw error;
+			const fields = error.details?.["fields"];
+			expect(Array.isArray(fields) ? fields.map((field) => field["field"]) : []).toEqual(
+				expect.arrayContaining([
+					"gateReview.by",
+					"iteration.status",
+					"criteriaCoverage.totalCriteria",
+					"manualQa.artifactRefs",
+				]),
+			);
+		}
+	});
+
+	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-cap-and-dedupe.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { throwQualityGateDefects } from "../src/quality-gate-fields.js";
+import { UlwLoopError } from "../src/types.js";
+
+describe("quality gate cap and dedupe", () => {
+	it("#given duplicate defects beyond the cap #when formatting #then deduplicates before capping", () => {
+		const defects = Array.from({ length: 30 }, (_, index) => ({
+			field: index < 10 ? "duplicate" : `field-${index - 10}`,
+			message: index < 10 ? "same defect" : `defect-${index - 10}`,
+		}));
+		try {
+			throwQualityGateDefects(defects);
+			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 : 0).toBe(21);
+			expect(error.details?.["truncated"]).toBeUndefined();
+		}
+	});
+});

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

@@ -0,0 +1,97 @@
+import { existsSync } from "node:fs";
+import { describe, expect, it } from "vitest";
+import { validateQualityGate } from "../src/quality-gate.js";
+import { UlwLoopError } from "../src/types.js";
+
+const shared = {
+	gateReview: {
+		by: "category:deep",
+		recommendation: "APPROVE",
+		evidence: "review",
+		reportPath: "report.txt",
+		blockers: [],
+	},
+	iteration: { fullRerun: true, status: "passed", rerunCommands: ["test"], evidence: "rerun" },
+	criteriaCoverage: {
+		totalCriteria: 1,
+		passCount: 1,
+		originalIntent: "intent",
+		desiredOutcome: "outcome",
+		userOutcomeReview: "review",
+		adversarialClassesCovered: ["none"],
+	},
+};
+function fields(gate: Record<string, unknown>, withFs = false): readonly string[] {
+	try {
+		validateQualityGate(gate, {
+			reviewerSurface: "omo-senpi",
+			...(withFs ? { repoRoot: process.cwd(), fs: { existsSync, statSync: () => ({ size: 1 }) } } : {}),
+		});
+	} catch (error) {
+		if (error instanceof UlwLoopError) {
+			const list = error.details?.["fields"];
+			return Array.isArray(list) ? list.map((item) => `${String(item["field"])}: ${String(item["message"])}`) : [];
+		}
+		throw error;
+	}
+	throw new Error("expected validation failure");
+}
+function manual(overrides: Record<string, unknown> = {}): Record<string, unknown> {
+	return {
+		by: "main-session",
+		status: "passed",
+		evidence: "qa",
+		surfaceEvidence: [],
+		adversarialCases: [],
+		artifactRefs: [{ id: "a", kind: "log", description: "x", path: "x.txt" }],
+		...overrides,
+	};
+}
+describe("quality gate poisoning contract", () => {
+	it.each([
+		[
+			"invalid artifact kind",
+			[{ id: "a", kind: "invalid-kind", description: "x", path: "x.txt" }],
+			(list: readonly string[]) => {
+				expect(list.some((x) => x.startsWith("manualQa.artifactRefs[0].kind:"))).toBe(true);
+				expect(list.some((x) => x.includes("references unknown artifact a"))).toBe(false);
+			},
+		],
+		[
+			"duplicate id with invalid kind",
+			[
+				{ id: "a", kind: "cli-transcript", description: "x", path: "x.txt" },
+				{ id: "a", kind: "invalid-kind", description: "x", path: "x.txt" },
+			],
+			(list: readonly string[]) => {
+				expect(list.some((x) => x.startsWith("manualQa.artifactRefs[1].kind:"))).toBe(true);
+				expect(list.some((x) => x.includes("duplicate a"))).toBe(true);
+			},
+		],
+	] as const)("#given %s #when validating #then preserves independent defects", (_name, artifactRefs, assertResult) =>
+		assertResult(fields({ ...shared, manualQa: manual({ artifactRefs }) })),
+	);
+	it("#given a poisoned numeric input #when validating #then skips its cross-field comparison", () => {
+		const list = fields({
+			...shared,
+			criteriaCoverage: { ...shared.criteriaCoverage, passCount: "bad" },
+			manualQa: manual(),
+		});
+		expect(list.some((x) => x.includes("passCount") && x.includes("numeric"))).toBe(true);
+		expect(list.some((x) => x.includes("cover totalCriteria"))).toBe(false);
+	});
+	it("#given poisoned parent rows #when validating #then suppresses all child defects", () => {
+		const list = fields({ ...shared, manualQa: manual({ surfaceEvidence: [null], adversarialCases: [null] }) });
+		expect(list.some((x) => x.startsWith("manualQa.surfaceEvidence[0]:"))).toBe(true);
+		expect(list.some((x) => x.startsWith("manualQa.surfaceEvidence[0]."))).toBe(false);
+		expect(list.some((x) => x.startsWith("manualQa.adversarialCases[0]:"))).toBe(true);
+	});
+	it("#given a poisoned report path #when validating with fs options #then skips file checks", () => {
+		const list = fields(
+			{ ...shared, gateReview: { ...shared.gateReview, reportPath: "tbd" }, manualQa: manual() },
+			true,
+		);
+		expect(list.some((x) => x.includes("reportPath") && x.includes("placeholder"))).toBe(true);
+		expect(list.some((x) => x.includes("gateReview.reportPath") && x.includes("existing artifact"))).toBe(false);
+	});
+});

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

@@ -75,9 +75,9 @@ function gateWith(overrides: Record<string, unknown>): Record<string, unknown> {
 	return { ...BASE_GATE, ...overrides };
 }
 
-function qualityGateError(input: unknown): UlwLoopError {
+function qualityGateError(input: unknown, surface?: "lazycodex" | "omo-senpi"): UlwLoopError {
 	try {
-		validateQualityGate(input);
+		validateQualityGate(input, surface === undefined ? undefined : { reviewerSurface: surface });
 	} catch (error) {
 		if (error instanceof UlwLoopError) return error;
 		throw error;
@@ -85,6 +85,22 @@ function qualityGateError(input: unknown): UlwLoopError {
 	throw new Error("Expected UlwLoopError");
 }
 
+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", () => {
 	it("#given arbitrary reviewer role names #when validated #then each role field is rejected", () => {
 		const cases = [
@@ -106,6 +122,34 @@ describe("validateQualityGate reviewer roles", () => {
 		}
 	});
 
+	it("#given omo-senpi reviewer identities #when validated on the omo-senpi surface #then the gate is accepted", () => {
+		expect(() => validateQualityGate(senpiGate(), { reviewerSurface: "omo-senpi" })).not.toThrow();
+	});
+
+	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("no codeReview lane");
+	});
+
+	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("codeReview");
+	});
+
+	it("#given swapped omo-senpi reviewer roles #when validated on the omo-senpi surface #then section-specific roles are enforced", () => {
+		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("manualQa.by");
+	});
+
 	it("#given swapped LazyCodex reviewer roles #when validated #then section-specific roles are enforced", () => {
 		const cases = [
 			{