oh-my-opencode 4.10.0 → 4.11.0

package/packages/omo-codex/plugin/skills/ulw-plan/scripts/scaffold-plan.mjs

@@ -0,0 +1,301 @@
+#!/usr/bin/env node
+// scaffold-plan.mjs - generate the ulw-plan draft + plan skeleton deterministically.
+//
+// Zero external dependencies (node:fs/path/process/url builtins only) so it runs
+// byte-identically under `node` and `bun` on macOS, Linux, and Windows with no uv
+// bootstrap, no npm/pip install, and no POSIX-shell or python3 precondition - the
+// two things genuinely not guaranteed on native Windows across the omo harnesses.
+//
+// Usage:  node "<skill-root>/scripts/scaffold-plan.mjs" <slug> [--clear|--unclear] [--reset [--force]]
+//
+// RESUME-SAFE: run it ONCE at plan generation. A plain re-run on an existing
+// ulw-plan artifact is a NO-OP success (it never overwrites your appended todos),
+// so a model resuming after compaction cannot crash the turn or clobber the plan.
+// Destructive overwrite is reserved behind --reset, and --reset refuses to discard
+// a hand-edited file unless --force is also passed.
+//
+// WRITE BOUNDARY: the prometheus-md-only hook gates Write/Edit but NOT Bash, so
+// this node:fs script writes out of band of that hook. It self-guards THIS script's
+// own writes to resolve under .omo/ (it does not, and cannot, contain other Bash
+// commands; it only guarantees the mandated generator never escapes .omo). Mirrors
+// packages/omo-opencode/src/hooks/prometheus-md-only/path-policy.ts.
+
+import { lstat, mkdir, writeFile, readFile, realpath } from "node:fs/promises";
+import { dirname, join, relative, resolve, isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// The canonical AI-plan section headers, in order. references/full-workflow.md
+// documents this exact list; a build-time test asserts the two never drift.
+export const PLAN_SECTION_HEADERS = [
+	"## TL;DR (For humans)",
+	"## Scope",
+	"## Verification strategy",
+	"## Execution strategy",
+	"## Todos",
+	"## Final verification wave",
+	"## Commit strategy",
+	"## Success criteria",
+];
+
+export const FINAL_VERIFICATION_ITEMS = [
+	"F1. Plan compliance audit",
+	"F2. Code quality review",
+	"F3. Real manual QA",
+	"F4. Scope fidelity",
+];
+
+const SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,79}$/;
+
+export function parseArgs(argv) {
+	const rest = argv.slice(2);
+	let slug;
+	let intent = "unspecified";
+	let force = false;
+	let reset = false;
+	for (const arg of rest) {
+		if (arg === "--clear") intent = "clear";
+		else if (arg === "--unclear") intent = "unclear";
+		else if (arg === "--reset") reset = true;
+		else if (arg === "--force") force = true;
+		else if (arg.startsWith("--")) throw new Error(`unknown flag: ${arg}`);
+		else if (slug === undefined) slug = arg;
+		else throw new Error(`unexpected argument: ${arg}`);
+	}
+	if (!slug) throw new Error('usage: scaffold-plan.mjs <slug> [--clear|--unclear] [--reset [--force]]');
+	if (!SLUG_PATTERN.test(slug)) {
+		throw new Error(`invalid slug "${slug}" - use lowercase letters, digits, and hyphens only`);
+	}
+	return { slug, intent, reset, force };
+}
+
+// Resolve a project-relative path and confine it under .omo/ - the script's own
+// enforcement of the prometheus planner write boundary.
+export function resolveSafeOmoPath(cwd, relPath) {
+	const resolved = resolve(cwd, relPath);
+	const rel = relative(cwd, resolved);
+	if (rel.startsWith("..") || isAbsolute(rel)) {
+		throw new Error(`refused: path escapes the workspace root: ${relPath}`);
+	}
+	if (!/(^|[/\\])\.omo([/\\]|$)/i.test(rel)) {
+		throw new Error(`refused: ulw-plan may only write under .omo/: ${relPath}`);
+	}
+	if (!resolved.toLowerCase().endsWith(".md")) {
+		throw new Error(`refused: ulw-plan may only write .md files: ${relPath}`);
+	}
+	return resolved;
+}
+
+function assertContainedPath(parent, child, message) {
+	const rel = relative(parent, child);
+	if (rel.startsWith("..") || isAbsolute(rel)) {
+		throw new Error(message);
+	}
+}
+
+async function mkdirWithoutSymlinks(dir, stopAt) {
+	if (dir === stopAt) return;
+	const parent = dirname(dir);
+	if (parent === dir || relative(stopAt, dir).startsWith("..") || isAbsolute(relative(stopAt, dir))) {
+		throw new Error(`refused: path escapes the workspace root: ${dir}`);
+	}
+	await mkdirWithoutSymlinks(parent, stopAt);
+	const stat = await lstat(dir).catch((err) => {
+		if (err && err.code === "ENOENT") return null;
+		throw err;
+	});
+	if (stat) {
+		if (stat.isSymbolicLink()) {
+			throw new Error(`refused: path component is a symlink: ${dir}`);
+		}
+		if (!stat.isDirectory()) {
+			throw new Error(`refused: path component is not a directory: ${dir}`);
+		}
+		return;
+	}
+	await mkdir(dir);
+}
+
+async function assertSafeWriteParent(cwd, target) {
+	const workspaceReal = await realpath(cwd);
+	const workspaceRoot = resolve(cwd);
+	const omoRoot = resolve(cwd, ".omo");
+	const parent = dirname(target);
+	assertContainedPath(workspaceRoot, parent, `refused: path escapes the workspace root: ${target}`);
+	assertContainedPath(omoRoot, parent, `refused: ulw-plan may only write under .omo/: ${target}`);
+	await mkdirWithoutSymlinks(parent, workspaceRoot);
+	const omoReal = await realpath(omoRoot);
+	const parentReal = await realpath(parent);
+	assertContainedPath(workspaceReal, parentReal, `refused: path escapes the workspace root through symlinks: ${target}`);
+	assertContainedPath(omoReal, parentReal, `refused: ulw-plan may only write under .omo/ through real paths: ${target}`);
+}
+
+async function assertSafeWriteTarget(target) {
+	const stat = await lstat(target).catch((err) => {
+		if (err && err.code === "ENOENT") return null;
+		throw err;
+	});
+	if (stat?.isSymbolicLink()) {
+		throw new Error(`refused: target is a symlink: ${target}`);
+	}
+}
+
+// A file this script previously emitted (plan skeleton or draft), used to make a
+// plain re-run a safe no-op instead of a crash or a clobber.
+export function isUlwArtifact(content) {
+	const isPlan = content.includes("## TL;DR (For humans)") && content.includes("## Final verification wave");
+	const isDraft = content.includes("# Draft:") && content.includes("## Approval gate");
+	return isPlan || isDraft;
+}
+
+export function buildDraft(slug, intent) {
+	const assumptionsNote =
+		intent === "unclear"
+			? "Intent is UNCLEAR: research resolves ambiguity, defaults are adopted (not asked), and each is surfaced in the plan's human TL;DR for veto."
+			: "Record any default you adopt instead of asking, so the user can veto it at the gate.";
+	return `---
+slug: ${slug}
+status: drafting
+intent: ${intent}
+pending-action: write .omo/plans/${slug}.md
+approach: <fill: the approach you intend to plan>
+---
+
+# Draft: ${slug}
+
+## Components (topology ledger)
+<!-- Lock the SHAPE before depth. One row per top-level component that can succeed or fail independently. -->
+<!-- id | outcome (one line) | status: active|deferred | evidence path -->
+
+## Open assumptions (announced defaults)
+<!-- ${assumptionsNote} -->
+<!-- assumption | adopted default | rationale | reversible? -->
+
+## Findings (cited - path:lines)
+
+## Decisions (with rationale)
+
+## Scope IN
+
+## Scope OUT (Must NOT have)
+
+## Open questions
+
+## Approval gate
+status: drafting
+<!-- When exploration is exhausted and unknowns are answered, set status: awaiting-approval. -->
+<!-- That durable record is the loop guard: on a later turn read it and resume at the gate instead of re-running exploration. -->
+`;
+}
+
+export function buildPlanSkeleton(slug, intent) {
+	const decisionsLine =
+		intent === "unclear"
+			? "**Decisions I made for you:** <fill last - the best-practice defaults you adopted; the user vetoes any here>"
+			: "**Decisions to sanity-check:** <fill last - the few choices worth a human glance>";
+	return `# ${slug} - Work Plan
+
+## TL;DR (For humans)
+<!-- Fill this LAST, after the detailed plan below is written, so it summarizes the REAL plan. -->
+<!-- Plain English for a non-engineer: NO file paths, NO todo numbers, NO wave/agent/tool names. -->
+
+**What you'll get:** <fill last - deliverables in human terms, 1-2 sentences>
+
+**Why this approach:** <fill last - the one or two load-bearing decisions and why>
+
+**What it will NOT do:** <fill last - 1-3 plain lines mirroring Must NOT have>
+
+**Effort:** <Quick | Short | Medium | Large | XL>
+**Risk:** <Low | Medium | High> - <one-line driver>
+${decisionsLine}
+
+Your next move: <fill - e.g. approve, or run a high-accuracy review>. Full execution detail follows below.
+
+---
+
+> TL;DR (machine): <1 line - effort, risk, deliverables>
+
+## Scope
+### Must have
+### Must NOT have (guardrails, anti-slop, scope boundaries)
+
+## Verification strategy
+> Zero human intervention - all verification is agent-executed.
+- Test decision: <TDD | tests-after | none> + framework
+- Evidence: .omo/evidence/task-<N>-${slug}.<ext>
+
+## Execution strategy
+### Parallel execution waves
+> Target 5-8 todos per wave. Fewer than 3 (except the final) means you under-split.
+
+### Dependency matrix
+| Todo | Depends on | Blocks | Can parallelize with |
+| --- | --- | --- | --- |
+
+## Todos
+> Implementation + Test = ONE todo. Never separate.
+<!-- APPEND TASK BATCHES BELOW THIS LINE WITH edit/apply_patch - never rewrite the headers above. -->
+- [ ] 1. <title>
+  What to do / Must NOT do: <...>
+  Parallelization: Wave <N> | Blocked by: <...> | Blocks: <...>
+  References (executor has NO interview context - be exhaustive): <src/path:lines>
+  Acceptance criteria (agent-executable): <exact command or assertion>
+  QA scenarios (name the exact tool + invocation): happy + failure, Evidence .omo/evidence/task-1-${slug}.<ext>
+  Commit: <Y/N> | <type>(<scope>): <summary>
+
+## Final verification wave
+> Runs in parallel after ALL todos. ALL must APPROVE. Surface results and wait for the user's explicit okay before declaring complete.
+${FINAL_VERIFICATION_ITEMS.map((item) => `- [ ] ${item}`).join("\n")}
+
+## Commit strategy
+
+## Success criteria
+`;
+}
+
+// Resume-safe write: plain re-run on an existing ulw-plan artifact is a no-op
+// success; --reset overwrites but refuses to discard a hand-edited file unless
+// --force is also passed.
+export async function writeGuarded(cwd, relPath, content, { reset = false, force = false } = {}) {
+	const target = resolveSafeOmoPath(cwd, relPath);
+	await assertSafeWriteParent(cwd, target);
+	await assertSafeWriteTarget(target);
+	const existing = await readFile(target, "utf8").catch(() => null);
+	if (existing && existing.trim() !== "") {
+		if (!reset) {
+			if (isUlwArtifact(existing)) return { relPath, status: "exists" };
+			throw new Error(`refused: ${relPath} exists and is not a ulw-plan artifact (pass --reset to overwrite)`);
+		}
+		if (existing.trim() !== content.trim() && !force) {
+			throw new Error(`refused: ${relPath} has edits that differ from a fresh skeleton; pass --reset --force to discard them`);
+		}
+	}
+	await writeFile(target, content, "utf8");
+	return { relPath, status: existing ? "reset" : "created" };
+}
+
+export async function scaffold(cwd, { slug, intent, reset = false, force = false }) {
+	const draftRel = join(".omo", "drafts", `${slug}.md`);
+	const planRel = join(".omo", "plans", `${slug}.md`);
+	const draft = await writeGuarded(cwd, draftRel, buildDraft(slug, intent), { reset, force });
+	const plan = await writeGuarded(cwd, planRel, buildPlanSkeleton(slug, intent), { reset, force });
+	return [draft, plan];
+}
+
+async function main() {
+	const { slug, intent, reset, force } = parseArgs(process.argv);
+	const results = await scaffold(process.cwd(), { slug, intent, reset, force });
+	for (const r of results) process.stdout.write(`${r.status}: ${r.relPath}\n`);
+	const created = results.some((r) => r.status !== "exists");
+	process.stdout.write(
+		created
+			? `next: record findings/decisions in the draft, then APPEND task batches into the "## Todos" region of the plan; fill "## TL;DR (For humans)" LAST.\n`
+			: `skeleton already present - left untouched. APPEND task batches into the "## Todos" region; the human "## TL;DR (For humans)" stays on top.\n`,
+	);
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+	await main().catch((err) => {
+		process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+		process.exit(1);
+	});
+}

