oh-my-opencode 4.9.1 → 4.10.0

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

@@ -0,0 +1,249 @@
+import assert from "node:assert/strict";
+import { chmod, mkdir, mkdtemp, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+
+const CLI_URL = new URL("../components/bootstrap/dist/cli.js", import.meta.url);
+const { runBootstrapWorker, runWorkerSetup } = await import(CLI_URL.href);
+
+const REPO_MODEL_CATALOG_PATH = fileURLToPath(new URL("../model-catalog.json", import.meta.url));
+const MARKETPLACE_SOURCE_LINE = 'source = "https://github.com/code-yeongyu/lazycodex.git"';
+const PERMISSIONS_KEY_PATTERN = /approval_policy|sandbox_mode|network_access/;
+const PLUGIN_VERSION = "9.9.9";
+
+const BUNDLED_EXPLORER_TOML = 'description = "Explorer agent"\nmodel_reasoning_effort = "medium"\n';
+const BUNDLED_METIS_TOML = 'description = "Metis agent"\nmodel_reasoning_effort = "high"\n';
+
+async function withSetupFixture(run) {
+	const root = await mkdtemp(join(tmpdir(), "omo-bootstrap-setup-"));
+	try {
+		const pluginRoot = join(root, "plugin");
+		const pluginData = join(root, "plugin-data");
+		const codexHome = join(root, "codex-home");
+		await mkdir(join(pluginRoot, ".codex-plugin"), { recursive: true });
+		await mkdir(join(pluginRoot, "hooks"), { recursive: true });
+		await mkdir(join(pluginRoot, "components", "ultrawork", "agents"), { recursive: true });
+		// A complete npx-style payload ships dist/cli; the marketplace-payload
+		// (no dist/cli -> degraded omo-cli) path is covered by
+		// bootstrap-binlinks.test.mjs.
+		await mkdir(join(pluginRoot, "dist", "cli"), { recursive: true });
+		await writeFile(join(pluginRoot, "dist", "cli", "index.js"), "");
+		await mkdir(pluginData, { recursive: true });
+		await mkdir(codexHome, { recursive: true });
+		await writeFile(
+			join(pluginRoot, ".codex-plugin", "plugin.json"),
+			`${JSON.stringify({ hooks: "./hooks/hooks.json", name: "omo", version: PLUGIN_VERSION })}\n`,
+		);
+		await writeFile(
+			join(pluginRoot, "hooks", "hooks.json"),
+			`${JSON.stringify({
+				hooks: {
+					SessionStart: [
+						{
+							hooks: [
+								{
+									command: 'node "${PLUGIN_ROOT}/components/bootstrap/dist/cli.js" hook session-start',
+									statusMessage: "LazyCodex(9.9.9): Checking Bootstrap Provisioning",
+									timeout: 30,
+									type: "command",
+								},
+							],
+						},
+					],
+				},
+			})}\n`,
+		);
+		await writeFile(
+			join(pluginRoot, ".mcp.json"),
+			`${JSON.stringify({ mcpServers: { git_bash: { args: ["serve"], command: "node", env: {} } } }, null, "\t")}\n`,
+		);
+		await writeFile(join(pluginRoot, "components", "ultrawork", "agents", "explorer.toml"), BUNDLED_EXPLORER_TOML);
+		await writeFile(join(pluginRoot, "components", "ultrawork", "agents", "metis.toml"), BUNDLED_METIS_TOML);
+		await writeFile(join(codexHome, "config.toml"), `[marketplaces.sisyphuslabs]\n${MARKETPLACE_SOURCE_LINE}\n`);
+		await run({ codexHome, pluginData, pluginRoot, root });
+	} finally {
+		await rm(root, { force: true, recursive: true });
+	}
+}
+
+function setupOptions(fixture, overrides = {}) {
+	return {
+		codexHome: fixture.codexHome,
+		env: {},
+		platform: "darwin",
+		pluginData: fixture.pluginData,
+		pluginRoot: fixture.pluginRoot,
+		...overrides,
+	};
+}
+
+async function readConfig(fixture) {
+	return readFile(join(fixture.codexHome, "config.toml"), "utf8");
+}
+
+test("#given a marketplace-flow CODEX_HOME #when the worker setup runs #then config gains plugin, hook-state, and agent blocks without permissions keys", async () => {
+	await withSetupFixture(async (fixture) => {
+		const outcome = await runWorkerSetup(setupOptions(fixture));
+
+		assert.deepEqual(outcome.degraded, []);
+		const config = await readConfig(fixture);
+		assert.match(config, /\[plugins\."omo@sisyphuslabs"\]\nenabled = true/);
+		assert.match(config, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.context7\]\nenabled = true/);
+		assert.match(config, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]\nenabled = false/);
+		assert.match(
+			config,
+			/\[hooks\.state\."omo@sisyphuslabs:hooks\/hooks\.json:session_start:0:0"\]\ntrusted_hash = "sha256:[0-9a-f]{64}"/,
+		);
+		assert.match(config, /\[agents\.explorer\]\nconfig_file = "\.\/agents\/explorer\.toml"/);
+		assert.match(config, /\[agents\.metis\]\nconfig_file = "\.\/agents\/metis\.toml"/);
+		assert.doesNotMatch(config, PERMISSIONS_KEY_PATTERN);
+		assert.equal(await readFile(join(fixture.codexHome, "agents", "explorer.toml"), "utf8"), BUNDLED_EXPLORER_TOML);
+		assert.equal(await readFile(join(fixture.codexHome, "agents", "metis.toml"), "utf8"), BUNDLED_METIS_TOML);
+	});
+});
+
+test("#given an existing git marketplace source #when the worker setup runs #then the [marketplaces.sisyphuslabs] block stays byte-identical", async () => {
+	await withSetupFixture(async (fixture) => {
+		await runWorkerSetup(setupOptions(fixture));
+
+		const config = await readConfig(fixture);
+		assert.ok(config.includes(`[marketplaces.sisyphuslabs]\n${MARKETPLACE_SOURCE_LINE}`), "git source line must stay verbatim");
+		assert.doesNotMatch(config, /source_type/);
+		assert.doesNotMatch(config, /last_updated/);
+	});
+});
+
+test("#given a completed first run #when the worker setup runs again #then config.toml is byte-identical (idempotent)", async () => {
+	await withSetupFixture(async (fixture) => {
+		await runWorkerSetup(setupOptions(fixture));
+		const firstRun = await readConfig(fixture);
+
+		const outcome = await runWorkerSetup(setupOptions(fixture));
+
+		assert.deepEqual(outcome.degraded, []);
+		assert.equal(await readConfig(fixture), firstRun);
+	});
+});
+
+test("#given bootstrap-managed staging #when agents are linked #then nothing is persisted under PLUGIN_ROOT", async () => {
+	await withSetupFixture(async (fixture) => {
+		await runWorkerSetup(setupOptions(fixture));
+
+		await assert.rejects(() => stat(join(fixture.pluginRoot, ".installed-agents.json")));
+		const manifest = JSON.parse(
+			await readFile(join(fixture.pluginData, "bootstrap", "agents-stage", ".installed-agents.json"), "utf8"),
+		);
+		assert.equal(manifest.agents.length, 2);
+	});
+});
+
+test("#given user-tuned reasoning and service tier on an installed agent #when agents are re-linked #then both are preserved", async () => {
+	await withSetupFixture(async (fixture) => {
+		await mkdir(join(fixture.codexHome, "agents"), { recursive: true });
+		await writeFile(
+			join(fixture.codexHome, "agents", "explorer.toml"),
+			'description = "Explorer agent"\nmodel_reasoning_effort = "low"\nservice_tier = "flex"\n',
+		);
+
+		await runWorkerSetup(setupOptions(fixture));
+
+		const linked = await readFile(join(fixture.codexHome, "agents", "explorer.toml"), "utf8");
+		assert.match(linked, /model_reasoning_effort = "low"/);
+		assert.match(linked, /service_tier = "flex"/);
+	});
+});
+
+test("#given an unwritable config.toml #when the worker setup runs #then it degrades naming config.toml and leaves the file untouched", async () => {
+	await withSetupFixture(async (fixture) => {
+		const configPath = join(fixture.codexHome, "config.toml");
+		const before = await readFile(configPath, "utf8");
+		await chmod(configPath, 0o444);
+		try {
+			const outcome = await runWorkerSetup(setupOptions(fixture));
+
+			const configEntries = outcome.degraded.filter((entry) => entry.component === "config");
+			assert.equal(configEntries.length, 1);
+			assert.match(configEntries[0].reason, /config\.toml/);
+			assert.equal(await readFile(configPath, "utf8"), before);
+			assert.equal((await stat(configPath)).mode & 0o777, 0o444);
+		} finally {
+			await chmod(configPath, 0o644);
+		}
+	});
+});
+
+test("#given win32 without Git Bash and auto-install skipped #when the worker setup runs #then it degrades instead of throwing and disables the git_bash MCP", async () => {
+	await withSetupFixture(async (fixture) => {
+		const commands = [];
+		const outcome = await runWorkerSetup(
+			setupOptions(fixture, {
+				env: { OMO_CODEX_SKIP_GIT_BASH_AUTO_INSTALL: "1" },
+				platform: "win32",
+				resolveGitBash: () => ({ checkedPaths: [], found: false, installHint: "install git bash" }),
+				runCommand: async (command, args) => {
+					commands.push([command, ...args]);
+				},
+			}),
+		);
+
+		assert.deepEqual(commands, []);
+		const gitBashEntries = outcome.degraded.filter((entry) => entry.component === "git-bash");
+		assert.equal(gitBashEntries.length, 1);
+		const config = await readConfig(fixture);
+		assert.match(config, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]\nenabled = false/);
+		assert.match(config, /\[plugins\."omo@sisyphuslabs"\]\nenabled = true/, "setup must continue past a missing Git Bash");
+	});
+});
+
+test("#given win32 with Git Bash and OMO_CODEX_GIT_BASH_PATH #when the worker setup runs #then git_bash is enabled and the MCP env is stamped", async () => {
+	await withSetupFixture(async (fixture) => {
+		const bashPath = "C:\\Tools\\Git\\bin\\bash.exe";
+		const outcome = await runWorkerSetup(
+			setupOptions(fixture, {
+				env: { OMO_CODEX_GIT_BASH_PATH: bashPath },
+				platform: "win32",
+				resolveGitBash: () => ({ checkedPaths: [bashPath], found: true, path: bashPath, source: "env" }),
+			}),
+		);
+
+		assert.deepEqual(outcome.degraded, []);
+		const config = await readConfig(fixture);
+		assert.match(config, /\[plugins\."omo@sisyphuslabs"\.mcp_servers\.git_bash\]\nenabled = true/);
+		const manifest = JSON.parse(await readFile(join(fixture.pluginRoot, ".mcp.json"), "utf8"));
+		assert.equal(manifest.mcpServers.git_bash.env.OMO_CODEX_GIT_BASH_PATH, bashPath);
+	});
+});
+
+test("#given the shipped plugin model catalog #when the worker setup stamps reasoning config #then the bundled fallback has not drifted from it", async () => {
+	await withSetupFixture(async (fixture) => {
+		const catalog = JSON.parse(await readFile(REPO_MODEL_CATALOG_PATH, "utf8"));
+
+		await runWorkerSetup(setupOptions(fixture));
+
+		const config = await readConfig(fixture);
+		assert.ok(config.includes(`model = ${JSON.stringify(catalog.current.model)}`));
+		assert.ok(config.includes(`model_context_window = ${catalog.current.model_context_window}`));
+		assert.ok(config.includes(`model_reasoning_effort = ${JSON.stringify(catalog.current.model_reasoning_effort)}`));
+		assert.ok(config.includes(`plan_mode_reasoning_effort = ${JSON.stringify(catalog.current.plan_mode_reasoning_effort)}`));
+	});
+});
+
+test("#given the default worker step list #when the worker runs end to end #then the setup step updates config and records a success marker", async () => {
+	await withSetupFixture(async (fixture) => {
+		const result = await runBootstrapWorker({
+			argv: ["--codex-home", fixture.codexHome, "--only", "setup"],
+			env: { PLUGIN_DATA: fixture.pluginData, PLUGIN_ROOT: fixture.pluginRoot },
+		});
+
+		assert.equal(result.ran, true);
+		assert.equal(result.status, "success");
+		const state = JSON.parse(await readFile(join(fixture.pluginData, "bootstrap", "state.json"), "utf8"));
+		assert.equal(state.completedForVersion, PLUGIN_VERSION);
+		assert.equal(state.lastStatus, "success");
+		const config = await readConfig(fixture);
+		assert.match(config, /\[plugins\."omo@sisyphuslabs"\]\nenabled = true/);
+		assert.ok(config.includes(`[marketplaces.sisyphuslabs]\n${MARKETPLACE_SOURCE_LINE}`));
+	});
+});

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

