oh-my-opencode 4.6.0 → 4.7.0

package/packages/omo-codex/plugin/test/migrate-codex-config.test.mjs

@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import test from "node:test";
+
+import { ensureCodexReasoningConfig, migrateCodexConfig } from "../scripts/migrate-codex-config.mjs";
+
+test("#given stale root reasoning config #when ensuring config #then replaces stale values without duplicate keys", () => {
+	const result = ensureCodexReasoningConfig(
+		[
+			'model = "gpt-5.2"',
+			"model_context_window = 272000",
+			'model_reasoning_effort = "low"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+			"[features]",
+			"plugins = true",
+			"",
+		].join("\n"),
+	);
+
+	assert.equal(result.match(/^model\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^model_context_window\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^model_reasoning_effort\s*=/gm)?.length, 1);
+	assert.equal(result.match(/^plan_mode_reasoning_effort\s*=/gm)?.length, 1);
+	assert.match(result, /model = "gpt-5\.5"/);
+	assert.match(result, /model_context_window = 400000/);
+	assert.match(result, /model_reasoning_effort = "high"/);
+	assert.match(result, /plan_mode_reasoning_effort = "xhigh"/);
+	assert.doesNotMatch(result, /gpt-5\.2/);
+	assert.match(result, /\[features\]/);
+});
+
+test("#given global and project-local stale Codex configs #when migrating #then both configs are forced to current defaults", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-migration-"));
+	const codexHome = join(root, "codex-home");
+	const project = join(root, "project", "nested");
+	const projectConfig = join(root, "project", ".codex", "config.toml");
+	await mkdir(codexHome, { recursive: true });
+	await mkdir(dirname(projectConfig), { recursive: true });
+	await writeFile(join(codexHome, "config.toml"), 'model = "gpt-5.2"\n');
+	await writeFile(projectConfig, 'model = "gpt-5.2"\nmodel_context_window = 272000\n');
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: project,
+	});
+
+	assert.deepEqual(result.changed.sort(), [join(codexHome, "config.toml"), projectConfig].sort());
+	assert.match(await readFile(join(codexHome, "config.toml"), "utf8"), /model = "gpt-5\.5"/);
+	assert.match(await readFile(projectConfig, "utf8"), /model_context_window = 400000/);
+});
+
+test("#given user-customized Codex model config #when migrating #then user values are preserved", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-custom-"));
+	const codexHome = join(root, "codex-home");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		join(codexHome, "config.toml"),
+		[
+			'model = "gpt-5.4"',
+			"model_context_window = 123456",
+			'model_reasoning_effort = "medium"',
+			'plan_mode_reasoning_effort = "medium"',
+			"",
+		].join("\n"),
+	);
+
+	const result = await migrateCodexConfig({
+		env: { CODEX_HOME: codexHome, LAZYCODEX_MODEL_CATALOG_STATE_PATH: join(root, "model-state.json") },
+		cwd: root,
+	});
+
+	const content = await readFile(join(codexHome, "config.toml"), "utf8");
+	assert.deepEqual(result.changed, []);
+	assert.match(content, /model = "gpt-5\.4"/);
+	assert.match(content, /model_context_window = 123456/);
+	assert.match(content, /model_reasoning_effort = "medium"/);
+	assert.match(content, /plan_mode_reasoning_effort = "medium"/);
+});
+
+test("#given managed catalog state #when catalog version advances #then only previously managed config is updated", async () => {
+	const root = await mkdtemp(join(tmpdir(), "lazycodex-config-catalog-state-"));
+	const codexHome = join(root, "codex-home");
+	const catalogPath = join(root, "catalog.json");
+	const statePath = join(root, "model-state.json");
+	await mkdir(codexHome, { recursive: true });
+	await writeFile(
+		catalogPath,
+		JSON.stringify(
+			{
+				version: "test.v1",
+				current: {
+					model: "gpt-5.4",
+					model_context_window: 1000000,
+					model_reasoning_effort: "high",
+					plan_mode_reasoning_effort: "xhigh",
+				},
+				managedProfiles: [],
+			},
+			null,
+			2,
+		),
+	);
+
+	const first = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath,
+		},
+		cwd: root,
+	});
+	await writeFile(
+		catalogPath,
+		JSON.stringify(
+			{
+				version: "test.v2",
+				current: {
+					model: "gpt-5.5",
+					model_context_window: 400000,
+					model_reasoning_effort: "high",
+					plan_mode_reasoning_effort: "xhigh",
+				},
+				managedProfiles: [],
+			},
+			null,
+			2,
+		),
+	);
+	const second = await migrateCodexConfig({
+		env: {
+			CODEX_HOME: codexHome,
+			LAZYCODEX_MODEL_CATALOG_PATH: catalogPath,
+			LAZYCODEX_MODEL_CATALOG_STATE_PATH: statePath,
+		},
+		cwd: root,
+	});
+
+	const content = await readFile(join(codexHome, "config.toml"), "utf8");
+	assert.deepEqual(first.changed, [join(codexHome, "config.toml")]);
+	assert.deepEqual(second.changed, [join(codexHome, "config.toml")]);
+	assert.match(content, /model = "gpt-5\.5"/);
+	assert.match(content, /model_context_window = 400000/);
+});

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

