oh-my-codex-pennix 0.18.13

package/dist/config/__tests__/generator-idempotent.test.js

@@ -0,0 +1,1150 @@
+/**
+ * Idempotency tests for config.toml generator (issue #384)
+ * Verifies that repeated `omx setup` runs do not duplicate OMX sections.
+ */
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import TOML from "@iarna/toml";
+import { buildMergedConfig, cleanCodexModelAvailabilityNuxIfNeeded, mergeConfig, repairConfigIfNeeded, stripManagedCodexHookTrustState, upsertManagedCodexHookTrustState, } from "../generator.js";
+import { buildManagedCodexHookTrustState } from "../codex-hooks.js";
+import { OMX_FIRST_PARTY_MCP_SERVER_NAMES } from "../omx-first-party-mcp.js";
+/** Count occurrences of a pattern in text */
+function count(text, pattern) {
+    return (text.match(pattern) ?? []).length;
+}
+/** Assert the current OMX block appears exactly once */
+function assertSingleOmxBlock(toml, options = {}) {
+    assert.equal(count(toml, /# oh-my-codex \(OMX\) Configuration/g), 1, "OMX marker should appear once");
+    assert.equal(count(toml, /^# End oh-my-codex$/gm), 1, "End marker should appear once");
+    if (options.includeFirstPartyMcp) {
+        assertFirstPartyMcpBlocks(toml);
+    }
+    else {
+        for (const name of OMX_FIRST_PARTY_MCP_SERVER_NAMES) {
+            assert.equal(count(toml, new RegExp(`^\\[mcp_servers\\.${name}\\]$`, "gm")), 0, `[mcp_servers.${name}] should not be emitted by default`);
+        }
+    }
+    assert.equal(count(toml, /^\[mcp_servers\.omx_team_run\]$/gm), 0, "[mcp_servers.omx_team_run] should not be emitted");
+    assert.doesNotMatch(toml, /dist\/mcp\/team-server\.js/, "team-server path should not be emitted");
+    assert.equal(count(toml, /^\[tui\]$/gm), 1, "[tui] should appear once");
+    assert.equal(count(toml, /^\[features\]$/gm), 1, "[features] should appear once");
+    assert.equal(count(toml, /^hooks = true$/gm), 1, "hooks should appear once");
+    assert.equal(count(toml, /^codex_hooks = true$/gm), 0, "legacy codex_hooks should not be emitted");
+    assert.equal(count(toml, /^notify\s*=/gm), 1, "notify key should appear once");
+    assert.equal(count(toml, /^model_reasoning_effort\s*=/gm), 1, "model_reasoning_effort should appear once");
+    assert.equal(count(toml, /^developer_instructions\s*=/gm), 1, "developer_instructions should appear once");
+    assert.equal(count(toml, /^\[env\]$/gm), 0, "[env] should not be emitted");
+    assert.equal(count(toml, /^\[shell_environment_policy\.set\]$/gm), 1, "[shell_environment_policy.set] should appear once");
+    assert.equal(count(toml, /^USE_OMX_EXPLORE_CMD = "0"$/gm), 1, "USE_OMX_EXPLORE_CMD should appear once");
+}
+function assertFirstPartyMcpBlocks(toml) {
+    const parsed = TOML.parse(toml);
+    for (const name of OMX_FIRST_PARTY_MCP_SERVER_NAMES) {
+        assert.equal(count(toml, new RegExp(`^\\[mcp_servers\\.${name}\\]$`, "gm")), 1, `[mcp_servers.${name}] should appear once when first-party MCP is enabled`);
+        const command = parsed.mcp_servers?.[name]?.command;
+        assert.equal(command, process.execPath, `[mcp_servers.${name}] should use the Node executable that ran setup`);
+        assert.notEqual(command, "node", `[mcp_servers.${name}] should not depend on PATH lookup for node`);
+        assert.equal(typeof command === "string" && isAbsolute(command), true, `[mcp_servers.${name}] command should be absolute`);
+    }
+}
+function assertSingleManagedHookTrustState(toml) {
+    const parsed = TOML.parse(toml);
+    const managedKeys = Object.keys(parsed.hooks?.state ?? {}).filter((key) => key.startsWith("/tmp/codex/hooks.json:"));
+    assert.deepEqual(managedKeys.sort(), [
+        "/tmp/codex/hooks.json:post_compact:0:0",
+        "/tmp/codex/hooks.json:post_tool_use:0:0",
+        "/tmp/codex/hooks.json:pre_compact:0:0",
+        "/tmp/codex/hooks.json:pre_tool_use:0:0",
+        "/tmp/codex/hooks.json:session_start:0:0",
+        "/tmp/codex/hooks.json:stop:0:0",
+        "/tmp/codex/hooks.json:user_prompt_submit:0:0",
+    ]);
+    assert.equal(count(toml, /^# OMX-owned Codex hook trust state$/gm), 1, "managed hook trust fence should appear once");
+    assert.equal(count(toml, /^# End OMX-owned Codex hook trust state$/gm), 1, "managed hook trust end fence should appear once");
+    assert.equal(count(toml, /^\[hooks\.state\."\/tmp\/codex\/hooks\.json:/gm), managedKeys.length, "managed hook trust tables should not duplicate");
+}
+describe("Codex transient TUI NUX cleanup", () => {
+    it("removes only model availability NUX counters from project-local config", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-codex-nux-cleanup-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, [
+                'model = "gpt-5.5"',
+                'status_line = ["model-with-reasoning", "git-branch"]',
+                "",
+                "[tui]",
+                'theme = "dark"',
+                "notifications = true",
+                "",
+                "[tui.model_availability_nux]",
+                '"gpt-5.5" = 4',
+                '"gpt-5.4" = 1',
+                "",
+                "[mcp_servers.user]",
+                'command = "node"',
+                'args = ["server.js"]',
+                "",
+            ].join("\n"));
+            const cleaned = await cleanCodexModelAvailabilityNuxIfNeeded(configPath);
+            const toml = await readFile(configPath, "utf-8");
+            assert.equal(cleaned, true);
+            assert.doesNotMatch(toml, /^\[tui\.model_availability_nux\]$/m);
+            assert.doesNotMatch(toml, /gpt-5\.5" = 4/);
+            assert.match(toml, /^status_line = \["model-with-reasoning", "git-branch"\]$/m);
+            assert.match(toml, /^\[tui\]$/m);
+            assert.match(toml, /^theme = "dark"$/m);
+            assert.match(toml, /^notifications = true$/m);
+            assert.match(toml, /^\[mcp_servers\.user\]$/m);
+            assert.match(toml, /^command = "node"$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("is a no-op when project config has no Codex NUX counters", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-codex-nux-noop-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const original = [
+                'model = "gpt-5.5"',
+                "",
+                "[tui]",
+                'theme = "dark"',
+                "",
+            ].join("\n");
+            await writeFile(configPath, original);
+            const cleaned = await cleanCodexModelAvailabilityNuxIfNeeded(configPath);
+            assert.equal(cleaned, false);
+            assert.equal(await readFile(configPath, "utf-8"), original);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+});
+describe("config generator idempotency (#384)", () => {
+    it("first run creates config with all current OMX sections", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+            assert.match(toml, /^multi_agent = true$/m);
+            assert.match(toml, /^child_agents_md = true$/m);
+            assert.match(toml, /^hooks = true$/m);
+            assert.match(toml, /^goals = true$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("emits first-party MCP blocks only when explicitly enabled", () => {
+        const toml = buildMergedConfig("", "/tmp/omx", {
+            includeFirstPartyMcp: true,
+        });
+        assertSingleOmxBlock(toml, { includeFirstPartyMcp: true });
+    });
+    it("omits first-party MCP blocks in no-MCP mode while preserving user MCP servers", () => {
+        const compatConfig = buildMergedConfig([
+            "[mcp_servers.user_tool]",
+            'command = "user-tool"',
+            'args = ["serve"]',
+            "enabled = true",
+            "",
+        ].join("\n"), "/tmp/omx", { includeFirstPartyMcp: true });
+        const noMcpConfig = buildMergedConfig(compatConfig, "/tmp/omx", {
+            includeFirstPartyMcp: false,
+        });
+        assertSingleOmxBlock(noMcpConfig);
+        assert.match(noMcpConfig, /^\[mcp_servers\.user_tool\]$/m, "user-authored MCP servers should not be removed by no-MCP mode");
+        assert.doesNotMatch(noMcpConfig, /dist\/mcp\/state-server\.js/, "first-party MCP entrypoints should be removed when no-MCP mode is selected");
+    });
+    it("second run updates without duplicating any section", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            // First run
+            await mergeConfig(configPath, wd);
+            const first = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(first);
+            // Second run
+            await mergeConfig(configPath, wd);
+            const second = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(second);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("triple run stays clean", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await mergeConfig(configPath, wd);
+            await mergeConfig(configPath, wd);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("cleans up legacy config without markers", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            // Simulate a legacy config written without OMX markers
+            // Note: [tui] is intentionally excluded — orphan-strip does not
+            // claim [tui] to avoid deleting user-owned TUI settings.
+            const legacy = [
+                'model = "o3"',
+                "",
+                'notify = ["node", "/old/path/notify-hook.js"]',
+                'model_reasoning_effort = "medium"',
+                'developer_instructions = "old instructions"',
+                "",
+                "[features]",
+                "multi_agent = true",
+                "goals = false",
+                "",
+                "[mcp_servers.omx_state]",
+                'command = "node"',
+                'args = ["/old/path/state-server.js"]',
+                "enabled = true",
+                "",
+                "[mcp_servers.omx_memory]",
+                'command = "node"',
+                'args = ["/old/path/memory-server.js"]',
+                "enabled = true",
+                "",
+                "[user.custom]",
+                'name = "kept"',
+                "",
+            ].join("\n");
+            await writeFile(configPath, legacy);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+            // User settings preserved
+            assert.match(toml, /^model = "o3"$/m, "user model preserved");
+            assert.match(toml, /^\[user\.custom\]$/m, "user section preserved");
+            assert.match(toml, /^name = "kept"$/m, "user key preserved");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("cleans up orphaned OMX sections outside marker block", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            // Config with both orphaned sections AND a marker block
+            const mixed = [
+                'model = "o3"',
+                "",
+                "# OMX State Management MCP Server",
+                "[mcp_servers.omx_state]",
+                'command = "node"',
+                'args = ["/orphaned/state-server.js"]',
+                "enabled = true",
+                "",
+                "[user.settings]",
+                'name = "kept"',
+                "",
+                "# ============================================================",
+                "# oh-my-codex (OMX) Configuration",
+                "# Managed by omx setup",
+                "# ============================================================",
+                "",
+                "[mcp_servers.omx_state]",
+                'command = "node"',
+                'args = ["/marker-block/state-server.js"]',
+                "enabled = true",
+                "",
+                "# ============================================================",
+                "# End oh-my-codex",
+                "",
+            ].join("\n");
+            await writeFile(configPath, mixed);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+            assert.match(toml, /^model = "o3"$/m, "user model preserved");
+            assert.match(toml, /^\[user\.settings\]$/m, "user section preserved");
+            assert.match(toml, /^name = "kept"$/m, "user key preserved");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves user-owned omx-prefixed MCP servers that are not first-party", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const userMcp = [
+                "[mcp_servers.omx_custom]",
+                'command = "node"',
+                'args = ["/user/custom-server.js"]',
+                "enabled = true",
+                "",
+            ].join("\n");
+            await writeFile(configPath, userMcp);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+            assert.match(toml, /^\[mcp_servers\.omx_custom\]$/m, "user-owned omx-prefixed MCP server preserved");
+            assert.match(toml, /^args = \["\/user\/custom-server\.js"\]$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves user content between OMX re-runs", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            // First run
+            await mergeConfig(configPath, wd);
+            // User adds content
+            let toml = await readFile(configPath, "utf-8");
+            toml += '\n[user.prefs]\ntheme = "dark"\n';
+            await writeFile(configPath, toml);
+            // Second run
+            await mergeConfig(configPath, wd);
+            const result = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(result);
+            assert.match(result, /^\[user\.prefs\]$/m, "user section preserved after re-run");
+            assert.match(result, /^theme = "dark"$/m, "user key preserved after re-run");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("handles config with only orphaned agents sections", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const orphanedAgents = [
+                "[features]",
+                "multi_agent = true",
+                "goals = false",
+                "",
+                "# OMX Native Agent Roles (Codex multi-agent)",
+                "",
+                "[agents.executor]",
+                'description = "old executor"',
+                'config_file = "/old/path/executor.toml"',
+                "",
+                "[agents.explore]",
+                'description = "old explore"',
+                'config_file = "/old/path/explore.toml"',
+                "",
+                "[user.custom]",
+                'name = "kept"',
+                "",
+            ].join("\n");
+            await writeFile(configPath, orphanedAgents);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+            assert.match(toml, /^\[user\.custom\]$/m, "user section preserved");
+            assert.match(toml, /^name = "kept"$/m, "user key preserved");
+            assert.match(toml, /^\[agents\]$/m, "global agents settings added");
+            assert.match(toml, /^max_threads = 6$/m, "global agents max_threads seeded");
+            assert.match(toml, /^max_depth = 2$/m, "global agents max_depth seeded");
+            assert.doesNotMatch(toml, /^\[agents\.executor\]$/m, "legacy OMX agent entry removed");
+            assert.doesNotMatch(toml, /^\[agents\.explore\]$/m, "legacy OMX agent entry removed");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves non-OMX agent sections", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const userAgents = [
+                '[agents."my-custom-bot"]',
+                'description = "My custom agent"',
+                'config_file = "/home/user/my-bot.toml"',
+                "",
+                "[agents.myreviewer]",
+                'description = "Company code reviewer"',
+                'config_file = "/home/user/reviewer.toml"',
+                "",
+            ].join("\n");
+            await writeFile(configPath, userAgents);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            // User-defined agents must survive
+            assert.match(toml, /^\[agents\."my-custom-bot"\]$/m, "user agent my-custom-bot preserved");
+            assert.match(toml, /^description = "My custom agent"$/m, "user agent description preserved");
+            assert.match(toml, /^\[agents\.myreviewer\]$/m, "user agent myreviewer preserved");
+            assert.match(toml, /^description = "Company code reviewer"$/m, "user agent description preserved");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves a user-owned status_line in an existing [tui] section", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const userTui = [
+                "[tui]",
+                "theme = \"night\"",
+                'status_line = ["git-branch"]',
+                "",
+            ].join("\n");
+            await writeFile(configPath, userTui);
+            await mergeConfig(configPath, wd);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.equal(count(toml, /^\[tui\]$/gm), 1, "[tui] should appear once");
+            assert.match(toml, /^theme = "night"$/m, "user tui key preserved");
+            assert.match(toml, /^status_line = \["git-branch"\]$/m, "user status_line preserved");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("seeds the default status_line into a fresh [tui] section", () => {
+        const toml = buildMergedConfig("", "/tmp/omx");
+        assert.equal(count(toml, /^\[tui\]$/gm), 1, "[tui] should appear once");
+        assert.match(toml, /^status_line = \["model-with-reasoning", "git-branch", "context-remaining", "total-input-tokens", "total-output-tokens", "five-hour-limit", "weekly-limit"\]$/m);
+    });
+    it("seeds the default status_line into an existing [tui] section without one", () => {
+        const toml = buildMergedConfig(["[tui]", 'theme = "night"', ""].join("\n"), "/tmp/omx");
+        assert.equal(count(toml, /^\[tui\]$/gm), 1, "[tui] should appear once");
+        assert.match(toml, /^theme = "night"$/m, "existing tui key preserved");
+        assert.match(toml, /^status_line = \["model-with-reasoning", "git-branch", "context-remaining", "total-input-tokens", "total-output-tokens", "five-hour-limit", "weekly-limit"\]$/m, "default status_line should be seeded when [tui] lacks one");
+    });
+    it("preserves a multiline user-owned status_line", () => {
+        const toml = buildMergedConfig([
+            "[tui]",
+            "status_line = [",
+            '  "git-branch",',
+            '  "context-remaining",',
+            "]",
+            "",
+        ].join("\n"), "/tmp/omx");
+        assert.equal(count(toml, /^\[tui\]$/gm), 1, "[tui] should appear once");
+        assert.ok(toml.includes([
+            "status_line = [",
+            '"git-branch",',
+            '"context-remaining",',
+            "]",
+        ].join("\n")), "multiline user status_line should be preserved");
+        assert.doesNotMatch(toml, /^status_line = \["model-with-reasoning", "git-branch", "context-remaining", "total-input-tokens", "total-output-tokens", "five-hour-limit", "weekly-limit"\]$/m, "default status_line should not overwrite multiline customization");
+    });
+    it("preserves a customized managed-block status_line when refreshing setup", () => {
+        const firstRun = buildMergedConfig("", "/tmp/omx");
+        const customized = firstRun.replace(/^status_line = \["model-with-reasoning", "git-branch", "context-remaining", "total-input-tokens", "total-output-tokens", "five-hour-limit", "weekly-limit"\]$/m, 'status_line = ["git-branch", "context-remaining"]');
+        const refreshed = buildMergedConfig(customized, "/tmp/omx");
+        assert.equal(count(refreshed, /^\[tui\]$/gm), 1, "[tui] should appear once");
+        assert.match(refreshed, /^status_line = \["git-branch", "context-remaining"\]$/m, "customized status_line should survive managed-block stripping");
+        assert.doesNotMatch(refreshed, /^status_line = \["model-with-reasoning", "git-branch", "context-remaining", "total-input-tokens", "total-output-tokens", "five-hour-limit", "weekly-limit"\]$/m, "default status_line should not overwrite customization");
+    });
+    it("skips emitting an OMX [tui] table when includeTui is disabled", () => {
+        const toml = buildMergedConfig("", "/tmp/omx", {
+            includeTui: false,
+        });
+        assert.doesNotMatch(toml, /^\[tui\]$/m);
+        assert.doesNotMatch(toml, /^\[mcp_servers\.omx_state\]$/m);
+        assert.match(toml, /^\[shell_environment_policy\.set\]$/m);
+        assert.match(toml, /^USE_OMX_EXPLORE_CMD = "0"$/m);
+    });
+    it('seeds USE_OMX_EXPLORE_CMD=0 into generated config by default', () => {
+        const toml = buildMergedConfig('', '/tmp/omx');
+        assert.doesNotMatch(toml, /^\[env\]$/m);
+        assert.match(toml, /^\[shell_environment_policy\.set\]$/m);
+        assert.match(toml, /^USE_OMX_EXPLORE_CMD = "0"$/m);
+    });
+    it('migrates existing [env] keys and explicit explore routing opt-outs', () => {
+        const toml = buildMergedConfig(['[env]', 'FOO = "bar"', 'USE_OMX_EXPLORE_CMD = "0"', ''].join('\n'), '/tmp/omx');
+        assert.doesNotMatch(toml, /^\[env\]$/m);
+        assert.match(toml, /^\[shell_environment_policy\.set\]$/m);
+        assert.match(toml, /^FOO = "bar"$/m);
+        assert.match(toml, /^USE_OMX_EXPLORE_CMD = "0"$/m);
+    });
+    it("migrates multiline [env] values without truncating TOML entries", () => {
+        const toml = buildMergedConfig([
+            "[env]",
+            'FOO = """first line',
+            "  second line",
+            'third line"""',
+            "BAR = [",
+            '  "one",',
+            '  "two",',
+            "]",
+            "",
+        ].join("\n"), "/tmp/omx");
+        assert.doesNotMatch(toml, /^\[env\]$/m);
+        assert.match(toml, /^\[shell_environment_policy\.set\]$/m);
+        assert.match(toml, /FOO = """first line\n  second line\nthird line"""/);
+        assert.match(toml, /BAR = \[\n  "one",\n  "two",\n\]/);
+        assert.match(toml, /^USE_OMX_EXPLORE_CMD = "0"$/m);
+        assert.doesNotThrow(() => TOML.parse(toml));
+    });
+    it("replaces an existing OMX notify entry without leaving orphan fragments behind", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const existing = [
+                "[shell_environment_policy]",
+                'inherit = "all"',
+                "",
+                'notify = ["node", "/tmp/legacy-notify-hook.js"]',
+                "",
+                '    "node",',
+                '    "/tmp/legacy-notify-hook.js",',
+                "]",
+                "",
+            ].join("\n");
+            await writeFile(configPath, existing);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.equal(count(toml, /^notify\s*=/gm), 1, "notify should appear once");
+            assert.match(toml, /^notify = \["node", ".*notify-hook\.js"\]$/m);
+            assert.doesNotMatch(toml, /^\s*"node",\s*$/m, "orphan fragment removed");
+            assert.doesNotMatch(toml, /legacy-notify-hook\.js/, "legacy notify path removed");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("seeds context keys when root model is missing and both context keys are absent", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, 'approval_policy = "on-failure"\n');
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.match(toml, /^model = "gpt-5.5"$/m);
+            assert.match(toml, /^# oh-my-codex seeded behavioral defaults \(uninstall removes unchanged defaults\)$/m);
+            assert.match(toml, /^model_context_window = 250000$/m);
+            assert.match(toml, /^model_auto_compact_token_limit = 200000$/m);
+            assert.match(toml, /^# End oh-my-codex seeded behavioral defaults$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("can override gpt-5.3-codex to gpt-5.5 and seed 250k context defaults", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const toml = buildMergedConfig('model = \"gpt-5.3-codex\"\n', wd, {
+                modelOverride: "gpt-5.5",
+            });
+            assert.match(toml, /^model = "gpt-5\.5"$/m);
+            assert.doesNotMatch(toml, /^model = "gpt-5\.3-codex"$/m);
+            assert.match(toml, /^# oh-my-codex seeded behavioral defaults \(uninstall removes unchanged defaults\)$/m);
+            assert.match(toml, /^model_context_window = 250000$/m);
+            assert.match(toml, /^model_auto_compact_token_limit = 200000$/m);
+            assert.match(toml, /^# End oh-my-codex seeded behavioral defaults$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("does not seed 250k context defaults for non-gpt-5.5 models", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, 'model = "o3"\n');
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.match(toml, /^model = "o3"$/m, "user model preserved");
+            assert.doesNotMatch(toml, /^model_context_window = 250000$/m);
+            assert.doesNotMatch(toml, /^model_auto_compact_token_limit = 200000$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("seeds missing auto compact limit without overwriting an existing context window", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, ['model = "gpt-5.5"', "model_context_window = 640000", ""].join("\n"));
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.match(toml, /^model = "gpt-5\.5"$/m);
+            assert.match(toml, /^model_context_window = 640000$/m);
+            assert.match(toml, /^model_auto_compact_token_limit = 200000$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("seeds missing context window without overwriting an existing auto compact limit", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, ['model = "gpt-5.5"', "model_auto_compact_token_limit = 150000", ""].join("\n"));
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.match(toml, /^model = "gpt-5\.5"$/m);
+            assert.match(toml, /^model_context_window = 250000$/m);
+            assert.match(toml, /^model_auto_compact_token_limit = 150000$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("does not duplicate independently seeded defaults across reruns", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, ['model = "gpt-5.5"', "model_context_window = 640000", ""].join("\n"));
+            await mergeConfig(configPath, wd);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.equal(count(toml, /^model_context_window = 640000$/gm), 1);
+            assert.equal(count(toml, /^model_auto_compact_token_limit = 200000$/gm), 1);
+            assert.doesNotMatch(toml, /^model_context_window = 250000$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("does not duplicate seeded model defaults across reruns", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await mergeConfig(configPath, wd);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.equal(count(toml, /^model = "gpt-5\.5"$/gm), 1, "seeded model should appear once");
+            assert.equal(count(toml, /^model_context_window = 250000$/gm), 1, "seeded context window should appear once");
+            assert.equal(count(toml, /^model_auto_compact_token_limit = 200000$/gm), 1, "seeded auto compact limit should appear once");
+            assert.equal(count(toml, /^# oh-my-codex seeded behavioral defaults \(uninstall removes unchanged defaults\)$/gm), 1, "seeded defaults start marker should appear once");
+            assert.equal(count(toml, /^# End oh-my-codex seeded behavioral defaults$/gm), 1, "seeded defaults end marker should appear once");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("writes only the global [agents] defaults into config", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assert.match(toml, /^\[agents\]$/m, "global [agents] section present");
+            assert.match(toml, /^max_threads = 6$/m, "max_threads default written");
+            assert.match(toml, /^max_depth = 2$/m, "max_depth default written");
+            assert.doesNotMatch(toml, /^\[agents\.[^\]]+\]$/m, "legacy per-agent config_file entries omitted");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("repairs config with duplicate [tui] sections from upgrade", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            // Simulate a broken config left by an older omx setup: an orphaned
+            // [tui] outside the OMX block AND another [tui] inside the block.
+            const broken = [
+                '[mcp_servers.figma]',
+                'url = "https://mcp.figma.com/mcp"',
+                '',
+                '# OMX TUI StatusLine (Codex CLI v0.101.0+)',
+                '[tui]',
+                'status_line = ["git-branch"]',
+                '',
+                '# ============================================================',
+                '# End oh-my-codex',
+                '',
+                '# ============================================================',
+                '# oh-my-codex (OMX) Configuration',
+                '# Managed by omx setup - manual edits preserved on next setup',
+                '# ============================================================',
+                '',
+                '[mcp_servers.omx_state]',
+                'command = "node"',
+                `args = ["${join(wd, "dist/mcp/state-server.js")}"]`,
+                'enabled = true',
+                '',
+                '# OMX TUI StatusLine (Codex CLI v0.101.0+)',
+                '[tui]',
+                'status_line = ["model-with-reasoning", "git-branch"]',
+                '',
+                '# ============================================================',
+                '# End oh-my-codex',
+                '',
+            ].join("\n");
+            await writeFile(configPath, broken);
+            // buildMergedConfig should produce a clean config with only one [tui]
+            const toml = buildMergedConfig(broken, wd);
+            assert.equal(count(toml, /^\[tui\]$/gm), 1, "[tui] should appear once");
+            assert.equal(count(toml, /^# End oh-my-codex$/gm), 1, "End marker should appear once");
+            // User MCP server must survive
+            assert.match(toml, /^\[mcp_servers\.figma\]$/m, "user MCP preserved");
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("mergeConfig removes legacy omx_team_run tables during setup upgrade", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const legacy = [
+                '[user.before]',
+                'name = "kept-before"',
+                "",
+                '# ============================================================',
+                '# oh-my-codex (OMX) Configuration',
+                '# Managed by omx setup - manual edits preserved on next setup',
+                '# ============================================================',
+                "",
+                '[mcp_servers.omx_team_run]',
+                'command = "node"',
+                'args = ["/tmp/team-server.js"]',
+                'enabled = true',
+                "",
+                '# ============================================================',
+                '# End oh-my-codex',
+                "",
+                '[user.after]',
+                'name = "kept-after"',
+                "",
+            ].join("\n");
+            await writeFile(configPath, legacy);
+            await mergeConfig(configPath, wd);
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+            assert.doesNotMatch(toml, /^\[mcp_servers\.omx_team_run\]$/m);
+            assert.doesNotMatch(toml, /team-server\.js/);
+            assert.match(toml, /^\[user\.before\]$/m);
+            assert.match(toml, /^name = "kept-before"$/m);
+            assert.match(toml, /^\[user\.after\]$/m);
+            assert.match(toml, /^name = "kept-after"$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("repairConfigIfNeeded removes legacy omx_team_run tables during launch repair", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            const legacy = [
+                '[user.before]',
+                'name = "kept-before"',
+                "",
+                '[mcp_servers.omx_team_run]',
+                'command = "node"',
+                'args = ["/tmp/team-server.js"]',
+                'enabled = true',
+                "",
+                '[user.after]',
+                'name = "kept-after"',
+                "",
+            ].join("\n");
+            await writeFile(configPath, legacy);
+            const didRepair = await repairConfigIfNeeded(configPath, wd);
+            assert.equal(didRepair, true, "legacy team-run config should be repaired");
+            const toml = await readFile(configPath, "utf-8");
+            assertSingleOmxBlock(toml);
+            assert.doesNotMatch(toml, /^\[mcp_servers\.omx_team_run\]$/m);
+            assert.doesNotMatch(toml, /team-server\.js/);
+            assert.match(toml, /^\[user\.before\]$/m);
+            assert.match(toml, /^name = "kept-before"$/m);
+            assert.match(toml, /^\[user\.after\]$/m);
+            assert.match(toml, /^name = "kept-after"$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("repairConfigIfNeeded fixes duplicate [tui] and is a no-op when clean", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            // First: create a clean config
+            await mergeConfig(configPath, wd);
+            const clean = await readFile(configPath, "utf-8");
+            assert.equal(count(clean, /^\[tui\]$/gm), 1);
+            // repairConfigIfNeeded should be a no-op
+            const wasRepaired = await repairConfigIfNeeded(configPath, wd);
+            assert.equal(wasRepaired, false, "clean config should not need repair");
+            // Now break it by appending a second [tui]
+            await writeFile(configPath, clean + "\n[tui]\nstatus_line = [\"git-branch\"]\n");
+            const broken = await readFile(configPath, "utf-8");
+            assert.equal(count(broken, /^\[tui\]$/gm), 2);
+            // repairConfigIfNeeded should fix it
+            const didRepair = await repairConfigIfNeeded(configPath, wd);
+            assert.equal(didRepair, true, "broken config should be repaired");
+            const repaired = await readFile(configPath, "utf-8");
+            assert.equal(count(repaired, /^\[tui\]$/gm), 1, "[tui] should appear once after repair");
+            assertSingleOmxBlock(repaired);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("preserves trailing user config after an unmatched managed hook trust-state start marker", () => {
+        const malformed = [
+            'model = "gpt-5.5"',
+            "",
+            "# OMX-owned Codex hook trust state",
+            "# Missing the end fence must not cause trailing user config deletion.",
+            "",
+            '[hooks.state."custom:/hooks.json:stop:0:0"]',
+            'trusted_hash = "sha256:user"',
+            "enabled = false",
+            "",
+            "[hooks.state.user_prompt_submit]",
+            'trusted_hash = "sha256:prompt"',
+            "enabled = true",
+            "",
+        ].join("\n");
+        const stripped = stripManagedCodexHookTrustState(malformed);
+        assert.match(stripped, /^# OMX-owned Codex hook trust state$/m);
+        assert.match(stripped, /^\[hooks\.state\."custom:\/hooks\.json:stop:0:0"\]$/m);
+        assert.match(stripped, /^enabled = false$/m);
+        assert.match(stripped, /^\[hooks\.state\.user_prompt_submit\]$/m);
+        assert.match(stripped, /^trusted_hash = "sha256:prompt"$/m);
+        assert.doesNotThrow(() => TOML.parse(stripped));
+    });
+    it("removes orphaned managed hook trust-state tables only when hashes prove ownership", () => {
+        const hooksPath = "/tmp/codex/hooks.json";
+        const managedTrustState = buildManagedCodexHookTrustState(hooksPath, "/tmp/omx");
+        const managedPostCompactHash = managedTrustState[`${hooksPath}:post_compact:0:0`]?.trusted_hash;
+        const managedStopHash = managedTrustState[`${hooksPath}:stop:0:0`]?.trusted_hash;
+        assert.ok(managedPostCompactHash);
+        assert.ok(managedStopHash);
+        const orphaned = [
+            'model = "gpt-5.5"',
+            "",
+            "[hooks.state]",
+            "",
+            '[plugins."oh-my-codex@oh-my-codex-local"]',
+            "enabled = true",
+            "",
+            '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+            `trusted_hash = "${managedPostCompactHash}"`,
+            "",
+            '[hooks.state."/tmp/codex/hooks.json:stop:0:0"]',
+            `trusted_hash = "${managedStopHash}"`,
+            "",
+            '[hooks.state."custom:/hooks.json:stop:0:0"]',
+            'trusted_hash = "sha256:user"',
+            "",
+            "# End OMX-owned Codex hook trust state",
+            "",
+            "[desktop]",
+            "git-create-pull-request-as-draft = true",
+            "",
+        ].join("\n");
+        const stripped = stripManagedCodexHookTrustState(orphaned, {
+            managedTrustState,
+        });
+        assert.doesNotMatch(stripped, /\/tmp\/codex\/hooks\.json:post_compact:0:0/);
+        assert.doesNotMatch(stripped, /\/tmp\/codex\/hooks\.json:stop:0:0/);
+        assert.match(stripped, /^# End OMX-owned Codex hook trust state$/m);
+        assert.match(stripped, /^\[hooks\.state\."custom:\/hooks\.json:stop:0:0"\]$/m);
+        assert.match(stripped, /^trusted_hash = "sha256:user"$/m);
+        assert.match(stripped, /^\[desktop\]$/m);
+        assert.doesNotThrow(() => TOML.parse(stripped));
+    });
+    it("preserves same-key user hook trust state and suppresses generated duplicates", () => {
+        const hooksPath = "/tmp/codex/hooks.json";
+        const config = [
+            'model = "gpt-5.5"',
+            "",
+            '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+            'trusted_hash = "sha256:user"',
+            "enabled = false",
+            "",
+        ].join("\n");
+        const refreshed = upsertManagedCodexHookTrustState(config, "/tmp/omx", hooksPath);
+        assert.match(refreshed, /^trusted_hash = "sha256:user"$/m);
+        assert.match(refreshed, /^enabled = false$/m);
+        assert.equal(count(refreshed, /^\[hooks\.state\."\/tmp\/codex\/hooks\.json:post_compact:0:0"\]$/gm), 1, "preserved same-key user trust state must not be duplicated");
+        assert.doesNotThrow(() => TOML.parse(refreshed));
+    });
+    it("preserves unproven same-key hook trust-state tables", () => {
+        const hooksPath = "/tmp/codex/hooks.json";
+        const managedTrustState = buildManagedCodexHookTrustState(hooksPath, "/tmp/omx");
+        const fixtures = [
+            [
+                "missing hash",
+                [
+                    '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+                    "enabled = false",
+                ],
+            ],
+            [
+                "malformed hash",
+                [
+                    '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+                    "trusted_hash = true",
+                ],
+            ],
+            [
+                "extra assignment",
+                [
+                    '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+                    'trusted_hash = "sha256:user"',
+                    "enabled = false",
+                ],
+            ],
+            [
+                "body comment",
+                [
+                    '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+                    "# user comment",
+                    'trusted_hash = "sha256:user"',
+                ],
+            ],
+            [
+                "inline body comment",
+                [
+                    '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+                    'trusted_hash = "sha256:user" # user comment',
+                ],
+            ],
+            [
+                "inline header comment",
+                [
+                    '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"] # user comment',
+                    'trusted_hash = "sha256:user"',
+                ],
+            ],
+        ];
+        for (const [name, table] of fixtures) {
+            const stripped = stripManagedCodexHookTrustState(table.join("\n"), {
+                managedTrustState,
+            });
+            assert.match(stripped, /^\[hooks\.state\."\/tmp\/codex\/hooks\.json:post_compact:0:0"\]/m, `${name} should be preserved`);
+        }
+    });
+    it("does not remove unfenced hook trust-state tables without a proof map", () => {
+        const config = [
+            '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+            'trusted_hash = "sha256:managed-looking"',
+            "",
+        ].join("\n");
+        const stripped = stripManagedCodexHookTrustState(config);
+        assert.match(stripped, /managed-looking/);
+    });
+    it("dedupes prior fenced managed hook trust-state blocks before writing a replacement", () => {
+        const first = upsertManagedCodexHookTrustState([
+            'model = "gpt-5.5"',
+            "",
+            '[hooks.state."custom:/hooks.json:stop:0:0"]',
+            'trusted_hash = "sha256:user"',
+            "enabled = false",
+            "",
+        ].join("\n"), "/tmp/omx", "/tmp/codex/hooks.json");
+        const brokenWithDuplicatePriorBlock = `${first}\n${first.slice(first.indexOf("# OMX-owned Codex hook trust state"))}`;
+        assert.equal(count(brokenWithDuplicatePriorBlock, /^\[hooks\.state\."\/tmp\/codex\/hooks\.json:stop:0:0"\]$/gm), 2, "regression fixture should contain duplicate managed trust tables");
+        const repaired = upsertManagedCodexHookTrustState(brokenWithDuplicatePriorBlock, "/tmp/omx", "/tmp/codex/hooks.json");
+        const repeated = upsertManagedCodexHookTrustState(repaired, "/tmp/omx", "/tmp/codex/hooks.json");
+        assert.equal(repeated, repaired);
+        assert.match(repaired, /^\[hooks\.state\."custom:\/hooks\.json:stop:0:0"\]$/m, "unrelated user hook state should be preserved");
+        assert.match(repaired, /^enabled = false$/m);
+        assertSingleManagedHookTrustState(repaired);
+    });
+    it("dedupes stale unfenced managed hook trust-state tables during legacy setup refresh", () => {
+        const hooksPath = "/tmp/codex/hooks.json";
+        const stalePluginModeConfig = [
+            "[features]",
+            "codex_hooks = true",
+            "goals = true",
+            "",
+            '[hooks.state."custom:/hooks.json:stop:0:0"]',
+            'trusted_hash = "sha256:user"',
+            "enabled = false",
+            "",
+            // Regression fixture for #2225: plugin-mode state could be left outside
+            // the managed fence, then legacy setup appended the same table again.
+            '[hooks.state."/tmp/codex/hooks.json:post_compact:0:0"]',
+            'trusted_hash = "sha256:stale-plugin-mode"',
+            "",
+        ].join("\n");
+        const refreshed = buildMergedConfig(stalePluginModeConfig, "/tmp/omx", {
+            codexHooksFile: hooksPath,
+        });
+        assert.doesNotThrow(() => TOML.parse(refreshed));
+        assert.equal(count(refreshed, /^\[hooks\.state\."\/tmp\/codex\/hooks\.json:post_compact:0:0"\]$/gm), 1, "legacy refresh should replace the stale plugin-mode managed hook state");
+        assert.match(refreshed, /^\[hooks\.state\."custom:\/hooks\.json:stop:0:0"\]$/m, "unrelated user hook state should be preserved");
+        assert.match(refreshed, /^enabled = false$/m);
+        assertSingleManagedHookTrustState(refreshed);
+    });
+    it("syncs shared MCP registry entries in a dedicated managed block", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const first = buildMergedConfig("", wd, {
+                sharedMcpServers: [
+                    {
+                        name: "eslint",
+                        command: "npx",
+                        args: ["@eslint/mcp@latest"],
+                        enabled: true,
+                        startupTimeoutSec: 12,
+                    },
+                ],
+                sharedMcpRegistrySource: "/tmp/.omx/mcp-registry.json",
+            });
+            const second = buildMergedConfig(first, wd, {
+                sharedMcpServers: [
+                    {
+                        name: "eslint",
+                        command: "npx",
+                        args: ["@eslint/mcp@latest"],
+                        enabled: true,
+                        startupTimeoutSec: 12,
+                    },
+                ],
+                sharedMcpRegistrySource: "/tmp/.omx/mcp-registry.json",
+            });
+            assert.equal(count(second, /oh-my-codex \(OMX\) Shared MCP Registry Sync/g), 1, "shared MCP sync block should appear once");
+            assert.equal(count(second, /^\[mcp_servers\.eslint\]$/gm), 1, "shared eslint MCP table should appear once");
+            assert.match(second, /# Source: \/tmp\/\.omx\/mcp-registry\.json/);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("skips shared MCP entries that already exist in user config", () => {
+        const existing = [
+            "[mcp_servers.existing_server]",
+            'command = "custom"',
+            'args = ["serve"]',
+            "",
+        ].join("\n");
+        const merged = buildMergedConfig(existing, "/tmp/omx", {
+            sharedMcpServers: [
+                {
+                    name: "existing_server",
+                    command: "existing-server",
+                    args: ["mcp"],
+                    enabled: true,
+                },
+                {
+                    name: "eslint",
+                    command: "npx",
+                    args: ["@eslint/mcp@latest"],
+                    enabled: true,
+                },
+            ],
+            sharedMcpRegistrySource: "/tmp/.omx/mcp-registry.json",
+        });
+        assert.equal(count(merged, /^\[mcp_servers\.existing_server\]$/gm), 1);
+        assert.match(merged, /command = "custom"/);
+        assert.equal(count(merged, /^\[mcp_servers\.eslint\]$/gm), 1);
+    });
+    it("adds a default startup timeout to launcher-backed non-OMX MCP servers and stays idempotent", () => {
+        const existing = [
+            '[mcp_servers.filesystem]',
+            'command = "npx"',
+            'args = ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]',
+            "",
+        ].join("\n");
+        const first = buildMergedConfig(existing, "/tmp/omx");
+        const second = buildMergedConfig(first, "/tmp/omx");
+        assert.match(first, /^\[mcp_servers\.filesystem\]$/m);
+        assert.match(first, /^startup_timeout_sec = 15$/m);
+        assert.equal(count(second, /^startup_timeout_sec = 15$/gm), 1);
+    });
+    it("preserves explicit launcher timeouts and leaves non-launcher MCP servers untouched", () => {
+        const existing = [
+            '[mcp_servers.fetch]',
+            'command = "uvx"',
+            'args = ["mcp-server-fetch"]',
+            "startup_timeout_sec = 22",
+            "",
+            '[mcp_servers.custom]',
+            'command = "custom-mcp"',
+            'args = ["serve"]',
+            "",
+        ].join("\n");
+        const merged = buildMergedConfig(existing, "/tmp/omx");
+        assert.equal(count(merged, /^startup_timeout_sec = 22$/gm), 1);
+        assert.doesNotMatch(merged, /\[mcp_servers\.custom\][\s\S]*?startup_timeout_sec = 15/);
+    });
+    it("treats npm exec launchers as timeout-backed MCP commands", () => {
+        const existing = [
+            '[mcp_servers.seq]',
+            'command = "npm"',
+            'args = ["exec", "@modelcontextprotocol/server-sequential-thinking"]',
+            "",
+        ].join("\n");
+        const merged = buildMergedConfig(existing, "/tmp/omx");
+        assert.match(merged, /^\[mcp_servers\.seq\]$/m);
+        assert.match(merged, /^startup_timeout_sec = 15$/m);
+    });
+    it("removes an existing multiline developer_instructions assignment as one root entry", () => {
+        const existing = [
+            'model = "gpt-5.5"',
+            'developer_instructions = """Custom instructions survive as valid TOML.',
+            'This line used to be orphaned by setup.',
+            'This closing line used to break parsing."""',
+            "",
+            "[features]",
+            "web_search = true",
+            "",
+        ].join("\n");
+        const merged = buildMergedConfig(existing, "/tmp/omx");
+        assert.doesNotMatch(merged, /This line used to be orphaned/);
+        assert.doesNotMatch(merged, /This closing line used to break parsing/);
+        assert.equal(count(merged, /^developer_instructions\s*=/gm), 1);
+        assert.doesNotThrow(() => TOML.parse(merged));
+    });
+    it("preserves root model values when mergeConfig sees multiline root strings", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, [
+                'developer_instructions = """Custom instructions.',
+                'Multiple lines.',
+                'Done."""',
+                'model = "o3"',
+                "model_context_window = 123456",
+                "",
+                "[features]",
+                "web_search = true",
+                "",
+            ].join("\n"));
+            await mergeConfig(configPath, wd);
+            const merged = await readFile(configPath, "utf-8");
+            assert.match(merged, /^model = "o3"$/m);
+            assert.match(merged, /^model_context_window = 123456$/m);
+            assert.doesNotMatch(merged, /^model_auto_compact_token_limit = 200000$/m);
+            assert.doesNotThrow(() => TOML.parse(merged));
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+    it("repairConfigIfNeeded backfills launcher-backed MCP startup timeouts", async () => {
+        const wd = await mkdtemp(join(tmpdir(), "omx-idem-"));
+        try {
+            const configPath = join(wd, "config.toml");
+            await writeFile(configPath, [
+                '[mcp_servers.filesystem]',
+                'command = "npx"',
+                'args = ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"]',
+                "",
+            ].join("\n"));
+            const repaired = await repairConfigIfNeeded(configPath, wd);
+            const config = await readFile(configPath, "utf-8");
+            assert.equal(repaired, true);
+            assert.match(config, /^startup_timeout_sec = 15$/m);
+        }
+        finally {
+            await rm(wd, { recursive: true, force: true });
+        }
+    });
+});
+//# sourceMappingURL=generator-idempotent.test.js.map