oh-my-opencode 4.6.0 → 4.7.1

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

@@ -20,9 +20,12 @@ test("#given a component without hooks #when hook status messages sync #then bui
 	await mkdir(join(root, ".codex-plugin"), { recursive: true });
 	await mkdir(join(root, "hooks"), { recursive: true });
 	await mkdir(join(root, "components", "comment-checker", "hooks"), { recursive: true });
+	await mkdir(join(root, "components", "lsp", "hooks"), { recursive: true });
 	await mkdir(join(root, "components", "git-bash"), { recursive: true });
+	await mkdir(join(root, "components", "stale-build-output", "dist"), { recursive: true });
 	await writeJson(join(root, ".codex-plugin", "plugin.json"), { version: "0.1.0" });
 	await writeJson(join(root, "components", "comment-checker", "package.json"), { version: "0.1.1" });
+	await writeJson(join(root, "components", "lsp", "package.json"), { version: "0.2.0" });
 	await writeJson(join(root, "components", "git-bash", "package.json"), { version: "0.3.0" });
 	await writeJson(join(root, "hooks", "hooks.json"), {
 		hooks: {
@@ -34,6 +37,11 @@ test("#given a component without hooks #when hook status messages sync #then bui
 							command: 'node "${PLUGIN_ROOT}/components/comment-checker/dist/cli.js" hook post-tool-use',
 							statusMessage: "LazyCodex(0.1.0): Checking Comments",
 						},
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/components/lsp/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking LSP Diagnostics",
+						},
 					],
 				},
 			],
@@ -54,6 +62,21 @@ test("#given a component without hooks #when hook status messages sync #then bui
 			],
 		},
 	});
+	await writeJson(join(root, "components", "lsp", "hooks", "hooks.json"), {
+		hooks: {
+			PostToolUse: [
+				{
+					hooks: [
+						{
+							type: "command",
+							command: 'node "${PLUGIN_ROOT}/dist/cli.js" hook post-tool-use',
+							statusMessage: "LazyCodex(0.1.0): Checking LSP Diagnostics",
+						},
+					],
+				},
+			],
+		},
+	});
 
 	// when
 	await syncHookStatusMessages(root);
@@ -61,6 +84,9 @@ test("#given a component without hooks #when hook status messages sync #then bui
 	// then
 	const aggregateHooks = await readJson(join(root, "hooks", "hooks.json"));
 	const componentHooks = await readJson(join(root, "components", "comment-checker", "hooks", "hooks.json"));
-	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
+	const lspHooks = await readJson(join(root, "components", "lsp", "hooks", "hooks.json"));
+	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.0): Checking Comments");
+	assert.equal(aggregateHooks.hooks.PostToolUse[0].hooks[1].statusMessage, "LazyCodex(0.1.0): Checking LSP Diagnostics");
 	assert.equal(componentHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.1.1): Checking Comments");
+	assert.equal(lspHooks.hooks.PostToolUse[0].hooks[0].statusMessage, "LazyCodex(0.2.0): Checking LSP Diagnostics");
 });

package/packages/omo-codex/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/permissions.mjs

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

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-autonomous-features.test.mjs

@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { 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";
+
+const AUTONOMOUS_FEATURES = ["multi_agent", "child_agents_md", "unified_exec", "goals"];
+
+test("#given autonomous permissions requested #when script installer updates config #then enables Codex autonomy feature flags", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-autonomous-features-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'network_access = "disabled"',
+			"",
+			"[features]",
+			"multi_agent = false",
+			"child_agents_md = false",
+			"unified_exec = false",
+			"goals = false",
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+		autonomousPermissions: true,
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /network_access = "enabled"/);
+	for (const featureName of AUTONOMOUS_FEATURES) {
+		assert.match(content, new RegExp(`${featureName} = true`));
+	}
+});
+
+test("#given autonomous permissions disabled #when script installer updates config #then preserves autonomy feature opt-outs", async () => {
+	// given
+	const root = await mkdtemp(join(tmpdir(), "omo-codex-script-config-autonomous-features-disabled-"));
+	const configPath = join(root, "config.toml");
+	await writeFile(
+		configPath,
+		[
+			'network_access = "disabled"',
+			"",
+			"[features]",
+			"multi_agent = false",
+			"child_agents_md = false",
+			"unified_exec = false",
+			"goals = false",
+			"",
+		].join("\n"),
+	);
+
+	// when
+	await updateCodexConfig({
+		configPath,
+		repoRoot: "/repo/packages/omo-codex",
+		marketplaceName: "debug",
+		marketplaceSource: { sourceType: "local", source: "/repo/packages/omo-codex" },
+		pluginNames: ["omo"],
+		autonomousPermissions: false,
+	});
+
+	// then
+	const content = await readFile(configPath, "utf8");
+	assert.match(content, /network_access = "disabled"/);
+	for (const featureName of AUTONOMOUS_FEATURES) {
+		assert.match(content, new RegExp(`${featureName} = false`));
+	}
+	assert.match(content, /plugins = true/);
+	assert.match(content, /plugin_hooks = true/);
+});

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");