@@ -21,6 +21,7 @@ test("#given a component without hooks #when hook status messages sync #then bui
 	await mkdir(join(root, "hooks"), { recursive: true });
 	await mkdir(join(root, "components", "comment-checker", "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", "git-bash", "package.json"), { version: "0.3.0" });

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

@@ -14,6 +14,7 @@ const expectedSkills = [
 	"debugging",
 	"frontend-ui-ux",
 	"init-deep",
+	"lcx-report-bug",
 	"lsp",
 	"programming",
 	"refactor",
@@ -33,6 +34,7 @@ const componentSkillSources = [
 ];
 
 const codexCompatibilityEndMarkers = [
+	"Codex full-history forks inherit the parent agent type, model, and reasoning effort, so role-specific spawns with `agent_type` must use a non-full-history fork mode such as `fork_turns=\"none\"`. Include any required conversation context, files, diffs, constraints, and requested skill names directly in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
 	"When translating `load_skills=[...]`, include the requested skill names in the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
 	"When translating `load_skills=[...]`, name the skills inside the spawned agent's `message`. If a code block below conflicts with this section, this section wins.\n\n",
 ];
@@ -153,6 +155,26 @@ test("#given synced ulw-loop skill #when Codex hint metadata is inspected #then
 	assert.match(interfaceMetadata, /- "ulw-loop"/);
 });
 
+test("#given synced lcx-report-bug skill #when inspected #then it files LazyCodex bug issues from proven debugging evidence", async () => {
+	// given
+	const skillRoot = join(root, "skills", "lcx-report-bug");
+
+	// when
+	const skill = await readFile(join(skillRoot, "SKILL.md"), "utf8");
+	const interfaceMetadata = await readFile(join(skillRoot, "agents", "openai.yaml"), "utf8");
+
+	// then
+	assert.match(skill, /^---\r?\nname: lcx-report-bug\r?\n/m);
+	assert.match(skill, /code-yeongyu\/lazycodex/);
+	assert.match(skill, /\$omo:debugging/);
+	assert.match(skill, /gh issue create --repo code-yeongyu\/lazycodex/);
+	assert.match(skill, /Browser use fallback/);
+	assert.match(skill, /Computer use fallback/);
+	assert.match(skill, /## Issue Body Template/);
+	assert.match(interfaceMetadata, /display_name: "lcx-report-bug \(omo\)"/);
+	assert.match(interfaceMetadata, /- "lazycodex bug"/);
+});
+
 test("#given synced ulw-loop skill #when worker guidance is inspected #then context-hygiene guidance matches the source", async () => {
 	// given
 	const sourceSkill = await readFile(

package/packages/omo-codex/scripts/install/cli-args.mjs

@@ -1,5 +1,5 @@
 const CODEX_ONLY_ERROR = "lazycodex-ai installs the Codex Light edition only. Use the omo installer for OpenCode or both-platform installs.";
-const PASSTHROUGH_COMMANDS = new Set(["doctor", "cleanup", "get-local-version", "boulder", "refresh-model-capabilities", "run"]);
+const PASSTHROUGH_COMMANDS = new Set(["doctor", "cleanup", "get-local-version", "boulder", "refresh-model-capabilities", "run", "ulw-loop"]);
 
 export function parseLazyCodexInstallCliArgs(argv) {
 	const args = [...argv];

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

@@ -2,6 +2,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 
 import { ensureCodexMultiAgentV2Config } from "./multi-agent-v2-config.mjs";
+import { readCodexModelCatalog } from "./model-catalog.mjs";
 import { ensureCodexReasoningConfig } from "./reasoning-config.mjs";
 import { ensureAutonomousPermissions } from "./permissions.mjs";
 import { appendBlock, findTomlSection, replaceOrInsertSetting } from "./toml-editor.mjs";
@@ -17,14 +18,6 @@ const MANAGED_CODEX_AGENT_NAMES = [
 	"momus",
 	"plan",
 ];
-const CONTEXT7_MCP_SERVER_HEADER = "mcp_servers.context7";
-const CONTEXT7_MCP_SERVER_BLOCK = [
-	`[${CONTEXT7_MCP_SERVER_HEADER}]`,
-	`command = "npx"`,
-	`args = ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"]`,
-	`startup_timeout_sec = 20`,
-	"",
-].join("\n");
 
 export async function updateCodexConfig({
 	configPath,
@@ -51,10 +44,9 @@ export async function updateCodexConfig({
 	config = removeStaleManagedAgentBlocks(config, new Set(agentConfigs.map((agentConfig) => agentConfig.name)));
 	config = ensureFeatureEnabled(config, "plugins");
 	config = ensureFeatureEnabled(config, "plugin_hooks");
-	config = ensureCodexReasoningConfig(config);
+	config = ensureCodexReasoningConfig(config, await readCodexModelCatalog(repoRoot));
 	config = ensureCodexMultiAgentV2Config(config);
 	if (autonomousPermissions === true) config = ensureAutonomousPermissions(config);
-	config = ensureContext7McpServer(config);
 	config = ensureMarketplaceBlock(config, marketplaceName, marketplaceSource);
 	for (const pluginName of pluginNames) {
 		config = ensurePluginEnabled(config, `${pluginName}@${marketplaceName}`);
@@ -145,11 +137,6 @@ function ensureMarketplaceBlock(config, marketplaceName, source) {
 	return appendBlock(config, block);
 }
 
-function ensureContext7McpServer(config) {
-	if (findTomlSection(config, CONTEXT7_MCP_SERVER_HEADER)) return config;
-	return appendBlock(config, CONTEXT7_MCP_SERVER_BLOCK);
-}
-
 function ensurePluginEnabled(config, pluginKey) {
 	const header = `plugins.${JSON.stringify(pluginKey)}`;
 	const section = findTomlSection(config, header);

package/packages/omo-codex/scripts/install/delegated-command.mjs

@@ -13,7 +13,7 @@ export function buildDelegatedOmoInvocation(parsed) {
 		args.push("--platform=codex");
 		if (parsed.noTui) args.push("--no-tui");
 		if (parsed.skipAuth) args.push("--skip-auth");
-		if (parsed.autonomousPermissions === true) args.push("--codex-autonomous");
+		if (parsed.autonomousPermissions !== false) args.push("--codex-autonomous");
 		if (parsed.autonomousPermissions === false) args.push("--no-codex-autonomous");
 		if (parsed.repoRoot) args.push(`--repo-root=${parsed.repoRoot}`);
 	} else if (parsed.command === "cleanup") {

package/packages/omo-codex/scripts/install/legacy-bins.mjs

@@ -5,6 +5,7 @@ import { COMMAND_SHIM_MARKER } from "./command-shim.mjs";
 
 const LEGACY_CODEX_COMPONENT_BINS = [
 	{ name: "codex-comment-checker", component: "comment-checker" },
+	{ name: "codex-lsp", component: "lsp" },
 	{ name: "codex-rules", component: "rules" },
 	{ name: "codex-start-work-continuation", component: "start-work-continuation" },
 	{ name: "codex-telemetry", component: "telemetry" },

package/packages/omo-codex/scripts/install/model-catalog.mjs

@@ -0,0 +1,66 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+const FALLBACK_CODEX_MODEL_CATALOG = {
+	current: {
+		model: "gpt-5.5",
+		modelContextWindow: 400_000,
+		modelReasoningEffort: "high",
+		planModeReasoningEffort: "xhigh",
+	},
+	managedProfiles: [{ model: "gpt-5.2" }],
+};
+
+export async function readCodexModelCatalog(codexPackageRoot) {
+	try {
+		const parsed = JSON.parse(await readFile(join(codexPackageRoot, "plugin", "model-catalog.json"), "utf8"));
+		return parseCodexModelCatalog(parsed) ?? FALLBACK_CODEX_MODEL_CATALOG;
+	} catch (error) {
+		if (!(error instanceof Error)) throw error;
+		return FALLBACK_CODEX_MODEL_CATALOG;
+	}
+}
+
+export async function readCodexReasoningProfile(codexPackageRoot) {
+	return (await readCodexModelCatalog(codexPackageRoot)).current;
+}
+
+function parseCodexModelCatalog(value) {
+	if (!isRecord(value) || !isRecord(value.current) || !Array.isArray(value.managedProfiles)) return null;
+	const { current } = value;
+	if (
+		typeof current.model !== "string" ||
+		typeof current.model_context_window !== "number" ||
+		typeof current.model_reasoning_effort !== "string" ||
+		typeof current.plan_mode_reasoning_effort !== "string"
+	) {
+		return null;
+	}
+	const managedProfiles = [];
+	for (const profile of value.managedProfiles) {
+		if (!isRecord(profile) || !isRecord(profile.match)) return null;
+		managedProfiles.push(parseProfileMatch(profile.match));
+	}
+	return {
+		current: {
+			model: current.model,
+			modelContextWindow: current.model_context_window,
+			modelReasoningEffort: current.model_reasoning_effort,
+			planModeReasoningEffort: current.plan_mode_reasoning_effort,
+		},
+		managedProfiles,
+	};
+}
+
+function parseProfileMatch(match) {
+	const profile = {};
+	if (typeof match.model === "string") profile.model = match.model;
+	if (typeof match.model_context_window === "number") profile.modelContextWindow = match.model_context_window;
+	if (typeof match.model_reasoning_effort === "string") profile.modelReasoningEffort = match.model_reasoning_effort;
+	if (typeof match.plan_mode_reasoning_effort === "string") profile.planModeReasoningEffort = match.plan_mode_reasoning_effort;
+	return profile;
+}
+
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -1,14 +1,72 @@
 import { replaceOrInsertRootSetting } from "./toml-editor.mjs";
 
-const DEFAULT_MODE_REASONING_EFFORT = "high";
-const PLAN_MODE_REASONING_EFFORT = "xhigh";
+const MANAGED_KEYS = ["model", "model_context_window", "model_reasoning_effort", "plan_mode_reasoning_effort"];
 
-export function ensureCodexReasoningConfig(config) {
-	let next = replaceOrInsertRootSetting(
-		config,
+export function ensureCodexReasoningConfig(config, catalog) {
+	const current = readRootReasoningSettings(config);
+	if (
+		Object.keys(current).length > 0 &&
+		!matchesProfile(current, catalog.current) &&
+		!catalog.managedProfiles.some((profile) => matchesProfile(current, profile))
+	) {
+		return config;
+	}
+	let next = replaceOrInsertRootSetting(config, "model", JSON.stringify(catalog.current.model));
+	next = replaceOrInsertRootSetting(next, "model_context_window", catalog.current.modelContextWindow.toString());
+	next = replaceOrInsertRootSetting(
+		next,
 		"model_reasoning_effort",
-		JSON.stringify(DEFAULT_MODE_REASONING_EFFORT),
+		JSON.stringify(catalog.current.modelReasoningEffort),
 	);
-	next = replaceOrInsertRootSetting(next, "plan_mode_reasoning_effort", JSON.stringify(PLAN_MODE_REASONING_EFFORT));
+	next = replaceOrInsertRootSetting(next, "plan_mode_reasoning_effort", JSON.stringify(catalog.current.planModeReasoningEffort));
 	return next;
 }
+
+function readRootReasoningSettings(config) {
+	const settings = {};
+	for (const line of config.split(/\n/)) {
+		if (isSectionHeader(line)) break;
+		for (const key of MANAGED_KEYS) {
+			if (!isRootSetting(line, key)) continue;
+			const value = parseTomlScalar(line.slice(line.indexOf("=") + 1));
+			if (key === "model" && typeof value === "string") settings.model = value;
+			if (key === "model_context_window" && typeof value === "number") settings.modelContextWindow = value;
+			if (key === "model_reasoning_effort" && typeof value === "string") settings.modelReasoningEffort = value;
+			if (key === "plan_mode_reasoning_effort" && typeof value === "string") settings.planModeReasoningEffort = value;
+		}
+	}
+	return settings;
+}
+
+function matchesProfile(current, profile) {
+	for (const [key, value] of Object.entries(profile)) {
+		if (current[key] !== value) return false;
+	}
+	return true;
+}
+
+function parseTomlScalar(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+		try {
+			return JSON.parse(trimmed);
+		} catch (error) {
+			if (error instanceof SyntaxError) return undefined;
+			throw error;
+		}
+	}
+	const numeric = Number(trimmed);
+	return Number.isFinite(numeric) ? numeric : undefined;
+}
+
+function isSectionHeader(line) {
+	const trimmed = line.trim();
+	return trimmed.startsWith("[") && trimmed.endsWith("]");
+}
+
+function isRootSetting(line, key) {
+	const trimmed = line.trimStart();
+	if (trimmed.startsWith("#") || trimmed.startsWith("[")) return false;
+	const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*=/);
+	return match?.[1] === key;
+}

package/packages/omo-codex/scripts/install-bin-links.test.mjs

@@ -76,6 +76,29 @@ test("#given managed legacy Codex component symlink #when linking bins #then rem
 	assert.equal(await readlink(join(binDir, "omo-rules")), join(pluginRoot, "dist", "cli.js"));
 });
 
+test("#given managed legacy Codex LSP symlink #when linking bins #then removes stale lsp symlink", async () => {
+	const root = await makeTempDir();
+	const pluginRoot = join(root, "plugin");
+	const binDir = join(root, "bin");
+	const oldTarget = join(root, "codex-home", "plugins", "cache", "legacy-market", "omo", "0.0.1", "components", "lsp", "dist", "cli.js");
+
+	await mkdir(join(pluginRoot, "dist"), { recursive: true });
+	await mkdir(join(root, "codex-home", "plugins", "cache", "legacy-market", "omo", "0.0.1", "components", "lsp", "dist"), { recursive: true });
+	await mkdir(binDir, { recursive: true });
+	await writeJson(join(pluginRoot, "package.json"), {
+		name: "@example/omo",
+		bin: { omo: "./dist/cli.js" },
+	});
+	await writeFile(join(pluginRoot, "dist", "cli.js"), "#!/usr/bin/env node\n");
+	await writeFile(oldTarget, "#!/usr/bin/env node\n");
+	await symlink(oldTarget, join(binDir, "codex-lsp"));
+
+	await linkCachedPluginBins({ binDir, pluginRoot, platform: "linux" });
+
+	await assert.rejects(readlink(join(binDir, "codex-lsp")));
+	assert.equal(await readlink(join(binDir, "omo")), join(pluginRoot, "dist", "cli.js"));
+});
+
 test("#given user-owned legacy Codex symlink #when linking bins #then preserves the user symlink", async () => {
 	const root = await makeTempDir();
 	const pluginRoot = join(root, "plugin");

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

@@ -1,12 +1,12 @@
 import assert from "node:assert/strict";
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+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 default and Plan-mode reasoning effort", async () => {
+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");
@@ -22,17 +22,21 @@ test("#given empty Codex config #when script installer updates config #then sets
 
 	// 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 reasoning config #when script installer updates config #then replaces stale defaults without duplicate keys", async () => {
+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"',
 			"",
@@ -53,10 +57,85 @@ test("#given existing reasoning config #when script installer updates config #th
 
 	// 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,7 +27,7 @@ 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 installs Context7 MCP", async () => {
+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");
@@ -43,13 +43,12 @@ test("#given empty Codex config #when script installer updates config #then inst
 
 	// then
 	const config = await readFile(configPath, "utf8");
-	assert.match(config, /\[mcp_servers\.context7\]/);
-	assert.match(config, /command = "npx"/);
-	assert.match(config, /args = \["-y", "@upstash\/context7-mcp", "--api-key", "YOUR_API_KEY"\]/);
-	assert.match(config, /startup_timeout_sec = 20/);
+	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 preserves user setup", async () => {
+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");

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

@@ -57,14 +57,14 @@ test("#given lazycodex runs through an npm bin symlink #when running the Node in
 	}
 });
 
-test("#given dry-run install flags #when running the Node installer entrypoint #then prints delegated codex install command", () => {
+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", "--codex-autonomous"],
+		[scriptPath, "--dry-run", "install", "--no-tui"],
 		{ encoding: "utf8" },
 	).trim();
 
@@ -72,6 +72,21 @@ test("#given dry-run install flags #when running the Node installer entrypoint #
 	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));
@@ -100,6 +115,19 @@ test("#given dry-run cleanup #when running the Node installer entrypoint #then p
 	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));