oh-my-opencode 4.11.1 → 4.12.0

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

@@ -7,16 +7,24 @@ import {
 	collectCommandHooks,
 	exists,
 	hookLocation,
+	readAggregateHookManifests,
 	readComponentHookManifests,
-	readJson,
-	readPluginVersion,
 	root,
 } from "./aggregate-plugin-fixture.mjs";
 
+async function readAggregateCommandHooks() {
+	const manifests = await readAggregateHookManifests();
+	return manifests.flatMap(({ source, hooks }) => collectCommandHooks(hooks, source));
+}
+
+async function readAggregateHooksText() {
+	const manifests = await readAggregateHookManifests();
+	return manifests.map(({ hooks }) => JSON.stringify(hooks)).join("\n");
+}
+
 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);
+	const text = await readAggregateHooksText();
 
 	// when
 	const componentMarkers = [
@@ -40,12 +48,11 @@ test("#given isolated components #when hooks are inspected #then commands stay i
 
 test("#given aggregate SubagentStop hooks #when inspected #then start-work and LazyCodex executor verifier are separate groups", async () => {
 	// given
-	const hooks = await readJson("hooks/hooks.json");
-	const aggregateVersion = await readPluginVersion();
+	const manifests = await readAggregateHookManifests();
 
 	// when
-	const subagentStopGroups = hooks.hooks.SubagentStop;
-	const verifierGroups = collectCommandHooks(hooks, "hooks/hooks.json").filter(
+	const subagentStopGroups = manifests.filter(({ hooks }) => hooks.hooks.SubagentStop).flatMap(({ hooks }) => hooks.hooks.SubagentStop);
+	const verifierGroups = manifests.flatMap(({ source, hooks }) => collectCommandHooks(hooks, source)).filter(
 		(hook) =>
 			hook.eventName === "SubagentStop" &&
 			hook.handler.command ===
@@ -57,21 +64,17 @@ test("#given aggregate SubagentStop hooks #when inspected #then start-work and L
 	assert.equal(subagentStopGroups[0]?.matcher, undefined);
 	assert.equal(subagentStopGroups[1]?.matcher, "^lazycodex-executor$");
 	assert.equal(verifierGroups.length, 1);
-	assert.equal(verifierGroups[0]?.groupIndex, 1);
+	assert.equal(verifierGroups[0]?.groupIndex, 0);
 	assert.equal(verifierGroups[0]?.handler.timeout, 10);
-	assert.equal(
-		verifierGroups[0]?.handler.statusMessage,
-		`LazyCodex(${aggregateVersion}): Verifying LazyCodex Executor Evidence`,
-	);
+	assert.equal(verifierGroups[0]?.handler.statusMessage, "(OmO) Verifying LazyCodex Executor Evidence");
 });
 
 test("#given aggregate PostCompact hooks #when hooks are inspected #then LSP diagnostics cache reset is registered", async () => {
 	// given
-	const hooks = await readJson("hooks/hooks.json");
-	const aggregateVersion = await readPluginVersion();
+	const commandHooks = await readAggregateCommandHooks();
 
 	// when
-	const lspPostCompactHooks = collectCommandHooks(hooks, "hooks/hooks.json").filter(
+	const lspPostCompactHooks = commandHooks.filter(
 		(hook) =>
 			hook.eventName === "PostCompact" &&
 			hook.handler.command === 'node "${PLUGIN_ROOT}/components/lsp/dist/cli.js" hook post-compact',
@@ -79,15 +82,13 @@ test("#given aggregate PostCompact hooks #when hooks are inspected #then LSP dia
 
 	// then
 	assert.equal(lspPostCompactHooks.length, 1);
-	assert.equal(lspPostCompactHooks[0]?.handler.statusMessage, `LazyCodex(${aggregateVersion}): Resetting LSP Diagnostics Cache`);
+	assert.equal(lspPostCompactHooks[0]?.handler.statusMessage, "(OmO) Resetting LSP Diagnostics Cache");
 });
 
 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 commandHooks = await readAggregateCommandHooks();
 	const missingStatusMessages = commandHooks
 		.filter(({ handler }) => typeof handler.statusMessage !== "string" || handler.statusMessage.trim() === "")
 		.map(hookLocation);
@@ -98,10 +99,8 @@ test("#given aggregate hook commands #when inspected #then every command exposes
 
 test("#given aggregate hook commands #when inspected #then commands stay Node-based and platform-neutral", async () => {
 	// given
-	const hooks = await readJson("hooks/hooks.json");
-
 	// when
-	const commands = collectCommandHooks(hooks, "hooks/hooks.json").map(({ handler }) => handler.command);
+	const commands = (await readAggregateCommandHooks()).map(({ handler }) => handler.command);
 
 	// then
 	assert(!commands.some((command) => /\bpython3?\b/i.test(command)));
@@ -126,12 +125,11 @@ test("#given component hook commands #when inspected #then standalone packages e
 
 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"),
+		...(await readAggregateCommandHooks()),
 		...componentHooks.flatMap(({ source, hooks }) => collectCommandHooks(hooks, source)),
 	];
 	const genericStatusMessages = commandHooks
@@ -144,11 +142,11 @@ test("#given hook status messages #when inspected #then labels describe OMO resp
 
 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);
+	const manifests = await readAggregateHookManifests();
+	const text = await readAggregateHooksText();
 
 	// when
-	const preToolUseGroups = hooks.hooks.PreToolUse;
+	const preToolUseGroups = manifests.filter(({ hooks }) => hooks.hooks.PreToolUse).flatMap(({ hooks }) => hooks.hooks.PreToolUse);
 
 	// then
 	assert.match(text, /components\/git-bash\/dist\/cli\.js/);
@@ -162,14 +160,17 @@ test("#given aggregate OMO plugin is enabled #when hooks are inspected #then she
 
 test("#given aggregate SessionStart hooks #when inspected #then LazyCodex auto-update is registered", async () => {
 	// given
-	const hooks = await readJson("hooks/hooks.json");
-	const text = JSON.stringify(hooks);
+	const manifests = await readAggregateHookManifests();
+	const text = await readAggregateHooksText();
 
 	// when
-	const sessionStartCommands = collectCommandHooks(hooks, "hooks/hooks.json")
+	const sessionStartCommands = (await readAggregateCommandHooks())
 		.filter(({ eventName }) => eventName === "SessionStart")
 		.map(({ handler }) => handler.command);
-	const autoUpdateGroup = hooks.hooks.SessionStart.find((group) => JSON.stringify(group).includes("scripts/auto-update.mjs"));
+	const autoUpdateGroup = manifests
+		.filter(({ hooks }) => hooks.hooks.SessionStart)
+		.flatMap(({ hooks }) => hooks.hooks.SessionStart)
+		.find((group) => JSON.stringify(group).includes("scripts/auto-update.mjs"));
 
 	// then
 	assert.equal(autoUpdateGroup?.matcher, "^startup$");
@@ -180,7 +181,7 @@ test("#given aggregate SessionStart hooks #when inspected #then LazyCodex auto-u
 
 test("#given aggregate plugin packaging #when inspected #then hooks and compatibility sentinels stay Python-free", async () => {
 	// given
-	const hooksText = await readFile(join(root, "hooks/hooks.json"), "utf8");
+	const hooksText = (await Promise.all((await readAggregateHookManifests()).map(({ source }) => readFile(join(root, source), "utf8")))).join("\n");
 	const aggregateTestText = await readFile(join(root, "test/aggregate.test.mjs"), "utf8");
 
 	// when

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

@@ -10,13 +10,16 @@ test("#given aggregate plugin manifest #when inspected #then it owns the omo nam
 	const manifest = await readJson(".codex-plugin/plugin.json");
 
 	// when
-	const hookPath = manifest.hooks;
+	const hookPaths = manifest.hooks;
 	const skillsPath = manifest.skills;
 	const mcpPath = manifest.mcpServers;
 
 	// then
 	assert.equal(manifest.name, "omo");
-	assert.equal(hookPath, "./hooks/hooks.json");
+	assert(Array.isArray(hookPaths));
+	assert.equal(hookPaths.length, 19);
+	assert(hookPaths.every((hookPath) => typeof hookPath === "string" && hookPath.startsWith("./hooks/")));
+	assert(!hookPaths.includes("./hooks/hooks.json"));
 	assert.equal(skillsPath, "./skills/");
 	assert.equal(mcpPath, "./.mcp.json");
 });

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

@@ -17,6 +17,19 @@ export async function readPluginVersion() {
 	return (await readJson(".codex-plugin/plugin.json")).version;
 }
 
+export async function readAggregateHookManifests() {
+	const manifest = await readJson(".codex-plugin/plugin.json");
+	const hookPaths = Array.isArray(manifest.hooks) ? manifest.hooks : [manifest.hooks];
+	return Promise.all(
+		hookPaths
+			.filter((hookPath) => typeof hookPath === "string")
+			.map(async (hookPath) => {
+				const source = hookPath.replace(/^\.\//, "");
+				return { source, hooks: await readJson(source) };
+			}),
+	);
+}
+
 export async function exists(relativePath) {
 	try {
 		await stat(join(root, relativePath));

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

@@ -50,7 +50,7 @@ async function writeVersionedRoot(root, version, { withRuntimeCli = false } = {}
 						hooks: [
 							{
 								command: 'node "${PLUGIN_ROOT}/components/bootstrap/dist/cli.js" hook session-start',
-								statusMessage: `LazyCodex(${version}): Checking Bootstrap Provisioning`,
+								statusMessage: "(OmO) Checking Bootstrap Provisioning",
 								timeout: 30,
 								type: "command",
 							},

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

@@ -3,7 +3,13 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import test from "node:test";
 
-import { collectCommandHooks, readComponentHookManifests, readJson, root } from "./aggregate-plugin-fixture.mjs";
+import {
+	collectCommandHooks,
+	readAggregateHookManifests,
+	readComponentHookManifests,
+	readJson,
+	root,
+} from "./aggregate-plugin-fixture.mjs";
 
 const PLUGIN_ROOT_TARGET_PATTERN = /\$\{PLUGIN_ROOT\}([^"']+)/g;
 const SKIPPED_DIRECTORY_NAMES = new Set([".git", "node_modules"]);
@@ -58,13 +64,13 @@ function collectPluginRootTargets(handler) {
 }
 
 async function readHookManifestsWithRoots() {
-	const aggregate = { source: "hooks/hooks.json", hooks: await readJson("hooks/hooks.json"), roots: [root] };
+	const aggregate = (await readAggregateHookManifests()).map(({ source, hooks }) => ({ source, hooks, roots: [root] }));
 	const components = (await readComponentHookManifests()).map(({ source, hooks }) => ({
 		source,
 		hooks,
 		roots: [dirname(dirname(join(root, source))), root],
 	}));
-	return [aggregate, ...components];
+	return [...aggregate, ...components];
 }
 
 function findBootstrapSessionStartHandlers(hooks) {
@@ -123,11 +129,13 @@ test("#given aggregate and component hook manifests #when command targets are re
 
 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 readJson("hooks/hooks.json");
+	const aggregateHooks = (await readAggregateHookManifests()).find(({ source }) =>
+		source.endsWith("session-start-checking-bootstrap-provisioning.json"),
+	)?.hooks;
 	const componentHooks = await readJson("components/bootstrap/hooks/hooks.json");
 
 	// when
-	const aggregateEntries = findBootstrapSessionStartHandlers(aggregateHooks);
+	const aggregateEntries = findBootstrapSessionStartHandlers(aggregateHooks ?? {});
 	const componentEntries = findBootstrapSessionStartHandlers(componentHooks);
 
 	// then
@@ -144,7 +152,7 @@ test("#given the bootstrap component #when its SessionStart registration is insp
 		assert.equal(typeof handler.timeout, "number");
 		assert(handler.timeout <= 60, `${label} bootstrap timeout must stay <= 60 seconds`);
 		assert.equal(typeof handler.statusMessage, "string");
-		assert.match(handler.statusMessage, /^LazyCodex\([^)]+\): .+$/);
+		assert.match(handler.statusMessage, /^\(OmO\) .+$/);
 	}
 });
 

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

@@ -3,10 +3,11 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import test from "node:test";
 
-import { collectCommandHooks, readJson, root } from "./aggregate-plugin-fixture.mjs";
+import { collectCommandHooks, readAggregateHookManifests, readJson, root } from "./aggregate-plugin-fixture.mjs";
 
 const BOOTSTRAP_SCRIPT_RELATIVE_PATH = join("components", "bootstrap", "scripts", "bootstrap.ps1");
-const HOOK_MANIFEST_SOURCES = ["hooks/hooks.json", "components/bootstrap/hooks/hooks.json"];
+const BOOTSTRAP_AGGREGATE_HOOK_SOURCE = "hooks/session-start-checking-bootstrap-provisioning.json";
+const HOOK_MANIFEST_SOURCES = [BOOTSTRAP_AGGREGATE_HOOK_SOURCE, "components/bootstrap/hooks/hooks.json"];
 const BOOTSTRAP_PS1_COMMAND_WINDOWS_TARGET = "\\components\\bootstrap\\scripts\\bootstrap.ps1";
 const TLS12_LINE_PATTERN =
 	/\[Net\.ServicePointManager\]::SecurityProtocol\s*=\s*\[Net\.ServicePointManager\]::SecurityProtocol\s+-bor\s+\[Net\.SecurityProtocolType\]::Tls12/;
@@ -114,9 +115,12 @@ test("#given bootstrap.ps1 #when every character is inspected #then the script i
 });
 
 test("#given the aggregate and bootstrap component hook manifests #when commandWindows entries are read #then the bootstrap SessionStart hook launches bootstrap.ps1", async () => {
+	const aggregateHooks = await readAggregateHookManifests();
 	for (const source of HOOK_MANIFEST_SOURCES) {
 		// given
-		const hooks = await readJson(source);
+		const hooks =
+			aggregateHooks.find((manifest) => manifest.source === source)?.hooks ??
+			(await readJson(source));
 
 		// when
 		const launchers = collectCommandHooks(hooks, source)

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

@@ -6,7 +6,7 @@ import { join } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import test from "node:test";
 
-import { readJson, root } from "./aggregate-plugin-fixture.mjs";
+import { readAggregateHookManifests, readJson, root } from "./aggregate-plugin-fixture.mjs";
 import { componentHookContractCases } from "./component-hook-contract-cases.mjs";
 
 const HOOK_EVENTS_BY_COMPONENT = {
@@ -142,8 +142,8 @@ test("#given malformed comment-checker stdin #when executed through dist CLI con
 
 test("#given aggregate hook manifest #when command hooks are inspected #then component CLI invocation contract is unchanged", async () => {
 	// given
-	const hooks = await readJson("hooks/hooks.json");
-	const commands = collectHookCommands(hooks.hooks);
+	const manifests = await readAggregateHookManifests();
+	const commands = manifests.flatMap(({ hooks }) => collectHookCommands(hooks.hooks));
 	const components = await workspaceComponents();
 
 	// when

package/packages/omo-codex/plugin/test/display-metadata.test.mjs

@@ -0,0 +1,83 @@
+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 { readJson, root } from "./aggregate-plugin-fixture.mjs";
+
+const hookSlugPattern = /^\.\/hooks\/[a-z0-9]+(?:-[a-z0-9]+)*\.json$/;
+const displayNamePrefix = "(OmO) ";
+
+async function exists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return false;
+		throw error;
+	}
+}
+
+async function readSkillName(skillPath) {
+	const content = await readFile(skillPath, "utf8");
+	const frontmatter = content.match(/^---\n(?<body>[\s\S]*?)\n---\n/);
+	assert(frontmatter?.groups?.body, `${skillPath} must have YAML frontmatter`);
+	const name = frontmatter.groups.body.match(/^name:\s*"?([^"\n]+)"?\s*$/m)?.[1]?.trim();
+	assert(name, `${skillPath} must have a frontmatter name`);
+	return name;
+}
+
+async function readOpenAiDisplayName(skillDir) {
+	const metadataPath = join(skillDir, "agents", "openai.yaml");
+	assert(await exists(metadataPath), `${basename(skillDir)} must include agents/openai.yaml`);
+	const content = await readFile(metadataPath, "utf8");
+	const displayName = content.match(/^\s*display_name:\s*"?([^"\n]+)"?\s*$/m)?.[1]?.trim();
+	assert(displayName, `${metadataPath} must define interface.display_name`);
+	return displayName;
+}
+
+test("#given Codex plugin hooks #when plugin metadata is inspected #then hook keys contain human-readable hook slugs", async () => {
+	// given
+	const manifest = await readJson(".codex-plugin/plugin.json");
+
+	// when
+	const hookPaths = manifest.hooks;
+
+	// then
+	assert(Array.isArray(hookPaths), "plugin manifest hooks must list per-hook metadata files");
+	assert(hookPaths.length > 0, "plugin manifest must expose at least one hook file");
+	for (const hookPath of hookPaths) {
+		assert.equal(typeof hookPath, "string");
+		assert.match(hookPath, hookSlugPattern);
+		assert.notEqual(hookPath, "./hooks/hooks.json");
+		const hooksJson = await readJson(hookPath.replace(/^\.\//, ""));
+		const commandHookCount = Object.values(hooksJson.hooks)
+			.flat()
+			.flatMap((group) => group.hooks)
+			.filter((hook) => hook.type === "command").length;
+		assert.equal(commandHookCount, 1, `${hookPath} should describe exactly one displayed hook`);
+	}
+});
+
+test("#given Codex plugin skills #when skill metadata is inspected #then every skill has an OmO display name", async () => {
+	// given
+	const skillsDir = join(root, "skills");
+	const skillEntries = await readdir(skillsDir, { withFileTypes: true });
+	const skillDirs = skillEntries.filter((entry) => entry.isDirectory()).map((entry) => join(skillsDir, entry.name));
+
+	// when
+	const invalidDisplayNames = [];
+	for (const skillDir of skillDirs) {
+		const skillPath = join(skillDir, "SKILL.md");
+		if (!(await exists(skillPath))) continue;
+		const skillName = await readSkillName(skillPath);
+		const displayName = await readOpenAiDisplayName(dirname(skillPath));
+		const expected = `${displayNamePrefix}${skillName}`;
+		if (displayName !== expected) {
+			invalidDisplayNames.push(`${basename(skillDir)}: expected ${expected}, got ${displayName}`);
+		}
+	}
+
+	// then
+	assert.deepEqual(invalidDisplayNames, []);
+});

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

@@ -68,6 +68,19 @@ async function readPluginVersion() {
 	return (await readJson(".codex-plugin/plugin.json")).version;
 }
 
+async function readAggregateHookManifests() {
+	const manifest = await readJson(".codex-plugin/plugin.json");
+	const hookPaths = Array.isArray(manifest.hooks) ? manifest.hooks : [manifest.hooks];
+	return Promise.all(
+		hookPaths
+			.filter((hookPath) => typeof hookPath === "string")
+			.map(async (hookPath) => {
+				const source = hookPath.replace(/^\.\//, "");
+				return { source, version: await readPluginVersion(), hooks: await readJson(source) };
+			}),
+	);
+}
+
 async function readComponentVersion(componentName) {
 	return (await readJson(join("components", componentName, "package.json"))).version;
 }
@@ -114,7 +127,7 @@ function collectCommandHooks(hooks, source, version) {
 	return commandHooks;
 }
 
-test("#given hook status label #when formatting #then prefixes LazyCodex with current version", async () => {
+test("#given hook status label #when formatting #then prefixes OmO display namespace", async () => {
 	// given
 	const version = (await readRepoJson("package.json")).version;
 	const label = "Checking Comments";
@@ -123,10 +136,10 @@ test("#given hook status label #when formatting #then prefixes LazyCodex with cu
 	const message = formatLazyCodexHookStatusMessage(version, label);
 
 	// then
-	assert.equal(message, `LazyCodex(${version}): Checking Comments`);
+	assert.equal(message, "(OmO) Checking Comments");
 });
 
-test("#given hook status label with blank version #when formatting #then prefixes LazyCodex with local version", () => {
+test("#given hook status label with blank version #when formatting #then still prefixes OmO display namespace", () => {
 	// given
 	const version = "  ";
 	const label = "Checking Comments";
@@ -135,7 +148,7 @@ test("#given hook status label with blank version #when formatting #then prefixe
 	const message = formatLazyCodexHookStatusMessage(version, label);
 
 	// then
-	assert.equal(message, "LazyCodex(local): Checking Comments");
+	assert.equal(message, "(OmO) Checking Comments");
 });
 
 test("#given loose legacy status label #when normalizing #then removes OMO wording and title-cases label", async () => {
@@ -149,7 +162,7 @@ test("#given loose legacy status label #when normalizing #then removes OMO wordi
 
 	// then
 	assert.equal(normalized, "Checking Comments");
-	assert.equal(message, `LazyCodex(${version}): Checking Comments`);
+	assert.equal(message, "(OmO) Checking Comments");
 });
 
 test("#given LazyCodex appears inside hook label #when normalizing #then product casing is preserved", async () => {
@@ -163,7 +176,7 @@ test("#given LazyCodex appears inside hook label #when normalizing #then product
 
 	// then
 	assert.equal(normalized, "Verifying LazyCodex Executor Evidence");
-	assert.equal(message, `LazyCodex(${version}): Verifying LazyCodex Executor Evidence`);
+	assert.equal(message, "(OmO) Verifying LazyCodex Executor Evidence");
 });
 
 test("#given MCP appears inside hook label #when normalizing #then protocol casing is preserved", () => {
@@ -176,31 +189,29 @@ test("#given MCP appears inside hook label #when normalizing #then protocol casi
 
 	// then
 	assert.equal(normalized, "Recommending Git Bash MCP");
-	assert.equal(message, "LazyCodex(4.10.0): Recommending Git Bash MCP");
+	assert.equal(message, "(OmO) Recommending Git Bash MCP");
 });
-test("#given aggregate comment-checker hook #when status is inspected #then it uses LazyCodex comments label", async () => {
+test("#given aggregate comment-checker hook #when status is inspected #then it uses OmO comments label", async () => {
 	// given
-	const aggregateVersion = await readPluginVersion();
-	const aggregateHooks = await readJson("hooks/hooks.json");
+	const aggregateManifests = await readAggregateHookManifests();
 
 	// when
-	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion);
-	const commentCheckerHook = hooks.find((hook) => hook.id === "hooks/hooks.json:PostToolUse:0:0");
+	const hooks = aggregateManifests.flatMap((manifest) => collectCommandHooks(manifest.hooks, manifest.source, manifest.version));
+	const commentCheckerHook = hooks.find((hook) => hook.command.includes("components/comment-checker/dist/cli.js"));
 
 	// then
-	assert.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage(aggregateVersion, "Checking Comments"));
-	assert.doesNotMatch(JSON.stringify(aggregateHooks), /checking\s+OMO\s+comments/i);
+	assert.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage("", "Checking Comments"));
+	assert.doesNotMatch(JSON.stringify(aggregateManifests), /checking\s+OMO\s+comments/i);
 });
 
-test("#given aggregate and component hooks #when status messages are inspected #then all use the LazyCodex formatter", async () => {
+test("#given aggregate and component hooks #when status messages are inspected #then all use the OmO formatter", async () => {
 	// given
-	const aggregateVersion = await readPluginVersion();
-	const aggregateHooks = await readJson("hooks/hooks.json");
+	const aggregateManifests = await readAggregateHookManifests();
 	const componentManifests = await readComponentHookManifests();
 
 	// when
 	const commandHooks = [
-		...collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion),
+		...aggregateManifests.flatMap((manifest) => collectCommandHooks(manifest.hooks, manifest.source, manifest.version)),
 		...componentManifests.flatMap((manifest) => collectCommandHooks(manifest.hooks, manifest.source, manifest.version)),
 	];
 	const expectedLabels = new Map([...AGGREGATE_EXPECTED_LABELS, ...COMPONENT_EXPECTED_LABELS]);
@@ -219,6 +230,6 @@ test("#given aggregate and component hooks #when status messages are inspected #
 	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);
+		assert.match(hook.statusMessage, /^\(OmO\) /);
 	}
 });

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

@@ -20,7 +20,7 @@ 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: "lcx-report-bug \(omo\)"/);
+	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-report-bug"/);
 	assert.match(interfaceMetadata, /- "lazycodex bug"/);
 	assert.match(interfaceMetadata, /- "openai codex bug"/);
 });
@@ -40,7 +40,7 @@ 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: "lcx-contribute-bug-fix \(omo\)"/);
+	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-contribute-bug-fix"/);
 	assert.match(interfaceMetadata, /- "contribute a bug fix"/);
 	assert.match(interfaceMetadata, /- "fix bug pr"/);
 });
@@ -55,7 +55,7 @@ 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: "lcx-doctor \(omo\)"/);
+	assert.match(interfaceMetadata, /display_name: "\(OmO\) lcx-doctor"/);
 	assert.match(interfaceMetadata, /- "lazycodex doctor"/);
 	assert.match(interfaceMetadata, /- "lazycodex health check"/);
 });

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

@@ -88,10 +88,10 @@ test("#given source package versions and component without hooks #when hook stat
 	const aggregateHooks = await readJson(join(root, "hooks", "hooks.json"));
 	const componentHooks = await readJson(join(root, "components", "comment-checker", "hooks", "hooks.json"));
 	const lspHooks = await readJson(join(root, "components", "lsp", "hooks", "hooks.json"));
-	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.0): Checking Comments");
-	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[1].statusMessage, "LazyCodex(0.1.0): Checking LSP Diagnostics");
-	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
-	assert.equal(lspHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.2.0): Checking LSP Diagnostics");
+	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "(OmO) Checking Comments");
+	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[1].statusMessage, "(OmO) Checking LSP Diagnostics");
+	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "(OmO) Checking Comments");
+	assert.equal(lspHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "(OmO) Checking LSP Diagnostics");
 });
 
 test("#given release version override #when hook status messages sync #then aggregate hooks use release version", async () => {
@@ -139,6 +139,6 @@ test("#given release version override #when hook status messages sync #then aggr
 	// then
 	const aggregateHooks = await readJson(join(root, "hooks", "hooks.json"));
 	const componentHooks = await readJson(join(root, "components", "comment-checker", "hooks", "hooks.json"));
-	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(4.8.0): Checking Comments");
-	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(4.8.0): Checking Comments");
+	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "(OmO) Checking Comments");
+	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "(OmO) Checking Comments");
 });

package/packages/omo-codex/plugin/test/sync-skills-test-support.mjs

@@ -22,6 +22,7 @@ export const expectedSkills = [
 	"review-work",
 	"rules",
 	"start-work",
+	"teammode",
 	"ultraresearch",
 	"ulw-loop",
 	"ulw-plan",
@@ -32,6 +33,7 @@ export const componentSkillSources = [
 	["comment-checker", "components/comment-checker/skills/comment-checker"],
 	["lsp", "components/lsp/skills/lsp"],
 	["rules", "components/rules/skills/rules"],
+	["teammode", "components/teammode/skills/teammode"],
 	["ulw-loop", "components/ulw-loop/skills/ulw-loop"],
 	["ulw-plan", "components/ultrawork/skills/ulw-plan"],
 ];

package/packages/omo-codex/plugin/test/sync-skills.test.mjs

@@ -17,6 +17,7 @@ import {
 const root = dirname(dirname(fileURLToPath(import.meta.url)));
 const repoRoot = join(root, "..", "..", "..");
 const opencodeOnlyToolPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
+const generatedSkillMetadataFiles = new Set(["agents/openai.yaml"]);
 
 async function readPackagedSkillFile(...segments) {
 	const path = join(root, "skills", ...segments);
@@ -24,6 +25,10 @@ async function readPackagedSkillFile(...segments) {
 	return { path, content };
 }
 
+function excludeGeneratedSkillMetadata(files) {
+	return files.filter((file) => !generatedSkillMetadataFiles.has(file.replaceAll("\\", "/")));
+}
+
 test("#given synced aggregate Codex skills #when inspected #then component and shared skills are present", async () => {
 	// given
 	const skillsRoot = join(root, "skills");
@@ -121,8 +126,8 @@ test("#given component skill sources #when aggregate Codex component skills are
 	for (const [skillName, sourcePath] of componentSkillSources) {
 		const sourceDir = join(root, sourcePath);
 		const aggregateDir = join(aggregateSkillsRoot, skillName);
-		const sourceFiles = await listSkillFiles(sourceDir);
-		const aggregateFiles = await listSkillFiles(aggregateDir);
+		const sourceFiles = excludeGeneratedSkillMetadata(await listSkillFiles(sourceDir));
+		const aggregateFiles = excludeGeneratedSkillMetadata(await listSkillFiles(aggregateDir));
 		assert.deepEqual(aggregateFiles, sourceFiles, `${skillName} resource set drifted from its component skill source`);
 		for (const relativePath of sourceFiles) {
 			const sourceContent = await readFile(join(sourceDir, relativePath), "utf8");
@@ -146,7 +151,7 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 
 	// then
 	assert.match(skill, /^---\r?\nname: ulw-loop\r?\n/m);
-	assert.match(interfaceMetadata, /display_name: "ulw-loop \(omo\)"/);
+	assert.match(interfaceMetadata, /display_name: "\(OmO\) ulw-loop"/);
 	assert.doesNotMatch(interfaceMetadata, /ulw-loop \/ ulw-loop/);
 	assert.match(interfaceMetadata, /short_description: "Goal-like ultrawork loop for systematic decomposition"/);
 	assert.match(interfaceMetadata, /default_prompt: "Use \$ulw-loop/);
@@ -179,7 +184,7 @@ test("#given synced git-master skill #when inspected #then commits and git histo
 	assert.match(skill, /Choose the Git tool by the question/);
 	assert.match(skill, /git log -S "text"/);
 	assert.match(skill, /git blame -L start,end -- file/);
-	assert.match(interfaceMetadata, /display_name: "git-master \(omo\)"/);
+	assert.match(interfaceMetadata, /display_name: "\(OmO\) git-master"/);
 	assert.match(interfaceMetadata, /- "git commit"/);
 	assert.match(interfaceMetadata, /- "history search"/);
 });