oh-my-opencode 4.9.2 → 4.11.0

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

@@ -49,8 +49,11 @@ 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",

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

@@ -5,7 +5,7 @@ import test from "node:test";
 
 import { exists, readJson, root } from "./aggregate-plugin-fixture.mjs";
 
-const mcpPackageManifestPaths = ["../../lsp-tools-mcp/package.json", "../../ast-grep-mcp/package.json", "../../git-bash-mcp/package.json"];
+const mcpPackageManifestPaths = ["../../lsp-tools-mcp/package.json", "../../git-bash-mcp/package.json"];
 const mcpPackageManifestExists = await Promise.all(mcpPackageManifestPaths.map(exists));
 
 test("#given aggregate MCP config #when inspected #then code MCPs reference package runtimes without package names", async () => {
@@ -17,30 +17,31 @@ test("#given aggregate MCP config #when inspected #then code MCPs reference pack
 
 	// when
 	const lspServer = mcp.mcpServers.lsp;
-	const astGrepServer = mcp.mcpServers.ast_grep;
 	const gitBashServer = mcp.mcpServers.git_bash;
+	const codegraphServer = mcp.mcpServers.codegraph;
 	const codeMcpNames = Object.keys(mcp.mcpServers)
-		.filter((name) => name === "lsp" || name === "ast_grep" || name === "git_bash")
+		.filter((name) => name === "lsp" || name === "git_bash" || name === "codegraph")
 		.sort();
 	const componentLocalMcpSources = lspSources.filter((name) => name.startsWith("lazy-mcp") || name === "lazy-lsp-mcp.ts");
 
 	// then
-	assert.deepEqual(codeMcpNames, ["ast_grep", "git_bash", "lsp"]);
+	assert.deepEqual(codeMcpNames, ["codegraph", "git_bash", "lsp"]);
 	assert.equal(packageJson.workspaces.includes("components/lsp/packages/lsp-tools-mcp"), false);
-	assert.equal(packageJson.workspaces.includes("components/ast-grep/packages/ast-grep-mcp"), false);
 	assert.deepEqual(packageJson.dependencies, { "@oh-my-opencode/shared-skills": "file:../../shared-skills" });
-	assert.match(bundledMcpBuildScript, /ast-grep-mcp/);
+	assert.doesNotMatch(bundledMcpBuildScript, new RegExp(["ast", "grep", "mcp"].join("-")));
 	assert.match(bundledMcpBuildScript, /git-bash-mcp/);
 	assert.doesNotMatch(packageJson.scripts.build, /--workspaces/);
 	assert.equal(lspServer.command, "node");
 	assert.deepEqual(lspServer.args, ["../../lsp-daemon/dist/cli.js", "mcp"]);
 	assert.equal(lspServer.cwd, ".");
-	assert.equal(astGrepServer.command, "node");
-	assert.deepEqual(astGrepServer.args, ["../../ast-grep-mcp/dist/cli.js", "mcp"]);
-	assert.equal(astGrepServer.cwd, ".");
+	assert.equal(Object.hasOwn(mcp.mcpServers, "ast_grep"), false);
 	assert.equal(gitBashServer.command, "node");
 	assert.deepEqual(gitBashServer.args, ["../../git-bash-mcp/dist/cli.js", "mcp"]);
 	assert.equal(gitBashServer.cwd, ".");
+	assert.equal(codegraphServer.command, "node");
+	assert.deepEqual(codegraphServer.args, ["components/codegraph/dist/serve.js"]);
+	assert.equal(codegraphServer.cwd, ".");
+	assert.equal(codegraphServer.required, false);
 	assert.deepEqual(componentLocalMcpSources, []);
 });
 
@@ -49,19 +50,18 @@ test(
 	{ skip: mcpPackageManifestExists.some((exists) => !exists) },
 	async () => {
 		// given
-		const [lspPackageJson, astGrepPackageJson, gitBashPackageJson] = await Promise.all(
+		const [lspPackageJson, gitBashPackageJson] = await Promise.all(
 			mcpPackageManifestPaths.map((path) => readJson(path)),
 		);
 
 		// when
 		const binNames = [
 			...Object.keys(lspPackageJson.bin ?? {}),
-			...Object.keys(astGrepPackageJson.bin ?? {}),
 			...Object.keys(gitBashPackageJson.bin ?? {}),
 		].sort();
 
 		// then
-		assert.deepEqual(binNames, ["omo-ast-grep", "omo-git-bash", "omo-lsp"]);
+		assert.deepEqual(binNames, ["omo-git-bash", "omo-lsp"]);
 		for (const name of binNames) {
 			assert.match(name, /^omo-/);
 		}

package/packages/omo-codex/plugin/test/auto-update.test.mjs

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import test from "node:test";
 
 import { resolveAutoUpdatePlan, resolveLazyCodexUpdatePlan, runAutoUpdateCheck } from "../scripts/auto-update.mjs";
+import { detectInstallFlow } from "../scripts/install-flow.mjs";
 import { resolveSpawnInvocation } from "../scripts/spawn-command.mjs";
 
 function autoUpdateEnv(root, extra = {}) {
@@ -282,6 +283,150 @@ test("#given stale lock #when running check #then removes lock and runs update",
 	});
 });
 
+async function makeStorePluginRoot(prefix) {
+	const root = await mkdtemp(join(tmpdir(), prefix));
+	const pluginRoot = join(root, "store", "omo", "1.0.0");
+	await mkdir(pluginRoot, { recursive: true });
+	return { root, pluginRoot };
+}
+
+function marketplaceCheckEnv(root, pluginRoot, spawnLogPath, extra = {}) {
+	return autoUpdateEnv(root, {
+		PLUGIN_ROOT: pluginRoot,
+		LAZYCODEX_CONFIG_MIGRATION_DISABLED: "1",
+		LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "0",
+		LAZYCODEX_AUTO_UPDATE_WAIT: "1",
+		LAZYCODEX_AUTO_UPDATE_COMMAND: process.execPath,
+		LAZYCODEX_AUTO_UPDATE_ARGS_JSON: JSON.stringify(["-e", `require("node:fs").writeFileSync(${JSON.stringify(spawnLogPath)}, "ok")`]),
+		...extra,
+	});
+}
+
+test("#given marketplace plugin root without install snapshot #when running check #then skips npx update with marketplace-flow log and upgrade notice", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-");
+	const spawnLogPath = join(root, "spawn.log");
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath);
+
+	const result = await runAutoUpdateCheck({ env, now: 123_456 });
+
+	assert.equal(result.started, false);
+	assert.equal(result.reason, "marketplace-flow");
+	assert.equal(result.notices.length, 1);
+	assert.match(result.notices[0], /codex plugin marketplace upgrade sisyphuslabs/);
+	assert.match(result.notices[0], /re-approve/);
+	await assert.rejects(readFile(spawnLogPath, "utf8"), { code: "ENOENT" });
+	const state = JSON.parse(await readFile(env.LAZYCODEX_AUTO_UPDATE_STATE_PATH, "utf8"));
+	assert.equal(state.lastCheckedAt, 123_456);
+	assert.equal(state.lastStatus, "success");
+	assert.notEqual(state.lastStatus, "started");
+	const logEntries = (await readFile(env.LAZYCODEX_AUTO_UPDATE_LOG_PATH, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
+	assert.deepEqual(logEntries, [
+		{
+			timestamp: "1970-01-01T00:02:03.456Z",
+			event: "skipped",
+			kind: "marketplace-flow",
+		},
+	]);
+});
+
+test("#given install snapshot at plugin root #when running check #then npx update behavior is unchanged", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-npx-snapshot-");
+	await writeFile(join(pluginRoot, "lazycodex-install.json"), JSON.stringify({ packageName: "lazycodex-ai", version: "1.0.0" }));
+	const spawnLogPath = join(root, "spawn.log");
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath);
+
+	const result = await runAutoUpdateCheck({ env, now: 123_456 });
+
+	assert.equal(result.started, true);
+	assert.equal(result.status, 0);
+	assert.equal(await readFile(spawnLogPath, "utf8"), "ok");
+	assert.equal(result.notices.length, 1);
+	assert.match(result.notices[0], /Auto-update started in the background/);
+	assert.doesNotMatch(result.notices[0], /marketplace upgrade/);
+});
+
+test("#given marketplace skip already recorded #when next session is within interval #then throttled without repeated notice", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-marketplace-throttle-");
+	const spawnLogPath = join(root, "spawn.log");
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath, {
+		LAZYCODEX_AUTO_UPDATE_INTERVAL_MS: "",
+	});
+
+	const first = await runAutoUpdateCheck({ env, now: 123_456 });
+	const second = await runAutoUpdateCheck({ env, now: 123_457 });
+
+	assert.equal(first.reason, "marketplace-flow");
+	assert.equal(first.notices.length, 1);
+	assert.equal(second.started, false);
+	assert.equal(second.reason, "throttled");
+	assert.deepEqual(second.notices, []);
+});
+
+test("#given unreadable install snapshot #when running check #then conservatively keeps npx flow and logs unknown detection", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-auto-update-unknown-flow-");
+	await mkdir(join(pluginRoot, "lazycodex-install.json"));
+	const spawnLogPath = join(root, "spawn.log");
+	const env = marketplaceCheckEnv(root, pluginRoot, spawnLogPath);
+
+	const result = await runAutoUpdateCheck({ env, now: 123_456 });
+
+	assert.equal(result.started, true);
+	assert.equal(result.status, 0);
+	assert.equal(await readFile(spawnLogPath, "utf8"), "ok");
+	const logEntries = (await readFile(env.LAZYCODEX_AUTO_UPDATE_LOG_PATH, "utf8")).trim().split("\n").map((line) => JSON.parse(line));
+	assert.equal(logEntries[0].event, "install-flow-unknown");
+	assert.match(logEntries[0].reason, /install-snapshot/);
+});
+
+test("#given install flow fixtures #when detecting install flow #then discriminates on the install snapshot", async () => {
+	const { pluginRoot } = await makeStorePluginRoot("lazycodex-install-flow-detect-");
+
+	assert.deepEqual(detectInstallFlow({ pluginRoot }), {
+		flow: "marketplace",
+		reason: "install-snapshot-absent",
+	});
+
+	await writeFile(join(pluginRoot, "lazycodex-install.json"), JSON.stringify({ packageName: "lazycodex-ai", version: "1.0.0" }));
+	assert.deepEqual(detectInstallFlow({ pluginRoot }), {
+		flow: "npx-local",
+		reason: "install-snapshot-present",
+	});
+});
+
+test("#given workspace tree without install snapshot #when detecting install flow #then stays npx-local", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-install-flow-workspace-"));
+	const pluginRoot = join(root, "packages", "omo-codex", "plugin");
+	await mkdir(pluginRoot, { recursive: true });
+	await writeFile(join(root, "package.json"), JSON.stringify({ name: "oh-my-opencode", version: "4.9.2" }));
+
+	assert.deepEqual(detectInstallFlow({ pluginRoot }), {
+		flow: "npx-local",
+		reason: "workspace-tree",
+	});
+});
+
+test("#given snapshot path that is not a regular file #when detecting install flow #then reports unknown", async () => {
+	const { pluginRoot } = await makeStorePluginRoot("lazycodex-install-flow-unknown-");
+	await mkdir(join(pluginRoot, "lazycodex-install.json"));
+
+	const detected = detectInstallFlow({ pluginRoot });
+
+	assert.equal(detected.flow, "unknown");
+	assert.match(detected.reason, /install-snapshot/);
+});
+
+test("#given LAZYCODEX_INSTALLED_VERSION_PATH override #when detecting install flow #then honors the override path", async () => {
+	const { root, pluginRoot } = await makeStorePluginRoot("lazycodex-install-flow-override-");
+	const overridePath = join(root, "elsewhere", "lazycodex-install.json");
+	await mkdir(join(root, "elsewhere"), { recursive: true });
+	await writeFile(overridePath, JSON.stringify({ packageName: "lazycodex-ai", version: "1.0.0" }));
+
+	assert.deepEqual(detectInstallFlow({ pluginRoot, env: { LAZYCODEX_INSTALLED_VERSION_PATH: overridePath } }), {
+		flow: "npx-local",
+		reason: "install-snapshot-present",
+	});
+});
+
 test("#given throttled updater and stale Codex config #when running check #then config migration still runs", async () => {
 	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-migration-"));
 	const statePath = join(root, "state.json");
@@ -322,3 +467,29 @@ test("#given throttled updater and stale Codex config #when running check #then
 	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
 	assert.doesNotMatch(content, /gpt-5\.2/);
 });
+
+test("#given throttled updater and no OMO SOT #when running check #then OMO SOT seed migration still runs", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-auto-update-omo-sot-"));
+	const statePath = join(root, "state.json");
+	const home = join(root, "home");
+	await writeFile(statePath, JSON.stringify({ lastCheckedAt: 99_999 }, null, 2));
+	await mkdir(join(root, "codex-home"), { recursive: true });
+
+	const result = await runAutoUpdateCheck({
+		env: {
+			CODEX_HOME: join(root, "codex-home"),
+			HOME: home,
+			CODEX_CODEGRAPH_ENABLED: "0",
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json"),
+			LAZYCODEX_AUTO_UPDATE_STATE_PATH: statePath,
+			LAZYCODEX_AUTO_UPDATE_LOG_PATH: join(root, "auto-update.log"),
+		},
+		now: 100_000,
+	});
+
+	const content = await readFile(join(home, ".omo", "config.jsonc"), "utf8");
+	assert.equal(result.started, false);
+	assert.equal(result.reason, "throttled");
+	assert.match(content, /"\[codex\]"/);
+	assert.match(content, /"\[opencode\]"/);
+});