lazycodex-ai 5.0.0-beta.9 → 5.0.0

package/packages/omo-codex/plugin/test/AGENTS.md

@@ -0,0 +1,47 @@
+# test — aggregate plugin contract suite (node:test)
+
+**Score 14** (53 files, ~9.7k LOC; distinct domain: black-box contract checking over generated artifacts).
+
+## OVERVIEW
+
+51 `*.test.mjs` suites + `index.js` loader asserting contracts over GENERATED/INSTALLED artifacts — manifests, aggregate hook JSON, built CLIs, synced skills — not over component sources. Runs via `npm test` from `plugin/` after `npm run build`; also the tail of repo-root `bun run test:codex`.
+
+## KEY FILES
+
+| File | Role |
+|------|------|
+| `index.js` | Suite loader: sorted dynamic import of every `*.test.mjs` |
+| `aggregate-plugin-fixture.mjs` | Shared fixture API: manifest readers, hook collectors, structural `spawn_agent` scanning (balanced call/token shapes — never prose grep) |
+| `sync-skills-test-support.mjs` | Skill inventory + exact-content assertions (`assertPackagedContentMatches`, `CONTEXT_PRESSURE_SKILL_BUDGET_BYTES`, `expectedSkills`) |
+| `component-hook-contract-cases.mjs` | Shared per-component hook contract cases |
+| `teammode-safety-fixture.mjs` | Teammode safety fixture |
+
+## WHERE TO LOOK
+
+| Family | Suites |
+|--------|--------|
+| Aggregate wiring | `aggregate-{manifest,hooks,build,mcp,agents,model-catalog}.test.mjs` |
+| Bootstrap | `bootstrap-{hooks,setup,binlinks,orchestration,ps-guard}.test.mjs` |
+| Update flow | `auto-update{,-state-persistence,-restart-notice,-release-notes}.test.mjs` |
+| Migration | `migrate-codex-config.test.mjs` (1,242 LOC — densest), `multi-agent-v2-regression`, `subagent-limit-migration` |
+| Skills sync | `sync-skills{,-codex-compatibility}.test.mjs`, `ulw-plan`/`ulw-research`/`ulw-loop` skill contracts |
+| Teammode | `teammode-{transport,communication,worktree,safety,thread-links,thread-title,archive-ambiguity}.test.mjs` |
+| Component CLIs | `component-{bundled-cli,bin-names}.test.mjs`, `lsp-prebuild-layouts` |
+
+## CONVENTIONS
+
+- `node:test` + `node:assert/strict`, ESM, test names in `#given ... #when ... #then` form.
+- Idempotence asserted with byte equality; skill copies checked for hand-authored drift.
+- Paths resolve from `import.meta.url`; temp roots isolated per test; subprocesses via `process.execPath`, never a shell assumption.
+- Windows behavior explicit: `.cmd` shims, `commandWindows`, PowerShell 5.1/TLS/ASCII constraints.
+
+## ANTI-PATTERNS
+
+- Structural checks must parse balanced shapes; never trust prose text.
+- Hooks must fail closed/silent on malformed input; migration must not mutate user-owned settings or change bytes on repeat runs.
+- Never assert prompt/skill prose wording — machine-consumed fields and shipped-copy equality only.
+
+## COMMANDS
+
+- `npm test` (from `plugin/`, after `npm run build`)
+- `node --test packages/omo-codex/plugin/test/<file>.test.mjs` (single suite; `--test-name-pattern` filters)

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