package/packages/omo-codex/plugin/skills/visual-qa/SKILL.md

@@ -12,12 +12,12 @@ This skill may include examples copied from the OpenCode harness. In Codex, do n
 | `call_omo_agent(subagent_type="explore", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as an explorer. ...","agent_type":"explorer","fork_context":false})` |
 | `call_omo_agent(subagent_type="librarian", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as a librarian. ...","agent_type":"librarian","fork_context":false})` |
 | `task(subagent_type="plan", ...)` | `multi_agent_v1.spawn_agent({"message":"TASK: act as a planning agent. ...","agent_type":"plan","fork_context":false})` |
-| `task(subagent_type="oracle", ...)` for final verification | `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"codex-ultrawork-reviewer","fork_context":false})` |
+| `task(subagent_type="oracle", ...)` for final verification | `multi_agent_v1.spawn_agent({"message":"TASK: act as a rigorous reviewer. ...","agent_type":"lazycodex-gate-reviewer","fork_context":false})` |
 | `task(category="...", ...)` for implementation or QA | `multi_agent_v1.spawn_agent({"message":"TASK: act as an implementation or QA worker. ...","fork_context":false})` |
 | `background_output(task_id="...")` | `multi_agent_v1.wait_agent(...)` for mailbox signals |
 | `team_*(...)` | Use Codex native subagents via `multi_agent_v1.spawn_agent`, `multi_agent_v1.send_input`, `multi_agent_v1.wait_agent`, and `multi_agent_v1.close_agent` |
 
-Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. OMO installs these selectable agent roles into `~/.codex/agents/`: `explorer`, `librarian`, `plan`, `momus`, `metis`, and `codex-ultrawork-reviewer` — pass the matching name as `agent_type` so the child gets that role's model and instructions. On `multi_agent_v2` sessions the same `agent_type` applies (the OMO installer exposes it) with `fork_turns` instead of `fork_context`. If the spawn tool exposes no `agent_type` parameter, omit it and describe the role inside `message`. If a code block below conflicts with this section, this section wins.
+Role-specific behavior must be described in a self-contained `message`. Use `fork_context: false` to start the child with only the initial prompt (no parent history); use `fork_context: true` only when full parent history is truly required. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. OMO installs these selectable agent roles into `~/.codex/agents/`: `explorer`, `librarian`, `plan`, `momus`, `metis`, `lazycodex-code-reviewer`, `lazycodex-qa-executor`, and `lazycodex-gate-reviewer` - pass the matching name as `agent_type` so the child gets that role's model and instructions. If the spawn tool exposes no `agent_type` parameter, omit it and describe the role inside `message`. If a code block below conflicts with this section, this section wins.
 
 For work likely to exceed one wait cycle, require the child to send `WORKING: <task> - <current phase>` before long passes and `BLOCKED: <reason>` only when progress stops. A `multi_agent_v1.wait_agent` timeout only means no new mailbox update arrived. Treat a running child as alive. Fallback only when the child is completed without the deliverable, ack-only after followup, explicitly `BLOCKED:`, or no longer running.
 
