oh-my-opencode 4.13.0 → 4.14.1

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

@@ -1,20 +1,27 @@
 import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
 import { lstat, mkdir, mkdtemp, readdir, readFile, readlink, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, sep } from "node:path";
+import { dirname, join, sep } from "node:path";
 import test from "node:test";
+import { promisify } from "node:util";
 
 const CLI_URL = new URL("../components/bootstrap/dist/cli.js", import.meta.url);
 const { runBootstrapWorker, runWorkerSetup } = await import(CLI_URL.href);
 
 const MARKETPLACE_SOURCE_LINE = 'source = "https://github.com/code-yeongyu/lazycodex.git"';
 const COMPONENT_BIN_NAME = "omo-toolbox";
+const execFileAsync = promisify(execFile);
 const OMO_CLI_DEGRADED_ENTRY = {
 	component: "omo-cli",
 	hint: "use npx lazycodex-ai for the omo CLI",
 	reason: "marketplace payload has no dist/cli",
 };
 
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 async function withBinLinkFixture(run) {
 	const root = await mkdtemp(join(tmpdir(), "omo-bootstrap-binlinks-"));
 	try {
@@ -33,7 +40,7 @@ async function withBinLinkFixture(run) {
 // Mirrors the Codex marketplace store layout: each plugin version is installed
 // under its own root and old version dirs are deleted on upgrade
 // (core-plugins store.rs), which is why stale bin links MUST be re-pointed.
-async function writeVersionedRoot(root, version, { withRuntimeCli = false } = {}) {
+async function writeVersionedRoot(root, version, { withRuntimeCli = false, withUlwLoopAliases = false } = {}) {
 	const pluginRoot = join(root, "store", "omo", version);
 	await mkdir(join(pluginRoot, ".codex-plugin"), { recursive: true });
 	await writeFile(
@@ -76,9 +83,27 @@ async function writeVersionedRoot(root, version, { withRuntimeCli = false } = {}
 		`${JSON.stringify({ bin: { [COMPONENT_BIN_NAME]: "./dist/cli.js" }, name: "@sisyphuslabs/toolbox" })}\n`,
 	);
 	await writeFile(join(componentRoot, "dist", "cli.js"), "#!/usr/bin/env node\nconsole.log('toolbox');\n");
+	if (withUlwLoopAliases) {
+		const ulwLoopRoot = join(pluginRoot, "components", "ulw-loop");
+		await mkdir(join(ulwLoopRoot, "dist"), { recursive: true });
+		await writeFile(
+			join(ulwLoopRoot, "package.json"),
+			`${JSON.stringify({
+				bin: {
+					"omo-ulw-loop": "./dist/cli.js",
+					ulw: "./dist/cli.js",
+					"ulw-loop": "./dist/cli.js",
+				},
+				name: "@sisyphuslabs/ulw-loop",
+			})}\n`,
+		);
+		await writeFile(join(ulwLoopRoot, "dist", "cli.js"), "#!/usr/bin/env node\nconsole.log('ulw-loop');\n");
+	}
 	if (withRuntimeCli) {
 		await mkdir(join(pluginRoot, "dist", "cli"), { recursive: true });
 		await writeFile(join(pluginRoot, "dist", "cli", "index.js"), "console.log('omo');\n");
+		await mkdir(join(pluginRoot, "dist", "cli-node"), { recursive: true });
+		await writeFile(join(pluginRoot, "dist", "cli-node", "index.js"), "console.log('omo node runtime');\n");
 	}
 	return pluginRoot;
 }
@@ -196,14 +221,18 @@ test("#given platform win32 #when the worker setup links bins #then component bi
 		assert.deepEqual(outcome.degraded, []);
 		const shim = await readFile(join(fixture.binDir, `${COMPONENT_BIN_NAME}.cmd`), "utf8");
 		assert.match(shim, /@echo off/);
-		assert.ok(shim.includes(`node "${join(pluginRoot, "components", "toolbox", "dist", "cli.js")}"`));
+		const componentEntrypoint = join(pluginRoot, "components", "toolbox", "dist", "cli.js");
+		assert.match(shim, /NODE_REPL_NODE_PATH/);
+		assert.match(shim, /"%OMO_NODE_BINARY%"/);
+		assert.match(shim, new RegExp(`"${escapeRegExp(componentEntrypoint)}" %\\*`));
+		assert.doesNotMatch(shim, new RegExp(`node "${escapeRegExp(componentEntrypoint)}" %\\*`));
 		const wrapper = await readFile(join(fixture.binDir, "omo.cmd"), "utf8");
 		assert.ok(wrapper.includes(join(pluginRoot, "dist", "cli", "index.js")));
 		await assert.rejects(() => lstat(join(fixture.binDir, COMPONENT_BIN_NAME)), "win32 must not leave posix symlinks behind");
 	});
 });
 
-test("#given a marketplace payload without dist/cli #when the worker setup runs #then it records the degraded omo-cli entry, logs the skip warning, and leaves no broken or omo link", async () => {
+test("#given a legacy payload without root CLI dist #when the worker setup runs #then it records degraded omo-cli and leaves no broken link", async () => {
 	await withBinLinkFixture(async (fixture) => {
 		const pluginRoot = await writeVersionedRoot(fixture.root, "1.0.0");
 
@@ -219,7 +248,7 @@ test("#given a marketplace payload without dist/cli #when the worker setup runs
 		assert.ok(
 			warning.includes("skipped the omo runtime wrapper because ") &&
 				warning.includes(`${join("dist", "cli", "index.js")} is missing; `) &&
-				warning.includes("omo sparkshell/ulw-loop commands will be unavailable until a package shipping dist/cli is installed"),
+				warning.includes("omo ulw-loop commands will be unavailable until a package shipping dist/cli is installed"),
 			`bootstrap.log must carry the install-local warning text, got: ${log}`,
 		);
 	});
@@ -234,17 +263,42 @@ test("#given a payload shipping dist/cli #when the worker setup runs with no bin
 		assert.deepEqual(outcome.degraded, []);
 		const defaultBinDir = join(fixture.codexHome, "bin");
 		const wrapperName = process.platform === "win32" ? "omo.cmd" : "omo";
-		const wrapper = await readFile(join(defaultBinDir, wrapperName), "utf8");
+		const wrapperPath = join(defaultBinDir, wrapperName);
+		const wrapper = await readFile(wrapperPath, "utf8");
 		assert.ok(wrapper.includes(join(pluginRoot, "dist", "cli", "index.js")));
 		if (process.platform !== "win32") {
-			assert.ok((await stat(join(defaultBinDir, "omo"))).mode & 0o111, "the posix omo wrapper must be executable");
+			assert.ok((await stat(wrapperPath)).mode & 0o111, "the posix omo wrapper must be executable");
 			assert.equal(
 				await readlink(join(defaultBinDir, COMPONENT_BIN_NAME)),
 				join(pluginRoot, "components", "toolbox", "dist", "cli.js"),
 			);
+			const result = await execFileAsync(wrapperPath, ["--version"], {
+				env: { ...process.env, OMO_RUNTIME: "node", PATH: `${dirname(process.execPath)}:/usr/bin:/bin` },
+			});
+			assert.match(result.stdout, /omo node runtime/);
 		} else {
 			const shim = await readFile(join(defaultBinDir, `${COMPONENT_BIN_NAME}.cmd`), "utf8");
 			assert.ok(shim.includes(join(pluginRoot, "components", "toolbox", "dist", "cli.js")));
 		}
 	});
 });
+
+test("#given ulw-loop aliases in the plugin payload #when worker setup links bins #then public ULW commands point at the current component without adding SessionStart hooks", async () => {
+	await withBinLinkFixture(async (fixture) => {
+		const pluginRoot = await writeVersionedRoot(fixture.root, "1.0.0", { withUlwLoopAliases: true });
+
+		await runWorkerSetup(setupOptions(fixture, pluginRoot));
+
+		const targets = await symlinkTargets(fixture.binDir);
+		const ulwLoopCli = join(pluginRoot, "components", "ulw-loop", "dist", "cli.js");
+		assert.equal(targets.get("omo-ulw-loop"), ulwLoopCli);
+		assert.equal(targets.get("ulw"), ulwLoopCli);
+		assert.equal(targets.get("ulw-loop"), ulwLoopCli);
+		const hooks = JSON.parse(await readFile(join(pluginRoot, "hooks", "hooks.json"), "utf8"));
+		const sessionStartCommands = hooks.hooks.SessionStart.flatMap((group) => group.hooks)
+			.filter((hook) => hook.type === "command")
+			.map((hook) => hook.command)
+			.filter((command) => command.includes("components/bootstrap/dist/cli.js"));
+		assert.equal(sessionStartCommands.length, 1);
+	});
+});

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

@@ -16,6 +16,8 @@ const SKIPPED_DIRECTORY_NAMES = new Set([".git", "node_modules"]);
 const EXPECTED_BOOTSTRAP_COMMAND = 'node "${PLUGIN_ROOT}/components/bootstrap/dist/cli.js" hook session-start';
 const EXPECTED_BOOTSTRAP_COMMAND_WINDOWS =
 	'powershell -NoProfile -ExecutionPolicy Bypass -File "${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\bootstrap.ps1"';
+const EXPECTED_NODE_DISPATCH_PREFIX =
+	'powershell -NoProfile -ExecutionPolicy Bypass -File "${PLUGIN_ROOT}\\components\\bootstrap\\scripts\\node-dispatch.ps1"';
 
 async function pathExists(absolutePath) {
 	try {
@@ -127,6 +129,23 @@ test("#given aggregate and component hook manifests #when command targets are re
 	assert.deepEqual(missing, []);
 });
 
+test("#given aggregate hook manifests #when command handlers are inspected #then each has a Windows dispatcher", async () => {
+	// given
+	const aggregateHooks = await readAggregateHookManifests();
+
+	// when
+	const missing = [];
+	for (const manifest of aggregateHooks) {
+		for (const { handler } of collectCommandHooks(manifest.hooks, manifest.source)) {
+			if (typeof handler.commandWindows === "string" && handler.commandWindows.length > 0) continue;
+			missing.push(`${manifest.source}: ${handler.command}`);
+		}
+	}
+
+	// then
+	assert.deepEqual(missing, [], `Aggregate hook commands need commandWindows dispatchers:\n${missing.join("\n")}`);
+});
+
 test("#given the bootstrap component #when its SessionStart registration is inspected #then aggregate and component entries declare both platform commands", async () => {
 	// given
 	const aggregateHooks = (await readAggregateHookManifests()).find(({ source }) =>
@@ -156,6 +175,25 @@ test("#given the bootstrap component #when its SessionStart registration is insp
 	}
 });
 
+test("#given non-bootstrap aggregate hook manifests #when commandWindows entries are read #then they launch the managed Node dispatcher", async () => {
+	// given
+	const aggregateHooks = await readAggregateHookManifests();
+
+	// when
+	const offenders = [];
+	for (const manifest of aggregateHooks) {
+		for (const { handler } of collectCommandHooks(manifest.hooks, manifest.source)) {
+			if (handler.command === EXPECTED_BOOTSTRAP_COMMAND) continue;
+			if (typeof handler.commandWindows !== "string" || !handler.commandWindows.startsWith(EXPECTED_NODE_DISPATCH_PREFIX)) {
+				offenders.push(`${manifest.source}: ${handler.commandWindows ?? "<missing>"}`);
+			}
+		}
+	}
+
+	// then
+	assert.deepEqual(offenders, [], `Non-bootstrap aggregate hooks must use node-dispatch.ps1 on Windows:\n${offenders.join("\n")}`);
+});
+
 test("#given the built bootstrap bundle #when its module references are inspected #then it depends on Node built-ins only", async () => {
 	// given
 	const bundlePath = join(root, "components", "bootstrap", "dist", "cli.js");

package/packages/omo-codex/plugin/test/bootstrap-ps-guard.test.mjs

@@ -68,6 +68,31 @@ test("#given bootstrap.ps1 #when environment writes are scanned #then no Machine
 	assert.deepEqual(offenders, [], "bootstrap.ps1 must only touch User-scope environment values (Machine scope needs elevation)");
 });
 
+test("#given bootstrap.ps1 #when dependency discovery misses #then it never invokes winget or mutates user PATH", async () => {
+	// given
+	const content = await readBootstrapScript();
+
+	// then
+	assert.doesNotMatch(content, /&\s*winget\s+install/i, "bootstrap.ps1 must not install system dependencies with winget");
+	assert.doesNotMatch(
+		content,
+		/SetEnvironmentVariable\("Path"/,
+		"bootstrap.ps1 must not mutate the user PATH when Codex Desktop misses PATH entries",
+	);
+});
+
+test("#given bootstrap.ps1 #when resolving Node #then Codex NODE_REPL_NODE_PATH is checked before PATH", async () => {
+	// given
+	const content = await readBootstrapScript();
+
+	// then
+	assert.match(content, /NODE_REPL_NODE_PATH/, "bootstrap.ps1 must know how to read the Codex bundled Node setting");
+	assert(
+		content.indexOf("NODE_REPL_NODE_PATH") < content.indexOf("Get-Command node"),
+		"bootstrap.ps1 must prefer Codex bundled Node config before probing PATH",
+	);
+});
+
 test("#given bootstrap.ps1 #when execution policy mutations are scanned #then Set-ExecutionPolicy is never invoked", async () => {
 	// given
 	const content = await readBootstrapScript();

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

@@ -205,21 +205,15 @@ test("#given an unwritable config.toml #when the worker setup runs #then it degr
 	});
 });
 
-test("#given win32 without Git Bash and auto-install skipped #when the worker setup runs #then it degrades instead of throwing and disables the git_bash MCP", async () => {
+test("#given win32 without Git Bash #when the worker setup runs #then it degrades instead of throwing and disables the git_bash MCP", async () => {
 	await withSetupFixture(async (fixture) => {
-		const commands = [];
 		const outcome = await runWorkerSetup(
 			setupOptions(fixture, {
-				env: { OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL: "1" },
 				platform: "win32",
 				resolveGitBash: () => ({ checkedPaths: [], found: false, installHint: "install git bash" }),
-				runCommand: async (command, args) => {
-					commands.push([command, ...args]);
-				},
 			}),
 		);
 
-		assert.deepEqual(commands, []);
 		const gitBashEntries = outcome.degraded.filter((entry) => entry.component === "git-bash");
 		assert.equal(gitBashEntries.length, 1);
 		const config = await readConfig(fixture);

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

@@ -7,13 +7,13 @@ import { fileURLToPath } from "node:url";
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 
 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-loop", "omo-ulw-loop"],
+	["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-loop", ["omo-ulw-loop", "ulw", "ulw-loop"]],
 ]);
 
 const EXPECTED_USAGE_PREFIXES = new Map([
@@ -29,18 +29,19 @@ async function readJson(relativePath) {
 	return JSON.parse(await readFile(join(root, relativePath), "utf8"));
 }
 
-test("#given aggregate component package metadata #when bin names are inspected #then local component CLIs use the OMO prefix", async () => {
+test("#given aggregate component package metadata #when bin names are inspected #then component CLIs expose documented commands", async () => {
 	// given
 	const components = [...EXPECTED_COMPONENT_BINS.entries()];
 
 	// when
 	const mismatches = [];
-	for (const [component, expectedName] of components) {
+	for (const [component, expectedNames] of components) {
 		const packageJson = await readJson(join("components", component, "package.json"));
 		const bin = packageJson.bin ?? {};
 		const binNames = Object.keys(bin).sort();
-		if (bin[expectedName] !== "./dist/cli.js" || binNames.some((name) => name.startsWith("codex-"))) {
-			mismatches.push({ component, expectedName, bin });
+		const missing = expectedNames.filter((expectedName) => bin[expectedName] !== "./dist/cli.js");
+		if (missing.length > 0 || binNames.some((name) => name.startsWith("codex-"))) {
+			mismatches.push({ component, missing, bin });
 		}
 	}
 

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

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { chmodSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -125,6 +125,54 @@ test("#given representative component hook payloads #when executed through dist
 	}
 });
 
+test("#given bundled LSP hook CLI in installed layout #when diagnostics run #then it spawns sibling daemon target", () => {
+	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-lsp-installed-"));
+	try {
+		const lspDist = join(tempRoot, "components", "lsp", "dist");
+		const daemonDist = join(tempRoot, "components", "lsp-daemon", "dist");
+		const daemonDir = join(tempRoot, "daemon");
+		const invocationLog = join(tempRoot, "fake-daemon-invocations.jsonl");
+		mkdirSync(lspDist, { recursive: true });
+		mkdirSync(daemonDist, { recursive: true });
+		mkdirSync(join(tempRoot, "src"), { recursive: true });
+		writeFileSync(join(tempRoot, "package.json"), JSON.stringify({ type: "module" }));
+		writeFileSync(join(lspDist, "cli.js"), readFileSync(componentCliPath("lsp"), "utf8"));
+		writeFileSync(join(daemonDist, "package.json"), JSON.stringify({ type: "module", version: "0.1.0" }));
+		writeFakeLspDaemonCli(join(daemonDist, "cli.js"));
+		const editedFile = join(tempRoot, "src", "broken.c");
+		writeFileSync(editedFile, "int main(void) { return missing_symbol; }\n");
+
+		const result = spawnSync(process.execPath, [join(lspDist, "cli.js"), "hook", "post-tool-use"], {
+			cwd: tempRoot,
+			encoding: "utf8",
+			env: hookEnv(tempRoot, {
+				CODEX_LSP_DAEMON_DIR: daemonDir,
+				FAKE_LSP_DAEMON_LOG: invocationLog,
+			}),
+			input: JSON.stringify({
+				session_id: "bundled-lsp-hook",
+				tool_name: "Edit",
+				tool_input: { file_path: editedFile },
+				tool_response: { ok: true },
+			}),
+			timeout: HOOK_CLI_TEST_TIMEOUT_MS,
+		});
+
+		const daemonInvocations = existsSync(invocationLog) ? readFileSync(invocationLog, "utf8") : "";
+		const failureContext = `stdout: ${result.stdout}\nstderr: ${result.stderr}\ndaemon log: ${daemonInvocations}`;
+		assert.equal(result.status, 0, failureContext);
+		assert.equal(result.stderr, "", failureContext);
+		assert.notEqual(result.stdout, "", failureContext);
+		const parsed = JSON.parse(result.stdout);
+		assert.equal(parsed.decision, "block");
+		assert.match(parsed.reason, /error\[fake\] \(1\) at 1:1: Missing fake symbol\./);
+		assert.deepEqual(daemonInvocations.trim().split("\n").map(JSON.parse), [["daemon"]]);
+		assert.equal(existsSync(join(daemonDir, "v0.1.0", "daemon.log")), true);
+	} finally {
+		rmSync(tempRoot, { recursive: true, force: true });
+	}
+});
+
 test("#given malformed comment-checker stdin #when executed through dist CLI contract #then it exits successfully without output", () => {
 	// given
 	const tempRoot = mkdtempSync(join(tmpdir(), "omo-codex-cli-malformed-"));
@@ -276,6 +324,56 @@ function smokeImportComponent(component, event) {
 	}
 }
 
+function writeFakeLspDaemonCli(path) {
+	writeFileSync(
+		path,
+		[
+			"#!/usr/bin/env node",
+			'import { createHash } from "node:crypto";',
+			'import { appendFileSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";',
+			'import { tmpdir } from "node:os";',
+			'import { dirname, join } from "node:path";',
+			'import { createServer } from "node:net";',
+			"",
+			"appendFileSync(process.env.FAKE_LSP_DAEMON_LOG, `${JSON.stringify(process.argv.slice(2))}\\n`);",
+			"const baseDir = process.env.CODEX_LSP_DAEMON_DIR;",
+			'const versionDirName = readdirSync(baseDir).find((entry) => entry.startsWith("v")) ?? "v0";',
+			"const version = versionDirName.slice(1);",
+			"const dir = join(baseDir, versionDirName);",
+			'const naturalSocket = join(dir, "daemon.sock");',
+			'const digest = createHash("sha256").update(dir).digest("hex").slice(0, 16);',
+			"const socketPath = process.platform === \"win32\"",
+			"\t? `\\\\\\\\.\\\\pipe\\\\omo-lsp-${version}-${digest}`",
+			"\t: naturalSocket.length < 100 ? naturalSocket : join(tmpdir(), `omo-lsp-${version}-${digest}.sock`);",
+			"if (process.platform !== \"win32\") {",
+			"\tmkdirSync(dirname(socketPath), { recursive: true });",
+			"\ttry { unlinkSync(socketPath); } catch {}",
+			"}",
+			"const server = createServer((socket) => {",
+			'\tlet raw = "";',
+			'\tsocket.setEncoding("utf8");',
+			'\tsocket.on("data", (chunk) => {',
+			"\t\traw += chunk;",
+			'\t\tif (!raw.includes("\\n")) return;',
+			"\t\tconst request = JSON.parse(raw.trim());",
+			"\t\tconst response = {",
+			'\t\t\tjsonrpc: "2.0",',
+			"\t\t\tid: request.id,",
+			"\t\t\tresult: {",
+			'\t\t\t\tcontent: [{ type: "text", text: "error[fake] (1) at 1:1: Missing fake symbol." }],',
+			"\t\t\t},",
+			"\t\t};",
+			'\t\tsocket.end(`${JSON.stringify(response)}\\n`);',
+			"\t\tserver.close(() => process.exit(0));",
+			"\t});",
+			"});",
+			"server.listen(socketPath);",
+			"setTimeout(() => process.exit(1), 10000).unref();",
+			"",
+		].join("\n"),
+	);
+}
+
 function hookEnv(tempRoot, extraEnv = {}) {
 	return {
 		...process.env,

package/packages/omo-codex/plugin/test/lcx-bug-skills.test.mjs

@@ -4,11 +4,16 @@ import { dirname, join } from "node:path";
 import test from "node:test";
 import { fileURLToPath } from "node:url";
 
-const root = dirname(dirname(fileURLToPath(import.meta.url)));
+const pluginRoot = dirname(dirname(fileURLToPath(import.meta.url)));
+const sharedSkillsRoot = join(pluginRoot, "..", "..", "shared-skills");
+
+async function readSkill(name) {
+	return readFile(join(sharedSkillsRoot, "skills", name, "SKILL.md"), "utf8");
+}
 
 test("#given synced lcx-report-bug skill #when inspected #then it files LazyCodex bug issues with generated labels", async () => {
 	// given
-	const skillRoot = join(root, "skills", "lcx-report-bug");
+	const skillRoot = join(sharedSkillsRoot, "skills", "lcx-report-bug");
 
 	// when
 	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
@@ -20,14 +25,14 @@ test("#given synced lcx-report-bug skill #when inspected #then it files LazyCode
 	assert.match(skill, /gh pr create --repo openai\/codex/);
 	assert.doesNotMatch(skill, /gh pr create --repo "\$TARGET_REPO"/);
 	assert.doesNotMatch(skill, /gh pr create --repo code-yeongyu\/lazycodex/);
-	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-report-bug"/);
+	assert.match(interfaceMetadata, /display_name: "lcx-report-bug \(omo\)"/);
 	assert.match(interfaceMetadata, /- "lazycodex bug"/);
 	assert.match(interfaceMetadata, /- "openai codex bug"/);
 });
 
 test("#given synced lcx-contribute-bug-fix skill #when inspected #then it delivers LazyCodex fixes as issues and upstream fixes as fork PRs", async () => {
 	// given
-	const skillRoot = join(root, "skills", "lcx-contribute-bug-fix");
+	const skillRoot = join(sharedSkillsRoot, "skills", "lcx-contribute-bug-fix");
 
 	// when
 	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
@@ -40,14 +45,14 @@ test("#given synced lcx-contribute-bug-fix skill #when inspected #then it delive
 	assert.match(skill, /gh pr create --repo openai\/codex/);
 	assert.doesNotMatch(skill, /gh pr create --repo "\$TARGET_REPO"/);
 	assert.doesNotMatch(skill, /gh pr create --repo code-yeongyu\/lazycodex/);
-	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-contribute-bug-fix"/);
+	assert.match(interfaceMetadata, /display_name: "lcx-contribute-bug-fix \(omo\)"/);
 	assert.match(interfaceMetadata, /- "contribute a bug fix"/);
 	assert.match(interfaceMetadata, /- "fix bug pr"/);
 });
 
-test("#given synced lcx-doctor skill #when inspected #then it diagnoses installs against latest /tmp sources without mutating them", async () => {
+test("#given synced lcx-doctor skill #when inspected #then it diagnoses installs against latest temp-root sources without mutating them", async () => {
 	// given
-	const skillRoot = join(root, "skills", "lcx-doctor");
+	const skillRoot = join(sharedSkillsRoot, "skills", "lcx-doctor");
 
 	// when
 	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
@@ -55,7 +60,56 @@ test("#given synced lcx-doctor skill #when inspected #then it diagnoses installs
 
 	// then
 	assert.match(skill, /^---\r?\nname: lcx-doctor\r?\n/m);
-	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-doctor"/);
+	assert.match(interfaceMetadata, /display_name: "lcx-doctor \(omo\)"/);
 	assert.match(interfaceMetadata, /- "lazycodex doctor"/);
 	assert.match(interfaceMetadata, /- "lazycodex health check"/);
 });
+
+test("#given lcx source-sync skills #when inspected #then source caches are validated before reuse", async () => {
+	// given
+	const skillNames = ["lcx-doctor", "lcx-report-bug", "lcx-contribute-bug-fix"];
+
+	for (const skillName of skillNames) {
+		// when
+		const skill = await readSkill(skillName);
+
+		// then
+		assert.match(skill, /LAZYCODEX_SOURCE_ROOT="\$\{LAZYCODEX_SOURCE_ROOT:-\$\{TMPDIR:-\/tmp\}\/lazycodex-sources\}"/);
+		assert.match(skill, /git -C "\$DEST" rev-parse --is-inside-work-tree/);
+		assert.match(skill, /git -C "\$DEST" config --get remote\.origin\.url/);
+		assert.match(skill, /DEST\.corrupt\.\$\(date \+%Y%m%d%H%M%S\)/);
+		assert.doesNotMatch(skill, /if \[ ! -d "\$DEST\/\.git" \]; then/);
+		assert.doesNotMatch(skill, /sync_latest_source code-yeongyu\/lazycodex \/tmp\/lazycodex-source/);
+		assert.doesNotMatch(skill, /sync_latest_source openai\/codex \/tmp\/openai-codex-source/);
+	}
+});
+
+test("#given lcx-doctor skill #when inspected #then aggregate hook validation follows the current manifest", async () => {
+	// given
+	const skill = await readSkill("lcx-doctor");
+
+	// then
+	assert.match(skill, /\.codex-plugin\/plugin\.json/);
+	assert.match(skill, /manifest declares a `hooks` array/);
+	assert.match(skill, /validate every direct hook path declared by the manifest/);
+	assert.match(skill, /`hooks\/hooks\.json` only when the manifest declares it/);
+	assert.match(skill, /do not require retired paths such as `components\/workflow-selector`/);
+	assert.match(skill, /`hooks\/user-prompt-submit-selecting-lazycodex-workflow\.json` unless the current manifest declares them/);
+	assert.doesNotMatch(skill, /Plugin payload present and non-empty: `hooks\/hooks\.json`/);
+});
+
+test("#given lcx-doctor skill #when inspected #then runtime probes and materialized payloads distinguish expected rewrites from missing files", async () => {
+	// given
+	const skill = await readSkill("lcx-doctor");
+
+	// then
+	assert.match(skill, /manifest-declared runtime payload/);
+	assert.match(skill, /`dist\/cli\/index\.js` and `dist\/cli-node\/index\.js`/);
+	assert.match(skill, /install-time materialization rewrites as expected/);
+	assert.match(skill, /absolute `\.mcp\.json` runtime paths/);
+	assert.match(skill, /Missing or zero-byte rewritten targets are FAIL/);
+	assert.match(skill, /Use the configured Codex default model/);
+	assert.match(skill, /unless the user explicitly passed a model override/);
+	assert.match(skill, /never force a guessed\/rejected model such as `gpt-5\.5-codex-mini`/);
+	assert.doesNotMatch(skill, /--model gpt-5\.5-codex-mini/);
+});