@@ -22,18 +22,18 @@ const agentSchemaKeys = new Set([
 // -manual-qa.md are the artifact names the ulw-loop spawn guard requires before a gate-reviewer
 // spawn; currentAttemptDir is a field of `ulw-loop status --json`.
 const lazycodexAgentInvariants = new Map([
-	["explorer.toml", { model: "gpt-5.6-luna", effort: "low" }],
-	["librarian.toml", { model: "gpt-5.6-luna", effort: "low" }],
-	["metis.toml", { model: "gpt-5.6-sol", effort: "high" }],
-	["momus.toml", { model: "gpt-5.6-terra", effort: "high" }],
-	["plan.toml", { model: "gpt-5.6-sol", effort: "high" }],
-	["lazycodex-worker-low.toml", { model: "gpt-5.6-luna", effort: "high", includes: [/EVIDENCE_RECORDED: <path>/] }],
-	["lazycodex-worker-medium.toml", { model: "gpt-5.6-terra", effort: "high", includes: [/EVIDENCE_RECORDED: <path>/] }],
-	["lazycodex-worker-high.toml", { model: "gpt-5.6-sol", effort: "medium", includes: [/EVIDENCE_RECORDED: <path>/] }],
-	["lazycodex-clone-fidelity-reviewer.toml", { model: "gpt-5.6-terra", effort: "high", includes: [/recommendation/, /blockers/] }],
-	["lazycodex-code-reviewer.toml", { model: "gpt-5.6-terra", effort: "medium", includes: [/codeQualityStatus/, /recommendation/, /<attemptDir>\/<goalId>-code-review\.md/, /currentAttemptDir/] }],
-	["lazycodex-qa-executor.toml", { model: "gpt-5.6-luna", effort: "high", includes: [/not_applicable/, /surfaceEvidence/, /adversarialCases/, /<attemptDir>\/<goalId>-manual-qa\.md/] }],
-	["lazycodex-gate-reviewer.toml", { model: "gpt-5.6-sol", effort: "low", includes: [/blockers/, /currentAttemptDir/] }],
+	["explorer.toml", { model: "gpt-6-astra", effort: "low" }],
+	["librarian.toml", { model: "gpt-6-astra", effort: "low" }],
+	["metis.toml", { model: "gpt-6-astra", effort: "high" }],
+	["momus.toml", { model: "gpt-6-astra", effort: "high" }],
+	["plan.toml", { model: "gpt-6-astra", effort: "high" }],
+	["lazycodex-worker-low.toml", { model: "gpt-6-astra", effort: "high", includes: [/EVIDENCE_RECORDED: <path>/] }],
+	["lazycodex-worker-medium.toml", { model: "gpt-6-astra", effort: "high", includes: [/EVIDENCE_RECORDED: <path>/] }],
+	["lazycodex-worker-high.toml", { model: "gpt-6-astra", effort: "medium", includes: [/EVIDENCE_RECORDED: <path>/] }],
+	["lazycodex-clone-fidelity-reviewer.toml", { model: "gpt-6-astra", effort: "high", includes: [/recommendation/, /blockers/] }],
+	["lazycodex-code-reviewer.toml", { model: "gpt-6-astra", effort: "medium", includes: [/codeQualityStatus/, /recommendation/, /<attemptDir>\/<goalId>-code-review\.md/, /currentAttemptDir/] }],
+	["lazycodex-qa-executor.toml", { model: "gpt-6-astra", effort: "high", includes: [/not_applicable/, /surfaceEvidence/, /adversarialCases/, /<attemptDir>\/<goalId>-manual-qa\.md/] }],
+	["lazycodex-gate-reviewer.toml", { model: "gpt-6-astra", effort: "low", includes: [/blockers/, /currentAttemptDir/] }],
 ]);
 
 const externalSourceTokenPattern = new RegExp(

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

@@ -30,9 +30,8 @@ test("#given isolated components #when hooks are inspected #then commands stay i
 	const componentMarkers = [
 		"components/comment-checker/dist/cli.js",
 		"components/lsp/dist/cli.js",
-		"components/codegraph/dist/cli.js",
 		"components/rules/dist/cli.js",
-		"components/start-work-continuation/dist/cli.js",
+		"components/ulw-execute-continuation/dist/cli.js",
 		"components/telemetry/dist/cli.js",
 		"components/teammode/dist/cli.js",
 		"components/ulw-loop/dist/cli.js",
@@ -48,7 +47,7 @@ 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 Stop hooks #when inspected #then start-work continuation and ulw-loop resume are separate groups", async () => {
+test("#given aggregate Stop hooks #when inspected #then ulw-execute continuation and ulw-loop resume are separate groups", async () => {
 	// given
 	const manifests = await readAggregateHookManifests();
 
@@ -60,11 +59,11 @@ test("#given aggregate Stop hooks #when inspected #then start-work continuation
 
 	// then
 	assert.equal(stopCommands.length, 2);
-	assert.ok(stopCommands.some((command) => command.includes("start-work-continuation/dist/cli.js")));
+	assert.ok(stopCommands.some((command) => command.includes("ulw-execute-continuation/dist/cli.js")));
 	assert.ok(stopCommands.some((command) => command.includes("ulw-loop/dist/cli.js\" hook stop")));
 });
 
-test("#given aggregate SubagentStop hooks #when inspected #then start-work and LazyCodex executor verifier are separate groups", async () => {
+test("#given aggregate SubagentStop hooks #when inspected #then only LazyCodex executor verification remains", async () => {
 	// given
 	const manifests = await readAggregateHookManifests();
 
@@ -78,9 +77,8 @@ test("#given aggregate SubagentStop hooks #when inspected #then start-work and L
 	);
 
 	// then
-	assert.equal(subagentStopGroups.length, 2);
-	assert.equal(subagentStopGroups[0]?.matcher, undefined);
-	assert.equal(subagentStopGroups[1]?.matcher, "^lazycodex-worker-(low|medium|high)$");
+	assert.equal(subagentStopGroups.length, 1);
+	assert.equal(subagentStopGroups[0]?.matcher, "^lazycodex-worker-(low|medium|high)$");
 	assert.equal(verifierGroups.length, 1);
 	assert.equal(verifierGroups[0]?.groupIndex, 0);
 	assert.equal(verifierGroups[0]?.handler.timeout, 10);
@@ -161,6 +159,11 @@ test("#given aggregate OMO plugin is enabled #when hooks are inspected #then she
 		"^(spawn_agent|collaborationspawn_agent|collaboration\\.spawn_agent)$",
 	]);
 	assert.match(text, /hook pre-tool-use-spawn/);
+	const admissionGroups = manifests.flatMap(({ hooks }) => hooks.hooks.PostToolUse ?? [])
+		.filter((group) => group.hooks.some((hook) => hook.command.endsWith(" hook post-tool-use-spawn")));
+	assert.equal(admissionGroups.length, 1);
+	assert.equal(admissionGroups[0].matcher, preToolUseGroups[2].matcher);
+	assert.match(admissionGroups[0].hooks[0].commandWindows, /hook post-tool-use-spawn$/);
 });
 
 test("#given aggregate OMO plugin has a dedicated ultrawork trigger #when hooks are inspected #then ulw-loop does not duplicate ultrawork injection", async () => {
@@ -220,34 +223,16 @@ test("#given aggregate SessionStart hooks #when inspected #then cold-start-prone
 	const coldStartHooks = sessionStartHooks.filter(
 		({ command }) =>
 			command.includes("components/telemetry/dist/cli.js") ||
-			command.includes("scripts/auto-update.mjs") ||
-			command.includes("components/codegraph/dist/cli.js"),
+			command.includes("scripts/auto-update.mjs"),
 	);
 
 	// then
-	assert.equal(coldStartHooks.length, 3);
+	assert.equal(coldStartHooks.length, 2);
 	for (const hook of coldStartHooks) {
 		assert.equal(hook.timeout, 15, `${hook.source} must carry timeout 15 for cold-start headroom`);
 	}
 });
 
-test("#given aggregate PostToolUse hooks #when inspected #then CodeGraph init guidance is registered for CodeGraph tools", async () => {
-	// given
-	const commandHooks = await readAggregateCommandHooks();
-
-	// when
-	const codegraphPostToolUseHooks = commandHooks.filter(
-		(hook) =>
-			hook.eventName === "PostToolUse" &&
-			hook.handler.command === 'node "${PLUGIN_ROOT}/components/codegraph/dist/cli.js" hook post-tool-use',
-	);
-
-	// then
-	assert.equal(codegraphPostToolUseHooks.length, 1);
-	assert.equal(codegraphPostToolUseHooks[0]?.matcher, "^(codegraph[._].*|mcp__codegraph__.*)$");
-	assert.match(codegraphPostToolUseHooks[0]?.handler.statusMessage ?? "", /\S/);
-});
-
 test("#given aggregate PostToolUse hooks #when inspected #then thread title hygiene is registered for created Codex threads", async () => {
 	// given
 	const commandHooks = await readAggregateCommandHooks();

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

@@ -17,7 +17,7 @@ test("#given aggregate plugin manifest #when inspected #then it owns the omo nam
 	// then
 	assert.equal(manifest.name, "omo");
 	assert(Array.isArray(hookPaths));
-	assert.equal(hookPaths.length, 23);
+	assert.equal(hookPaths.length, 21);
 	assert(hookPaths.every((hookPath) => typeof hookPath === "string" && hookPath.startsWith("./hooks/")));
 	assert(!hookPaths.includes("./hooks/hooks.json"));
 	assert(!hookPaths.includes("./hooks/user-prompt-submit-selecting-lazycodex-workflow.json"));
@@ -54,16 +54,15 @@ 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",
 		"teammode",
 		"telemetry",
 		"ultrawork",
+		"ulw-execute-continuation",
 		"ulw-loop",
 	]);
 	for (const name of componentNames) {

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

@@ -18,14 +18,13 @@ test("#given aggregate MCP config #when inspected #then code MCPs reference pack
 	// when
 	const lspServer = mcp.mcpServers.lsp;
 	const gitBashServer = mcp.mcpServers.git_bash;
-	const codegraphServer = mcp.mcpServers.codegraph;
 	const codeMcpNames = Object.keys(mcp.mcpServers)
-		.filter((name) => name === "lsp" || name === "git_bash" || name === "codegraph")
+		.filter((name) => name === "lsp" || name === "git_bash")
 		.sort();
 	const componentLocalMcpSources = lspSources.filter((name) => name.startsWith("lazy-mcp") || name === "lazy-lsp-mcp.ts");
 
 	// then
-	assert.deepEqual(codeMcpNames, ["codegraph", "git_bash", "lsp"]);
+	assert.deepEqual(codeMcpNames, ["git_bash", "lsp"]);
 	assert.equal(packageJson.workspaces.includes("components/lsp/packages/lsp-tools-mcp"), false);
 	assert.deepEqual(packageJson.dependencies, { "@oh-my-opencode/shared-skills": "file:../../shared-skills" });
 	assert.doesNotMatch(bundledMcpBuildScript, new RegExp(["ast", "grep", "mcp"].join("-")));
@@ -38,10 +37,6 @@ test("#given aggregate MCP config #when inspected #then code MCPs reference pack
 	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, []);
 });
 

package/packages/omo-codex/plugin/test/aggregate-model-catalog.test.mjs

@@ -8,19 +8,29 @@ import { root } from "./aggregate-plugin-fixture.mjs";
 test("#given bundled model catalog #when inspected #then default verifier and worker roles are pinned", async () => {
 	const catalog = JSON.parse(await readFile(join(root, "model-catalog.json"), "utf8"));
 
-	assert.equal(catalog.current.model, "gpt-5.6-sol");
-	assert.equal(catalog.current.model_context_window, 372000);
+	assert.equal(catalog.version, "2026-09-08.gpt-6-astra-600k-high");
+	assert.equal(catalog.current.model, "gpt-6-astra");
+	assert.equal(catalog.current.model_context_window, 600000);
 	assert.equal(catalog.current.model_reasoning_effort, "high");
 	assert.equal(catalog.current.plan_mode_reasoning_effort, "xhigh");
 	assert.deepEqual(catalog.roles.default, catalog.current);
 	assert.deepEqual(catalog.roles.verifier, {
-		model: "gpt-5.6-sol",
+		model: "gpt-6-astra",
 		model_reasoning_effort: "high",
 	});
 	assert.deepEqual(catalog.roles.worker, {
-		model: "gpt-5.6-sol",
+		model: "gpt-6-astra",
 		model_reasoning_effort: "high",
 	});
+	assert.deepEqual(catalog.managedProfiles.at(-1), {
+		version: "legacy.gpt-5.6-sol-650k-high",
+		match: {
+			model: "gpt-5.6-sol",
+			model_context_window: 650000,
+			model_reasoning_effort: "high",
+			plan_mode_reasoning_effort: "xhigh",
+		},
+	});
 });
 
 test("#given bundled model catalog #when inspected #then no role or managed preset uses pure GPT-5.4", async () => {

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

@@ -225,7 +225,7 @@ test("#given test command override #when running check #then records state and l
 			toVersion: "1.0.1",
 		},
 	]);
-	assert.match(await readFile(join(env.CODEX_HOME, "config.toml"), "utf8"), /model = "gpt-5\.6-sol"/);
+	assert.match(await readFile(join(env.CODEX_HOME, "config.toml"), "utf8"), /model = "gpt-6-astra"/);
 });
 
 test("#given failed waited update #when retry window passes #then next update is not blocked by success throttle", async () => {
@@ -279,7 +279,7 @@ test("#given active lock #when running check #then skips concurrent update", asy
 
 	assert.equal(result.started, false);
 	assert.equal(result.reason, "locked");
-	assert.match(await readFile(join(root, "codex-home", "config.toml"), "utf8"), /model_context_window = 372000/);
+	assert.match(await readFile(join(root, "codex-home", "config.toml"), "utf8"), /model_context_window = 600000/);
 });
 
 test("#given stale lock #when running check #then removes lock and runs update", async () => {
@@ -645,35 +645,10 @@ test("#given throttled updater and stale Codex config #when running check #then
 	const content = await readFile(join(codexHome, "config.toml"), "utf8");
 	assert.equal(result.started, false);
 	assert.equal(result.reason, "throttled");
-	assert.match(content, /model = "gpt-5\.6-sol"/);
-	assert.match(content, /model_context_window = 372000/);
+	assert.match(content, /model = "gpt-6-astra"/);
+	assert.match(content, /model_context_window = 600000/);
 	assert.match(content, /model_reasoning_effort = "high"/);
 	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\]"/);
-});

package/packages/omo-codex/plugin/test/bootstrap-default-role.test.mjs

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { runWorkerSetup } from "../components/bootstrap/dist/cli.js";
+
+async function fixture(run) {
+	const root = await mkdtemp(join(tmpdir(), "bootstrap-default-"));
+	try {
+		const pluginRoot = join(root, "plugin");
+		const codexHome = join(root, "codex");
+		const pluginData = join(root, "data");
+		const agents = join(pluginRoot, "components", "ultrawork", "agents");
+		await mkdir(agents, { recursive: true });
+		await mkdir(join(pluginRoot, "dist", "cli"), { recursive: true });
+		await mkdir(join(root, ".omo"), { recursive: true });
+		await mkdir(join(codexHome, "agents"), { recursive: true });
+		await writeFile(join(pluginRoot, "dist", "cli", "index.js"), "");
+		await writeFile(join(agents, "lazycodex-worker-medium.toml"), 'name = "lazycodex-worker-medium"\nmodel = "qa-model"\ndeveloper_instructions = "qa worker"\n');
+		await run({ root, codexHome, pluginRoot, pluginData, platform: "darwin", env: { HOME: root, USERPROFILE: root }, target: join(codexHome, "agents", "default.toml") });
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+}
+
+test("#given a bundled worker #when bootstrap repeats #then default registration and bytes are stable", async () => {
+	await fixture(async (input) => {
+		await runWorkerSetup(input);
+		const content = await readFile(input.target, "utf8");
+		assert.match(content, /^name = "default"$/m);
+		assert.match(content, /^model = "qa-model"$/m);
+		const config = await readFile(join(input.codexHome, "config.toml"), "utf8");
+		assert.match(config, /\[agents\.default\]\nconfig_file = "\.\/agents\/default\.toml"/);
+		await runWorkerSetup(input);
+		assert.equal(await readFile(input.target, "utf8"), content);
+		assert.equal(await readFile(join(input.codexHome, "config.toml"), "utf8"), config);
+	});
+});
+
+test("#given unified default.disable #when bootstrap runs #then fresh and previously managed defaults are absent", async () => {
+	await fixture(async (input) => {
+		const configPath = join(input.root, ".omo", "omo.jsonc");
+		const disabled = JSON.stringify({ "[codex]": { agents: { default: { disable: true } } } });
+		await writeFile(configPath, disabled);
+		await runWorkerSetup(input);
+		await assert.rejects(readFile(input.target), { code: "ENOENT" });
+		await writeFile(configPath, "{}");
+		await runWorkerSetup(input);
+		assert.match(await readFile(input.target, "utf8"), /^name = "default"$/m);
+		await writeFile(configPath, disabled);
+		await runWorkerSetup(input);
+		await assert.rejects(readFile(input.target), { code: "ENOENT" });
+		assert.doesNotMatch(await readFile(join(input.codexHome, "config.toml"), "utf8"), /\[agents\.default\]/);
+	});
+});
+
+test("#given a user default #when bootstrap runs #then it is preserved and degradation is visible", async () => {
+	await fixture(async (input) => {
+		const custom = 'name = "default"\nmodel = "custom"\n';
+		await writeFile(input.target, custom);
+		const outcome = await runWorkerSetup(input);
+		assert.ok(outcome.degraded.some((entry) => entry.component === "agents"));
+		assert.equal(await readFile(input.target, "utf8"), custom);
+	});
+});

package/packages/omo-codex/plugin/test/bootstrap-setup.test.mjs

@@ -168,37 +168,6 @@ test("#given a config.toml with no pre-existing agent entries #when the worker s
 	});
 });
 
-test("#given a package-relative CodeGraph MCP path #when worker setup runs #then the path is stamped absolute", async () => {
-	await withSetupFixture(async (fixture) => {
-		await writeFile(
-			join(fixture.pluginRoot, ".mcp.json"),
-			`${JSON.stringify(
-				{
-					mcpServers: {
-						codegraph: {
-							args: ["components/codegraph/dist/serve.js"],
-							command: "node",
-							cwd: ".",
-							required: false,
-						},
-						git_bash: { args: ["serve"], command: "node", env: {} },
-					},
-				},
-				null,
-				"\t",
-			)}\n`,
-		);
-
-		await runWorkerSetup(setupOptions(fixture));
-
-		const manifest = JSON.parse(await readFile(join(fixture.pluginRoot, ".mcp.json"), "utf8"));
-		assert.deepEqual(manifest.mcpServers.codegraph.args, [
-			join(fixture.pluginRoot, "components", "codegraph", "dist", "serve.js"),
-		]);
-		assert.equal(manifest.mcpServers.codegraph.cwd, ".");
-	});
-});
-
 test("#given bootstrap-managed staging #when agents are linked #then nothing is persisted under PLUGIN_ROOT", async () => {
 	await withSetupFixture(async (fixture) => {
 		await runWorkerSetup(setupOptions(fixture));

package/packages/omo-codex/plugin/test/canonical-ultrawork-directive.test.mjs

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+	canonicalUltraworkDirectiveRelativePath,
+	resolveCanonicalUltraworkDirectivePath,
+} from "../scripts/canonical-ultrawork-directive.mjs";
+
+test("#given a repo checkout #when resolving the ultrawork directive #then the checkout copy wins over a plugin-internal copy", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-canonical-prompt-"));
+	const pluginRoot = join(root, "plugin");
+	const repoRoot = join(root, "checkout");
+	const checkoutPrompt = join(repoRoot, canonicalUltraworkDirectiveRelativePath);
+	const pluginPrompt = join(pluginRoot, canonicalUltraworkDirectiveRelativePath);
+	await mkdir(join(checkoutPrompt, ".."), { recursive: true });
+	await mkdir(join(pluginPrompt, ".."), { recursive: true });
+	await writeFile(checkoutPrompt, "checkout");
+	await writeFile(pluginPrompt, "staged");
+
+	try {
+		// when
+		const resolved = resolveCanonicalUltraworkDirectivePath(pluginRoot, repoRoot);
+
+		// then
+		assert.equal(resolved, checkoutPrompt);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});
+
+test("#given the flattened plugin cache #when the repo-relative directive is absent #then the plugin-internal copy is resolved", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-canonical-prompt-"));
+	const pluginRoot = join(root, "plugins", "cache", "sisyphuslabs", "omo", "0.1.0");
+	const repoRoot = join(pluginRoot, "..", "..", "..");
+	const pluginPrompt = join(pluginRoot, canonicalUltraworkDirectiveRelativePath);
+	await mkdir(join(pluginPrompt, ".."), { recursive: true });
+	await writeFile(pluginPrompt, "staged");
+
+	try {
+		// when
+		const resolved = resolveCanonicalUltraworkDirectivePath(pluginRoot, repoRoot);
+
+		// then
+		assert.equal(resolved, pluginPrompt);
+	} finally {
+		await rm(root, { recursive: true, force: true });
+	}
+});

package/packages/omo-codex/plugin/test/component-bin-names.test.mjs

@@ -10,9 +10,9 @@ const EXPECTED_COMPONENT_BINS = new Map([
 	["comment-checker", ["omo-comment-checker"]],
 	["lsp", ["omo-lsp"]],
 	["rules", ["omo-rules"]],
-	["start-work-continuation", ["omo-start-work-continuation"]],
 	["telemetry", ["omo-telemetry"]],
 	["ultrawork", ["omo-ultrawork"]],
+	["ulw-execute-continuation", ["omo-ulw-execute-continuation"]],
 	["ulw-loop", ["omo-ulw-loop", "ulw", "ulw-loop"]],
 ]);
 
@@ -20,9 +20,9 @@ const EXPECTED_USAGE_PREFIXES = new Map([
 	["comment-checker", "Usage: omo-comment-checker "],
 	["lsp", "Usage: omo-lsp "],
 	["rules", "Usage: omo-rules "],
-	["start-work-continuation", "Usage: omo-start-work-continuation "],
 	["telemetry", "Usage: omo-telemetry "],
 	["ultrawork", "Usage: omo-ultrawork "],
+	["ulw-execute-continuation", "Usage: omo-ulw-execute-continuation "],
 ]);
 
 async function readJson(relativePath) {

package/packages/omo-codex/plugin/test/component-bundled-cli.test.mjs

@@ -1,6 +1,5 @@
 import assert from "node:assert/strict";
 import {
-	chmodSync,
 	cpSync,
 	existsSync,
 	mkdirSync,
@@ -25,13 +24,12 @@ const HOOK_EVENTS_BY_COMPONENT = {
 	"lazycodex-executor-verify": "subagent-stop",
 	lsp: "post-compact",
 	rules: "session-start",
-	"start-work-continuation": "stop",
+	"ulw-execute-continuation": "stop",
 	telemetry: "session-start",
 	teammode: "post-tool-use",
 	ultrawork: "user-prompt-submit",
 	"ulw-loop": "pre-tool-use",
 };
-const MCP_ONLY_COMPONENTS = new Set(["codegraph"]);
 const HOOK_CLI_TEST_TIMEOUT_MS = 45_000;
 const DAEMON_EXIT_TIMEOUT_MS = 5_000;
 
@@ -84,38 +82,6 @@ test("#given built workspace component CLIs #when dynamically imported with hook
 	assert.deepEqual(failures, []);
 });
 
-test("#given built MCP-only CodeGraph entries #when executed with a fake binary #then each entry is self-contained", () => {
-	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-mcp-wrapper-"));
-	try {
-		const fakeBinaryPath = join(tempRoot, "codegraph-fake.cjs");
-		const invocationLogPath = join(tempRoot, "invocations.log");
-		writeFileSync(
-			fakeBinaryPath,
-			[
-				"#!/usr/bin/env node",
-				"const fs = require('node:fs');",
-				"fs.appendFileSync(process.env.CODEGRAPH_FAKE_LOG, JSON.stringify(process.argv.slice(2)) + '\\n');",
-				"",
-			].join("\n"),
-		);
-		chmodSync(fakeBinaryPath, 0o755);
-
-		const serveResult = runCodegraphMcpEntry("serve.js", tempRoot, fakeBinaryPath, invocationLogPath);
-		const cliResult = runCodegraphMcpEntry("cli.js", tempRoot, fakeBinaryPath, invocationLogPath);
-
-		assert.equal(serveResult.status, 0, `serve.js stderr: ${serveResult.stderr}`);
-		assert.equal(cliResult.status, 0, `cli.js stderr: ${cliResult.stderr}`);
-		assert.equal(serveResult.stderr, "");
-		assert.equal(cliResult.stderr, "");
-		assert.deepEqual(readFileSync(invocationLogPath, "utf8").trim().split("\n"), [
-			'["serve","--mcp"]',
-			'["serve","--mcp"]',
-		]);
-	} finally {
-		rmSync(tempRoot, { recursive: true, force: true });
-	}
-});
-
 test("#given representative component hook payloads #when executed through dist CLI contract #then current hook behavior is preserved", async () => {
 	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-cli-contract-"));
 	try {
@@ -264,7 +230,6 @@ test("#given aggregate hook manifest #when command hooks are inspected #then com
 	// when
 	const missingContracts = components.filter(
 		(component) =>
-			!MCP_ONLY_COMPONENTS.has(component) &&
 			!commands.some((command) =>
 				command.startsWith(`node "\${PLUGIN_ROOT}/components/${component}/dist/cli.js" hook `),
 			),
@@ -279,7 +244,6 @@ async function workspaceComponents() {
 	return packageJson.workspaces
 		.filter((workspace) => workspace.startsWith("components/"))
 		.map((workspace) => workspace.slice("components/".length))
-		.filter((component) => !MCP_ONLY_COMPONENTS.has(component))
 		.sort();
 }
 
@@ -306,20 +270,6 @@ function componentCliPath(component) {
 	return join(root, "components", component, "dist", "cli.js");
 }
 
-function runCodegraphMcpEntry(entryName, tempRoot, fakeBinaryPath, invocationLogPath) {
-	return spawnSync(process.execPath, [join(root, "components", "codegraph", "dist", entryName)], {
-		cwd: root,
-		encoding: "utf8",
-		env: {
-			...process.env,
-			CODEGRAPH_FAKE_LOG: invocationLogPath,
-			HOME: tempRoot,
-			OMO_CODEGRAPH_BIN: fakeBinaryPath,
-		},
-		timeout: HOOK_CLI_TEST_TIMEOUT_MS,
-	});
-}
-
 function runHookCli(component, event, payload, tempRoot, extraEnv = {}) {
 	return runHookCliAsync(component, event, `${JSON.stringify(payload)}\n`, tempRoot, extraEnv);
 }