oh-my-opencode 4.5.12 → 4.7.0

package/packages/omo-codex/plugin/components/git-bash/test/codex-hook.test.ts

@@ -0,0 +1,195 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Readable, Writable } from "node:stream";
+
+import {
+	applyGitBashPostCompactReset,
+	applyGitBashPreToolUseReminder,
+	runGitBashHookCli,
+	type PostCompactPayload,
+	type PreToolUsePayload,
+} from "../src/codex-hook.js";
+
+const temporaryDirectories: string[] = [];
+
+function createTemporaryDirectory(prefix: string): string {
+	const directory = mkdtempSync(join(tmpdir(), prefix));
+	temporaryDirectories.push(directory);
+	return directory;
+}
+
+afterEach(() => {
+	for (const directory of temporaryDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function preToolPayload(toolName: string, sessionId = "session-1"): PreToolUsePayload {
+	return {
+		cwd: "/repo",
+		hook_event_name: "PreToolUse",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		session_id: sessionId,
+		tool_input: { command: "pwd" },
+		tool_name: toolName,
+		tool_use_id: "call-1",
+		transcript_path: null,
+		turn_id: "turn-1",
+	};
+}
+
+function postCompactPayload(sessionId = "session-1"): PostCompactPayload {
+	return {
+		hook_event_name: "PostCompact",
+		session_id: sessionId,
+		transcript_path: null,
+		trigger: "manual",
+	};
+}
+
+function windowsEnv(): NodeJS.ProcessEnv {
+	return { OS: "Windows_NT", ComSpec: "C:\\Windows\\System32\\cmd.exe" };
+}
+
+function captureStdout(): { readonly stdout: Writable; readonly read: () => string } {
+	let captured = "";
+	const stdout = new Writable({
+		write(chunk: unknown, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void {
+			captured += chunk instanceof Buffer ? chunk.toString() : String(chunk);
+			callback();
+		},
+	});
+	return { stdout, read: () => captured };
+}
+
+describe("applyGitBashPreToolUseReminder", () => {
+	it("#given first Windows Bash call #when hook runs #then emits non-blocking git_bash guidance", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+
+		// when
+		const output = applyGitBashPreToolUseReminder(preToolPayload("Bash"), {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		const parsed = JSON.parse(output);
+		expect(parsed.hookSpecificOutput).toEqual({
+			hookEventName: "PreToolUse",
+			additionalContext:
+				"On Windows, prefer the OMO git_bash MCP for shell commands before using built-in exec_command. Use exec_command only when git_bash is unavailable or for non-shell operations.",
+		});
+	});
+
+	it("#given second Windows Bash call in same session #when hook runs #then it stays silent", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const payload = preToolPayload("Bash");
+
+		// when
+		const first = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+		const second = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+
+		// then
+		expect(first).toContain("git_bash");
+		expect(second).toBe("");
+	});
+
+	it("#given non-Windows Bash call #when hook runs #then it stays silent", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+
+		// when
+		const output = applyGitBashPreToolUseReminder(preToolPayload("Bash"), {
+			env: {},
+			platform: "darwin",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given non-Bash tool call #when hook runs #then it stays silent", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+
+		// when
+		const output = applyGitBashPreToolUseReminder(preToolPayload("exec_command"), {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(output).toBe("");
+	});
+});
+
+describe("applyGitBashPostCompactReset", () => {
+	it("#given reminder already emitted #when PostCompact runs #then next Windows Bash call emits reminder again", () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const payload = preToolPayload("Bash");
+		const first = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+		const second = applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+
+		// when
+		applyGitBashPostCompactReset(postCompactPayload(), { pluginDataRoot });
+		const afterCompact = applyGitBashPreToolUseReminder(payload, {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(first).toContain("git_bash");
+		expect(second).toBe("");
+		expect(afterCompact).toContain("git_bash");
+	});
+});
+
+describe("runGitBashHookCli", () => {
+	it("#given Codex PreToolUse stdin on Windows #when CLI hook runs #then it writes reminder JSON", async () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const stdin = Readable.from([JSON.stringify(preToolPayload("Bash"))]);
+		const capture = captureStdout();
+
+		// when
+		await runGitBashHookCli(stdin, capture.stdout, "pre-tool-use", {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(capture.read()).toContain("git_bash MCP");
+	});
+
+	it("#given PostCompact stdin #when CLI hook runs #then it resets the one-shot reminder", async () => {
+		// given
+		const pluginDataRoot = createTemporaryDirectory("omo-git-bash-hook-");
+		const payload = preToolPayload("Bash");
+		applyGitBashPreToolUseReminder(payload, { env: windowsEnv(), platform: "linux", pluginDataRoot });
+		const resetStdin = Readable.from([JSON.stringify(postCompactPayload())]);
+		const capture = captureStdout();
+
+		// when
+		await runGitBashHookCli(resetStdin, capture.stdout, "post-compact", { pluginDataRoot });
+		const afterCompact = applyGitBashPreToolUseReminder(payload, {
+			env: windowsEnv(),
+			platform: "linux",
+			pluginDataRoot,
+		});
+
+		// then
+		expect(capture.read()).toBe("");
+		expect(afterCompact).toContain("git_bash");
+	});
+});

package/packages/omo-codex/plugin/components/git-bash/tsconfig.build.json

@@ -0,0 +1,13 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": false,
+		"declaration": true,
+		"outDir": "dist",
+		"rootDir": "src",
+		"noEmit": false,
+		"types": ["node"]
+	},
+	"include": ["src/**/*"],
+	"exclude": ["test/**/*"]
+}

package/packages/omo-codex/plugin/components/git-bash/tsconfig.json

@@ -0,0 +1,25 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"lib": ["ES2022"],
+		"strict": true,
+		"exactOptionalPropertyTypes": true,
+		"noUncheckedIndexedAccess": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"verbatimModuleSyntax": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"esModuleInterop": true,
+		"allowImportingTsExtensions": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"types": ["node", "bun-types"],
+		"noEmit": true
+	},
+	"include": ["src/**/*", "test/**/*"]
+}

package/packages/omo-codex/plugin/components/lsp/README.md

@@ -118,7 +118,7 @@ printf '%s\n' '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node dist/cli.j
 ## Local Codex Installation
 
 ```bash
-bunx lazycodex install
+npx lazycodex-ai install
 ```
 
 The installer builds and copies the plugin into `~/.codex/plugins/cache/sisyphuslabs/omo/0.1.0`, registers the `sisyphuslabs` marketplace from the `lazycodex` Git repository, and enables:

package/packages/omo-codex/plugin/components/lsp/src/cli.ts

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { dirname, resolve } from "node:path";
+import { createRequire } from "node:module";
 import { argv, execPath, stderr } from "node:process";
-import { fileURLToPath } from "node:url";
 
-import { runPostToolUseHookCli } from "./codex-hook.js";
+import { runPostToolUseHookCli } from "./codex-hook-cli.js";
 
-const PACKAGE_LSP_MCP_CLI = "../../../../../lsp-tools-mcp/dist/cli.js";
+const require = createRequire(import.meta.url);
+const PACKAGE_LSP_MCP_CLI = "@code-yeongyu/lsp-tools-mcp/dist/cli.js";
 
 async function main(): Promise<void> {
 	const [command = "mcp", subcommand = ""] = argv.slice(2);
@@ -31,7 +31,7 @@ main().catch((error: unknown) => {
 });
 
 async function runPackageLspMcpCli(): Promise<void> {
-	const cliPath = resolve(dirname(fileURLToPath(import.meta.url)), PACKAGE_LSP_MCP_CLI);
+	const cliPath = require.resolve(PACKAGE_LSP_MCP_CLI);
 	const child = spawn(execPath, [cliPath, "mcp"], { stdio: "inherit" });
 	await new Promise<void>((resolve, reject) => {
 		child.once("error", reject);

package/packages/omo-codex/plugin/components/lsp/src/codex-hook-cli.ts

@@ -0,0 +1,33 @@
+import { stdin as processStdin } from "node:process";
+
+import { disposeDefaultLspManager } from "@code-yeongyu/lsp-tools-mcp/dist/lsp/manager.js";
+
+import { isRecord, runLspPostToolUseHook } from "./codex-hook.js";
+
+export async function runPostToolUseHookCli(stdin: NodeJS.ReadStream = processStdin): Promise<void> {
+	try {
+		const raw = await readStdin(stdin);
+		if (!raw.trim()) return;
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(raw);
+		} catch (error) {
+			if (error instanceof SyntaxError) return;
+			throw error;
+		}
+		const input = isRecord(parsed) ? parsed : {};
+		const output = await runLspPostToolUseHook(input);
+		if (output) process.stdout.write(output);
+	} finally {
+		await disposeDefaultLspManager();
+	}
+}
+
+async function readStdin(stdin: NodeJS.ReadStream): Promise<string> {
+	stdin.setEncoding("utf8");
+	let raw = "";
+	for await (const chunk of stdin) {
+		raw += chunk;
+	}
+	return raw;
+}

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

@@ -1,8 +1,6 @@
 import { readFileSync } from "node:fs";
-import { stdin as processStdin } from "node:process";
 
-import { disposeDefaultLspManager } from "../../../../../lsp-tools-mcp/dist/lsp/manager.js";
-import { executeLspDiagnostics } from "../../../../../lsp-tools-mcp/dist/tools.js";
+import { executeLspDiagnostics } from "@code-yeongyu/lsp-tools-mcp/dist/tools.js";
 
 export type DiagnosticsRunner = (filePath: string) => Promise<string>;
 
@@ -91,13 +89,29 @@ async function collectDiagnostics(
 			nextIndex += 1;
 			const filePath = filePaths[index];
 			if (filePath === undefined) return;
-			results[index] = { filePath, diagnostics: (await runDiagnostics(filePath)).trim() };
+			results[index] = { filePath, diagnostics: await collectFileDiagnostics(filePath, runDiagnostics) };
 		}
 	}
 	await Promise.all(Array.from({ length: workerCount }, () => worker()));
 	return results;
 }
 
+async function collectFileDiagnostics(filePath: string, runDiagnostics: DiagnosticsRunner): Promise<string> {
+	try {
+		return (await runDiagnostics(filePath)).trim();
+	} catch (error) {
+		return formatDiagnosticsError(error);
+	}
+}
+
+function formatDiagnosticsError(error: unknown): string {
+	if (error instanceof Error) {
+		const message = error.message.trim();
+		if (message.length > 0) return message;
+	}
+	return String(error).trim();
+}
+
 function formatDiagnosticBlock({ filePath, diagnostics }: DiagnosticBlock): string {
 	return `LSP diagnostics after editing ${filePath}:\n\n${formatDiagnosticsForDisplay(diagnostics)}`;
 }
@@ -191,19 +205,6 @@ export function extractMutatedFilePaths(input: CodexPostToolUseInput): string[]
 	return [...paths];
 }
 
-export async function runPostToolUseHookCli(stdin: NodeJS.ReadStream = processStdin): Promise<void> {
-	try {
-		const raw = await readStdin(stdin);
-		if (!raw.trim()) return;
-		const parsed: unknown = JSON.parse(raw);
-		const input = isRecord(parsed) ? parsed : {};
-		const output = await runLspPostToolUseHook(input);
-		if (output) process.stdout.write(output);
-	} finally {
-		await disposeDefaultLspManager();
-	}
-}
-
 function isMutationTool(value: unknown): boolean {
 	if (typeof value !== "string") return false;
 	return MUTATION_TOOL_NAMES.has(value.toLowerCase());
@@ -271,15 +272,6 @@ function addPatchFiles(paths: Set<string>, value: unknown): void {
 	}
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
+export function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-
-async function readStdin(stdin: NodeJS.ReadStream): Promise<string> {
-	stdin.setEncoding("utf8");
-	let raw = "";
-	for await (const chunk of stdin) {
-		raw += chunk;
-	}
-	return raw;
-}

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

@@ -0,0 +1,28 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { describe, expect, it } from "vitest";
+
+describe("codex PostToolUse hook CLI", () => {
+	it("#given malformed post-tool-use stdin #when hook CLI runs #then it no-ops without stderr", () => {
+		// given
+		const input = "break;\n";
+
+		// when
+		const result = runBuiltHookCli(input);
+
+		// then
+		expect(result.status).toBe(0);
+		expect(result.stderr).toBe("");
+		expect(result.stdout).toBe("");
+	});
+});
+
+function runBuiltHookCli(input: string): ReturnType<typeof spawnSync> {
+	const cliPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../dist/cli.js");
+	return spawnSync(process.execPath, [cliPath, "hook", "post-tool-use"], {
+		input,
+		encoding: "utf8",
+	});
+}

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

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import { runLspPostToolUseHook } from "../src/codex-hook.js";
+
+describe("codex PostToolUse diagnostics errors", () => {
+	it("#given diagnostics runner throws for a mutated file #when the hook evaluates diagnostics #then it returns blocked output with the thrown message", async () => {
+		// given
+		const output = await runLspPostToolUseHook(
+			{
+				tool_name: "write",
+				tool_input: { path: "src/missing.ts" },
+				tool_response: { ok: true },
+			},
+			async (filePath) => {
+				expect(filePath).toBe("src/missing.ts");
+				throw new Error("ENOENT: no such file or directory, open 'src/missing.ts'");
+			},
+		);
+
+		// when
+		const parsed: unknown = JSON.parse(output);
+		if (!isPostToolUseHookOutput(parsed)) throw new TypeError("Expected PostToolUse hook output");
+
+		// then
+		expect(parsed.reason).toBe(
+			"LSP diagnostics after editing src/missing.ts:\n\nENOENT: no such file or directory, open 'src/missing.ts'",
+		);
+		expect(parsed.hookSpecificOutput.additionalContext).toBe(parsed.reason);
+	});
+});
+
+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

@@ -56,6 +56,7 @@ describe("plugin package metadata", () => {
 		const hooksJson = readHooksJson("hooks/hooks.json");
 		const mcpJson = readMcpJson(".mcp.json");
 		const cliSource = readFileSync("src/cli.ts", "utf8");
+		const codexHookCliSource = readFileSync("src/codex-hook-cli.ts", "utf8");
 		const codexHookSource = readFileSync("src/codex-hook.ts", "utf8");
 		const sourceFiles = readdirSync("src");
 
@@ -79,11 +80,12 @@ describe("plugin package metadata", () => {
 		expect(lspServer?.command).toBe("node");
 		expect(lspServer?.args).toEqual(["../../../../lsp-tools-mcp/dist/cli.js", "mcp"]);
 		expect(cliSource).not.toContain("./lazy-lsp-mcp.js");
-		expect(cliSource).not.toContain("@code-yeongyu/lsp-tools-mcp");
-		expect(cliSource).toContain("../../../../../lsp-tools-mcp/dist/cli.js");
-		expect(codexHookSource).not.toContain("@code-yeongyu/lsp-tools-mcp");
-		expect(codexHookSource).toContain("../../../../../lsp-tools-mcp/dist/lsp/manager.js");
-		expect(codexHookSource).toContain("../../../../../lsp-tools-mcp/dist/tools.js");
+		expect(cliSource).toContain("@code-yeongyu/lsp-tools-mcp/dist/cli.js");
+		expect(cliSource).not.toContain("../../../../../lsp-tools-mcp/dist/cli.js");
+		expect(codexHookCliSource).toContain("@code-yeongyu/lsp-tools-mcp/dist/lsp/manager.js");
+		expect(codexHookSource).toContain("@code-yeongyu/lsp-tools-mcp/dist/tools.js");
+		expect(codexHookCliSource).not.toContain("../../../../../lsp-tools-mcp/dist/lsp/manager.js");
+		expect(codexHookSource).not.toContain("../../../../../lsp-tools-mcp/dist/tools.js");
 		expect(sourceFiles.filter((name) => name.startsWith("lazy-mcp") || name === "lazy-lsp-mcp.ts")).toEqual([]);
 	});
 

package/packages/omo-codex/plugin/components/rules/README.md

@@ -43,7 +43,7 @@ Prefer strict TypeScript and keep runtime imports ESM-compatible.
 ## Install Locally
 
 ```bash
-bunx lazycodex install
+npx lazycodex-ai install
 ```
 
 The local installer builds the plugin and copies a clean cache entry to:

package/packages/omo-codex/plugin/components/rules/bundled-rules/hephaestus.md

@@ -79,13 +79,15 @@ omo-codex bundles three read-only Codex subagent roles in `CODEX_HOME/agents/`:
 
 **Routing:**
 
-- "Where is X?" / "Find code that does Y" -> `spawn_agent(agent_type="explorer", ...)`
-- "How does library Z work?" / "What's the API contract?" -> `spawn_agent(agent_type="librarian", ...)`
-- 5+ interdependent steps, ambiguous scope, multi-module work -> `spawn_agent(agent_type="plan", ...)`
-- Heavy verification of a finished change -> `spawn_agent(agent_type="codex-ultrawork-reviewer", ...)`
+- "Where is X?" / "Find code that does Y" -> `spawn_agent(agent_type="explorer", fork_turns="none", ...)`
+- "How does library Z work?" / "What's the API contract?" -> `spawn_agent(agent_type="librarian", fork_turns="none", ...)`
+- 5+ interdependent steps, ambiguous scope, multi-module work -> `spawn_agent(agent_type="plan", fork_turns="none", ...)`
+- Heavy verification of a finished change -> `spawn_agent(agent_type="codex-ultrawork-reviewer", fork_turns="none", ...)`
 
 **Don't duplicate.** Once a subagent is dispatched for a question, do not re-do the same search yourself. Once results return, do not re-verify by repeating their tool calls; integrate and move on.
 
+**Keep parent liveness visible.** While any child is active, keep the parent visibly alive with brief status updates that include active subagent count, agent names, last heartbeat, and whether the parent is waiting for mailbox updates. Do this during long `wait_agent` cycles so the session does not look idle while children are still running.
+
 # Operating Loop
 
 **Explore -> Plan -> Implement -> Verify -> Manually QA.** Loops are short and tight; do not loop back with a draft when the work is yours to do.

package/packages/omo-codex/plugin/components/rules/bundled-rules/windows-git-bash.md

@@ -0,0 +1,10 @@
+---
+description: Windows Git Bash guidance for Codex
+alwaysApply: true
+---
+
+On Windows native Codex sessions, prefer Git Bash for shell commands.
+
+Use `shell: "bash"` when `bash.exe` is on PATH. Otherwise use the absolute Git Bash path from `OMO_CODEX_GIT_BASH_PATH` or `C:\Program Files\Git\bin\bash.exe`.
+
+Use PowerShell only for Windows-native operations that need PowerShell.

package/packages/omo-codex/plugin/components/rules/src/post-compact-budget.ts

@@ -24,8 +24,6 @@ const MODEL_CONTEXT_BUDGETS: readonly ModelContextBudget[] = [
 	{ slug: "gpt-5.5", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
 	{ slug: "gpt-5.4", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
 	{ slug: "gpt-5.4-mini", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
-	{ slug: "gpt-5.3-codex", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
-	{ slug: "gpt-5.2", contextWindowTokens: 272_000, effectivePercent: DEFAULT_EFFECTIVE_CONTEXT_WINDOW_PERCENT },
 	{
 		slug: "codex-auto-review",
 		contextWindowTokens: 272_000,

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

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 
 type PackageJson = {
@@ -51,6 +51,7 @@ describe("plugin package metadata", () => {
 		const pluginJson = readPluginJson(".codex-plugin/plugin.json");
 		const hooksJson = readHooksJson("hooks/hooks.json");
 		const cliSource = readFileSync("src/cli.ts", "utf8");
+		const bundledRules = readdirSync("bundled-rules").sort();
 
 		// when
 		const hookConfig = hooksJson.hooks;
@@ -69,6 +70,7 @@ describe("plugin package metadata", () => {
 		expect(packageJson.dependencies ?? {}).toEqual({ picomatch: "^4.0.3" });
 		expect(packageJson.bin["omo-rules"]).toBe("./dist/cli.js");
 		expect(packageJson.files).toContain("bundled-rules");
+		expect(bundledRules).toContain("windows-git-bash.md");
 		expect(pluginJson.hooks).toBe("./hooks/hooks.json");
 		expect(cliSource.startsWith("#!/usr/bin/env node")).toBe(true);
 		expect(commands).toEqual([

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

@@ -0,0 +1,97 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+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 { findPluginBundledCandidates } from "../src/rules/finder.js";
+
+const WINDOWS_RULE_DESCRIPTION = "Windows Git Bash guidance for Codex";
+const WINDOWS_RULE_PATH = "bundled-rules/windows-git-bash.md";
+const WINDOWS_GUIDANCE = "On Windows native Codex sessions, prefer Git Bash for shell commands.";
+const BUNDLED_ONLY_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: "plugin-bundled",
+};
+const PROJECT_AND_BUNDLED_ENV = {
+	CODEX_RULES_ENABLED_SOURCES: ".omo/rules,plugin-bundled",
+};
+const tempDirectories: string[] = [];
+let originalPluginRoot: string | undefined;
+
+afterEach(() => {
+	restoreEnv("PLUGIN_ROOT", originalPluginRoot);
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+function makeProject(): { readonly root: string; readonly pluginData: string } {
+	originalPluginRoot = process.env["PLUGIN_ROOT"];
+	process.env["PLUGIN_ROOT"] = process.cwd();
+	const root = mkdtempSync(join(tmpdir(), "codex-rules-windows-git-bash-project-"));
+	const pluginData = mkdtempSync(join(tmpdir(), "codex-rules-windows-git-bash-data-"));
+	tempDirectories.push(root, pluginData);
+	writeFileSync(join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+	return { root, pluginData };
+}
+
+function sessionStartInput(root: string): CodexSessionStartInput {
+	return {
+		session_id: "session-1",
+		transcript_path: null,
+		cwd: root,
+		hook_event_name: "SessionStart",
+		model: "gpt-5.5",
+		permission_mode: "default",
+		source: "startup",
+	};
+}
+
+function restoreEnv(name: string, value: string | undefined): void {
+	if (value === undefined) {
+		delete process.env[name];
+		return;
+	}
+	process.env[name] = value;
+}
+
+function occurrenceCount(value: string, search: string): number {
+	return value.split(search).length - 1;
+}
+
+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() });
+
+		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 () => {
+		const { root, pluginData } = makeProject();
+
+		const output = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: BUNDLED_ONLY_ENV,
+		});
+
+		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 () => {
+		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"),
+		);
+
+		const output = await runSessionStartHook(sessionStartInput(root), {
+			pluginDataRoot: pluginData,
+			env: PROJECT_AND_BUNDLED_ENV,
+		});
+
+		expect(output).toContain(projectGuidance);
+		expect(output).not.toContain(WINDOWS_GUIDANCE);
+	});
+});