oh-my-opencode 4.5.1 → 4.6.0

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

@@ -0,0 +1,345 @@
+import assert from "node:assert/strict";
+import { readdir, readFile, stat } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+async function readJson(relativePath) {
+	return JSON.parse(await readFile(join(root, relativePath), "utf8"));
+}
+
+async function readComponentHookManifests() {
+	const components = await readdir(join(root, "components"), { withFileTypes: true });
+	const manifests = [];
+	for (const entry of components) {
+		if (!entry.isDirectory()) continue;
+		const source = join("components", entry.name, "hooks", "hooks.json");
+		manifests.push({ source, hooks: await readJson(source) });
+	}
+	return manifests.sort((left, right) => left.source.localeCompare(right.source));
+}
+
+function collectCommandHooks(hooks, source) {
+	const config = hooks.hooks;
+	if (typeof config !== "object" || config === null || Array.isArray(config)) {
+		throw new TypeError(`Invalid hooks manifest: ${source}`);
+	}
+	const commandHooks = [];
+	for (const [eventName, groups] of Object.entries(config)) {
+		if (!Array.isArray(groups)) {
+			throw new TypeError(`Invalid hook groups in ${source}:${eventName}`);
+		}
+		groups.forEach((group, groupIndex) => {
+			if (typeof group !== "object" || group === null || !Array.isArray(group.hooks)) {
+				throw new TypeError(`Invalid hook group in ${source}:${eventName}:${groupIndex}`);
+			}
+			group.hooks.forEach((handler, handlerIndex) => {
+				if (typeof handler !== "object" || handler === null || handler.type !== "command") return;
+				commandHooks.push({ source, eventName, groupIndex, handlerIndex, handler });
+			});
+		});
+	}
+	return commandHooks;
+}
+
+function hookLocation({ source, eventName, groupIndex, handlerIndex, handler }) {
+	return `${source}:${eventName}:${groupIndex}:${handlerIndex}:${handler.command}`;
+}
+
+function findSpawnAgentTypes(content) {
+	const agentTypes = new Set();
+	const regex = /spawn_agent\(agent_type="([^"]+)"/g;
+	for (const match of content.matchAll(regex)) {
+		agentTypes.add(match[1]);
+	}
+	return [...agentTypes].sort();
+}
+
+test("#given aggregate plugin manifest #when inspected #then it owns the omo namespace", async () => {
+	// given
+	const manifest = await readJson(".codex-plugin/plugin.json");
+
+	// when
+	const hookPath = manifest.hooks;
+	const skillsPath = manifest.skills;
+	const mcpPath = manifest.mcpServers;
+
+	// then
+	assert.equal(manifest.name, "omo");
+	assert.equal(hookPath, "./hooks/hooks.json");
+	assert.equal(skillsPath, "./skills/");
+	assert.equal(mcpPath, "./.mcp.json");
+});
+
+test("#given aggregate plugin metadata #when inspected #then ulw-loop is the public loop name", async () => {
+	// given
+	const manifestText = await readFile(join(root, ".codex-plugin", "plugin.json"), "utf8");
+	const manifest = JSON.parse(manifestText);
+
+	// when
+	const longDescription = String(manifest.interface?.longDescription ?? "");
+
+	// then
+	assert.match(longDescription, /ulw-loop/);
+});
+
+test("#given isolated components #when hooks are inspected #then commands stay inside component roots", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const text = JSON.stringify(hooks);
+
+	// when
+	const componentMarkers = [
+		"components/comment-checker/dist/cli.js",
+		"components/lsp/dist/cli.js",
+		"components/rules/dist/cli.js",
+		"components/start-work-continuation/dist/cli.js",
+		"components/telemetry/dist/cli.js",
+		"components/ulw-loop/dist/cli.js",
+		"components/ultrawork/dist/cli.js",
+	];
+
+	// then
+	for (const marker of componentMarkers) {
+		assert.match(text, new RegExp(marker.replaceAll("/", "\\/")));
+	}
+	assert.doesNotMatch(text, /codex-(comment-checker|lsp|rules|telemetry|ulw-loop|ultrawork)@/);
+});
+
+test("#given aggregate hook commands #when inspected #then every command exposes a Codex status message", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+
+	// when
+	const commandHooks = collectCommandHooks(hooks, "hooks/hooks.json");
+	const missingStatusMessages = commandHooks
+		.filter(({ handler }) => typeof handler.statusMessage !== "string" || handler.statusMessage.trim() === "")
+		.map(hookLocation);
+
+	// then
+	assert.deepEqual(missingStatusMessages, []);
+});
+
+test("#given component hook commands #when inspected #then standalone packages expose Codex status messages", async () => {
+	// given
+	const componentHooks = await readComponentHookManifests();
+
+	// when
+	const missingStatusMessages = componentHooks
+		.flatMap(({ source, hooks }) => collectCommandHooks(hooks, source))
+		.filter(({ handler }) => typeof handler.statusMessage !== "string" || handler.statusMessage.trim() === "")
+		.map(hookLocation);
+
+	// then
+	assert.deepEqual(missingStatusMessages, []);
+});
+
+test("#given hook status messages #when inspected #then labels describe OMO responsibilities instead of the hook runner", async () => {
+	// given
+	const aggregateHooks = await readJson("hooks/hooks.json");
+	const componentHooks = await readComponentHookManifests();
+
+	// when
+	const commandHooks = [
+		...collectCommandHooks(aggregateHooks, "hooks/hooks.json"),
+		...componentHooks.flatMap(({ source, hooks }) => collectCommandHooks(hooks, source)),
+	];
+	const genericStatusMessages = commandHooks
+		.filter(({ handler }) => typeof handler.statusMessage !== "string" || /\bhook\b/i.test(handler.statusMessage))
+		.map(hookLocation);
+
+	// then
+	assert.deepEqual(genericStatusMessages, []);
+});
+
+test("#given aggregate OMO plugin is enabled #when hooks are inspected #then shell guidance and ulw-loop guard are registered", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+	const text = JSON.stringify(hooks);
+
+	// when
+	const preToolUseGroups = hooks.hooks.PreToolUse;
+
+	// then
+	assert.match(text, /components\/git-bash\/dist\/cli\.js/);
+	assert.match(text, /Recommending Git Bash Mcp/);
+	assert.match(text, /hook post-compact/);
+	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$"]);
+});
+
+test("#given aggregate MCP config #when inspected #then code MCPs reference package runtimes without package names", async () => {
+	// given
+	const packageJson = await readJson("package.json");
+	const mcp = await readJson(".mcp.json");
+	const lspSources = await readdir(join(root, "components", "lsp", "src"));
+	const bundledMcpBuildScript = await readFile(join(root, "scripts", "build-bundled-mcp-runtimes.mjs"), "utf8");
+
+	// when
+	const lspServer = mcp.mcpServers.lsp;
+	const astGrepServer = mcp.mcpServers.ast_grep;
+	const gitBashServer = mcp.mcpServers.git_bash;
+	const codeMcpNames = Object.keys(mcp.mcpServers)
+		.filter((name) => name === "lsp" || name === "ast_grep" || name === "git_bash")
+		.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.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.match(bundledMcpBuildScript, /git-bash-mcp/);
+	assert.doesNotMatch(packageJson.scripts.build, /--workspaces/);
+	assert.equal(lspServer.command, "node");
+	assert.deepEqual(lspServer.args, ["../../lsp-tools-mcp/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(gitBashServer.command, "node");
+	assert.deepEqual(gitBashServer.args, ["../../git-bash-mcp/dist/cli.js", "mcp"]);
+	assert.equal(gitBashServer.cwd, ".");
+	assert.deepEqual(componentLocalMcpSources, []);
+});
+
+test("#given package-level MCP CLIs #when package metadata is inspected #then bin names use the omo prefix", async () => {
+	// given
+	const lspPackageJson = await readJson("../../lsp-tools-mcp/package.json");
+	const astGrepPackageJson = await readJson("../../ast-grep-mcp/package.json");
+	const gitBashPackageJson = await readJson("../../git-bash-mcp/package.json");
+
+	// 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"]);
+	for (const name of binNames) {
+		assert.match(name, /^omo-/);
+	}
+});
+
+test("#given aggregate plugin build script #when inspected #then hook status and telemetry sync run before workspace builds", async () => {
+	// given
+	const packageJson = await readJson("package.json");
+	const telemetrySyncScript = await readFile(join(root, "..", "scripts", "sync-telemetry-component.mjs"), "utf8");
+
+	// when
+	const buildScript = packageJson.scripts.build;
+
+	// then
+	assert.equal(
+		buildScript,
+		"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",
+	);
+	assert.match(telemetrySyncScript, /syncTelemetryComponent/);
+});
+
+test("#given omo-codex package build script #when inspected #then delegates to the aggregate plugin package", async () => {
+	// given
+	const packageJson = JSON.parse(await readFile(join(root, "..", "package.json"), "utf8"));
+
+	// when
+	const buildPluginScript = packageJson.scripts["build:plugin"];
+
+	// then
+	assert.equal(buildPluginScript, "bun run --cwd plugin build");
+});
+
+test("#given component directories #when scanned #then only intentional resource roots declare plugin manifests", async () => {
+	// given
+	const components = await readdir(join(root, "components"), { withFileTypes: true });
+	const expectedComponentManifests = new Map([["rules", { hooks: "./hooks/hooks.json" }]]);
+
+	// when
+	const componentNames = components.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+
+	// then
+	assert.deepEqual(componentNames, [
+		"comment-checker",
+		"git-bash",
+		"lsp",
+		"rules",
+		"start-work-continuation",
+		"telemetry",
+		"ultrawork",
+		"ulw-loop",
+	]);
+	for (const name of componentNames) {
+		const expectedManifest = expectedComponentManifests.get(name);
+		if (expectedManifest !== undefined) {
+			assert.deepEqual(await readJson(join("components", name, ".codex-plugin", "plugin.json")), expectedManifest);
+			continue;
+		}
+
+		await assert.rejects(
+			readFile(join(root, "components", name, ".codex-plugin", "plugin.json"), "utf8"),
+			/code: 'ENOENT'|ENOENT/,
+		);
+	}
+});
+
+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 }))
+		.filter((entry) => entry.isFile() && entry.name.endsWith(".toml"))
+		.map((entry) => entry.name)
+		.sort();
+
+	assert.deepEqual(entries, [
+		"codex-ultrawork-reviewer.toml",
+		"explorer.toml",
+		"librarian.toml",
+		"metis.toml",
+		"momus.toml",
+		"plan.toml",
+	]);
+
+	for (const fileName of entries) {
+		const content = await readFile(join(agentsDir, fileName), "utf8");
+		assert.match(content, /^name\s*=\s*".+"$/m);
+		assert.match(content, /^description\s*=\s*".+"$/m);
+		assert.match(content, /^nickname_candidates\s*=\s*\[.+\]$/m);
+		assert.match(content, /^model\s*=\s*".+"$/m);
+		assert.match(content, /^model_reasoning_effort\s*=\s*".+"$/m);
+		assert.match(content, /^developer_instructions\s*=\s*"""/m);
+	}
+});
+
+test("#given synced skills with Codex compatibility guidance #when a bundled agent_type is referenced #then a matching TOML is bundled", async () => {
+	const skillsDir = join(root, "skills");
+	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
+	const skillFiles = skillEntries
+		.filter((entry) => entry.isDirectory())
+		.map((entry) => join(skillsDir, entry.name, "SKILL.md"));
+
+	const referencedAgentTypes = new Set();
+	for (const skillPath of skillFiles) {
+		const content = await readFile(skillPath, "utf8");
+		for (const agentType of findSpawnAgentTypes(content)) {
+			if (agentType === "worker" || agentType === "codex-ultrawork-reviewer") {
+				continue;
+			}
+			referencedAgentTypes.add(agentType);
+		}
+	}
+
+	const expected = [...referencedAgentTypes].sort();
+	assert.deepEqual(expected, ["explorer", "librarian", "metis", "momus", "plan"]);
+
+	for (const agentType of expected) {
+		const tomlPath = join(root, "components", "ultrawork", "agents", `${agentType}.toml`);
+		const fileStat = await stat(tomlPath);
+		assert.equal(fileStat.isFile(), true);
+		assert.equal(basename(tomlPath), `${agentType}.toml`);
+	}
+});

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

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+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 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"],
+]);
+
+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 "],
+]);
+
+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 () => {
+	// given
+	const components = [...EXPECTED_COMPONENT_BINS.entries()];
+
+	// when
+	const mismatches = [];
+	for (const [component, expectedName] 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 });
+		}
+	}
+
+	// then
+	assert.deepEqual(mismatches, []);
+});
+
+test("#given component CLI sources #when usage text is inspected #then user-facing command names use OMO names", async () => {
+	// given
+	const components = [...EXPECTED_USAGE_PREFIXES.entries()];
+
+	// when
+	const mismatches = [];
+	for (const [component, expectedUsage] of components) {
+		const source = await readFile(join(root, "components", component, "src", "cli.ts"), "utf8");
+		if (!source.includes(expectedUsage) || /Usage: codex-/.test(source)) {
+			mismatches.push({ component, expectedUsage });
+		}
+	}
+
+	// then
+	assert.deepEqual(mismatches, []);
+});

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

@@ -0,0 +1,195 @@
+import assert from "node:assert/strict";
+import { access, readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+import {
+	formatLazyCodexHookStatusMessage,
+	normalizeLazyCodexHookStatusLabel,
+	parseLazyCodexHookStatusMessage,
+} from "../scripts/hook-status-message.mjs";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+const AGGREGATE_EXPECTED_LABELS = new Map([
+	["hooks/hooks.json:SessionStart:0:0", "Loading Project Rules"],
+	["hooks/hooks.json:SessionStart:1:0", "Recording Session Telemetry"],
+	["hooks/hooks.json:UserPromptSubmit:0:0", "Loading Project Rules"],
+	["hooks/hooks.json:UserPromptSubmit:1:0", "Checking Ultrawork Trigger"],
+	["hooks/hooks.json:UserPromptSubmit:2:0", "Checking Ulw-Loop Steering"],
+	["hooks/hooks.json:PreToolUse:0: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:1:0", "Matching Project Rules"],
+	["hooks/hooks.json:PostCompact:0:0", "Resetting Project Rule Cache"],
+	["hooks/hooks.json:Stop:0:0", "Checking Start-Work Continuation"],
+	["hooks/hooks.json:SubagentStop:0:0", "Checking Start-Work Continuation"],
+]);
+
+const COMPONENT_EXPECTED_LABELS = new Map([
+	["components/comment-checker/hooks/hooks.json:PostToolUse:0:0", "Checking Comments"],
+	["components/lsp/hooks/hooks.json:PostToolUse:0:0", "Checking LSP Diagnostics"],
+	["components/rules/hooks/hooks.json:SessionStart:0:0", "Loading Project Rules"],
+	["components/rules/hooks/hooks.json:UserPromptSubmit:0:0", "Loading Project Rules"],
+	["components/rules/hooks/hooks.json:PostToolUse:0:0", "Matching Project Rules"],
+	["components/rules/hooks/hooks.json:PostCompact:0:0", "Resetting Project Rule Cache"],
+	["components/telemetry/hooks/hooks.json:SessionStart:0:0", "Recording Session Telemetry"],
+	["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"],
+]);
+
+async function readJson(relativePath) {
+	return JSON.parse(await readFile(join(root, relativePath), "utf8"));
+}
+
+async function exists(relativePath) {
+	try {
+		await access(join(root, relativePath));
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function readComponentHookManifests() {
+	const components = await readdir(join(root, "components"), { withFileTypes: true });
+	const manifests = [];
+	for (const entry of components) {
+		if (!entry.isDirectory()) continue;
+		const source = join("components", entry.name, "hooks", "hooks.json");
+		if (!(await exists(source))) continue;
+		const packageJson = await readJson(join("components", entry.name, "package.json"));
+		manifests.push({ source, version: packageJson.version, hooks: await readJson(source) });
+	}
+	return manifests.sort((left, right) => left.source.localeCompare(right.source));
+}
+
+async function readComponentVersions() {
+	const components = await readdir(join(root, "components"), { withFileTypes: true });
+	const versions = new Map();
+	for (const entry of components) {
+		if (!entry.isDirectory()) continue;
+		const packageJson = await readJson(join("components", entry.name, "package.json"));
+		versions.set(entry.name, packageJson.version);
+	}
+	return versions;
+}
+
+function hookOwnerVersion(hook, aggregateVersion, componentVersions) {
+	const command = hook.command;
+	for (const [componentName, version] of componentVersions.entries()) {
+		if (command.includes(`/components/${componentName}/dist/cli.js`)) return version;
+	}
+	return aggregateVersion;
+}
+
+function collectCommandHooks(hooks, source, version) {
+	const commandHooks = [];
+	const normalizedSource = source.replaceAll("\\", "/");
+	for (const [eventName, groups] of Object.entries(hooks.hooks)) {
+		groups.forEach((group, groupIndex) => {
+			group.hooks.forEach((handler, handlerIndex) => {
+				if (handler.type !== "command") return;
+				commandHooks.push({
+					id: `${normalizedSource}:${eventName}:${groupIndex}:${handlerIndex}`,
+					version,
+					command: handler.command,
+					statusMessage: handler.statusMessage,
+				});
+			});
+		});
+	}
+	return commandHooks;
+}
+
+test("#given hook status label #when formatting #then prefixes LazyCodex with version", () => {
+	// given
+	const version = "0.1.0";
+	const label = "Checking Comments";
+
+	// when
+	const message = formatLazyCodexHookStatusMessage(version, label);
+
+	// then
+	assert.equal(message, "LazyCodex(0.1.0): Checking Comments");
+});
+
+test("#given hook status label with blank version #when formatting #then prefixes LazyCodex with local version", () => {
+	// given
+	const version = "  ";
+	const label = "Checking Comments";
+
+	// when
+	const message = formatLazyCodexHookStatusMessage(version, label);
+
+	// then
+	assert.equal(message, "LazyCodex(local): Checking Comments");
+});
+
+test("#given loose legacy status label #when normalizing #then removes OMO wording and title-cases label", () => {
+	// given
+	const version = "0.1.0";
+	const label = "  checking   OMO comments  ";
+
+	// when
+	const normalized = normalizeLazyCodexHookStatusLabel(label);
+	const message = formatLazyCodexHookStatusMessage(version, label);
+
+	// then
+	assert.equal(normalized, "Checking Comments");
+	assert.equal(message, "LazyCodex(0.1.0): Checking Comments");
+});
+
+test("#given aggregate comment-checker hook #when status is inspected #then it uses LazyCodex comments label", async () => {
+	// given
+	const aggregateHooks = await readJson("hooks/hooks.json");
+	const componentVersions = await readComponentVersions();
+
+	// when
+	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", "0.1.0");
+	const commentCheckerHook = hooks.find((hook) => hook.id === "hooks/hooks.json:PostToolUse:0:0");
+
+	// then
+	assert.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage(componentVersions.get("comment-checker"), "Checking Comments"));
+	assert.doesNotMatch(JSON.stringify(aggregateHooks), /checking\s+OMO\s+comments/i);
+});
+
+test("#given aggregate and component hooks #when status messages are inspected #then all use the LazyCodex formatter", async () => {
+	// given
+	const aggregateVersion = (await readJson(".codex-plugin/plugin.json")).version;
+	const aggregateHooks = await readJson("hooks/hooks.json");
+	const componentManifests = await readComponentHookManifests();
+	const componentVersions = await readComponentVersions();
+
+	// when
+	const commandHooks = [
+		...collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion).map((hook) => ({
+			...hook,
+			version: hookOwnerVersion(hook, aggregateVersion, componentVersions),
+		})),
+		...componentManifests.flatMap((manifest) => collectCommandHooks(manifest.hooks, manifest.source, manifest.version)),
+	];
+	const expectedLabels = new Map([...AGGREGATE_EXPECTED_LABELS, ...COMPONENT_EXPECTED_LABELS]);
+	const mismatches = commandHooks
+		.map((hook) => {
+			const parsed = parseLazyCodexHookStatusMessage(hook.statusMessage);
+			const label = parsed?.label;
+			const expected = label === undefined ? undefined : formatLazyCodexHookStatusMessage(hook.version, label);
+			return { ...hook, expected, parsed };
+		})
+		.filter((hook) => hook.expected === undefined || hook.statusMessage !== hook.expected || hook.parsed === null)
+		.map((hook) => `${hook.id}: expected ${hook.expected ?? "<missing expectation>"} but got ${hook.statusMessage}`);
+
+	// then
+	assert.deepEqual(mismatches, []);
+	const actualLabels = new Set(commandHooks.map((hook) => parseLazyCodexHookStatusMessage(hook.statusMessage)?.label));
+	assert.deepEqual([...expectedLabels.values()].filter((label) => !actualLabels.has(label)), []);
+	for (const hook of commandHooks) {
+		assert.doesNotMatch(hook.statusMessage, /\bOMO\b/i);
+	}
+});

package/packages/omo-codex/plugin/test/install-time-build-runtime.test.mjs

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test("#given aggregate build scripts #when inspected #then install-time build does not invoke Bun", async () => {
+	// given
+	const buildComponentsScript = await readFile(join(root, "scripts", "build-components.mjs"), "utf8");
+	const buildBundledMcpRuntimesScript = await readFile(join(root, "scripts", "build-bundled-mcp-runtimes.mjs"), "utf8");
+
+	// when
+	const installTimeBuildScripts = [buildComponentsScript, buildBundledMcpRuntimesScript].join("\n");
+
+	// then
+	assert.doesNotMatch(installTimeBuildScripts, /spawnSync\("bun"/);
+	assert.doesNotMatch(installTimeBuildScripts, /\bbun\s+run\b/);
+});
+
+test("#given aggregate build scripts #when inspected #then npm subprocesses resolve on Windows", async () => {
+	// given
+	const buildComponentsScript = await readFile(join(root, "scripts", "build-components.mjs"), "utf8");
+	const buildBundledMcpRuntimesScript = await readFile(join(root, "scripts", "build-bundled-mcp-runtimes.mjs"), "utf8");
+
+	// when
+	const installTimeBuildScripts = [buildComponentsScript, buildBundledMcpRuntimesScript].join("\n");
+
+	// then
+	assert.match(installTimeBuildScripts, /process\.platform === "win32"/);
+	assert.match(installTimeBuildScripts, /shell: process\.platform === "win32"/);
+	assert.doesNotMatch(installTimeBuildScripts, /npm\.cmd/);
+});

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

@@ -0,0 +1,21 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const root = dirname(dirname(fileURLToPath(import.meta.url)));
+
+test("#given aggregate MCP config #when inspected #then registers research and structural-search MCPs", async () => {
+	// given
+	const mcp = JSON.parse(await readFile(join(root, ".mcp.json"), "utf8"));
+
+	// when
+	const serverNames = Object.keys(mcp.mcpServers).sort();
+
+	// then
+	assert.deepEqual(serverNames, ["ast_grep", "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.deepEqual(mcp.mcpServers.ast_grep.args, ["../../ast-grep-mcp/dist/cli.js", "mcp"]);
+});