@@ -45,7 +45,7 @@ If the change touches both, run both capture tracks and feed both into the passe
 ### Web
 
 1. Capture a REFERENCE image: the user's mock/target, or a known-good baseline. Save as PNG.
-2. Capture the ACTUAL rendered screenshot at the same viewport size using the project's browser tooling (the playwright, agent-browser, or dev-browser skill). Save as PNG.
+2. Capture the ACTUAL rendered screenshot at the same viewport size using the project's browser tooling (the playwright, agent-browser, or dev-browser skill). Save as PNG. If none is configured or available, install [agent-browser](https://github.com/vercel-labs/agent-browser) (`bun add -g agent-browser && agent-browser install`) and capture with it — see `$SKILL_DIR/references/agent-browser-setup.md` for the full setup, including how to shoot a fixed-viewport screenshot.
 3. Run the diff and keep the JSON:
 
 ```
@@ -197,6 +197,22 @@ Completion gate: do not declare the UI done until both passes are satisfied, OR
 [Satisfied, or the exact remaining gaps and who accepted them]
 ```
 
+## Step 5 - Clone-coding mode (when the task was a clone or design port)
+
+Run this step IN ADDITION to Steps 1-4, but ONLY when the original user task was a clone or design port: "clone this site", "move this Figma design to code", "rebuild this screen", "make it look exactly like X". For these tasks the normal dual-oracle is necessary but NOT sufficient. After it returns, run the following TWO additional MANDATORY verifications and LOOP until BOTH pass.
+
+1. Pixel-perfect design-compare subagent (visual oracle). Dispatch a focused, read-only design-compare reviewer (recommend `gpt-5.5` with medium reasoning). It must crop/zoom BOTH the reference (the target / Figma export / source-site screenshot) and the ACTUAL screenshot into matching regions and read them **pixel-by-pixel** - header, nav, each card, spacing, type ramp, color tokens - not at a glance. Anchor every claim with the bundled tool:
+
+```
+bun "$SKILL_DIR/scripts/cli.ts" image-diff <reference.png> <actual.png>
+```
+
+   It judges whether layout geometry, spacing, design tokens (color, type, radius, shadow), and the design itself are identical to the target, region by region. Anything off by more than rounding is a finding.
+
+2. Code-level design-system fidelity (code oracle). Call the code-quality reviewer named EXACTLY `lazycodex-clone-fidelity-reviewer` (spawn it by that agent name). It verifies the implementation is a RIGOROUS design-system build - a real component tree, real design tokens, reused primitives - and is NOT a pasted image, a screenshot or background-image substitute, or a hardcoded one-off that merely looks right in one screenshot. If that named reviewer is not installed in this harness, fall back to an inline rigorous code review against the SAME criteria.
+
+RULE (mandatory, non-negotiable): the clone is NOT done until BOTH the pixel-compare AND the `lazycodex-clone-fidelity-reviewer` (or its inline fallback) confirm that the **layer structure, the design system, and the design itself** are strictly identical to the target. If EITHER fails, it is a MANDATORY retry: re-implement the gaps and re-run BOTH verifications from the top. Repeat the retry loop until both pass on the same revision. Never declare a clone complete on a single pass, on visual-only evidence, or on code-only evidence - both oracles must confirm on the same build.
+
 ## Reference evidence is not the verdict
 
 The script quantifies pixels and columns. It cannot judge whether the result is a real design system, whether features work, or whether intent was met. A 99/100 `similarityScore` can still hide a pasted-image fake, a broken interaction, or clipped CJK descenders. Use the numbers to aim the oracles, then trust the synthesized review.

