oh-my-opencode 4.7.0 → 4.7.1

package/packages/omo-codex/plugin/components/lsp/test/codex-hook-unavailable.test.ts

@@ -0,0 +1,206 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { runLspPostCompactHook, runLspPostToolUseHook } from "../src/codex-hook.js";
+
+const MARKSMAN_INITIALIZE_TIMEOUT = [
+	"LSP request timeout (method: initialize)",
+	'recent stderr: [01:16:41 INF] <LSP Entry> Starting Marksman LSP server: {"arch":"Arm64"}',
+	'[01:16:41 INF] <Folder> Loading folder documents: {"uri":"file:///repo"}',
+].join("\n");
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+	for (const tempDir of tempDirs.splice(0)) {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});
+
+describe("codex PostToolUse unavailable LSP suppression", () => {
+	it("#given unavailable markdown LSP in one session #when PostToolUse repeats #then suppresses feedback and skips the cached extension", async () => {
+		// given
+		const pluginData = tempPluginData();
+		const input = postToolUseInput("session-unavailable", ".omo/ulw-loop/evidence/note.md");
+		let calls = 0;
+
+		await withPluginData(pluginData, async () => {
+			// when
+			const firstOutput = await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return MARKSMAN_INITIALIZE_TIMEOUT;
+			});
+			const secondOutput = await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return "error[markdown] (1000) at 1:1: second call should have been skipped.";
+			});
+
+			// then
+			expect(firstOutput).toBe("");
+			expect(secondOutput).toBe("");
+			expect(calls).toBe(1);
+		});
+	});
+
+	it("#given cached unavailable LSP after PostCompact #when the next PostToolUse runs #then probes once and suppresses again", async () => {
+		// given
+		const pluginData = tempPluginData();
+		const input = postToolUseInput("session-compact", ".omo/ulw-loop/evidence/note.md");
+		let calls = 0;
+
+		await withPluginData(pluginData, async () => {
+			await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return MARKSMAN_INITIALIZE_TIMEOUT;
+			});
+			await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return "error[markdown] (1000) at 1:1: cached call should have been skipped.";
+			});
+
+			// when
+			const compactInput = {
+				cwd: "/repo",
+				hook_event_name: "PostCompact",
+				model: "gpt-5.5",
+				session_id: "session-compact",
+				transcript_path: null,
+				trigger: "manual",
+				turn_id: "turn-compact",
+			};
+			const compactOutput = await runLspPostCompactHook(compactInput);
+			const afterCompactOutput = await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return MARKSMAN_INITIALIZE_TIMEOUT;
+			});
+			await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return "error[markdown] (1000) at 1:1: post-compact cached call should have been skipped.";
+			});
+
+			// then
+			expect(compactOutput).toBe("");
+			expect(afterCompactOutput).toBe("");
+			expect(calls).toBe(2);
+		});
+	});
+
+	it("#given cached unavailable LSP after PostCompact #when the probe is clean #then clears the unavailable cache", async () => {
+		// given
+		const pluginData = tempPluginData();
+		const input = postToolUseInput("session-compact-clean", ".omo/ulw-loop/evidence/note.md");
+		let calls = 0;
+
+		await withPluginData(pluginData, async () => {
+			await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return MARKSMAN_INITIALIZE_TIMEOUT;
+			});
+			await runLspPostCompactHook({ session_id: "session-compact-clean" });
+
+			// when
+			const cleanProbeOutput = await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return "No diagnostics found";
+			});
+			const laterDiagnosticOutput = await runLspPostToolUseHook(input, async () => {
+				calls += 1;
+				return "error[markdown] (1000) at 1:1: recovered markdown diagnostic.";
+			});
+
+			// then
+			expect(cleanProbeOutput).toBe("");
+			expect(laterDiagnosticOutput).toContain("recovered markdown diagnostic");
+			expect(calls).toBe(3);
+		});
+	});
+
+	it("#given markdown LSP is cached unavailable #when TypeScript diagnostics run #then real diagnostics still block", async () => {
+		// given
+		const pluginData = tempPluginData();
+		const markdownInput = postToolUseInput("session-real-diagnostics", "README.md");
+		const typescriptInput = postToolUseInput("session-real-diagnostics", "src/broken.ts");
+
+		await withPluginData(pluginData, async () => {
+			await runLspPostToolUseHook(markdownInput, async () => MARKSMAN_INITIALIZE_TIMEOUT);
+
+			// when
+			const output = await runLspPostToolUseHook(
+				typescriptInput,
+				async () => "error[typescript] (2304) at 1:1: Cannot find name 'missing'.",
+			);
+
+			// then
+			const parsed: unknown = JSON.parse(output);
+			if (!isPostToolUseHookOutput(parsed)) throw new TypeError("Expected PostToolUse hook output");
+			expect(parsed.reason).toBe(
+				"LSP diagnostics after editing src/broken.ts:\n\n" +
+					"- error[typescript] (2304) at 1:1: Cannot find name 'missing'.",
+			);
+		});
+	});
+});
+
+function postToolUseInput(sessionId: string, filePath: string) {
+	return {
+		cwd: "/repo",
+		hook_event_name: "PostToolUse",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		session_id: sessionId,
+		tool_input: { path: filePath },
+		tool_name: "write",
+		tool_response: { ok: true },
+		tool_use_id: "tool-use-1",
+		transcript_path: null,
+		turn_id: "turn-1",
+	};
+}
+
+async function withPluginData(pluginData: string, fn: () => Promise<void>): Promise<void> {
+	const previous = process.env["PLUGIN_DATA"];
+	process.env["PLUGIN_DATA"] = pluginData;
+	try {
+		await fn();
+	} finally {
+		if (previous === undefined) {
+			delete process.env["PLUGIN_DATA"];
+		} else {
+			process.env["PLUGIN_DATA"] = previous;
+		}
+	}
+}
+
+function tempPluginData(): string {
+	const dir = mkdtempSync(path.join(tmpdir(), "codex-lsp-unavailable-"));
+	tempDirs.push(dir);
+	return dir;
+}
+
+interface PostToolUseHookOutput {
+	readonly decision: "block";
+	readonly reason: string;
+	readonly hookSpecificOutput: {
+		readonly hookEventName: "PostToolUse";
+		readonly additionalContext: string;
+	};
+}
+
+function isPostToolUseHookOutput(value: unknown): value is PostToolUseHookOutput {
+	if (!isRecord(value)) return false;
+	const hookSpecificOutput = value["hookSpecificOutput"];
+	return (
+		value["decision"] === "block" &&
+		typeof value["reason"] === "string" &&
+		isRecord(hookSpecificOutput) &&
+		hookSpecificOutput["hookEventName"] === "PostToolUse" &&
+		typeof hookSpecificOutput["additionalContext"] === "string"
+	);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/lsp/test/package-smoke.test.ts

@@ -61,7 +61,8 @@ describe("plugin package metadata", () => {
 		const sourceFiles = readdirSync("src");
 
 		// when
-		const command = hooksJson.hooks["PostToolUse"]?.[0]?.hooks[0]?.command;
+		const postToolUseCommand = hooksJson.hooks["PostToolUse"]?.[0]?.hooks[0]?.command;
+		const postCompactCommand = hooksJson.hooks["PostCompact"]?.[0]?.hooks[0]?.command;
 		const lspServer = mcpJson.mcpServers["lsp"];
 		const pluginRoot = ["$", "{PLUGIN_ROOT}"].join("");
 
@@ -75,8 +76,9 @@ describe("plugin package metadata", () => {
 		expect(packageJson.bin["codex-lsp"]).toBeUndefined();
 		expect(packageJson.scripts["build"]).toBe("node scripts/clean-dist.mjs && tsc -p tsconfig.build.json");
 		expect(cliSource.startsWith("#!/usr/bin/env node")).toBe(true);
-		expect(cliSource).toContain("Usage: omo-lsp [mcp | hook post-tool-use]");
-		expect(command).toBe(`node "${pluginRoot}/dist/cli.js" hook post-tool-use`);
+		expect(cliSource).toContain("Usage: omo-lsp [mcp | hook post-tool-use | hook post-compact]");
+		expect(postToolUseCommand).toBe(`node "${pluginRoot}/dist/cli.js" hook post-tool-use`);
+		expect(postCompactCommand).toBe(`node "${pluginRoot}/dist/cli.js" hook post-compact`);
 		expect(lspServer?.command).toBe("node");
 		expect(lspServer?.args).toEqual(["../../../../lsp-tools-mcp/dist/cli.js", "mcp"]);
 		expect(cliSource).not.toContain("./lazy-lsp-mcp.js");

package/packages/omo-codex/plugin/components/rules/src/codex-hook-options.ts

@@ -1,4 +1,5 @@
 export interface CodexRulesHookOptions {
 	env?: NodeJS.ProcessEnv;
 	pluginDataRoot?: string;
+	platform?: NodeJS.Platform;
 }

package/packages/omo-codex/plugin/components/rules/src/rules/finder.ts

@@ -36,6 +36,7 @@ export interface FinderOptions {
 	skipUserHome?: boolean;
 	/** Plugin root directory. Defaults to PLUGIN_ROOT env or this package root. */
 	pluginRoot?: string;
+	platform?: NodeJS.Platform;
 	cache?: RuleDiscoveryCache;
 }
 
@@ -43,8 +44,11 @@ interface PluginBundledFinderOptions {
 	readonly disabledSources?: ReadonlySet<string>;
 	readonly cache?: RuleDiscoveryCache;
 	readonly pluginRoot?: string;
+	readonly platform?: NodeJS.Platform;
 }
 
+const WINDOWS_GIT_BASH_BUNDLED_RULE_PATH = "bundled-rules/windows-git-bash.md";
+
 export function findRuleCandidates(options: FinderOptions): RuleCandidate[] {
 	const skipUserHome = options.skipUserHome ?? false;
 	const disabledSources = options.disabledSources ?? new Set<string>();
@@ -61,6 +65,7 @@ export function findRuleCandidates(options: FinderOptions): RuleCandidate[] {
 		disabledSources,
 		...(options.cache === undefined ? {} : { cache: options.cache }),
 		...(options.pluginRoot === undefined ? {} : { pluginRoot: options.pluginRoot }),
+		...(options.platform === undefined ? {} : { platform: options.platform }),
 	};
 	candidates.push(...findPluginBundledCandidates(pluginBundledOptions));
 
@@ -78,9 +83,10 @@ export function findPluginBundledCandidates(options: PluginBundledFinderOptions
 
 	const pluginRoot = resolvePluginRulesRoot(options.pluginRoot);
 	const ruleDirectory = join(pluginRoot, BUNDLED_RULE_SUBDIR);
+	const platform = options.platform ?? process.platform;
 	const candidates: RuleCandidate[] = [];
 	for (const scannedFile of scanRuleFilesCached(ruleDirectory, options.cache)) {
-		candidates.push({
+		const candidate: RuleCandidate = {
 			path: scannedFile.path,
 			realPath: scannedFile.realPath,
 			source: "plugin-bundled",
@@ -88,11 +94,18 @@ export function findPluginBundledCandidates(options: PluginBundledFinderOptions
 			isGlobal: true,
 			isSingleFile: false,
 			relativePath: toRelativePath(pluginRoot, scannedFile.path),
-		});
+		};
+		if (isPluginBundledCandidateEnabled(candidate, platform)) {
+			candidates.push(candidate);
+		}
 	}
 	return candidates;
 }
 
+function isPluginBundledCandidateEnabled(candidate: RuleCandidate, platform: NodeJS.Platform): boolean {
+	return candidate.relativePath !== WINDOWS_GIT_BASH_BUNDLED_RULE_PATH || platform === "win32";
+}
+
 function findProjectCandidates(
 	projectRoot: string,
 	targetFile: string | null,

package/packages/omo-codex/plugin/components/rules/src/rules-engine-factory.ts

@@ -7,11 +7,14 @@ import { findProjectRoot } from "./rules/project-root.js";
 
 interface RulesEngineFactoryOptions {
 	env?: NodeJS.ProcessEnv;
+	platform?: NodeJS.Platform;
 }
 
 export function createRulesEngine(options: RulesEngineFactoryOptions, config = configFromEnvironment(options.env)) {
+	const platform = options.platform ?? process.platform;
+
 	return createEngine(config, {
-		findCandidates: findRuleCandidates,
+		findCandidates: (finderOptions) => findRuleCandidates({ ...finderOptions, platform }),
 		findProjectRoot,
 		readFile: (path) => {
 			try {

package/packages/omo-codex/plugin/components/rules/test/windows-git-bash-bundled-rule.test.ts

@@ -3,7 +3,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
 
-import { runSessionStartHook, type CodexSessionStartInput } from "../src/codex-hook.js";
+import { type CodexSessionStartInput, runSessionStartHook } from "../src/codex-hook.js";
 import { findPluginBundledCandidates } from "../src/rules/finder.js";
 
 const WINDOWS_RULE_DESCRIPTION = "Windows Git Bash guidance for Codex";
@@ -61,34 +61,57 @@ function occurrenceCount(value: string, search: string): number {
 
 describe("Windows Git Bash bundled rule", () => {
 	it("#given packaged bundled rules #when discovering plugin-bundled candidates #then Windows Git Bash rule is included", () => {
-		const candidates = findPluginBundledCandidates({ pluginRoot: process.cwd() });
+		const candidates = findPluginBundledCandidates({ pluginRoot: process.cwd(), platform: "win32" });
 
 		expect(candidates.map((candidate) => candidate.relativePath)).toContain(WINDOWS_RULE_PATH);
 	});
 
-	it("#given bundled rules enabled #when SessionStart runs #then Windows Git Bash guidance is injected once", async () => {
+	it("#given packaged bundled rules off Windows #when discovering plugin-bundled candidates #then Windows Git Bash rule is excluded", () => {
+		const candidates = findPluginBundledCandidates({ pluginRoot: process.cwd(), platform: "darwin" });
+
+		expect(candidates.map((candidate) => candidate.relativePath)).not.toContain(WINDOWS_RULE_PATH);
+	});
+
+	it("#given bundled rules enabled on Windows #when SessionStart runs #then Windows Git Bash guidance is injected once", async () => {
 		const { root, pluginData } = makeProject();
 
 		const output = await runSessionStartHook(sessionStartInput(root), {
 			pluginDataRoot: pluginData,
 			env: BUNDLED_ONLY_ENV,
+			platform: "win32",
 		});
 
 		expect(occurrenceCount(output, WINDOWS_GUIDANCE)).toBe(1);
 	});
 
-	it("#given project rule with same description #when static rules load #then project guidance overrides bundled guidance", async () => {
+	it("#given bundled rules enabled off Windows #when SessionStart runs #then Windows Git Bash guidance is not injected", async () => {
+		const { root, pluginData } = makeProject();
+
+		const output = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: BUNDLED_ONLY_ENV,
+			platform: "darwin",
+		});
+
+		expect(output).not.toContain(WINDOWS_GUIDANCE);
+		expect(output).not.toContain(WINDOWS_RULE_PATH);
+	});
+
+	it("#given project rule with same description on Windows #when static rules load #then project guidance overrides bundled guidance", async () => {
 		const { root, pluginData } = makeProject();
 		const projectGuidance = "Project-specific Windows shell policy.";
 		mkdirSync(join(root, ".omo", "rules"), { recursive: true });
 		writeFileSync(
 			join(root, ".omo", "rules", "windows-git-bash.md"),
-			["---", `description: ${WINDOWS_RULE_DESCRIPTION}`, "alwaysApply: true", "---", "", projectGuidance].join("\n"),
+			["---", `description: ${WINDOWS_RULE_DESCRIPTION}`, "alwaysApply: true", "---", "", projectGuidance].join(
+				"\n",
+			),
 		);
 
 		const output = await runSessionStartHook(sessionStartInput(root), {
 			pluginDataRoot: pluginData,
 			env: PROJECT_AND_BUNDLED_ENV,
+			platform: "win32",
 		});
 
 		expect(output).toContain(projectGuidance);

package/packages/omo-codex/plugin/hooks/hooks.json

@@ -97,13 +97,13 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/comment-checker/dist/cli.js\" hook post-tool-use",
 						"timeout": 30,
-						"statusMessage": "LazyCodex(0.1.1): Checking Comments"
+						"statusMessage": "LazyCodex(0.1.0): Checking Comments"
 					},
 					{
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-tool-use",
 						"timeout": 60,
-						"statusMessage": "LazyCodex(0.2.0): Checking LSP Diagnostics"
+						"statusMessage": "LazyCodex(0.1.0): Checking LSP Diagnostics"
 					}
 				]
 			},
@@ -141,6 +141,17 @@
 						"statusMessage": "LazyCodex(0.1.0): Resetting Project Rule Cache"
 					}
 				]
+			},
+			{
+				"matcher": "manual|auto",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/components/lsp/dist/cli.js\" hook post-compact",
+						"timeout": 5,
+						"statusMessage": "LazyCodex(0.1.0): Resetting LSP Diagnostics Cache"
+					}
+				]
 			}
 		],
 		"Stop": [

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

@@ -44,13 +44,6 @@ async function readComponentVersions(root) {
 	return versions;
 }
 
-function componentVersionForCommand(command, componentVersions, fallbackVersion) {
-	for (const [componentName, version] of componentVersions.entries()) {
-		if (command.includes(`/components/${componentName}/dist/cli.js`)) return version;
-	}
-	return fallbackVersion;
-}
-
 function syncHooksJson(hooksJson, versionForCommand) {
 	for (const groups of Object.values(hooksJson.hooks)) {
 		for (const group of groups) {
@@ -76,7 +69,7 @@ export async function syncHookStatusMessages(root = defaultRoot) {
 	const componentVersions = await readComponentVersions(root);
 	const aggregateHooksPath = join(root, "hooks", "hooks.json");
 	const aggregateHooks = await readJson(aggregateHooksPath);
-	syncHooksJson(aggregateHooks, (command) => componentVersionForCommand(command, componentVersions, aggregateVersion));
+	syncHooksJson(aggregateHooks, () => aggregateVersion);
 	await writeJson(aggregateHooksPath, aggregateHooks);
 
 	for (const [componentName, version] of componentVersions.entries()) {

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

@@ -135,6 +135,22 @@ test("#given isolated components #when hooks are inspected #then commands stay i
 	assert.equal(await exists("scripts/migrate-codex-config.mjs"), true);
 });
 
+test("#given aggregate PostCompact hooks #when hooks are inspected #then LSP diagnostics cache reset is registered", async () => {
+	// given
+	const hooks = await readJson("hooks/hooks.json");
+
+	// when
+	const lspPostCompactHooks = collectCommandHooks(hooks, "hooks/hooks.json").filter(
+		(hook) =>
+			hook.eventName === "PostCompact" &&
+			hook.handler.command === 'node "${PLUGIN_ROOT}/components/lsp/dist/cli.js" hook post-compact',
+	);
+
+	// then
+	assert.equal(lspPostCompactHooks.length, 1);
+	assert.equal(lspPostCompactHooks[0]?.handler.statusMessage, "LazyCodex(0.1.0): 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");

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

@@ -24,6 +24,7 @@ const AGGREGATE_EXPECTED_LABELS = new Map([
 	["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: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"],
 ]);
@@ -31,6 +32,7 @@ const AGGREGATE_EXPECTED_LABELS = new Map([
 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/lsp/hooks/hooks.json:PostCompact:0:0", "Resetting LSP Diagnostics Cache"],
 	["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"],
@@ -70,26 +72,6 @@ async function readComponentHookManifests() {
 	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;
-		if (!(await exists(join("components", entry.name, "package.json")))) 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("\\", "/");
@@ -149,15 +131,15 @@ test("#given loose legacy status label #when normalizing #then removes OMO wordi
 
 test("#given aggregate comment-checker hook #when status is inspected #then it uses LazyCodex comments label", async () => {
 	// given
+	const aggregateVersion = (await readJson(".codex-plugin/plugin.json")).version;
 	const aggregateHooks = await readJson("hooks/hooks.json");
-	const componentVersions = await readComponentVersions();
 
 	// when
-	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", "0.1.0");
+	const hooks = collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion);
 	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.equal(commentCheckerHook?.statusMessage, formatLazyCodexHookStatusMessage(aggregateVersion, "Checking Comments"));
 	assert.doesNotMatch(JSON.stringify(aggregateHooks), /checking\s+OMO\s+comments/i);
 });
 
@@ -166,14 +148,10 @@ test("#given aggregate and component hooks #when status messages are inspected #
 	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),
-		})),
+		...collectCommandHooks(aggregateHooks, "hooks/hooks.json", aggregateVersion),
 		...componentManifests.flatMap((manifest) => collectCommandHooks(manifest.hooks, manifest.source, manifest.version)),
 	];
 	const expectedLabels = new Map([...AGGREGATE_EXPECTED_LABELS, ...COMPONENT_EXPECTED_LABELS]);

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

@@ -20,10 +20,12 @@ test("#given a component without hooks #when hook status messages sync #then bui
 	await mkdir(join(root, ".codex-plugin"), { recursive: true });
 	await mkdir(join(root, "hooks"), { recursive: true });
 	await mkdir(join(root, "components", "comment-checker", "hooks"), { recursive: true });
+	await mkdir(join(root, "components", "lsp", "hooks"), { recursive: true });
 	await mkdir(join(root, "components", "git-bash"), { recursive: true });
 	await mkdir(join(root, "components", "stale-build-output", "dist"), { recursive: true });
 	await writeJson(join(root, ".codex-plugin", "plugin.json"), { version: "0.1.0" });
 	await writeJson(join(root, "components", "comment-checker", "package.json"), { version: "0.1.1" });
+	await writeJson(join(root, "components", "lsp", "package.json"), { version: "0.2.0" });
 	await writeJson(join(root, "components", "git-bash", "package.json"), { version: "0.3.0" });
 	await writeJson(join(root, "hooks", "hooks.json"), {
 		hooks: {
@@ -35,6 +37,11 @@ test("#given a component without hooks #when hook status messages sync #then bui
 							command: 'node "${PLUGIN_ROOT}/components/comment-checker/dist/cli.js" hook post-tool-use',
 							statusMessage: "LazyCodex(0.1.0): Checking Comments",
 						},
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/components/lsp/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking LSP Diagnostics",
+						},
 					],
 				},
 			],
@@ -55,6 +62,21 @@ test("#given a component without hooks #when hook status messages sync #then bui
 			],
 		},
 	});
+	await writeJson(join(root, "components", "lsp", "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking LSP Diagnostics",
+						},
+					],
+				},
+			],
+		},
+	});
 
 	// when
 	await syncHookStatusMessages(root);
@@ -62,6 +84,9 @@ test("#given a component without hooks #when hook status messages sync #then bui
 	// 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(0.1.1): Checking Comments");
+	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");
 });

package/packages/omo-codex/scripts/install/permissions.mjs

@@ -1,9 +1,14 @@
 import { appendBlock, findTomlSection, removeSetting, replaceOrInsertRootSetting, replaceOrInsertSetting } from "./toml-editor.mjs";
 
+const AUTONOMOUS_FEATURES = ["multi_agent", "child_agents_md", "unified_exec", "goals"];
+
 export function ensureAutonomousPermissions(config) {
 	let next = replaceOrInsertRootSetting(config, "approval_policy", JSON.stringify("never"));
 	next = replaceOrInsertRootSetting(next, "sandbox_mode", JSON.stringify("danger-full-access"));
 	next = replaceOrInsertRootSetting(next, "network_access", JSON.stringify("enabled"));
+	for (const featureName of AUTONOMOUS_FEATURES) {
+		next = ensureFeatureEnabled(next, featureName);
+	}
 	next = removeWindowsSandboxSetting(next);
 	next = ensureNoticeEnabled(next, "hide_full_access_warning");
 	return ensureNoticeEnabled(next, "hide_world_writable_warning");
@@ -21,6 +26,12 @@ function ensureNoticeEnabled(config, key) {
 	return replaceOrInsertSetting(config, section, key, "true");
 }
 
+function ensureFeatureEnabled(config, key) {
+	const section = findTomlSection(config, "features");
+	if (!section) return appendBlock(config, `[features]\n${key} = true\n`);
+	return replaceOrInsertSetting(config, section, key, "true");
+}
+
 function appendNoticeBlock(config, key) {
 	return appendBlock(config, `[notice]\n${key} = true\n`);
 }