oh-my-opencode 4.5.12 → 4.7.0

package/packages/omo-codex/scripts/install-config-reasoning.test.mjs

@@ -0,0 +1,141 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { updateCodexConfig } from "./install/config.mjs";
+
+test("#given empty Codex config #when script installer updates config #then sets worker model and reasoning defaults", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-reasoning-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /model_context_window = 400000/);
+	assert.match(content, /model_reasoning_effort = "high"/);
+	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
+});
+
+test("#given existing model and reasoning config #when script installer updates config #then replaces stale defaults without duplicate keys", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-reasoning-existing-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "gpt-5.2"',
+			"model_context_window = 272000",
+			'model_reasoning_effort = "low"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+			"[features]",
+			"plugins = false",
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.equal(content.match(/^model\s*=/gm)?.length, 1);
+	assert.equal(content.match(/^model_context_window\s*=/gm)?.length, 1);
+	assert.equal(content.match(/^model_reasoning_effort\s*=/gm)?.length, 1);
+	assert.equal(content.match(/^plan_mode_reasoning_effort\s*=/gm)?.length, 1);
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /model_context_window = 400000/);
+	assert.match(content, /model_reasoning_effort = "high"/);
+	assert.match(content, /plan_mode_reasoning_effort = "xhigh"/);
+	assert.doesNotMatch(content, /model = "gpt-5\.2"/);
+	assert.doesNotMatch(content, /model_context_window = 272000/);
+	assert.doesNotMatch(content, /model_reasoning_effort = "low"/);
+	assert.doesNotMatch(content, /plan_mode_reasoning_effort = "medium"/);
+});
+
+test("#given user-customized model config #when script installer updates config #then preserves user reasoning values", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-reasoning-custom-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'model = "my-private-model"',
+			"model_context_window = 123456",
+			'model_reasoning_effort = "medium"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /model = "my-private-model"/);
+	assert.match(content, /model_context_window = 123456/);
+	assert.match(content, /model_reasoning_effort = "medium"/);
+	assert.match(content, /plan_mode_reasoning_effort = "medium"/);
+});
+
+test("#given bundled model catalog #when script installer updates config #then reads defaults from catalog", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-reasoning-catalog-"));
+	const repoRoot = join(root, "omo-codex");
+	const configPath = join(root, "config.toml");
+	await mkdir(join(repoRoot, "plugin"), { recursive: true });
+	await writeFile(
+		join(repoRoot, "plugin", "model-catalog.json"),
+		JSON.stringify({
+			version: "test.catalog",
+			current: {
+				model: "catalog-default",
+				model_context_window: 123456,
+				model_reasoning_effort: "medium",
+				plan_mode_reasoning_effort: "high",
+			},
+			managedProfiles: [],
+		}),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot,
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: repoRoot },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /model = "catalog-default"/);
+	assert.match(content, /model_context_window = 123456/);
+	assert.match(content, /model_reasoning_effort = "medium"/);
+	assert.match(content, /plan_mode_reasoning_effort = "high"/);
+});

package/packages/omo-codex/scripts/install-config.test.mjs

@@ -27,6 +27,60 @@ test("#given empty Codex config #when script installer updates config #then enab
 	assert.match(config, /max_concurrent_threads_per_session = 10000/);
 });
 