@@ -16,12 +16,16 @@ test("#given synced lcx-report-bug skill #when inspected #then it files LazyCode
 
 	// then
 	assert.match(skill, /^---\r?\nname: lcx-report-bug\r?\n/m);
+	assert.match(skill, /Never create a PR or push a branch against `code-yeongyu\/lazycodex`/);
+	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, /- "lazycodex bug"/);
 	assert.match(interfaceMetadata, /- "openai codex bug"/);
 });
 
-test("#given synced lcx-contribute-bug-fix skill #when inspected #then it contributes LazyCodex bug-fix PRs from fresh temp workspaces", async () => {
+test("#given synced lcx-contribute-bug-fix skill #when inspected #then it delivers LazyCodex fixes as issues and upstream fixes as fork PRs", async () => {
 	// given
 	const skillRoot = join(root, "skills", "lcx-contribute-bug-fix");
 
@@ -31,6 +35,11 @@ test("#given synced lcx-contribute-bug-fix skill #when inspected #then it contri
 
 	// then
 	assert.match(skill, /^---\r?\nname: lcx-contribute-bug-fix\r?\n/m);
+	assert.match(skill, /NEVER open a PR or push a branch against this repo/);
+	assert.match(skill, /gh issue create --repo code-yeongyu\/lazycodex/);
+	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, /- "contribute a bug fix"/);
 	assert.match(interfaceMetadata, /- "fix bug pr"/);

package/packages/omo-codex/plugin/test/ulw-plan-skill.test.mjs

@@ -30,6 +30,30 @@ test("#given ulw-plan skill #when the planning gate is inspected #then it explor
 	assert.doesNotMatch(skill, /Proceeding to plan generation/);
 });
 
+test("#given ulw-plan skill #when the execution gate is inspected #then plan mode is sticky, execution needs an explicit start, and the high-accuracy ask is mandatory", async () => {
+	// given
+	const skill = await readFile(skillPath, "utf8");
+
+	// then
+	assert.match(skill, /plan mode is sticky/i);
+	assert.match(skill, /never\s+(?:start|begin)[^.]{0,80}(?:implement|execut)/i);
+	assert.match(skill, /ask[^.]{0,160}high[- ]accuracy/i);
+	assert.match(skill, /two filters/i);
+	assert.match(skill, /\bWHY\b/);
+});
+
+test("#given ulw-plan full workflow reference #when the delivery phase is inspected #then it mandates the start-or-high-accuracy question and forbids self-started execution", async () => {
+	// given
+	const workflow = await readFile(workflowPath, "utf8");
+
+	// then
+	assert.match(workflow, /plan mode is sticky/i);
+	assert.match(workflow, /two filters/i);
+	assert.match(workflow, /ask[^.]{0,160}high[- ]accuracy/i);
+	assert.match(workflow, /execution belongs to the worker/i);
+	assert.doesNotMatch(workflow, /High-accuracy review \(optional\)/);
+});
+
 test("#given ulw-plan full workflow reference #when inspected #then it documents the approval gate and .omo plan output with Codex-native tools only", async () => {
 	// given
 	const workflow = await readFile(workflowPath, "utf8");
@@ -41,3 +65,25 @@ test("#given ulw-plan full workflow reference #when inspected #then it documents
 	assert.doesNotMatch(workflow, opencodeOnlyToolPattern);
 	assert.doesNotMatch(workflow, /Proceeding to plan generation/);
 });
+
+test("#given ulw-plan approval gate #when inspected #then it is a durable decision rule that ends the approval loop (lazycodex #48)", async () => {
+	// given
+	const skill = await readFile(skillPath, "utf8");
+	const workflow = await readFile(workflowPath, "utf8");
+	const combined = `${skill}\n${workflow}`;
+
+	// then — a durable approval-pending checkpoint guards against re-running exploration after compaction
+	assert.match(combined, /awaiting-approval/);
+	assert.match(combined, /instead of re-running exploration/i);
+
+	// then — approval is decided from intent, not a fixed passphrase
+	assert.match(combined, /"proceed"/);
+	assert.match(combined, /"write the plan"/);
+
+	// then — approval authorizes writing the plan, never implementation (resolves sticky-mode ambiguity)
+	assert.match(combined, /authoriz[^.]{0,80}writing the plan/i);
+	assert.match(combined, /never authorization to implement/i);
+
+	// then — the still-unclear path is a single prompt, never a re-exploration loop
+	assert.match(combined, /do not re-explore/i);
+});

package/packages/omo-codex/scripts/atomic-write.test.mjs

@@ -0,0 +1,82 @@
+import assert from "node:assert/strict";
+import { lstat, mkdir, mkdtemp, readFile, readdir, symlink, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { isRetriableRenameError, writeFileAtomic } from "./install/atomic-write.mjs";
+
+test("#given a fresh target path #when writeFileAtomic writes content #then the file holds exactly that content with no temp residue", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-atomic-write-fresh-"));
+	const target = join(root, "config.toml");
+
+	// when
+	await writeFileAtomic(target, "alpha = 1\n");
+
+	// then
+	assert.equal(await readFile(target, "utf8"), "alpha = 1\n");
+	assert.deepEqual(await readdir(root), ["config.toml"]);
+});
+
+test("#given an existing file #when writeFileAtomic overwrites it #then the content is replaced with no temp residue", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-atomic-write-replace-"));
+	const target = join(root, "config.toml");
+	await writeFile(target, "old = true\n");
+
+	// when
+	await writeFileAtomic(target, "new = true\n");
+
+	// then
+	assert.equal(await readFile(target, "utf8"), "new = true\n");
+	const residue = (await readdir(root)).filter((entry) => entry.startsWith(".tmp-"));
+	assert.deepEqual(residue, []);
+});
+
+test("#given the rename target cannot be replaced #when writeFileAtomic fails #then the original is untouched and the temp file is cleaned up", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-atomic-write-fail-"));
+	const target = join(root, "config.toml");
+	await mkdir(target);
+	await writeFile(join(target, "sentinel"), "keep\n");
+
+	// when
+	await assert.rejects(writeFileAtomic(target, "should not land\n"));
+
+	// then
+	assert.equal(await readFile(join(target, "sentinel"), "utf8"), "keep\n");
+	const residue = (await readdir(root)).filter((entry) => entry.startsWith(".tmp-"));
+	assert.deepEqual(residue, []);
+});
+
+test("#given the target is a symlink #when writeFileAtomic writes #then it writes through to the link target and preserves the symlink", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-atomic-write-symlink-"));
+	const realTarget = join(root, "actual.toml");
+	const link = join(root, "config.toml");
+	await writeFile(realTarget, "old = true\n");
+	await symlink(realTarget, link);
+
+	// when
+	await writeFileAtomic(link, "new = true\n");
+
+	// then
+	assert.equal(await readFile(realTarget, "utf8"), "new = true\n");
+	assert.equal((await lstat(link)).isSymbolicLink(), true);
+	const residue = (await readdir(root)).filter((entry) => entry.startsWith(".tmp-"));
+	assert.deepEqual(residue, []);
+});
+
+test("#given various rename errors #when classifying retriability #then only Windows file-lock codes are retriable", () => {
+	// given
+	const busy = Object.assign(new Error("busy"), { code: "EBUSY" });
+	const perm = Object.assign(new Error("perm"), { code: "EPERM" });
+	const missing = Object.assign(new Error("missing"), { code: "ENOENT" });
+
+	// when / then
+	assert.equal(isRetriableRenameError(busy), true);
+	assert.equal(isRetriableRenameError(perm), true);
+	assert.equal(isRetriableRenameError(missing), false);
+	assert.equal(isRetriableRenameError("not an error"), false);
+});

package/packages/omo-codex/scripts/install/agents.d.mts

@@ -0,0 +1,18 @@
+export interface LinkedPluginAgent {
+	name: string;
+	path: string;
+	target: string;
+}
+
+export declare function capturePreservedAgentReasoning(options: { codexHome: string }): Promise<Map<string, string>>;
+
+export declare function capturePreservedAgentServiceTier(options: {
+	codexHome: string;
+}): Promise<Map<string, string | null>>;
+
+export declare function linkCachedPluginAgents(options: {
+	codexHome: string;
+	pluginRoot: string;
+	preservedReasoning?: Map<string, string>;
+	preservedServiceTier?: Map<string, string | null>;
+}): Promise<LinkedPluginAgent[]>;

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

@@ -22,7 +22,22 @@ export async function capturePreservedAgentReasoning({ codexHome }) {
 	return preserved;
 }
 
-export async function linkCachedPluginAgents({ codexHome, pluginRoot, preservedReasoning = new Map() }) {
+export async function capturePreservedAgentServiceTier({ codexHome }) {
+	const agentsDir = join(codexHome, "agents");
+	if (!(await exists(agentsDir))) return new Map();
+
+	const preserved = new Map();
+	const agentEntries = await readdir(agentsDir, { withFileTypes: true });
+	for (const entry of agentEntries) {
+		if (!entry.name.endsWith(".toml")) continue;
+		const content = await readTextIfExists(join(agentsDir, entry.name));
+		if (content === null) continue;
+		preserved.set(agentNameFromToml(entry.name), extractServiceTier(content));
+	}
+	return preserved;
+}
+
+export async function linkCachedPluginAgents({ codexHome, pluginRoot, preservedReasoning = new Map(), preservedServiceTier = new Map() }) {
 	const bundledAgents = await discoverBundledAgents(pluginRoot);
 	if (bundledAgents.length === 0) {
 		await writeManifest(pluginRoot, []);
@@ -38,12 +53,26 @@ export async function linkCachedPluginAgents({ codexHome, pluginRoot, preservedR
 		const linkPath = join(agentsDir, agentFileName);
 		await replaceWithCopy(linkPath, agentPath);
 		await restorePreservedReasoning({ linkPath, target: agentPath, value: preservedReasoning.get(agentName) });
+		await restorePreservedServiceTier({
+			linkPath,
+			preserved: preservedServiceTier.has(agentName),
+			value: preservedServiceTier.get(agentName) ?? null,
+		});
 		linked.push({ name: agentFileName, path: linkPath, target: agentPath });
 	}
 	await writeManifest(pluginRoot, linked.map((entry) => entry.path));
 	return linked;
 }
 
+async function restorePreservedServiceTier({ linkPath, preserved, value }) {
+	if (!preserved) return;
+	const content = await readFile(linkPath, "utf8");
+	if (extractServiceTier(content) === value) return;
+	const replacement = replaceServiceTier(content, value);
+	if (!replacement.replaced) return;
+	await writeFile(linkPath, replacement.content);
+}
+
 async function discoverBundledAgents(pluginRoot) {
 	const componentsRoot = join(pluginRoot, "components");
 	if (!(await exists(componentsRoot))) return [];
@@ -106,29 +135,73 @@ async function readTextIfExists(path) {
 }
 
 function extractReasoningEffort(content) {
+	return extractTopLevelStringSetting(content, "model_reasoning_effort");
+}
+
+function extractServiceTier(content) {
+	return extractTopLevelStringSetting(content, "service_tier");
+}
+
+function extractTopLevelStringSetting(content, key) {
 	for (const line of content.split(/\n/)) {
 		if (isSectionHeader(line)) return null;
-		const match = line.match(/^\s*model_reasoning_effort\s*=\s*("(?:[^"\\]|\\.)*")/);
-		if (match === null) continue;
-		return JSON.parse(match[1]);
+		const rawValue = topLevelStringSettingRawValue(line, key);
+		if (rawValue === undefined) continue;
+		return JSON.parse(rawValue);
 	}
 	return null;
 }
 
 function replaceReasoningEffort(content, value) {
+	return replaceTopLevelStringSetting(content, "model_reasoning_effort", value, { insertIfMissing: false });
+}
+
+function replaceServiceTier(content, value) {
+	return replaceTopLevelStringSetting(content, "service_tier", value, { insertIfMissing: true });
+}
+
+function replaceTopLevelStringSetting(content, key, value, options) {
 	let replaced = false;
 	const lines = content.split(/\n/);
 	for (let index = 0; index < lines.length; index += 1) {
 		const line = lines[index];
 		if (isSectionHeader(line)) break;
-		if (!/^\s*model_reasoning_effort\s*=/.test(line)) continue;
+		if (topLevelStringSettingRawValue(line, key) === undefined) continue;
+		if (value === null) {
+			lines.splice(index, 1);
+			replaced = true;
+			break;
+		}
 		lines[index] = line.replace(/=\s*"(?:[^"\\]|\\.)*"/, `= ${JSON.stringify(value)}`);
 		replaced = true;
 		break;
 	}
+	if (!replaced && value !== null && options.insertIfMissing) {
+		lines.splice(topLevelInsertionIndex(lines), 0, `${key} = ${JSON.stringify(value)}`);
+		replaced = true;
+	}
 	return { content: lines.join("\n"), replaced };
 }
 
+function topLevelStringSettingRawValue(line, key) {
+	const match = line.match(/^\s*([A-Za-z0-9_]+)\s*=\s*("(?:[^"\\]|\\.)*")/);
+	if (match === null) return undefined;
+	const settingKey = match[1];
+	const rawValue = match[2];
+	if (settingKey !== key || rawValue === undefined) return undefined;
+	return rawValue;
+}
+
+function topLevelInsertionIndex(lines) {
+	const sectionIndex = lines.findIndex((line) => isSectionHeader(line));
+	const topLevelEnd = sectionIndex === -1 ? lines.length : sectionIndex;
+	let insertionIndex = topLevelEnd;
+	while (insertionIndex > 0 && lines[insertionIndex - 1] === "") {
+		insertionIndex -= 1;
+	}
+	return insertionIndex;
+}
+
 function isSectionHeader(line) {
 	const trimmed = line.trim();
 	return trimmed.startsWith("[") && trimmed.endsWith("]");

package/packages/omo-codex/scripts/install/atomic-write.mjs

@@ -0,0 +1,59 @@
+import { lstat, readlink, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+
+const RENAME_RETRY_DELAYS_MS = [10, 25, 50];
+const RETRIABLE_RENAME_CODES = new Set(["EPERM", "EBUSY"]);
+
+export function isRetriableRenameError(error) {
+	if (!(error instanceof Error)) return false;
+	return RETRIABLE_RENAME_CODES.has(Reflect.get(error, "code"));
+}
+
+export async function writeFileAtomic(targetPath, data) {
+	const writeTarget = await resolveSymlinkTarget(targetPath);
+	const temporaryPath = join(
+		dirname(writeTarget),
+		`.tmp-${basename(writeTarget)}-${process.pid}-${Date.now()}`,
+	);
+	await writeFile(temporaryPath, data);
+	try {
+		await renameWithRetry(temporaryPath, writeTarget);
+	} catch (renameError) {
+		await unlink(temporaryPath).catch(() => {});
+		throw renameError;
+	}
+}
+
+async function resolveSymlinkTarget(targetPath) {
+	let linkStats;
+	try {
+		linkStats = await lstat(targetPath);
+	} catch {
+		return targetPath;
+	}
+	if (!linkStats.isSymbolicLink()) return targetPath;
+	try {
+		return await realpath(targetPath);
+	} catch {
+		const linkValue = await readlink(targetPath);
+		return isAbsolute(linkValue) ? linkValue : resolve(dirname(targetPath), linkValue);
+	}
+}
+
+async function renameWithRetry(fromPath, toPath) {
+	for (let attempt = 0; ; attempt += 1) {
+		try {
+			await rename(fromPath, toPath);
+			return;
+		} catch (renameError) {
+			if (!isRetriableRenameError(renameError) || attempt >= RENAME_RETRY_DELAYS_MS.length) {
+				throw renameError;
+			}
+			await delay(RENAME_RETRY_DELAYS_MS[attempt]);
+		}
+	}
+}
+
+function delay(milliseconds) {
+	return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}

package/packages/omo-codex/scripts/install/bin-dir.d.mts

@@ -0,0 +1,7 @@
+export declare function resolveCodexInstallerBinDir(options?: {
+	codexHome?: string;
+	env?: Record<string, string | undefined>;
+	homeDir?: string;
+}): string;
+
+export declare function nonEmptyEnvValue(env: Record<string, string | undefined>, key: string): string | undefined;

package/packages/omo-codex/scripts/install/bin-links.d.mts

@@ -0,0 +1,18 @@
+export interface LinkedPluginBin {
+	name: string;
+	path: string;
+	target: string;
+}
+
+export declare function linkCachedPluginBins(options: {
+	binDir: string;
+	pluginRoot: string;
+	platform?: string;
+}): Promise<LinkedPluginBin[]>;
+
+export declare function linkRootRuntimeBin(options: {
+	binDir: string;
+	codexHome: string;
+	repoRoot: string;
+	platform?: string;
+}): Promise<LinkedPluginBin | null>;