lazycodex-ai 5.0.0-beta.8 → 5.0.0-beta.80

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);
 }

package/packages/omo-codex/plugin/test/component-hook-contract-cases.mjs

@@ -1,8 +1,62 @@
 import assert from "node:assert/strict";
 import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 
 export function componentHookContractCases(tempRoot) {
+	mkdirSync(join(tempRoot, ".omo", "evidence"), { recursive: true });
+	writeFileSync(join(tempRoot, ".omo", "evidence", "receipt.txt"), "command output PASS\n".repeat(10));
+	const spawnPayload = {
+		cwd: tempRoot, hook_event_name: "PreToolUse", model: "gpt-6-astra",
+		permission_mode: "default", session_id: "s-spawn-admission", tool_input: { message: "scan", agent_type: "explorer", fork_context: false },
+		tool_name: "spawn_agent", tool_use_id: "spawn-1", transcript_path: null, turn_id: "t-spawn",
+	};
+	const marker = join(tempRoot, "plugin-data", "spawn-breaker", "s-spawn-admission.json");
 	return [
+		{
+			name: "ulw-loop post-tool-use successful admission is silent",
+			component: "ulw-loop", event: "post-tool-use-spawn",
+			payload: { ...spawnPayload, hook_event_name: "PostToolUse", tool_response: { agent_id: "worker-1" } },
+			assertOutput(stdout) { assert.equal(stdout, ""); assert.equal(existsSync(marker), false); },
+		},
+		{
+			name: "ulw-loop post-tool-use failed admission records silently",
+			component: "ulw-loop", event: "post-tool-use-spawn",
+			payload: { ...spawnPayload, hook_event_name: "PostToolUse", tool_response: "AgentLimitReached" },
+			assertOutput(stdout) {
+				assert.equal(stdout, "");
+				const recorded = JSON.parse(readFileSync(marker, "utf8"));
+				assert.deepEqual(Object.keys(recorded).sort(), ["at", "reason"]);
+				assert.equal(recorded.reason, "AgentLimitReached");
+				assert.equal(Number.isFinite(Date.parse(recorded.at)), true);
+			},
+		},
+		{
+			name: "ulw-loop admission breaker denies without a plan",
+			component: "ulw-loop", event: "pre-tool-use-spawn", payload: spawnPayload,
+			assertOutput(stdout) {
+				const output = JSON.parse(stdout).hookSpecificOutput;
+				assert.equal(output.hookEventName, "PreToolUse");
+				assert.equal(output.permissionDecision, "deny");
+			},
+		},
+		{
+			name: "ulw-loop clean session admission is silent",
+			component: "ulw-loop", event: "pre-tool-use-spawn",
+			payload: { ...spawnPayload, session_id: "s-spawn-clean" },
+			assertOutput(stdout) { assert.equal(stdout, ""); },
+		},
+		...[
+			{ message: "scan", fork_context: false },
+			{ message: "scan", agent_type: "worker", fork_context: false },
+			{ message: "scan", fork_turns: "all", task_name: "scan" },
+		].map((tool_input, index) => ({
+			name: `ulw-loop rejects generic or unnamed role ${index}`,
+			component: "ulw-loop", event: "pre-tool-use-spawn",
+			payload: { ...spawnPayload, session_id: "s-spawn-clean", tool_input },
+			assertOutput(stdout) {
+				assert.equal(JSON.parse(stdout).hookSpecificOutput.permissionDecision, "deny");
+			},
+		})),
 		{
 			name: "rules session-start",
 			component: "rules",
@@ -202,8 +256,30 @@ export function componentHookContractCases(tempRoot) {
 			},
 		},
 		{
-			name: "start-work-continuation stop no state",
-			component: "start-work-continuation",
+			name: "lazycodex worker verifier passes receipt with nonexistent transcript",
+			component: "lazycodex-executor-verify",
+			event: "subagent-stop",
+			payload: {
+				hook_event_name: "SubagentStop",
+				agent_type: "lazycodex-worker-medium",
+				agent_id: "agent-task12",
+				session_id: "s-task12",
+				turn_id: "t-task12",
+				transcript_path: join(tempRoot, "transcript.jsonl"),
+				agent_transcript_path: join(tempRoot, "agent-transcript.jsonl"),
+				cwd: tempRoot,
+				model: "gpt-6-astra",
+				permission_mode: "default",
+				stop_hook_active: true,
+				last_assistant_message: "done\nEVIDENCE_RECORDED: .omo/evidence/receipt.txt",
+			},
+			assertOutput(stdout) {
+				assert.equal(stdout, "");
+			},
+		},
+		{
+			name: "ulw-execute-continuation stop no state",
+			component: "ulw-execute-continuation",
 			event: "stop",
 			payload: {
 				hook_event_name: "Stop",
@@ -219,5 +295,27 @@ export function componentHookContractCases(tempRoot) {
 				assert.equal(stdout, "");
 			},
 		},
+		{
+			name: "ulw-execute-continuation subagent-stop compatibility no-op",
+			component: "ulw-execute-continuation",
+			event: "subagent-stop",
+			payload: {
+				hook_event_name: "SubagentStop",
+				agent_id: "agent-task12",
+				agent_type: "lazycodex-worker-low",
+				session_id: "s-task12",
+				turn_id: "t-task12",
+				transcript_path: join(tempRoot, "transcript.jsonl"),
+				agent_transcript_path: join(tempRoot, "agent-transcript.jsonl"),
+				cwd: tempRoot,
+				model: "gpt-5.5",
+				permission_mode: "default",
+				stop_hook_active: false,
+				last_assistant_message: "done",
+			},
+			assertOutput(stdout) {
+				assert.equal(stdout, "");
+			},
+		},
 	];
 }

package/packages/omo-codex/plugin/test/hook-status-message.test.mjs

@@ -14,6 +14,7 @@ const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const repoRoot = join(root, "..", "..", "..");
 
 const AGGREGATE_EXPECTED_LABELS = new Map([
+	["hooks/post-tool-use-recording-spawn-admission.json:PostToolUse:0:0", "Recording Spawn Admission"],
 	["hooks/hooks.json:SessionStart:0:0", "Loading Project Rules"],
 	["hooks/hooks.json:SessionStart:1:0", "Recording Session Telemetry"],
 	["hooks/hooks.json:SessionStart:2:0", "Checking Auto Update"],
@@ -25,17 +26,16 @@ const AGGREGATE_EXPECTED_LABELS = new Map([
 	["hooks/hooks.json:PreToolUse:1:0", "Enforcing Unlimited Goal Budget"],
 	["hooks/hooks.json:PostToolUse:0:0", "Checking Comments"],
 	["hooks/hooks.json:PostToolUse:0:1", "Checking LSP Diagnostics"],
-	["hooks/hooks.json:PostToolUse:0:2", "Checking CodeGraph Init Guidance"],
 	["hooks/hooks.json:PostToolUse:1:0", "Matching Project Rules"],
 	["hooks/hooks.json:PostCompact:0:0", "Resetting Git Bash MCP Reminder"],
 	["hooks/hooks.json:PostCompact:1:0", "Resetting Project Rule Cache"],
 	["hooks/hooks.json:PostCompact:2:0", "Resetting LSP Diagnostics Cache"],
-	["hooks/hooks.json:Stop:0:0", "Checking Start-Work Continuation"],
-	["hooks/hooks.json:SubagentStop:0:0", "Checking Start-Work Continuation"],
-	["hooks/hooks.json:SubagentStop:1:0", "Verifying LazyCodex Executor Evidence"],
+	["hooks/hooks.json:Stop:0:0", "Checking Ulw-Execute Continuation"],
+	["hooks/hooks.json:SubagentStop:0:0", "Verifying LazyCodex Executor Evidence"],
 ]);
 
 const COMPONENT_EXPECTED_LABELS = new Map([
+	["components/ulw-loop/hooks/hooks.json:PostToolUse:0:0", "Recording Spawn Admission"],
 	["components/comment-checker/hooks/hooks.json:PostToolUse:0:0", "Checking Comments"],
 	["components/lsp/hooks/hooks.json:PostToolUse:0:0", "Checking LSP Diagnostics"],
 	["components/lsp/hooks/hooks.json:PostCompact:0:0", "Resetting LSP Diagnostics Cache"],
@@ -47,8 +47,7 @@ const COMPONENT_EXPECTED_LABELS = new Map([
 	["components/ultrawork/hooks/hooks.json:UserPromptSubmit:0:0", "Checking Ultrawork Trigger"],
 	["components/ulw-loop/hooks/hooks.json:UserPromptSubmit:0:0", "Checking Ulw-Loop Steering"],
 	["components/ulw-loop/hooks/hooks.json:PreToolUse:0:0", "Enforcing Unlimited Ulw-Loop Budget"],
-	["components/start-work-continuation/hooks/hooks.json:Stop:0:0", "Checking Start-Work Continuation"],
-	["components/start-work-continuation/hooks/hooks.json:SubagentStop:0:0", "Checking Start-Work Continuation"],
+	["components/ulw-execute-continuation/hooks/hooks.json:Stop:0:0", "Checking Ulw-Execute Continuation"],
 	[
 		"components/lazycodex-executor-verify/hooks/hooks.json:SubagentStop:0:0",
 		"Verifying LazyCodex Executor Evidence",

package/packages/omo-codex/plugin/test/lcx-contribute-bug-fix-template.test.mjs

@@ -8,7 +8,7 @@ import { fileURLToPath } from "node:url";
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const scriptPath = join(root, "skills", "lcx-contribute-bug-fix", "scripts", "create-pr-body.mjs");
 
-test("#given complete bug-fix evidence #when creating a PR body #then required LazyCodex sections and label are emitted", async () => {
+test("#given complete bug-fix evidence #when creating a PR body #then evidence and machine label are emitted", async () => {
 	// given
 	const { createLazyCodexBugFixPrBody } = await import(`file://${scriptPath}`);
 	const input = {
@@ -27,15 +27,11 @@ test("#given complete bug-fix evidence #when creating a PR body #then required L
 	const body = createLazyCodexBugFixPrBody(input);
 
 	// then
-	assert.match(body, /^## Problem Situation/m);
-	assert.match(body, /## Reproduction Logs/);
-	assert.match(body, /## Approach/);
-	assert.match(body, /## Why I Am Confident/);
-	assert.match(body, /## Risks/);
-	assert.match(body, /## User-Visible Behavior Changes/);
-	assert.match(body, /## Verification/);
-	assert.match(body, /lazycodex-generated/);
-	assert.match(body, /This PR was debugged, implemented, and created with \[LazyCodex\]/);
+	for (const field of ["problem", "reproductionLogs", "approach", "confidence", "risks", "userVisibleBehaviorChanges"]) {
+		assert.ok(body.includes(input[field]));
+	}
+	for (const command of input.verification) assert.ok(body.includes(command));
+	assert.match(body, /^Tag: lazycodex-generated$/m);
 });
 
 test("#given missing bug-fix evidence #when creating a PR body #then the script rejects the incomplete payload", async () => {
@@ -57,7 +53,7 @@ test("#given missing bug-fix evidence #when creating a PR body #then the script
 		});
 
 	// then
-	assert.throws(action, /reproductionLogs must be a non-empty string/);
+	assert.throws(action, /reproductionLogs/);
 });
 
 test("#given a JSON payload path #when running the PR body script #then markdown is written to the requested file", async () => {
@@ -65,27 +61,25 @@ test("#given a JSON payload path #when running the PR body script #then markdown
 	const workspace = await mkdtemp(join(tmpdir(), "lcx-pr-body-test-"));
 	const inputPath = join(workspace, "input.json");
 	const outputPath = join(workspace, "body.md");
-	await writeFile(
-		inputPath,
-		JSON.stringify({
-			title: "Fix Codex skill sync drift",
-			targetRepository: "code-yeongyu/lazycodex",
-			problem: "Skill sync omitted a shared skill from the aggregate plugin.",
-			reproductionLogs: "node --test failed before the fix.",
-			approach: "Add the missing shared skill source and sync the aggregate plugin.",
-			confidence: "The failing sync test now passes.",
-			risks: "Low risk.",
-			userVisibleBehaviorChanges: "Users get a direct bug-fix PR skill.",
-			verification: ["node --test test/lcx-contribute-bug-fix-template.test.mjs"],
-		}),
-		"utf8",
-	);
+	const input = {
+		title: "Fix Codex skill sync drift",
+		targetRepository: "code-yeongyu/lazycodex",
+		problem: "Skill sync omitted a shared skill from the aggregate plugin.",
+		reproductionLogs: "node --test failed before the fix.",
+		approach: "Add the missing shared skill source and sync the aggregate plugin.",
+		confidence: "The failing sync test now passes.",
+		risks: "Low risk.",
+		userVisibleBehaviorChanges: "Users get a direct bug-fix PR skill.",
+		verification: ["node --test test/lcx-contribute-bug-fix-template.test.mjs"],
+	};
+	await writeFile(inputPath, JSON.stringify(input), "utf8");
 
 	// when
 	const { spawnSync } = await import("node:child_process");
+	const { createLazyCodexBugFixPrBody } = await import(`file://${scriptPath}`);
 	const result = spawnSync(process.execPath, [scriptPath, inputPath, outputPath], { encoding: "utf8" });
 
 	// then
 	assert.equal(result.status, 0, result.stderr);
-	assert.match(await readFile(outputPath, "utf8"), /## User-Visible Behavior Changes/);
+	assert.equal(await readFile(outputPath, "utf8"), createLazyCodexBugFixPrBody(input));
 });

package/packages/omo-codex/plugin/test/mcp-research-servers.test.mjs

@@ -14,11 +14,9 @@ test("#given aggregate MCP config #when inspected #then registers research MCPs
 	const serverNames = Object.keys(mcp.mcpServers).sort();
 
 	// then
-	assert.deepEqual(serverNames, ["codegraph", "context7", "git_bash", "grep_app", "lsp"]);
+	assert.deepEqual(serverNames, ["context7", "git_bash", "grep_app", "lsp"]);
 	assert.equal(mcp.mcpServers.grep_app.url, "https://mcp.grep.app");
 	assert.equal(mcp.mcpServers.context7.url, "https://mcp.context7.com/mcp");
 	assert.equal(Object.hasOwn(mcp.mcpServers, "ast_grep"), false);
-	assert.deepEqual(mcp.mcpServers.codegraph.args, ["components/codegraph/dist/serve.js"]);
-	assert.equal(mcp.mcpServers.codegraph.required, false);
 	assert.equal(mcp.mcpServers.lsp.startup_timeout_sec, 10);
 });