package/packages/omo-codex/plugin/skills/visual-qa/references/agent-browser-setup.md

@@ -0,0 +1,44 @@
+# agent-browser setup (Web capture fallback)
+
+Use this when the project has **no** browser tooling configured or available for the Web
+capture path in Step 2 (no playwright / dev-browser skill, no usable headless browser).
+[agent-browser](https://github.com/vercel-labs/agent-browser) is a standalone CLI that
+drives a real Chromium and can screenshot a page at a fixed viewport — exactly what the
+`image-diff` evidence step needs.
+
+Repo: https://github.com/vercel-labs/agent-browser
+
+## Install
+
+```
+bun add -g agent-browser && agent-browser install
+```
+
+`bun add -g agent-browser` installs the CLI globally; `agent-browser install` downloads the
+managed browser it drives. (Equivalent with npm: `npm install -g agent-browser && agent-browser install`.)
+
+Confirm it is ready and discover the current flags:
+
+```
+agent-browser --help
+```
+
+## Capture a screenshot at a fixed viewport
+
+Set the viewport first, then screenshot — this guarantees the ACTUAL capture matches the
+REFERENCE viewport so `image-diff` compares like-for-like:
+
+```
+agent-browser set viewport 1280 720      # width height (add a third arg, e.g. 2, for retina scale)
+agent-browser screenshot actual.png      # add --full for full-page, --screenshot-dir ./shots for a custom dir
+```
+
+Then feed the PNG into the diff exactly as in Step 2:
+
+```
+bun "$SKILL_DIR/scripts/cli.ts" image-diff <reference.png> actual.png
+```
+
+Match the viewport numbers to whatever the reference/mock was captured at; mismatched
+dimensions make `dimensionsMatch` false and inflate `diffRatio`. Run `agent-browser --help`
+for the full command set (navigation, batch, annotate, format/quality flags).

package/packages/omo-codex/plugin/test/aggregate-agents.test.mjs

@@ -5,6 +5,59 @@ import test from "node:test";
 
 import { root } from "./aggregate-plugin-fixture.mjs";
 
+const agentSchemaKeys = new Set([
+	"name",
+	"description",
+	"nickname_candidates",
+	"model",
+	"model_reasoning_effort",
+	"service_tier",
+	"developer_instructions",
+]);
+
+const lazycodexAgentInvariants = new Map([
+	[
+		"lazycodex-executor.toml",
+		{
+			effort: "high",
+			includes: [/EVIDENCE_RECORDED: <path>/, /scenario/i, /artifact/i],
+		},
+	],
+	[
+		"lazycodex-clone-fidelity-reviewer.toml",
+		{
+			effort: "xhigh",
+			includes: [/recommendation/, /blockers/, /\.omo\/evidence\/<goal>-clone-fidelity\.md/],
+		},
+	],
+	[
+		"lazycodex-code-reviewer.toml",
+		{
+			effort: "xhigh",
+			includes: [/codeQualityStatus/, /recommendation/, /\.omo\/evidence\/<goal>-code-review\.md/],
+		},
+	],
+	[
+		"lazycodex-qa-executor.toml",
+		{
+			effort: "medium",
+			includes: [/not_applicable/, /surfaceEvidence/, /adversarialCases/],
+		},
+	],
+	[
+		"lazycodex-gate-reviewer.toml",
+		{
+			effort: "xhigh",
+			includes: [/APPROVE\/REJECT/, /blockers/, /\.omo\/evidence\/<goal>-gate-review\.md/],
+		},
+	],
+]);
+
+const externalSourceTokenPattern = new RegExp(
+	["ga" + "jae", "ga" + "jae" + "code", "ga" + "jae-code", "\uAC00\uC7AC", "g" + "jc"].join("|"),
+	"i",
+);
+
 test("#given bundled Codex agents #when components/ultrawork/agents directory is scanned #then planner support TOMLs are present and match expected schema keys", async () => {
 	const agentsDir = join(root, "components", "ultrawork", "agents");
 	const entries = (await readdir(agentsDir, { withFileTypes: true }))
@@ -13,8 +66,12 @@ test("#given bundled Codex agents #when components/ultrawork/agents directory is
 		.sort();
 
 	assert.deepEqual(entries, [
-		"codex-ultrawork-reviewer.toml",
 		"explorer.toml",
+		"lazycodex-clone-fidelity-reviewer.toml",
+		"lazycodex-code-reviewer.toml",
+		"lazycodex-executor.toml",
+		"lazycodex-gate-reviewer.toml",
+		"lazycodex-qa-executor.toml",
 		"librarian.toml",
 		"metis.toml",
 		"momus.toml",
@@ -29,6 +86,11 @@ test("#given bundled Codex agents #when components/ultrawork/agents directory is
 		assert.match(content, /^model\s*=\s*".+"$/m);
 		assert.match(content, /^model_reasoning_effort\s*=\s*".+"$/m);
 		assert.match(content, /^developer_instructions\s*=\s*"""/m);
+
+		const keys = Array.from(content.matchAll(/^([a-z_]+)\s*=/gm), (match) => match[1]);
+		for (const key of keys) {
+			assert.ok(agentSchemaKeys.has(key), `${fileName} uses unsupported key ${key}`);
+		}
 	}
 });
 
@@ -41,15 +103,61 @@ test("#given planner agent prompt #when inspected #then generated artifacts stay
 	assert.doesNotMatch(prompt, /(?<!\.omo\/)evidence\/task-/);
 });
 
-test("#given reviewer agent prompt #when inspected #then default model uses bounded reasoning", async () => {
-	const prompt = await readFile(
-		join(root, "components", "ultrawork", "agents", "codex-ultrawork-reviewer.toml"),
-		"utf8",
-	);
+test("#given lazycodex agent prompts #when inspected #then each role pins model effort and evidence discipline", async () => {
+	const agentsDir = join(root, "components", "ultrawork", "agents");
+
+	for (const [fileName, invariant] of lazycodexAgentInvariants) {
+		const prompt = await readFile(join(agentsDir, fileName), "utf8");
+
+		assert.match(prompt, /^model\s*=\s*"gpt-5\.5"$/m);
+		assert.match(prompt, new RegExp(`^model_reasoning_effort\\s*=\\s*"${invariant.effort}"$`, "m"));
+		assert.doesNotMatch(prompt, /^tools\s*=/m);
+		assert.doesNotMatch(prompt, /^blocking\s*=/m);
+		assert.doesNotMatch(prompt, externalSourceTokenPattern);
 
-	assert.match(prompt, /^model\s*=\s*"gpt-5\.5"$/m);
-	assert.match(prompt, /^model_reasoning_effort\s*=\s*"high"$/m);
-	assert.doesNotMatch(prompt, /^model_reasoning_effort\s*=\s*"xhigh"$/m);
-	assert.doesNotMatch(prompt, /^model\s*=\s*"gpt-5\.2"$/m);
-	assert.match(prompt, /ChatGPT account/);
+		for (const pattern of invariant.includes) {
+			assert.match(prompt, pattern, `${fileName} must include ${pattern}`);
+		}
+	}
+});
+
+test("#given LazyCodex reviewer prompts #when inspected #then anti-slop review coverage is required", async () => {
+	const agentsDir = join(root, "components", "ultrawork", "agents");
+	const codeReviewer = await readFile(join(agentsDir, "lazycodex-code-reviewer.toml"), "utf8");
+	const gateReviewer = await readFile(join(agentsDir, "lazycodex-gate-reviewer.toml"), "utf8");
+
+	assert.match(codeReviewer, /remove-ai-slops/);
+	assert.match(codeReviewer, /programming/);
+	assert.match(codeReviewer, /load or consult/);
+	assert.match(codeReviewer, /documented criteria/);
+	assert.match(codeReviewer, /violates either skill perspective/);
+	assert.match(codeReviewer, /overfit\/slop review pass/);
+	assert.match(codeReviewer, /deletion-only tests/);
+	assert.match(codeReviewer, /tests that merely verify a requested removal/);
+	assert.match(codeReviewer, /tautological tests/);
+	assert.match(codeReviewer, /mirror implementation constants/);
+	assert.match(codeReviewer, /unnecessary production data extraction, parsing, or normalization/);
+	assert.match(codeReviewer, /false confidence/);
+
+	assert.match(gateReviewer, /remove-ai-slops/);
+	assert.match(gateReviewer, /programming/);
+	assert.match(gateReviewer, /load or consult/);
+	assert.match(gateReviewer, /documented criteria/);
+	assert.match(gateReviewer, /Run the `remove-ai-slops`/);
+	assert.match(gateReviewer, /Apply the `programming`/);
+	assert.match(gateReviewer, /overfit\/slop pass yourself/);
+	assert.match(gateReviewer, /tests that merely verify a requested removal/);
+	assert.match(gateReviewer, /deletion-only/);
+	assert.match(gateReviewer, /tautological/);
+	assert.match(gateReviewer, /implementation-mirroring tests/);
+	assert.match(gateReviewer, /unnecessary production extraction, parsing, or normalization/);
+
+	const directPassIndex = gateReviewer.indexOf("overfit/slop pass yourself");
+	const reportCoverageIndex = gateReviewer.indexOf("Then confirm the code review report");
+	assert.notEqual(directPassIndex, -1);
+	assert.notEqual(reportCoverageIndex, -1);
+	assert.ok(
+		directPassIndex < reportCoverageIndex,
+		"gate reviewer must perform the overfit/slop pass directly before checking report coverage",
+	);
 });

package/packages/omo-codex/plugin/test/aggregate-build.test.mjs

@@ -5,11 +5,10 @@ import test from "node:test";
 
 import { readJson, root } from "./aggregate-plugin-fixture.mjs";
 
-test("#given aggregate plugin build script #when inspected #then hook status and telemetry sync run before workspace builds", async () => {
+test("#given aggregate plugin build script #when inspected #then generated assets run before workspace builds", async () => {
 	// given
 	const packageText = await readFile(join(root, "package.json"), "utf8");
 	const packageJson = await readJson("package.json");
-	const telemetrySyncScript = await readFile(join(root, "..", "scripts", "sync-telemetry-component.mjs"), "utf8");
 
 	// when
 	const buildScript = packageJson.scripts.build;
@@ -18,12 +17,11 @@ test("#given aggregate plugin build script #when inspected #then hook status and
 	// then
 	assert.equal(
 		buildScript,
-		"node scripts/sync-version.mjs && node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node ../scripts/sync-telemetry-component.mjs && node scripts/build-components.mjs",
+		"node scripts/sync-version.mjs && node scripts/sync-hook-status-messages.mjs && node scripts/build-bundled-mcp-runtimes.mjs && node scripts/sync-skills.mjs && node scripts/build-components.mjs",
 	);
 	assert.match(buildScript, /^node scripts\/sync-version\.mjs &&/);
 	assert.equal(testScript, "node --test test/*.test.mjs");
 	assert(packageJson.workspaces.includes("components/ultrawork"));
-	assert.match(telemetrySyncScript, /syncTelemetryComponent/);
 	assert.doesNotMatch(packageText, /\bpython3?\b|ultrawork-detector\.py/);
 });
 

package/packages/omo-codex/plugin/test/aggregate-hooks.test.mjs

@@ -38,6 +38,33 @@ test("#given isolated components #when hooks are inspected #then commands stay i
 	assert.equal(await exists("scripts/migrate-codex-config.mjs"), true);
 });
 
+test("#given aggregate SubagentStop hooks #when inspected #then start-work and LazyCodex executor verifier are separate groups", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const aggregateVersion = await readPluginVersion();
+
+	// when
+	const subagentStopGroups = hooks.hooks.SubagentStop;
+	const verifierGroups = collectCommandHooks(hooks, "hooks/hooks.json").filter(
+		(hook) =>
+			hook.eventName === "SubagentStop" &&
+			hook.handler.command ===
+				'node "${PLUGIN_ROOT}/components/lazycodex-executor-verify/dist/cli.js" hook subagent-stop',
+	);
+
+	// then
+	assert.equal(subagentStopGroups.length, 2);
+	assert.equal(subagentStopGroups[0]?.matcher, undefined);
+	assert.equal(subagentStopGroups[1]?.matcher, "^lazycodex-executor$");
+	assert.equal(verifierGroups.length, 1);
+	assert.equal(verifierGroups[0]?.groupIndex, 1);
+	assert.equal(verifierGroups[0]?.handler.timeout, 10);
+	assert.equal(
+		verifierGroups[0]?.handler.statusMessage,
+		`LazyCodex(${aggregateVersion}): Verifying LazyCodex Executor Evidence`,
+	);
+});
+
 test("#given aggregate PostCompact hooks #when hooks are inspected #then LSP diagnostics cache reset is registered", async () => {
 	// given
 	const hooks = await readJson("hooks/hooks.json");
@@ -125,9 +152,9 @@ test("#given aggregate OMO plugin is enabled #when hooks are inspected #then she
 
 	// then
 	assert.match(text, /components\/git-bash\/dist\/cli\.js/);
-	assert.match(text, /Recommending Git Bash Mcp/);
+	assert.match(text, /Recommending Git Bash MCP/);
 	assert.match(text, /hook post-compact/);
-	assert.match(text, /Resetting Git Bash Mcp Reminder/);
+	assert.match(text, /Resetting Git Bash MCP Reminder/);
 	assert.match(text, /components\/ulw-loop\/dist\/cli\.js/);
 	assert.match(text, /hook pre-tool-use/);
 	assert.deepEqual(preToolUseGroups.map((group) => group.matcher), ["^Bash$", "^create_goal$"]);

package/packages/omo-codex/plugin/test/aggregate-manifest.test.mjs

@@ -50,8 +50,10 @@ test("#given component directories #when scanned #then only intentional resource
 	// then
 	assert.deepEqual(componentNames, [
 		"bootstrap",
+		"codegraph",
 		"comment-checker",
 		"git-bash",
+		"lazycodex-executor-verify",
 		"lsp",
 		"rules",
 		"start-work-continuation",