+test("#given empty Codex config #when script installer updates config #then leaves Context7 to the plugin MCP manifest", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-context7-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.doesNotMatch(config, /\[mcp_servers\.context7\]/);
+	assert.doesNotMatch(config, /@upstash\/context7-mcp/);
+	assert.doesNotMatch(config, /YOUR_API_KEY/);
+});
+
+test("#given existing Context7 MCP config #when script installer updates config #then leaves user setup untouched", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-context7-existing-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[mcp_servers.context7]",
+			'command = "node"',
+			'args = ["/opt/context7/server.js"]',
+			'startup_timeout_sec = 40',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /\[mcp_servers\.context7\]/);
+	assert.match(config, /command = "node"/);
+	assert.match(config, /args = \["\/opt\/context7\/server\.js"\]/);
+	assert.match(config, /startup_timeout_sec = 40/);
+	assert.doesNotMatch(config, /YOUR_API_KEY/);
+});
+
 test("#given sisyphuslabs config without explicit source #when script installer updates config #then uses local marketplace", async () => {
 	// given
 	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-sisyphuslabs-"));
@@ -116,3 +170,154 @@ test("#given legacy boolean MultiAgentV2 flag and table #when script installer u
 	assert.match(config, /usage_hint_enabled = false/);
 	assert.match(config, /max_concurrent_threads_per_session = 10000/);
 });
+
+test("#given legacy agents max_threads #when script installer updates config #then removes the conflicting legacy thread cap", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-legacy-threads-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[agents]",
+			"max_threads = 16",
+			"max_depth = 4",
+			"job_max_runtime_seconds = 3600",
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.match(config, /\[features\.multi_agent_v2\]/);
+	assert.match(config, /enabled = true/);
+	assert.match(config, /max_concurrent_threads_per_session = 10000/);
+	assert.match(config, /\[agents\]/);
+	assert.doesNotMatch(config, /^max_threads\s*=/m);
+	assert.match(config, /max_depth = 4/);
+	assert.match(config, /job_max_runtime_seconds = 3600/);
+});
+
+test("#given managed agent role sections #when script installer updates config #then preserves role config while removing only root agents max_threads", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-multi-agent-role-section-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			"[agents]",
+			"max_threads = 16",
+			"",
+			"[agents.explorer]",
+			'description = "read-only explorer"',
+			'config_file = "./agents/explorer.toml"',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+		agentConfigs: [{ name: "explorer", configFile: "./agents/explorer.toml" }],
+	});
+
+	// then
+	const config = await readFile(configPath, "utf8");
+	assert.doesNotMatch(config, /^max_threads\s*=/m);
+	assert.match(config, /\[agents\.explorer\]/);
+	assert.match(config, /description = "read-only explorer"/);
+	assert.match(config, /config_file = "\.\/agents\/explorer\.toml"/);
+});
+
+test("#given existing trust and lsp blocks #when updating config #then existing blocks are preserved", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-config-baseline-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'[plugins."omo@sisyphuslabs"]',
+			"enabled = true",
+			"",
+			'[plugins."omo@sisyphuslabs".mcp_servers.lsp]',
+			"enabled = true",
+			"",
+			'[hooks.state."omo@sisyphuslabs:hooks/hooks.json:post_tool_use:0:0"]',
+			'trusted_hash = "sha256:keep"',
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+		pluginNames: ["omo"],
+		trustedHookStates: [{ key: "omo@sisyphuslabs:hooks/hooks.json:post_tool_use:0:0", trustedHash: "sha256:keep" }],
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\]/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.lsp\]/);
+	assert.match(content, /\[hooks\.state\."omo@sisyphuslabs:hooks\/hooks\.json:post_tool_use:0:0"\]/);
+	assert.match(content, /trusted_hash = "sha256:keep"/);
+});
+
+test("#given windows platform #when updating config #then enables git_bash plugin mcp policy", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-config-git-bash-win32-"));
+	const configPath = join(root, "config.toml");
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "sisyphuslabs",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+		pluginNames: ["omo"],
+		platform: "win32",
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
+	assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = true/);
+});
+
+test("#given non-windows platforms #when updating config #then disables git_bash plugin mcp policy", async () => {
+	for (const platform of ["linux", "darwin"]) {
+		// given
+		const root = await mkdtemp(join(tmpdir(), `omo-codex-config-git-bash-${platform}-`));
+		const configPath = join(root, "config.toml");
+
+		// when
+		await updateCodexConfig({
+			configPath,
+			repoRoot: "/repo/packages/omo-codex",
+			marketplaceName: "sisyphuslabs",
+			marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex/cache/sisyphuslabs" },
+			pluginNames: ["omo"],
+			platform,
+		});
+
+		// then
+		const content = await readFile(configPath, "utf8");
+		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]/);
+		assert.match(content, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\][\s\S]*?enabled = false/);
+	}
+});

package/packages/omo-codex/scripts/install-local-entrypoint.test.mjs

@@ -0,0 +1,157 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+import { resolveDefaultRepoRoot } from "./install-local.mjs";
+
+test("#given published lazycodex bin runs outside the package #when resolving default repo root #then uses installer location", () => {
+	// given
+	const scriptsDir = dirname(fileURLToPath(import.meta.url));
+
+	// when
+	const repoRoot = resolveDefaultRepoRoot();
+
+	// then
+	assert.equal(repoRoot, join(scriptsDir, "..", "..", ".."));
+});
+
+test("#given lazycodex version flag #when running the Node installer entrypoint #then prints the package version", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const manifestPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--version"], {
+		encoding: "utf8",
+	}).trim();
+
+	// then
+	assert.equal(output, `lazycodex-ai ${manifest.version}`);
+});
+
+test("#given lazycodex runs through an npm bin symlink #when running the Node installer entrypoint #then it still executes main", { skip: process.platform === "win32" }, () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const manifestPath = fileURLToPath(new URL("../../../package.json", import.meta.url));
+	const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+	const tempDir = mkdtempSync(join(tmpdir(), "lazycodex-bin-"));
+	const binPath = join(tempDir, "lazycodex-ai");
+
+	try {
+		symlinkSync(scriptPath, binPath);
+
+		// when
+		const output = execFileSync(process.execPath, [binPath, "--version"], {
+			encoding: "utf8",
+		}).trim();
+
+		// then
+		assert.equal(output, `lazycodex-ai ${manifest.version}`);
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});
+
+test("#given dry-run install flags #when running the Node installer entrypoint #then prints delegated autonomous codex install command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(
+		process.execPath,
+		[scriptPath, "--dry-run", "install", "--no-tui"],
+		{ encoding: "utf8" },
+	).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo install --platform=codex --no-tui --codex-autonomous");
+});
+
+test("#given dry-run install opt-out #when running the Node installer entrypoint #then preserves existing Codex permission settings", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(
+		process.execPath,
+		[scriptPath, "--dry-run", "install", "--no-tui", "--no-codex-autonomous"],
+		{ encoding: "utf8" },
+	).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo install --platform=codex --no-tui --no-codex-autonomous");
+});
+
+test("#given dry-run doctor #when running the Node installer entrypoint #then prints delegated doctor command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--dry-run", "doctor"], {
+		encoding: "utf8",
+	}).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo doctor");
+});
+
+test("#given dry-run cleanup #when running the Node installer entrypoint #then prints delegated codex cleanup command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(
+		process.execPath,
+		[scriptPath, "--dry-run", "cleanup", "--project", "/tmp/lazycodex-qa"],
+		{ encoding: "utf8" },
+	).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo cleanup --platform=codex --project /tmp/lazycodex-qa");
+});
+
+test("#given dry-run ulw-loop #when running the Node installer entrypoint #then prints delegated ulw-loop command", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+
+	// when
+	const output = execFileSync(process.execPath, [scriptPath, "--dry-run", "ulw-loop", "help"], {
+		encoding: "utf8",
+	}).trim();
+
+	// then
+	assert.equal(output, "npx --yes --package oh-my-openagent omo ulw-loop help");
+});
+
+test("#given the invoking argv path disappears #when importing the Node installer module #then the entrypoint guard does not throw", () => {
+	// given
+	const scriptPath = fileURLToPath(new URL("./install-local.mjs", import.meta.url));
+	const tempDir = mkdtempSync(join(tmpdir(), "lazycodex-import-"));
+	const missingArgvPath = join(tempDir, "missing-entrypoint.mjs");
+	const probePath = join(tempDir, "probe.mjs");
+
+	try {
+		writeFileSync(
+			probePath,
+			[
+				`process.argv[1] = ${JSON.stringify(missingArgvPath)};`,
+				`await import(${JSON.stringify(pathToFileURL(scriptPath).href)});`,
+			].join("\n"),
+		);
+
+		// when
+		const output = execFileSync(process.execPath, [probePath], {
+			encoding: "utf8",
+		}).trim();
+
+		// then
+		assert.equal(output, "");
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
+});

package/packages/omo-codex/scripts/install-local-git-bash-preflight.test.mjs

@@ -0,0 +1,145 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { installMarketplaceLocally } from "./install-local.mjs";
+
+const windowsGitBashPath = "C:\\Program Files\\Git\\bin\\bash.exe";
+const lspCliPath = join(process.cwd(), "packages", "lsp-tools-mcp", "dist", "cli.js");
+
+async function withBundledLspRuntimeForTest(run) {
+	try {
+		await stat(lspCliPath);
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		await mkdir(join(process.cwd(), "packages", "lsp-tools-mcp", "dist"), { recursive: true });
+		await writeFile(lspCliPath, "#!/usr/bin/env node\n");
+	}
+
+	return run();
+}
+
+test("#given Windows without Git Bash and auto install skip env #when installing local marketplace #then rejects before marketplace or config mutation", async () => {
+	const repoRoot = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-missing-repo-"));
+	const codexHome = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-missing-home-"));
+	const commands = [];
+
+	await assert.rejects(
+		installMarketplaceLocally({
+			repoRoot,
+			codexHome,
+			platform: "win32",
+			env: { OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL: "1" },
+			gitBashResolver: () => ({
+				found: false,
+				checkedPaths: [windowsGitBashPath],
+				installHint: [
+					"Git Bash is required.",
+					"winget install --id Git.Git -e --source winget",
+					"OMO_CODEX_GIT_BASH_PATH=C:\\path\\to\\bash.exe",
+					"rerun `npx lazycodex-ai install`",
+				].join("\n"),
+			}),
+			runCommand: async (command, args, options) => {
+				commands.push([command, ...args, options.cwd].join(" "));
+			},
+			log: () => {},
+		}),
+		/winget install --id Git\.Git -e --source winget/,
+	);
+	assert.deepEqual(commands, []);
+	await assert.rejects(stat(join(codexHome, "config.toml")), /ENOENT/);
+});
+
+test("#given Windows without Git Bash #when winget succeeds and resolver recovers #then install continues", async () => {
+	const runCalls = [];
+	const resolutions = [
+		{ found: false, checkedPaths: [windowsGitBashPath], installHint: "install hint before winget" },
+		{ found: true, path: windowsGitBashPath, source: "program-files" },
+	];
+	let resolveCallCount = 0;
+
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-auto-home-")),
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-auto-bin-")),
+		platform: "win32",
+		gitBashResolver: () => resolutions[resolveCallCount++] ?? resolutions[resolutions.length - 1],
+		runCommand: async (command, args, options) => {
+			runCalls.push([command, ...args, options.cwd].join(" "));
+		},
+		log: () => {},
+	}));
+
+	assert.equal(resolveCallCount, 2);
+	assert.match(runCalls.join("\n"), /^winget install --id Git\.Git -e --source winget /m);
+	assert.equal(result.gitBashPath, windowsGitBashPath);
+});
+
+test("#given non-Windows install #when running installer #then winget is never called", async () => {
+	const runCalls = [];
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-no-winget-home-")),
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-no-winget-bin-")),
+		platform: "linux",
+		runCommand: async (command, args, options) => {
+			runCalls.push([command, ...args, options.cwd].join(" "));
+		},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, null);
+	assert.equal(runCalls.some((command) => command.startsWith("winget ")), false);
+});
+
+test("#given Windows env override resolves Git Bash #when installing local marketplace #then install continues", async () => {
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-home-")),
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-bin-")),
+		platform: "win32",
+		gitBashResolver: () => ({ found: true, path: windowsGitBashPath, source: "env" }),
+		runCommand: async () => {},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, windowsGitBashPath);
+	assert.equal(result.installed.length, 1);
+});
+
+test("#given Windows env override in installer options #when no custom resolver is provided #then default resolver uses it", async () => {
+	const codexHome = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-env-home-"));
+	const gitBashPath = join(await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-env-")), "bash.exe");
+	await writeFile(gitBashPath, "");
+
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome,
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-env-bin-")),
+		platform: "win32",
+		env: { OMO_CODEX_GIT_BASH_PATH: gitBashPath },
+		runCommand: async () => {},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, gitBashPath);
+});
+
+test("#given non-Windows local install #when resolver would fail #then installer keeps existing behavior", async () => {
+	const codexHome = await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-linux-home-"));
+	const result = await withBundledLspRuntimeForTest(async () => installMarketplaceLocally({
+		repoRoot: process.cwd(),
+		codexHome,
+		binDir: await mkdtemp(join(tmpdir(), "omo-codex-script-git-bash-linux-bin-")),
+		platform: "linux",
+		gitBashResolver: () => ({ found: false, checkedPaths: [windowsGitBashPath], installHint: "should not be used" }),
+		runCommand: async () => {},
+		log: () => {},
+	}));
+
+	assert.equal(result.gitBashPath, null);
+	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /\[marketplaces\.sisyphuslabs\]/);
+});