oh-my-codex-pennix 0.18.13

package/dist/config/generator.js

@@ -0,0 +1,1845 @@
+/**
+ * Config.toml generator/merger for oh-my-codex
+ * Merges OMX MCP server entries and feature flags into existing config.toml
+ *
+ * TOML structure reminder: bare key=value pairs after a [table] header belong
+ * to that table.  Top-level (root-table) keys MUST appear before the first
+ * [table] header.  This generator therefore splits its output into:
+ *   1. Top-level keys  (notify, model_reasoning_effort, developer_instructions)
+ *   2. [features] flags
+ *   3. [table] sections (shell_environment_policy.set, mcp_servers, tui)
+ */
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join, resolve } from "path";
+import TOML from "@iarna/toml";
+import { AGENT_DEFINITIONS } from "../agents/definitions.js";
+import { DEFAULT_FRONTIER_MODEL } from "./models.js";
+import { DEFAULT_CODEX_HOOK_FEATURE_FLAG, CODEX_HOOK_FEATURE_FLAGS, CODEX_PLUGIN_SCOPED_HOOKS_FEATURE_FLAG, formatCodexHookFeatureFlagLine, normalizeCodexHookFeatureFlag, } from "./codex-feature-flags.js";
+import { OMX_FIRST_PARTY_MCP_SERVER_NAMES, getOmxFirstPartySetupMcpServers, } from "./omx-first-party-mcp.js";
+import { buildManagedCodexHookTrustState, escapeTomlBasicString, } from "./codex-hooks.js";
+function escapeTomlString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// ---------------------------------------------------------------------------
+// Top-level OMX keys (must live before any [table] header)
+// ---------------------------------------------------------------------------
+/** Keys we own at the TOML root level. Used for upsert + strip. */
+const OMX_TOP_LEVEL_KEYS = [
+    "notify",
+    "model_reasoning_effort",
+    "developer_instructions",
+];
+export const DEFAULT_SETUP_MODEL = DEFAULT_FRONTIER_MODEL;
+export const DEFAULT_SETUP_MODEL_CONTEXT_WINDOW = 250000;
+export const DEFAULT_SETUP_MODEL_AUTO_COMPACT_TOKEN_LIMIT = 200000;
+export function getModelContextRecommendation(model) {
+    if (model !== DEFAULT_SETUP_MODEL)
+        return null;
+    return {
+        model,
+        modelContextWindow: DEFAULT_SETUP_MODEL_CONTEXT_WINDOW,
+        modelAutoCompactTokenLimit: DEFAULT_SETUP_MODEL_AUTO_COMPACT_TOKEN_LIMIT,
+    };
+}
+const OMX_SEEDED_BEHAVIORAL_DEFAULTS_START_MARKER = "# oh-my-codex seeded behavioral defaults (uninstall removes unchanged defaults)";
+const OMX_SEEDED_BEHAVIORAL_DEFAULTS_END_MARKER = "# End oh-my-codex seeded behavioral defaults";
+export const OMX_DEVELOPER_INSTRUCTIONS = "You have oh-my-codex installed. AGENTS.md is the orchestration brain and main control surface. Follow AGENTS.md for skill/keyword routing, $name workflow invocation, and role-specialized subagents; when spawning native subagents, set `agent_type` to an installed role and never omit it for OMX work. Use outcome-first, concise progress updates: state the target result, constraints, validation evidence, and stop condition before adding process detail. Native subagents live in .codex/agents and may handle independent parallel subtasks within one Codex session or team pane. Skills load from .codex/skills, not native-agent TOMLs. Treat installed prompts as narrower execution surfaces under AGENTS.md authority.";
+export const OMX_PLUGIN_DEVELOPER_INSTRUCTIONS = '<omx version="1">You have oh-my-codex installed through Codex plugin mode. AGENTS.md is the orchestration brain and main control surface. Follow AGENTS.md for skill/keyword routing and $name workflow invocation. When spawning native subagents, set `agent_type` to an installed role and never omit it for OMX work. Registered Codex plugin marketplace surfaces supply OMX workflows and plugin-scoped companion resources when the plugin is installed; native agent roles are installed as setup-owned Codex agent TOML files in plugin mode so agent_type routing works. User-installed skills may still live under ~/.codex/skills. Use outcome-first, concise progress updates: state the target result, constraints, validation evidence, and stop condition before adding process detail.</omx>';
+const SHARED_MCP_REGISTRY_MARKER = "oh-my-codex (OMX) Shared MCP Registry Sync";
+const SHARED_MCP_REGISTRY_END_MARKER = "# End oh-my-codex shared MCP registry sync";
+const OMX_AGENTS_MAX_THREADS = 6;
+const OMX_AGENTS_MAX_DEPTH = 2;
+const OMX_EXPLORE_ROUTING_DEFAULT = "0";
+const OMX_EXPLORE_CMD_ENV = "USE_OMX_EXPLORE_CMD";
+const DEFAULT_LAUNCHER_MCP_STARTUP_TIMEOUT_SEC = 15;
+const STATUS_LINE_FOCUSED_FIELDS = [
+    "model-with-reasoning",
+    "git-branch",
+    "context-remaining",
+    "total-input-tokens",
+    "total-output-tokens",
+    "five-hour-limit",
+    "weekly-limit",
+];
+// `full` is currently identical to `focused`. It is reserved for future
+// expansion as Codex CLI adds support for additional status_line fields.
+export const STATUS_LINE_PRESETS = {
+    minimal: ["model-with-reasoning", "git-branch"],
+    focused: STATUS_LINE_FOCUSED_FIELDS,
+    full: STATUS_LINE_FOCUSED_FIELDS,
+};
+export const DEFAULT_STATUS_LINE_PRESET = "focused";
+export function statusLineForPreset(preset = DEFAULT_STATUS_LINE_PRESET) {
+    const fields = STATUS_LINE_PRESETS[preset] ??
+        STATUS_LINE_PRESETS[DEFAULT_STATUS_LINE_PRESET];
+    return `status_line = [${fields.map((field) => `"${field}"`).join(", ")}]`;
+}
+// Marker comment OMX emits immediately above any status_line it owns. New writes
+// always include it; the customized-section detector keys on this marker so a
+// user-edited status_line that happens to byte-match a preset literal (e.g.
+// `["model-with-reasoning", "git-branch"]` matching the `minimal` preset) is
+// still recognized as a user customization and preserved.
+const OMX_MANAGED_STATUS_LINE_MARKER = "# omx:managed-status-line";
+// Pre-marker installs only ever shipped the seven-field `focused` array.
+// Treat that exact value as OMX-managed for backward compatibility so
+// upgrades/preset switches still strip the legacy line. Any other preset
+// literal without the marker is assumed user-written.
+const LEGACY_OMX_STATUS_LINE = statusLineForPreset(DEFAULT_STATUS_LINE_PRESET);
+// Set of every status_line literal OMX itself can emit today. Used together
+// with the marker comment: if a status_line is preceded by the marker AND
+// its value is a known OMX preset, it is OMX-managed. If the marker is
+// present but the value is something else, the user edited the value (and
+// left the marker untouched) — treat as a user customization and preserve.
+const OMX_PRESET_STATUS_LINE_VALUES = new Set(Object.keys(STATUS_LINE_PRESETS).map((preset) => statusLineForPreset(preset)));
+const LEGACY_OMX_TEAM_RUN_TABLE_PATTERN = /^\s*\[mcp_servers\.(?:"omx_team_run"|omx_team_run)\]\s*$/m;
+const OMX_CONFIG_MARKER = "oh-my-codex (OMX) Configuration";
+const OMX_CONFIG_END_MARKER = "# End oh-my-codex";
+const CODEX_MODEL_AVAILABILITY_NUX_TABLE_PATTERN = /^\s*\[tui\.model_availability_nux\]\s*(?:#.*)?$/;
+const TOML_TABLE_HEADER_PATTERN = /^\s*\[\[?[^\]]+\]?\]\s*(?:#.*)?$/;
+export function stripCodexModelAvailabilityNux(config) {
+    const lines = config.split(/\r?\n/);
+    const result = [];
+    let removed = false;
+    for (let i = 0; i < lines.length;) {
+        if (CODEX_MODEL_AVAILABILITY_NUX_TABLE_PATTERN.test(lines[i])) {
+            removed = true;
+            i += 1;
+            while (i < lines.length && !TOML_TABLE_HEADER_PATTERN.test(lines[i])) {
+                i += 1;
+            }
+            continue;
+        }
+        result.push(lines[i]);
+        i += 1;
+    }
+    return removed ? result.join("\n") : config;
+}
+export async function cleanCodexModelAvailabilityNuxIfNeeded(configPath) {
+    if (!existsSync(configPath))
+        return false;
+    const content = await readFile(configPath, "utf-8");
+    const cleaned = stripCodexModelAvailabilityNux(content);
+    if (cleaned === content)
+        return false;
+    await writeFile(configPath, cleaned);
+    return true;
+}
+export function hasLegacyOmxTeamRunTable(config) {
+    return LEGACY_OMX_TEAM_RUN_TABLE_PATTERN.test(config);
+}
+function unwrapTomlString(value) {
+    return value?.match(/^"(.*)"$/)?.[1];
+}
+export function getRootModelName(config) {
+    return unwrapTomlString(parseRootKeyValues(config).get("model"));
+}
+const ROOT_TABLE_HEADER_PATTERN = /^\s*\[\[?[^\]]+\]?\]\s*$/;
+const ROOT_KEY_ASSIGNMENT_PATTERN = /^\s*([A-Za-z0-9_-]+)\s*=\s*(.*)$/;
+function parseStandaloneToml(snippet) {
+    try {
+        TOML.parse(snippet);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function splitRootLevelEntries(config) {
+    const lines = config.split(/\r?\n/);
+    const entries = [];
+    let index = 0;
+    while (index < lines.length) {
+        const line = lines[index];
+        if (ROOT_TABLE_HEADER_PATTERN.test(line))
+            break;
+        const match = line.match(ROOT_KEY_ASSIGNMENT_PATTERN);
+        if (!match) {
+            entries.push({ lines: [line] });
+            index += 1;
+            continue;
+        }
+        const entryLines = [line];
+        while (!parseStandaloneToml(entryLines.join("\n")) &&
+            index + entryLines.length < lines.length) {
+            entryLines.push(lines[index + entryLines.length]);
+        }
+        entries.push({ key: match[1], lines: entryLines });
+        index += entryLines.length;
+    }
+    return { entries, remainder: lines.slice(index) };
+}
+function parseRootKeyValues(config) {
+    const values = new Map();
+    const { entries } = splitRootLevelEntries(config);
+    for (const entry of entries) {
+        if (!entry.key)
+            continue;
+        const [firstLine, ...rest] = entry.lines;
+        const match = firstLine.match(ROOT_KEY_ASSIGNMENT_PATTERN);
+        if (!match)
+            continue;
+        const value = [match[2], ...rest].join("\n").trim();
+        values.set(entry.key, value);
+    }
+    return values;
+}
+function getDefaultNotifyCommand(pkgRoot) {
+    return ["node", join(pkgRoot, "dist", "scripts", "notify-hook.js")];
+}
+export function formatTomlStringArray(values) {
+    return `[${values.map((value) => `"${escapeTomlString(value)}"`).join(", ")}]`;
+}
+export function getRootTomlArray(config, key) {
+    const raw = parseRootKeyValues(config).get(key);
+    if (!raw)
+        return null;
+    try {
+        const parsed = TOML.parse(`${key} = ${raw}`);
+        const value = parsed[key];
+        if (!Array.isArray(value) ||
+            !value.every((item) => typeof item === "string")) {
+            return null;
+        }
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveNotifyEntrypoint(command) {
+    if (!/(?:^|[\\/])node(?:\.exe)?$/i.test(command[0] ?? "")) {
+        return command[0];
+    }
+    return command.slice(1).find((arg) => !arg.startsWith("-"));
+}
+function getPreviousNotifyWrapperValue(command) {
+    for (let index = 0; index < command.length; index += 1) {
+        const part = command[index];
+        if (part === "--previous-notify") {
+            return command[index + 1];
+        }
+        if (part.startsWith("--previous-notify=")) {
+            return part.slice("--previous-notify=".length);
+        }
+    }
+    return undefined;
+}
+function isOmxDispatcherMetadataCommand(command) {
+    if (!command)
+        return false;
+    const entrypoint = resolveNotifyEntrypoint(command);
+    if (!entrypoint || !/(?:^|[\\/])notify-dispatcher\.js$/.test(entrypoint)) {
+        return false;
+    }
+    const metadataIndex = command.indexOf("--metadata");
+    const metadataPath = metadataIndex >= 0 ? command[metadataIndex + 1] : undefined;
+    return typeof metadataPath === "string" && /(?:^|[\\/])(?:\.omx[\\/])?notify-dispatch\.json$/.test(metadataPath);
+}
+function isOmxManagedPayloadText(value) {
+    const containsManagedPackageNotify = /(?:^|[\\/])notify-(?:hook|dispatcher)\.js(?:\s|$|["'])/.test(value) && /(?:^|[\\/])oh-my-codex(?:[\\/]|$)/.test(value);
+    const containsDispatcherMetadataNotify = /(?:^|[\\/])notify-dispatcher\.js(?:\s|$|["'])/.test(value) &&
+        /--metadata(?:\s|=)/.test(value) &&
+        /(?:^|[\\/])(?:\.omx[\\/])?notify-dispatch\.json(?:\s|$|["'])/.test(value);
+    return containsManagedPackageNotify || containsDispatcherMetadataNotify;
+}
+function parseJsonString(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const first = trimmed[0];
+    if (first !== "[" && first !== "{" && first !== '"')
+        return undefined;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function containsOmxManagedNotifyPayload(value, pkgRoot, depth = 0) {
+    if (depth > 8 || value == null)
+        return false;
+    if (typeof value === "string") {
+        const parsed = parseJsonString(value);
+        if (parsed !== undefined && parsed !== value) {
+            return containsOmxManagedNotifyPayload(parsed, pkgRoot, depth + 1);
+        }
+        return isOmxManagedPayloadText(value);
+    }
+    if (Array.isArray(value)) {
+        if (value.every((item) => typeof item === "string")) {
+            const nestedCommand = value;
+            return (isOmxManagedNotifyCommand(nestedCommand, pkgRoot) ||
+                isOmxDispatcherMetadataCommand(nestedCommand) ||
+                isOmxManagedPreviousNotifyWrapper(nestedCommand, pkgRoot));
+        }
+        return value.some((item) => containsOmxManagedNotifyPayload(item, pkgRoot, depth + 1));
+    }
+    if (typeof value === "object") {
+        const record = value;
+        return [
+            record.previousNotify,
+            record.previous_notify,
+            record.notify,
+            record.command,
+            record.argv,
+            record.args,
+        ].some((item) => containsOmxManagedNotifyPayload(item, pkgRoot, depth + 1));
+    }
+    return false;
+}
+function isOmxManagedPreviousNotifyWrapper(command, pkgRoot) {
+    if (!command)
+        return false;
+    if (!command.some((part) => part === "turn-ended"))
+        return false;
+    const previousNotify = getPreviousNotifyWrapperValue(command);
+    if (!previousNotify)
+        return false;
+    return containsOmxManagedNotifyPayload(previousNotify, pkgRoot);
+}
+export function isOmxManagedNotifyCommand(command, pkgRoot) {
+    if (!command)
+        return false;
+    if (isOmxDispatcherMetadataCommand(command))
+        return true;
+    const entrypoint = resolveNotifyEntrypoint(command);
+    if (!entrypoint)
+        return false;
+    if (!/(?:^|[\\/])notify-(?:hook|dispatcher)\.js$/.test(entrypoint)) {
+        return false;
+    }
+    const managedScripts = pkgRoot
+        ? new Set([
+            resolve(pkgRoot, "dist", "scripts", "notify-hook.js"),
+            resolve(pkgRoot, "dist", "scripts", "notify-dispatcher.js"),
+        ])
+        : new Set();
+    if (pkgRoot && managedScripts.has(resolve(entrypoint)))
+        return true;
+    return /(?:^|[\\/])oh-my-codex(?:[\\/]|$)/.test(entrypoint);
+}
+export function sanitizePreviousNotifyCommand(command, pkgRoot) {
+    if (!command || command.length === 0)
+        return null;
+    if (isOmxManagedNotifyCommand(command, pkgRoot))
+        return null;
+    if (isOmxManagedPreviousNotifyWrapper(command, pkgRoot))
+        return null;
+    return [...command];
+}
+function getOmxTopLevelLines(pkgRoot, existingConfig = "", modelOverride, notifyCommand = getDefaultNotifyCommand(pkgRoot)) {
+    const rootValues = parseRootKeyValues(existingConfig);
+    const lines = [
+        "# oh-my-codex top-level settings (must be before any [table])",
+        ...(notifyCommand === false
+            ? []
+            : [`notify = ${formatTomlStringArray(notifyCommand)}`]),
+        'model_reasoning_effort = "medium"',
+        `developer_instructions = "${escapeTomlString(OMX_DEVELOPER_INSTRUCTIONS)}"`,
+    ];
+    const existingModel = rootValues.get("model");
+    const existingContextWindow = rootValues.get("model_context_window");
+    const existingAutoCompact = rootValues.get("model_auto_compact_token_limit");
+    const selectedModel = modelOverride ?? unwrapTomlString(existingModel) ?? DEFAULT_SETUP_MODEL;
+    if (modelOverride || !existingModel) {
+        lines.push(`model = "${selectedModel}"`);
+    }
+    if (selectedModel === DEFAULT_SETUP_MODEL) {
+        const seededBehavioralDefaults = [];
+        if (!existingContextWindow) {
+            seededBehavioralDefaults.push(`model_context_window = ${DEFAULT_SETUP_MODEL_CONTEXT_WINDOW}`);
+        }
+        if (!existingAutoCompact) {
+            seededBehavioralDefaults.push(`model_auto_compact_token_limit = ${DEFAULT_SETUP_MODEL_AUTO_COMPACT_TOKEN_LIMIT}`);
+        }
+        if (seededBehavioralDefaults.length > 0) {
+            lines.push(OMX_SEEDED_BEHAVIORAL_DEFAULTS_START_MARKER);
+            lines.push(...seededBehavioralDefaults);
+            lines.push(OMX_SEEDED_BEHAVIORAL_DEFAULTS_END_MARKER);
+        }
+    }
+    return lines;
+}
+function isUnchangedOmxSeededBehavioralDefaultsBlock(lines) {
+    const relevant = lines.filter((line) => {
+        const trimmed = line.trim();
+        return trimmed.length > 0 && !trimmed.startsWith("#");
+    });
+    if (relevant.length !== 2)
+        return false;
+    const parsed = parseRootKeyValues(relevant.join("\n"));
+    return (parsed.size === 2 &&
+        parsed.get("model_context_window") ===
+            String(DEFAULT_SETUP_MODEL_CONTEXT_WINDOW) &&
+        parsed.get("model_auto_compact_token_limit") ===
+            String(DEFAULT_SETUP_MODEL_AUTO_COMPACT_TOKEN_LIMIT));
+}
+export function stripOmxSeededBehavioralDefaults(config) {
+    const lines = config.split(/\r?\n/);
+    const firstTable = lines.findIndex((line) => /^\s*\[/.test(line));
+    const boundary = firstTable >= 0 ? firstTable : lines.length;
+    const result = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const trimmed = lines[index].trim();
+        if (index < boundary &&
+            trimmed === OMX_SEEDED_BEHAVIORAL_DEFAULTS_START_MARKER) {
+            const endIndex = lines.findIndex((line, candidateIndex) => candidateIndex > index &&
+                candidateIndex < boundary &&
+                line.trim() === OMX_SEEDED_BEHAVIORAL_DEFAULTS_END_MARKER);
+            if (endIndex < 0) {
+                continue;
+            }
+            const blockLines = lines.slice(index + 1, endIndex);
+            if (!isUnchangedOmxSeededBehavioralDefaultsBlock(blockLines)) {
+                result.push(...blockLines);
+            }
+            index = endIndex;
+            continue;
+        }
+        if (index < boundary &&
+            trimmed === OMX_SEEDED_BEHAVIORAL_DEFAULTS_END_MARKER) {
+            continue;
+        }
+        result.push(lines[index]);
+    }
+    return result.join("\n");
+}
+function stripRootLevelKeys(config, keys) {
+    const { entries, remainder } = splitRootLevelEntries(config);
+    const filteredEntries = entries.filter((entry) => {
+        if (keys.some((key) => OMX_TOP_LEVEL_KEYS.includes(key)) &&
+            entry.lines.length === 1 &&
+            entry.lines[0].trim() ===
+                "# oh-my-codex top-level settings (must be before any [table])") {
+            return false;
+        }
+        return !entry.key || !keys.includes(entry.key);
+    });
+    const result = [
+        ...filteredEntries.flatMap((entry) => entry.lines),
+        ...remainder,
+    ];
+    if (result.length === 0) {
+        return "";
+    }
+    return result.join("\n");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function stripOrphanedManagedNotify(config, pkgRoot) {
+    const rootNotify = getRootTomlArray(config, "notify");
+    if (rootNotify &&
+        !isOmxManagedNotifyCommand(rootNotify, pkgRoot)) {
+        return config;
+    }
+    const managedHookPath = escapeRegExp(resolve(pkgRoot, "dist", "scripts", "notify-hook.js"));
+    return config
+        .replace(new RegExp(`^\\s*notify\\s*=\\s*\\["node",\\s*"${managedHookPath}"\\]\\s*$(\\n)?`, "gm"), "")
+        .replace(/^\s*notify\s*=\s*\["node",\s*".*notify-hook\.js"\]\s*$(\n)?/gm, "")
+        .replace(/\n?\s*"node",\s*\n\s*".*notify-hook\.js",\s*\n\s*\]\s*(?=\n|$)/g, "");
+}
+/**
+ * Remove any existing OMX-owned top-level keys so we can re-insert them
+ * cleanly. Also removes the comment line that precedes them.
+ */
+export function stripOmxTopLevelKeys(config) {
+    return stripRootLevelKeys(config, OMX_TOP_LEVEL_KEYS);
+}
+// ---------------------------------------------------------------------------
+// [features] upsert
+// ---------------------------------------------------------------------------
+function isFeatureFlagLine(line, featureFlag) {
+    return new RegExp(`^\\s*${featureFlag}\\s*=`).test(line);
+}
+function isAnyCodexHookFeatureFlagLine(line) {
+    return CODEX_HOOK_FEATURE_FLAGS.some((flag) => isFeatureFlagLine(line, flag));
+}
+function isAnyPluginModeHookFeatureFlagLine(line) {
+    return isAnyCodexHookFeatureFlagLine(line)
+        || isFeatureFlagLine(line, CODEX_PLUGIN_SCOPED_HOOKS_FEATURE_FLAG);
+}
+function upsertFeatureFlagLineInSection(lines, featuresStart, sectionEnd, featureFlag, aliases) {
+    let featureFlagIdx = -1;
+    let fallbackAliasIdx = -1;
+    for (let i = featuresStart + 1; i < sectionEnd; i++) {
+        if (isFeatureFlagLine(lines[i], featureFlag)) {
+            featureFlagIdx = i;
+        }
+        else if (aliases(lines[i]) && fallbackAliasIdx < 0) {
+            fallbackAliasIdx = i;
+        }
+    }
+    if (featureFlagIdx < 0 && fallbackAliasIdx >= 0) {
+        featureFlagIdx = fallbackAliasIdx;
+    }
+    if (featureFlagIdx >= 0) {
+        lines[featureFlagIdx] = `${featureFlag} = true`;
+    }
+    else {
+        lines.splice(sectionEnd, 0, `${featureFlag} = true`);
+        featureFlagIdx = sectionEnd;
+        sectionEnd += 1;
+    }
+    for (let i = sectionEnd - 1; i > featuresStart; i--) {
+        if (i !== featureFlagIdx && aliases(lines[i])) {
+            lines.splice(i, 1);
+            sectionEnd -= 1;
+            if (featureFlagIdx > i)
+                featureFlagIdx -= 1;
+        }
+    }
+    return { sectionEnd, featureFlagIndex: featureFlagIdx };
+}
+function upsertCodexHookFeatureFlagInSection(lines, featuresStart, sectionEnd, codexHookFeatureFlag) {
+    const featureFlag = normalizeCodexHookFeatureFlag(codexHookFeatureFlag);
+    return upsertFeatureFlagLineInSection(lines, featuresStart, sectionEnd, featureFlag, isAnyCodexHookFeatureFlagLine);
+}
+function upsertPluginScopedHookFeatureFlagInSection(lines, featuresStart, sectionEnd) {
+    return upsertFeatureFlagLineInSection(lines, featuresStart, sectionEnd, CODEX_PLUGIN_SCOPED_HOOKS_FEATURE_FLAG, isAnyPluginModeHookFeatureFlagLine);
+}
+function upsertFeatureFlags(config, codexHookFeatureFlag = DEFAULT_CODEX_HOOK_FEATURE_FLAG) {
+    const lines = config.split(/\r?\n/);
+    const featuresStart = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+    const hookFeatureFlagLine = formatCodexHookFeatureFlagLine(codexHookFeatureFlag);
+    if (featuresStart < 0) {
+        const base = config.trimEnd();
+        const featureBlock = [
+            "[features]",
+            "multi_agent = true",
+            "child_agents_md = true",
+            hookFeatureFlagLine,
+            "goals = true",
+            "",
+        ].join("\n");
+        if (base.length === 0) {
+            return featureBlock;
+        }
+        return `${base}\n${featureBlock}`;
+    }
+    let sectionEnd = lines.length;
+    for (let i = featuresStart + 1; i < lines.length; i++) {
+        if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i])) {
+            sectionEnd = i;
+            break;
+        }
+    }
+    // Remove deprecated 'collab' key (superseded by multi_agent) and
+    // the misspelled singular 'goal' flag written by unreleased PR builds.
+    for (let i = sectionEnd - 1; i > featuresStart; i--) {
+        if (/^\s*(?:collab|goal)\s*=/.test(lines[i])) {
+            lines.splice(i, 1);
+            sectionEnd -= 1;
+        }
+    }
+    let multiAgentIdx = -1;
+    let childAgentsIdx = -1;
+    for (let i = featuresStart + 1; i < sectionEnd; i++) {
+        if (/^\s*multi_agent\s*=/.test(lines[i])) {
+            multiAgentIdx = i;
+        }
+        else if (/^\s*child_agents_md\s*=/.test(lines[i])) {
+            childAgentsIdx = i;
+        }
+    }
+    if (multiAgentIdx >= 0) {
+        lines[multiAgentIdx] = "multi_agent = true";
+    }
+    else {
+        lines.splice(sectionEnd, 0, "multi_agent = true");
+        sectionEnd += 1;
+    }
+    if (childAgentsIdx >= 0) {
+        lines[childAgentsIdx] = "child_agents_md = true";
+    }
+    else {
+        lines.splice(sectionEnd, 0, "child_agents_md = true");
+        sectionEnd += 1;
+    }
+    ({ sectionEnd } = upsertCodexHookFeatureFlagInSection(lines, featuresStart, sectionEnd, codexHookFeatureFlag));
+    let goalsIdx = -1;
+    for (let i = featuresStart + 1; i < sectionEnd; i++) {
+        if (/^\s*goals\s*=/.test(lines[i])) {
+            goalsIdx = i;
+        }
+    }
+    if (goalsIdx >= 0) {
+        lines[goalsIdx] = "goals = true";
+    }
+    else {
+        lines.splice(sectionEnd, 0, "goals = true");
+    }
+    return lines.join("\n");
+}
+const OMX_HOOK_TRUST_START_MARKER = "# OMX-owned Codex hook trust state";
+const OMX_HOOK_TRUST_END_MARKER = "# End OMX-owned Codex hook trust state";
+const OMX_PROJECT_TRUST_START_MARKER = "# OMX-synced Codex project trust state (from runtime CODEX_HOME)";
+const OMX_PROJECT_TRUST_END_MARKER = "# End OMX-synced Codex project trust state";
+function extractMarkerBlockContent(config, startMarker, endMarker) {
+    const lines = config.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() !== startMarker)
+            continue;
+        const nextEndIdx = lines.findIndex((line, index) => index > i && line.trim() === endMarker);
+        const nextStartIdx = lines.findIndex((line, index) => index > i && line.trim() === startMarker);
+        if (nextEndIdx === -1 || (nextStartIdx !== -1 && nextStartIdx < nextEndIdx)) {
+            return undefined;
+        }
+        return lines.slice(i + 1, nextEndIdx).join("\n").trim();
+    }
+    return undefined;
+}
+function stripMarkerBlock(config, startMarker, endMarker) {
+    const lines = config.split(/\r?\n/);
+    const kept = [];
+    for (let i = 0; i < lines.length;) {
+        if (lines[i].trim() !== startMarker) {
+            kept.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        const nextEndIdx = lines.findIndex((line, index) => index > i && line.trim() === endMarker);
+        const nextStartIdx = lines.findIndex((line, index) => index > i && line.trim() === startMarker);
+        if (nextEndIdx === -1 || (nextStartIdx !== -1 && nextStartIdx < nextEndIdx)) {
+            kept.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        i = nextEndIdx + 1;
+    }
+    return kept.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function isPlainTomlRecord(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.getPrototypeOf(value) === Object.prototype);
+}
+function safeParseToml(content) {
+    try {
+        const parsed = TOML.parse(content);
+        return isPlainTomlRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function collectProjectHookTrustStateKeys(config) {
+    const keys = new Set();
+    const parsed = safeParseToml(config);
+    const hooksTable = isPlainTomlRecord(parsed) ? parsed.hooks : undefined;
+    const hooksState = isPlainTomlRecord(hooksTable) ? hooksTable.state : undefined;
+    if (!isPlainTomlRecord(hooksState))
+        return keys;
+    for (const [key, entry] of Object.entries(hooksState)) {
+        if (!isPlainTomlRecord(entry))
+            continue;
+        keys.add(key);
+    }
+    return keys;
+}
+/**
+ * Repairs project configs from the 0.18.3 relaunch regression where a
+ * project-synced trust block could duplicate setup-owned hook trust tables and
+ * make the next runtime CODEX_HOME config.toml invalid before Codex started.
+ */
+export function repairProjectScopeTrustStateForLaunch(projectConfig, projectHooksPath) {
+    const syncedTrustBlock = extractMarkerBlockContent(projectConfig, OMX_PROJECT_TRUST_START_MARKER, OMX_PROJECT_TRUST_END_MARKER);
+    if (!syncedTrustBlock)
+        return projectConfig;
+    const stripped = stripMarkerBlock(projectConfig, OMX_PROJECT_TRUST_START_MARKER, OMX_PROJECT_TRUST_END_MARKER);
+    const repaired = syncProjectScopeTrustStateFromRuntime(stripped, syncedTrustBlock, projectHooksPath);
+    return repaired === stripped ? projectConfig : repaired;
+}
+/**
+ * Project-scope launches mirror the durable project config.toml into an
+ * ephemeral runtime CODEX_HOME. Codex writes its workspace-trust ledger and
+ * hook trust ledger into the runtime config.toml during the session. Without
+ * persistence, those entries die with the runtime, so Codex prompts to trust
+ * the workspace and hooks on every launch (issue #2470).
+ *
+ * This function extracts only trust-state tables (`[projects."<cwd>"]` and
+ * `[hooks.state."<projectHooksPath>:..."]`) from the runtime config.toml and
+ * upserts them into the durable project config.toml inside a marker-fenced
+ * block, preserving any surrounding user-managed content and comments and
+ * ignoring Codex's NUX counters or other ephemeral runtime-only writes.
+ */
+export function syncProjectScopeTrustStateFromRuntime(projectConfig, runtimeConfig, projectHooksPath) {
+    const parsed = safeParseToml(runtimeConfig);
+    if (!parsed)
+        return projectConfig;
+    const stripped = stripMarkerBlock(projectConfig, OMX_PROJECT_TRUST_START_MARKER, OMX_PROJECT_TRUST_END_MARKER);
+    const existingHookTrustStateKeys = collectProjectHookTrustStateKeys(stripped);
+    const trustBlockLines = [];
+    const projectsTable = parsed.projects;
+    if (isPlainTomlRecord(projectsTable)) {
+        for (const [projectKey, entry] of Object.entries(projectsTable).sort(([a], [b]) => a.localeCompare(b))) {
+            if (!isPlainTomlRecord(entry))
+                continue;
+            const serialized = TOML.stringify({ [projectKey]: entry });
+            const renderedHeader = `[projects."${escapeTomlBasicString(projectKey)}"]`;
+            const body = serialized
+                .split(/\r?\n/)
+                .filter((line) => !/^\s*\[/.test(line) && line.trim() !== "")
+                .join("\n");
+            if (body.length === 0)
+                continue;
+            trustBlockLines.push(renderedHeader, body, "");
+        }
+    }
+    const hooksTable = parsed.hooks;
+    const hooksState = isPlainTomlRecord(hooksTable) ? hooksTable.state : undefined;
+    if (isPlainTomlRecord(hooksState)) {
+        for (const [stateKey, entry] of Object.entries(hooksState).sort(([a], [b]) => a.localeCompare(b))) {
+            if (!isPlainTomlRecord(entry))
+                continue;
+            if (!stateKey.startsWith(`${projectHooksPath}:`))
+                continue;
+            if (existingHookTrustStateKeys.has(stateKey))
+                continue;
+            const trusted = entry.trusted_hash;
+            if (typeof trusted !== "string" || trusted.length === 0)
+                continue;
+            trustBlockLines.push(`[hooks.state."${escapeTomlBasicString(stateKey)}"]`, `trusted_hash = "${escapeTomlBasicString(trusted)}"`, "");
+        }
+    }
+    if (trustBlockLines.length === 0) {
+        return stripped.length === 0 ? "" : `${stripped}\n`;
+    }
+    const block = [
+        OMX_PROJECT_TRUST_START_MARKER,
+        ...trustBlockLines,
+        OMX_PROJECT_TRUST_END_MARKER,
+        "",
+    ].join("\n");
+    if (stripped.length === 0)
+        return block;
+    return `${stripped}\n\n${block}`;
+}
+function decodeTomlBasicString(raw) {
+    try {
+        const parsed = TOML.parse(`value = "${raw}"`);
+        return typeof parsed.value === "string" ? parsed.value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseHooksStateHeader(line) {
+    const match = line.match(/^\s*\[hooks\.state\."((?:\\.|[^"\\])*)"\]\s*(#.*)?$/);
+    if (!match)
+        return undefined;
+    const key = decodeTomlBasicString(match[1] ?? "");
+    if (key === undefined)
+        return undefined;
+    return { key, hasInlineComment: match[2] !== undefined };
+}
+function isTomlTableHeader(line) {
+    return /^\s*\[\[?[^\]]+\]?\]\s*(?:#.*)?$/.test(line);
+}
+function isExactlyManagedHookTrustBody(bodyLines, expectedHash) {
+    const nonBlank = bodyLines.filter((line) => line.trim().length > 0);
+    if (nonBlank.length !== 1)
+        return false;
+    const expected = expectedHash.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`^\\s*trusted_hash\\s*=\\s*"${expected}"\\s*$`).test(nonBlank[0] ?? "");
+}
+function stripProofManagedCodexHookTrustStateTables(config, managedTrustState) {
+    if (Object.keys(managedTrustState).length === 0) {
+        return { config, preservedConflictKeys: new Set() };
+    }
+    const lines = config.split(/\r?\n/);
+    const kept = [];
+    const preservedConflictKeys = new Set();
+    for (let i = 0; i < lines.length;) {
+        const header = parseHooksStateHeader(lines[i] ?? "");
+        if (!header) {
+            kept.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        let tableEnd = lines.length;
+        for (let next = i + 1; next < lines.length; next += 1) {
+            if (isTomlTableHeader(lines[next] ?? "")) {
+                tableEnd = next;
+                break;
+            }
+        }
+        const expectedState = managedTrustState[header.key];
+        const removable = expectedState !== undefined &&
+            !header.hasInlineComment &&
+            isExactlyManagedHookTrustBody(lines.slice(i + 1, tableEnd), expectedState.trusted_hash);
+        if (removable) {
+            i = tableEnd;
+            continue;
+        }
+        if (expectedState !== undefined) {
+            preservedConflictKeys.add(header.key);
+        }
+        kept.push(...lines.slice(i, tableEnd));
+        i = tableEnd;
+    }
+    return { config: kept.join("\n"), preservedConflictKeys };
+}
+function stripManagedCodexHookTrustStateWithResult(config, options = {}) {
+    const lines = config.split(/\r?\n/);
+    const kept = [];
+    for (let i = 0; i < lines.length;) {
+        const trimmed = lines[i].trim();
+        if (trimmed !== OMX_HOOK_TRUST_START_MARKER) {
+            kept.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        const nextEndIdx = lines.findIndex((line, index) => index > i && line.trim() === OMX_HOOK_TRUST_END_MARKER);
+        const nextStartIdx = lines.findIndex((line, index) => index > i && line.trim() === OMX_HOOK_TRUST_START_MARKER);
+        if (nextEndIdx === -1 || (nextStartIdx !== -1 && nextStartIdx < nextEndIdx)) {
+            kept.push(lines[i]);
+            i += 1;
+            continue;
+        }
+        i = nextEndIdx + 1;
+    }
+    const withoutFenced = kept.join("\n");
+    const proofStripped = options.managedTrustState
+        ? stripProofManagedCodexHookTrustStateTables(withoutFenced, options.managedTrustState)
+        : { config: withoutFenced, preservedConflictKeys: new Set() };
+    return {
+        config: proofStripped.config.replace(/\n{3,}/g, "\n\n").trimEnd(),
+        preservedConflictKeys: proofStripped.preservedConflictKeys,
+    };
+}
+export function stripManagedCodexHookTrustState(config, options = {}) {
+    return stripManagedCodexHookTrustStateWithResult(config, options).config;
+}
+function renderManagedCodexHookTrustToml(managedTrustState, excludedKeys = new Set()) {
+    return Object.entries(managedTrustState)
+        .filter(([key]) => !excludedKeys.has(key))
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([key, hookState]) => [
+        `[hooks.state."${escapeTomlBasicString(key)}"]`,
+        `trusted_hash = "${escapeTomlBasicString(hookState.trusted_hash)}"`,
+        "",
+    ])
+        .join("\n")
+        .trimEnd();
+}
+function buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, options = {}) {
+    if (!codexHooksFile)
+        return {};
+    return buildManagedCodexHookTrustState(codexHooksFile, pkgRoot, options);
+}
+export function upsertManagedCodexHookTrustState(config, pkgRoot, codexHooksFile, options = {}) {
+    const managedTrustState = buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, options);
+    const strippedResult = stripManagedCodexHookTrustStateWithResult(config, {
+        managedTrustState,
+    });
+    const stripped = strippedResult.config;
+    const hookTrustToml = renderManagedCodexHookTrustToml(managedTrustState, strippedResult.preservedConflictKeys);
+    if (!hookTrustToml)
+        return `${stripped}\n`;
+    return [
+        stripped,
+        "",
+        OMX_HOOK_TRUST_START_MARKER,
+        "# Trusts only setup-managed native hook wrappers.",
+        hookTrustToml,
+        OMX_HOOK_TRUST_END_MARKER,
+        "",
+    ].filter((line, index) => index !== 0 || line.length > 0).join("\n");
+}
+export function upsertPluginModeRuntimeFeatureFlags(config, codexHookFeatureFlag = DEFAULT_CODEX_HOOK_FEATURE_FLAG, options = {}) {
+    const lines = config.split(/\r?\n/);
+    const featuresStart = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+    const hookFeatureFlagLine = options.pluginScopedHooks
+        ? `${CODEX_PLUGIN_SCOPED_HOOKS_FEATURE_FLAG} = true`
+        : formatCodexHookFeatureFlagLine(codexHookFeatureFlag);
+    if (featuresStart < 0) {
+        const base = config.trimEnd();
+        const featureBlock = [
+            "[features]",
+            hookFeatureFlagLine,
+            "goals = true",
+            "",
+        ].join("\n");
+        if (base.length === 0) {
+            return featureBlock;
+        }
+        return `${base}\n${featureBlock}`;
+    }
+    let sectionEnd = lines.length;
+    for (let i = featuresStart + 1; i < lines.length; i++) {
+        if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i])) {
+            sectionEnd = i;
+            break;
+        }
+    }
+    // Remove the misspelled singular flag from unreleased PR builds before
+    // upserting the supported plural Codex feature flag.
+    for (let i = sectionEnd - 1; i > featuresStart; i--) {
+        if (/^\s*goal\s*=/.test(lines[i])) {
+            lines.splice(i, 1);
+            sectionEnd -= 1;
+        }
+    }
+    ({ sectionEnd } = options.pluginScopedHooks
+        ? upsertPluginScopedHookFeatureFlagInSection(lines, featuresStart, sectionEnd)
+        : upsertCodexHookFeatureFlagInSection(lines, featuresStart, sectionEnd, codexHookFeatureFlag));
+    let goalsIdx = -1;
+    for (let i = featuresStart + 1; i < sectionEnd; i++) {
+        if (/^\s*goals\s*=/.test(lines[i])) {
+            goalsIdx = i;
+        }
+    }
+    if (goalsIdx >= 0) {
+        lines[goalsIdx] = "goals = true";
+    }
+    else {
+        lines.splice(sectionEnd, 0, "goals = true");
+    }
+    return lines.join("\n");
+}
+function findTomlTableRange(lines, headerPattern) {
+    const start = lines.findIndex((line) => headerPattern.test(line));
+    if (start < 0)
+        return undefined;
+    let end = lines.length;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    return { start, end };
+}
+function tomlAssignmentKey(line) {
+    return line.match(/^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/)?.[1];
+}
+function findTomlTableEntryRanges(lines, start, end) {
+    const ranges = [];
+    let index = start;
+    while (index < end) {
+        const key = tomlAssignmentKey(lines[index]);
+        if (key === undefined) {
+            ranges.push({ start: index, end: index + 1 });
+            index += 1;
+            continue;
+        }
+        let entryEnd = index + 1;
+        while (!parseStandaloneToml(lines.slice(index, entryEnd).join("\n")) &&
+            entryEnd < end) {
+            entryEnd += 1;
+        }
+        ranges.push({ key, start: index, end: entryEnd });
+        index = entryEnd;
+    }
+    return ranges;
+}
+function collectTomlTableKeyEntries(lines, range) {
+    return findTomlTableEntryRanges(lines, range.start + 1, range.end)
+        .filter((entry) => entry.key !== undefined)
+        .map((entry) => ({
+        key: entry.key,
+        lines: lines.slice(entry.start, entry.end),
+    }));
+}
+function stripTomlTableKey(lines, headerPattern, keyName) {
+    const range = findTomlTableRange(lines, headerPattern);
+    if (!range)
+        return lines;
+    const filtered = [...lines];
+    const entries = findTomlTableEntryRanges(filtered, range.start + 1, range.end);
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.key === keyName) {
+            filtered.splice(entry.start, entry.end - entry.start);
+        }
+    }
+    const newRange = findTomlTableRange(filtered, headerPattern);
+    if (!newRange)
+        return filtered;
+    const sectionContent = filtered.slice(newRange.start + 1, newRange.end);
+    if (sectionContent.every((line) => line.trim() === "")) {
+        filtered.splice(newRange.start, newRange.end - newRange.start);
+    }
+    return filtered;
+}
+function upsertEnvSettings(config) {
+    const lines = config.split(/\r?\n/);
+    const legacyEnvRange = findTomlTableRange(lines, /^\s*\[env\]\s*$/);
+    const legacyEnvEntries = legacyEnvRange === undefined
+        ? []
+        : collectTomlTableKeyEntries(lines, legacyEnvRange);
+    if (legacyEnvRange !== undefined) {
+        lines.splice(legacyEnvRange.start, legacyEnvRange.end - legacyEnvRange.start);
+    }
+    const shellEnvSetRange = findTomlTableRange(lines, /^\s*\[shell_environment_policy\.set\]\s*$/);
+    if (shellEnvSetRange === undefined) {
+        const base = lines.join("\n").trimEnd();
+        const envLines = legacyEnvEntries.flatMap((entry) => entry.lines);
+        if (legacyEnvEntries.every((entry) => entry.key !== OMX_EXPLORE_CMD_ENV)) {
+            envLines.push(`${OMX_EXPLORE_CMD_ENV} = "${OMX_EXPLORE_ROUTING_DEFAULT}"`);
+        }
+        const envBlock = [
+            "[shell_environment_policy.set]",
+            ...envLines,
+            "",
+        ].join("\n");
+        if (base.length === 0)
+            return envBlock;
+        return `${base}\n\n${envBlock}`;
+    }
+    const shellEnvKeys = new Set();
+    for (let i = shellEnvSetRange.start + 1; i < shellEnvSetRange.end; i++) {
+        const key = tomlAssignmentKey(lines[i]);
+        if (key !== undefined)
+            shellEnvKeys.add(key);
+    }
+    const linesToInsert = [];
+    for (const entry of legacyEnvEntries) {
+        if (!shellEnvKeys.has(entry.key)) {
+            linesToInsert.push(...entry.lines);
+            shellEnvKeys.add(entry.key);
+        }
+    }
+    if (!shellEnvKeys.has(OMX_EXPLORE_CMD_ENV)) {
+        linesToInsert.push(`${OMX_EXPLORE_CMD_ENV} = "${OMX_EXPLORE_ROUTING_DEFAULT}"`);
+    }
+    if (linesToInsert.length > 0) {
+        lines.splice(shellEnvSetRange.end, 0, ...linesToInsert);
+    }
+    return lines.join("\n");
+}
+function upsertAgentsSettings(config) {
+    const lines = config.split(/\r?\n/);
+    const agentsStart = lines.findIndex((line) => /^\s*\[agents\]\s*$/.test(line));
+    if (agentsStart < 0) {
+        const base = config.trimEnd();
+        const agentsBlock = [
+            "[agents]",
+            `max_threads = ${OMX_AGENTS_MAX_THREADS}`,
+            `max_depth = ${OMX_AGENTS_MAX_DEPTH}`,
+            "",
+        ].join("\n");
+        if (base.length === 0)
+            return agentsBlock;
+        return `${base}\n\n${agentsBlock}`;
+    }
+    let sectionEnd = lines.length;
+    for (let i = agentsStart + 1; i < lines.length; i++) {
+        if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i])) {
+            sectionEnd = i;
+            break;
+        }
+    }
+    let maxThreadsIdx = -1;
+    let maxDepthIdx = -1;
+    for (let i = agentsStart + 1; i < sectionEnd; i++) {
+        if (/^\s*max_threads\s*=/.test(lines[i])) {
+            maxThreadsIdx = i;
+        }
+        else if (/^\s*max_depth\s*=/.test(lines[i])) {
+            maxDepthIdx = i;
+        }
+    }
+    if (maxThreadsIdx < 0) {
+        lines.splice(sectionEnd, 0, `max_threads = ${OMX_AGENTS_MAX_THREADS}`);
+        sectionEnd += 1;
+    }
+    if (maxDepthIdx < 0) {
+        lines.splice(sectionEnd, 0, `max_depth = ${OMX_AGENTS_MAX_DEPTH}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Remove OMX-owned feature flags from the [features] section.
+ * If the section becomes empty after removal, remove the section header too.
+ */
+export function stripOmxFeatureFlags(config) {
+    const lines = config.split(/\r?\n/);
+    const featuresStart = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+    if (featuresStart < 0)
+        return config;
+    let sectionEnd = lines.length;
+    for (let i = featuresStart + 1; i < lines.length; i++) {
+        if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i])) {
+            sectionEnd = i;
+            break;
+        }
+    }
+    const omxFlags = [
+        "multi_agent",
+        "child_agents_md",
+        "hooks",
+        "codex_hooks",
+        "goals",
+        "goal",
+        "collab",
+    ];
+    const filtered = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (i > featuresStart && i < sectionEnd) {
+            const isOmxFlag = omxFlags.some((f) => new RegExp(`^\\s*${f}\\s*=`).test(lines[i]));
+            if (isOmxFlag)
+                continue;
+        }
+        filtered.push(lines[i]);
+    }
+    // If [features] section is now empty, remove the header too
+    const newFeaturesStart = filtered.findIndex((l) => /^\s*\[features\]\s*$/.test(l));
+    if (newFeaturesStart >= 0) {
+        let newSectionEnd = filtered.length;
+        for (let i = newFeaturesStart + 1; i < filtered.length; i++) {
+            if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(filtered[i])) {
+                newSectionEnd = i;
+                break;
+            }
+        }
+        const sectionContent = filtered.slice(newFeaturesStart + 1, newSectionEnd);
+        if (sectionContent.every((l) => l.trim() === "")) {
+            filtered.splice(newFeaturesStart, newSectionEnd - newFeaturesStart);
+        }
+    }
+    return filtered.join("\n");
+}
+/**
+ * Preserve native Codex hook enablement without re-adding other OMX feature
+ * flags. Used by uninstall when user-owned hooks remain in hooks.json.
+ */
+export function upsertCodexHooksFeatureFlag(config, codexHookFeatureFlag = DEFAULT_CODEX_HOOK_FEATURE_FLAG) {
+    const lines = config.split(/\r?\n/);
+    const featuresStart = lines.findIndex((line) => /^\s*\[features\]\s*$/.test(line));
+    const hookFeatureFlagLine = formatCodexHookFeatureFlagLine(codexHookFeatureFlag);
+    if (featuresStart < 0) {
+        const base = config.trimEnd();
+        const featureBlock = ["[features]", hookFeatureFlagLine, ""].join("\n");
+        return base.length === 0 ? featureBlock : `${base}\n${featureBlock}`;
+    }
+    let sectionEnd = lines.length;
+    for (let i = featuresStart + 1; i < lines.length; i++) {
+        if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i])) {
+            sectionEnd = i;
+            break;
+        }
+    }
+    upsertCodexHookFeatureFlagInSection(lines, featuresStart, sectionEnd, codexHookFeatureFlag);
+    return lines.join("\n");
+}
+export function stripOmxEnvSettings(config) {
+    let lines = config.split(/\r?\n/);
+    lines = stripTomlTableKey(lines, /^\s*\[env\]\s*$/, OMX_EXPLORE_CMD_ENV);
+    lines = stripTomlTableKey(lines, /^\s*\[shell_environment_policy\.set\]\s*$/, OMX_EXPLORE_CMD_ENV);
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Orphaned OMX table sections (no marker block)
+// ---------------------------------------------------------------------------
+/**
+ * Check whether a TOML table name belongs to a legacy OMX-managed agent entry.
+ * Handles both `agents.name` and `agents."name"` forms.
+ */
+function isOmxFirstPartyMcpSection(tableName) {
+    const match = tableName.match(/^mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_-]+))$/);
+    const name = match?.[1] ?? match?.[2];
+    return Boolean(name &&
+        (OMX_FIRST_PARTY_MCP_SERVER_NAMES.includes(name) ||
+            name === "omx_team_run"));
+}
+function isLegacyOmxAgentSection(tableName) {
+    const m = tableName.match(/^agents\.(?:"([^"]+)"|(\w[\w-]*))$/);
+    if (!m)
+        return false;
+    const name = m[1] || m[2] || "";
+    return Object.prototype.hasOwnProperty.call(AGENT_DEFINITIONS, name);
+}
+/**
+ * Strip OMX-owned table sections that exist outside the marker block.
+ * This covers legacy configs that were written before markers were added,
+ * or configs where the marker was accidentally removed.
+ *
+ * Targets: exact first-party [mcp_servers.<name>] entries, retired
+ * [mcp_servers.omx_team_run], and legacy [agents.<name>] entries.
+ */
+function stripOrphanedOmxSections(config) {
+    const lines = config.split(/\r?\n/);
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const tableMatch = line.match(/^\s*\[([^\]]+)\]\s*$/);
+        if (tableMatch) {
+            const tableName = tableMatch[1];
+            // Note: [tui] is NOT stripped here because it could be user-owned.
+            // The marker-based stripExistingOmxBlocks already handles [tui]
+            // when it lives inside the OMX marker block.
+            const isOmxSection = isOmxFirstPartyMcpSection(tableName) ||
+                isLegacyOmxAgentSection(tableName);
+            if (isOmxSection) {
+                // Remove preceding OMX comment lines and blank lines
+                while (result.length > 0) {
+                    const last = result[result.length - 1];
+                    if (last.trim() === "" || /^#\s*(OMX|oh-my-codex)/i.test(last)) {
+                        result.pop();
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // Skip table header + all key=value / comment / blank lines until next section
+                i++;
+                while (i < lines.length && !/^\s*\[/.test(lines[i])) {
+                    i++;
+                }
+                continue;
+            }
+        }
+        result.push(line);
+        i++;
+    }
+    return result.join("\n");
+}
+export function hasFirstPartyOmxMcpRegistrations(config) {
+    const firstPartyNames = new Set([
+        ...OMX_FIRST_PARTY_MCP_SERVER_NAMES,
+        "omx_team_run",
+    ]);
+    for (const line of config.split(/\r?\n/)) {
+        const match = line.match(/^\s*\[mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_-]+))\]\s*$/);
+        const name = match?.[1] ?? match?.[2];
+        if (name && firstPartyNames.has(name))
+            return true;
+    }
+    return false;
+}
+export function extractFirstPartyOmxMcpSections(config) {
+    const lines = config.split(/\r?\n/);
+    const sections = [];
+    let i = 0;
+    while (i < lines.length) {
+        const tableMatch = lines[i].match(/^\s*\[([^\]]+)\]\s*$/);
+        if (!tableMatch || !isOmxFirstPartyMcpSection(tableMatch[1])) {
+            i += 1;
+            continue;
+        }
+        const sectionLines = [];
+        sectionLines.push(lines[i]);
+        i += 1;
+        while (i < lines.length && !/^\s*\[/.test(lines[i])) {
+            sectionLines.push(lines[i]);
+            i += 1;
+        }
+        sections.push(sectionLines.join("\n").trimEnd());
+    }
+    return sections.filter(Boolean).join("\n\n");
+}
+export function stripFirstPartyOmxMcpSections(config) {
+    const lines = config.split(/\r?\n/);
+    const result = [];
+    for (let index = 0; index < lines.length;) {
+        const tableMatch = lines[index].match(/^\s*\[([^\]]+)\]\s*$/);
+        if (tableMatch && isOmxFirstPartyMcpSection(tableMatch[1])) {
+            index += 1;
+            while (index < lines.length && !/^\s*\[/.test(lines[index])) {
+                index += 1;
+            }
+            continue;
+        }
+        result.push(lines[index]);
+        index += 1;
+    }
+    return result.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+}
+function extractCustomizedTuiSectionsFromOmxBlocks(config) {
+    const sections = [];
+    let searchStart = 0;
+    while (true) {
+        const markerIdx = config.indexOf(OMX_CONFIG_MARKER, searchStart);
+        if (markerIdx < 0)
+            break;
+        const endIdx = config.indexOf(OMX_CONFIG_END_MARKER, markerIdx);
+        if (endIdx < 0)
+            break;
+        const blockLines = config.slice(markerIdx, endIdx).split(/\r?\n/);
+        for (let i = 0; i < blockLines.length; i++) {
+            if (!/^\s*\[tui\]\s*$/.test(blockLines[i]))
+                continue;
+            const tuiLines = [blockLines[i].trim()];
+            let hasCustomizedStatusLine = false;
+            let lastNonBlankBeforeStatusLine;
+            for (let j = i + 1; j < blockLines.length; j++) {
+                if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(blockLines[j]))
+                    break;
+                const trimmed = blockLines[j].trim();
+                if (!trimmed)
+                    continue;
+                tuiLines.push(trimmed);
+                if (/^status_line\s*=/.test(trimmed)) {
+                    // OMX-managed when:
+                    //   1. Preceded by the managed-status-line marker AND the value is
+                    //      a known OMX preset literal (post-marker installs). If the
+                    //      marker is present but the value isn't a preset, the user
+                    //      edited the value and left the marker — treat as customized.
+                    //   2. No marker but the value byte-matches the legacy seven-field
+                    //      default (pre-marker installs only ever shipped focused).
+                    // Anything else inside an OMX-marker block is treated as a user
+                    // customization and preserved across rebuild.
+                    const hasMarker = lastNonBlankBeforeStatusLine === OMX_MANAGED_STATUS_LINE_MARKER;
+                    const matchesPreset = OMX_PRESET_STATUS_LINE_VALUES.has(trimmed);
+                    const isManagedByMarker = hasMarker && matchesPreset;
+                    const isManagedByLegacyValue = !hasMarker && trimmed === LEGACY_OMX_STATUS_LINE;
+                    if (!isManagedByMarker && !isManagedByLegacyValue) {
+                        hasCustomizedStatusLine = true;
+                    }
+                }
+                lastNonBlankBeforeStatusLine = trimmed;
+            }
+            if (hasCustomizedStatusLine) {
+                sections.push(tuiLines.join("\n"));
+            }
+        }
+        searchStart = endIdx + OMX_CONFIG_END_MARKER.length;
+    }
+    return sections;
+}
+function upsertTuiStatusLine(config, preset = DEFAULT_STATUS_LINE_PRESET, options = {}) {
+    const lines = config.split(/\r?\n/);
+    const sections = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (!/^\s*\[tui\]\s*$/.test(lines[i]))
+            continue;
+        let end = lines.length;
+        for (let j = i + 1; j < lines.length; j++) {
+            if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[j])) {
+                end = j;
+                break;
+            }
+        }
+        sections.push({ start: i, end });
+        i = end - 1;
+    }
+    if (sections.length === 0) {
+        return { cleaned: config, hadExistingTui: false };
+    }
+    const preservedKeyLines = [];
+    const seenKeys = new Set();
+    let preservedStatusLine;
+    for (const section of sections) {
+        let lastNonBlankBeforeStatusLine;
+        for (let i = section.start + 1; i < section.end; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            if (trimmed.startsWith("#")) {
+                lastNonBlankBeforeStatusLine = trimmed;
+                continue;
+            }
+            const keyMatch = trimmed.match(/^([A-Za-z0-9_-]+)\s*=/);
+            if (!keyMatch) {
+                lastNonBlankBeforeStatusLine = trimmed;
+                continue;
+            }
+            const key = keyMatch[1];
+            if (key === "status_line") {
+                const entryLines = [trimmed];
+                while (!parseStandaloneToml(entryLines.join("\n")) &&
+                    i + 1 < section.end) {
+                    i += 1;
+                    entryLines.push(lines[i].trim());
+                }
+                const statusLineEntry = entryLines.join("\n");
+                const hasMarker = lastNonBlankBeforeStatusLine === OMX_MANAGED_STATUS_LINE_MARKER;
+                const isManagedByMarker = hasMarker && OMX_PRESET_STATUS_LINE_VALUES.has(statusLineEntry);
+                const isManagedByLegacyValue = !hasMarker && statusLineEntry === LEGACY_OMX_STATUS_LINE;
+                const isOmxManagedStatusLine = isManagedByMarker || isManagedByLegacyValue;
+                if (!options.forceStatusLinePreset || !isOmxManagedStatusLine) {
+                    preservedStatusLine ??= statusLineEntry;
+                }
+                lastNonBlankBeforeStatusLine = statusLineEntry;
+                continue;
+            }
+            if (seenKeys.has(key)) {
+                lastNonBlankBeforeStatusLine = trimmed;
+                continue;
+            }
+            seenKeys.add(key);
+            preservedKeyLines.push(trimmed);
+            lastNonBlankBeforeStatusLine = trimmed;
+        }
+    }
+    // When OMX is supplying the status_line (no user-preserved value),
+    // emit the managed-status-line marker comment alongside it so the
+    // customized-section detector can unambiguously tell our writes apart
+    // from a user edit on the next merge.
+    const mergedSection = preservedStatusLine
+        ? ["[tui]", ...preservedKeyLines, preservedStatusLine]
+        : [
+            "[tui]",
+            ...preservedKeyLines,
+            OMX_MANAGED_STATUS_LINE_MARKER,
+            statusLineForPreset(preset),
+        ];
+    const firstStart = sections[0].start;
+    const rebuilt = [];
+    for (let i = 0; i < lines.length; i++) {
+        const section = sections.find((candidate) => candidate.start === i);
+        if (section) {
+            if (i === firstStart) {
+                if (rebuilt.length > 0 && rebuilt[rebuilt.length - 1].trim() !== "") {
+                    rebuilt.push("");
+                }
+                rebuilt.push(...mergedSection, "");
+            }
+            i = section.end - 1;
+            continue;
+        }
+        rebuilt.push(lines[i]);
+    }
+    return {
+        cleaned: rebuilt.join("\n").replace(/\n{3,}/g, "\n\n"),
+        hadExistingTui: true,
+    };
+}
+// ---------------------------------------------------------------------------
+// OMX [table] sections block (appended at end of file)
+// ---------------------------------------------------------------------------
+export function stripExistingOmxBlocks(config) {
+    let cleaned = config;
+    let removed = 0;
+    while (true) {
+        const markerIdx = cleaned.indexOf(OMX_CONFIG_MARKER);
+        if (markerIdx < 0)
+            break;
+        let blockStart = cleaned.lastIndexOf("\n", markerIdx);
+        blockStart = blockStart >= 0 ? blockStart + 1 : 0;
+        const previousLineEnd = blockStart - 1;
+        if (previousLineEnd >= 0) {
+            const previousLineStart = cleaned.lastIndexOf("\n", previousLineEnd - 1);
+            const previousLine = cleaned.slice(previousLineStart + 1, previousLineEnd);
+            if (/^# =+$/.test(previousLine.trim())) {
+                blockStart = previousLineStart >= 0 ? previousLineStart + 1 : 0;
+            }
+        }
+        let blockEnd = cleaned.length;
+        const endIdx = cleaned.indexOf(OMX_CONFIG_END_MARKER, markerIdx);
+        if (endIdx >= 0) {
+            const endLineBreak = cleaned.indexOf("\n", endIdx);
+            blockEnd = endLineBreak >= 0 ? endLineBreak + 1 : cleaned.length;
+        }
+        const before = cleaned.slice(0, blockStart).trimEnd();
+        const after = cleaned.slice(blockEnd).trimStart();
+        cleaned = [before, after].filter(Boolean).join("\n\n");
+        removed += 1;
+    }
+    return { cleaned, removed };
+}
+export function stripExistingSharedMcpRegistryBlock(config) {
+    let cleaned = config;
+    let removed = 0;
+    while (true) {
+        const markerIdx = cleaned.indexOf(SHARED_MCP_REGISTRY_MARKER);
+        if (markerIdx < 0)
+            break;
+        let blockStart = cleaned.lastIndexOf("\n", markerIdx);
+        blockStart = blockStart >= 0 ? blockStart + 1 : 0;
+        const previousLineEnd = blockStart - 1;
+        if (previousLineEnd >= 0) {
+            const previousLineStart = cleaned.lastIndexOf("\n", previousLineEnd - 1);
+            const previousLine = cleaned.slice(previousLineStart + 1, previousLineEnd);
+            if (/^# =+$/.test(previousLine.trim())) {
+                blockStart = previousLineStart >= 0 ? previousLineStart + 1 : 0;
+            }
+        }
+        let blockEnd = cleaned.length;
+        const endIdx = cleaned.indexOf(SHARED_MCP_REGISTRY_END_MARKER, markerIdx);
+        if (endIdx >= 0) {
+            const endLineBreak = cleaned.indexOf("\n", endIdx);
+            blockEnd = endLineBreak >= 0 ? endLineBreak + 1 : cleaned.length;
+        }
+        const before = cleaned.slice(0, blockStart).trimEnd();
+        const after = cleaned.slice(blockEnd).trimStart();
+        cleaned = [before, after].filter(Boolean).join("\n\n");
+        removed += 1;
+    }
+    return { cleaned, removed };
+}
+function getExistingSharedMcpRegistryBlocks(config) {
+    const blocks = [];
+    let cursor = 0;
+    while (cursor < config.length) {
+        const markerIdx = config.indexOf(SHARED_MCP_REGISTRY_MARKER, cursor);
+        if (markerIdx < 0)
+            break;
+        let blockStart = config.lastIndexOf("\n", markerIdx);
+        blockStart = blockStart >= 0 ? blockStart + 1 : 0;
+        const previousLineEnd = blockStart - 1;
+        if (previousLineEnd >= 0) {
+            const previousLineStart = config.lastIndexOf("\n", previousLineEnd - 1);
+            const previousLine = config.slice(previousLineStart + 1, previousLineEnd);
+            if (/^# =+$/.test(previousLine.trim())) {
+                blockStart = previousLineStart >= 0 ? previousLineStart + 1 : 0;
+            }
+        }
+        let blockEnd = config.length;
+        const endIdx = config.indexOf(SHARED_MCP_REGISTRY_END_MARKER, markerIdx);
+        if (endIdx >= 0) {
+            const endLineBreak = config.indexOf("\n", endIdx);
+            blockEnd = endLineBreak >= 0 ? endLineBreak + 1 : config.length;
+        }
+        blocks.push(config.slice(blockStart, blockEnd));
+        cursor = blockEnd;
+    }
+    return blocks;
+}
+export function extractSharedMcpRegistryServersFromConfig(config) {
+    const servers = [];
+    let sourcePath;
+    for (const block of getExistingSharedMcpRegistryBlocks(config)) {
+        sourcePath ??= block.match(/^# Source:\s*(.+?)\s*$/m)?.[1];
+        let parsed;
+        try {
+            parsed = TOML.parse(block);
+        }
+        catch {
+            continue;
+        }
+        if (!isRecord(parsed) || !isRecord(parsed.mcp_servers))
+            continue;
+        for (const [name, value] of Object.entries(parsed.mcp_servers)) {
+            if (!isRecord(value) || typeof value.command !== "string")
+                continue;
+            const args = Array.isArray(value.args)
+                ? value.args.filter((arg) => typeof arg === "string")
+                : [];
+            const enabled = typeof value.enabled === "boolean" ? value.enabled : true;
+            const timeoutCandidate = typeof value.startup_timeout_sec === "number"
+                ? value.startup_timeout_sec
+                : value.startupTimeoutSec;
+            const startupTimeoutSec = typeof timeoutCandidate === "number" && Number.isFinite(timeoutCandidate)
+                ? timeoutCandidate
+                : undefined;
+            servers.push({
+                name,
+                command: value.command,
+                args,
+                enabled,
+                ...(startupTimeoutSec !== undefined ? { startupTimeoutSec } : {}),
+            });
+        }
+    }
+    return { servers, sourcePath };
+}
+function toMcpServerTableKey(name) {
+    if (/^[A-Za-z0-9_-]+$/.test(name)) {
+        return `mcp_servers.${name}`;
+    }
+    return `mcp_servers."${escapeTomlString(name)}"`;
+}
+function configHasMcpServer(config, name) {
+    const tableName = toMcpServerTableKey(name).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`^\\s*\\[${tableName}\\]\\s*$`, "m").test(config);
+}
+function launcherCommandBasename(command) {
+    return (command.replace(/\\/g, "/").trim().split("/").pop()?.toLowerCase() ?? "");
+}
+function isLauncherBackedMcpCommand(command, args) {
+    const base = launcherCommandBasename(command);
+    if (base === "npx" || base === "uvx") {
+        return true;
+    }
+    return base === "npm" && args[0]?.toLowerCase() === "exec";
+}
+function findLauncherTimeoutRepairTargets(config) {
+    const lines = config.split(/\r?\n/);
+    const targets = [];
+    for (let start = 0; start < lines.length; start += 1) {
+        const isMcpSection = /^\s*\[mcp_servers\./.test(lines[start] ?? "");
+        if (!isMcpSection)
+            continue;
+        let end = lines.length;
+        for (let i = start + 1; i < lines.length; i += 1) {
+            if (/^\s*\[\[?[^\]]+\]?\]\s*$/.test(lines[i] ?? "")) {
+                end = i;
+                break;
+            }
+        }
+        let parsed;
+        try {
+            parsed = TOML.parse(lines.slice(start, end).join("\n"));
+        }
+        catch {
+            start = end - 1;
+            continue;
+        }
+        const mcpServers = parsed
+            .mcp_servers;
+        const [name, value] = Object.entries(mcpServers ?? {})[0] ?? [];
+        if (!name ||
+            name.startsWith("omx_") ||
+            typeof value !== "object" ||
+            !value) {
+            start = end - 1;
+            continue;
+        }
+        const section = value;
+        const command = typeof section.command === "string" ? section.command : undefined;
+        const args = Array.isArray(section.args) &&
+            section.args.every((item) => typeof item === "string")
+            ? section.args
+            : [];
+        const hasStartupTimeout = (typeof section.startup_timeout_sec === "number" &&
+            Number.isFinite(section.startup_timeout_sec)) ||
+            (typeof section.startupTimeoutSec === "number" &&
+                Number.isFinite(section.startupTimeoutSec));
+        if (!command ||
+            hasStartupTimeout ||
+            !isLauncherBackedMcpCommand(command, args)) {
+            start = end - 1;
+            continue;
+        }
+        let insertAt = end;
+        while (insertAt > start + 1 && (lines[insertAt - 1] ?? "").trim() === "") {
+            insertAt -= 1;
+        }
+        targets.push({ insertAt });
+        start = end - 1;
+    }
+    return targets;
+}
+function addDefaultLauncherMcpStartupTimeouts(config) {
+    const targets = findLauncherTimeoutRepairTargets(config);
+    if (targets.length === 0)
+        return config;
+    const lines = config.split(/\r?\n/);
+    for (const target of [...targets].reverse()) {
+        lines.splice(target.insertAt, 0, `startup_timeout_sec = ${DEFAULT_LAUNCHER_MCP_STARTUP_TIMEOUT_SEC}`);
+    }
+    return lines.join("\n");
+}
+function getSharedMcpRegistryBlock(servers, sourcePath, existingConfig) {
+    if (servers.length === 0)
+        return "";
+    const deduped = servers.filter((server) => !configHasMcpServer(existingConfig, server.name));
+    if (deduped.length === 0)
+        return "";
+    const lines = [
+        "# ============================================================",
+        `# ${SHARED_MCP_REGISTRY_MARKER}`,
+        "# Managed by omx setup - edit the registry file instead",
+    ];
+    if (sourcePath) {
+        lines.push(`# Source: ${sourcePath}`);
+    }
+    lines.push("# ============================================================", "");
+    for (const server of deduped) {
+        lines.push(`# Shared MCP Server: ${server.name}`);
+        lines.push(`[${toMcpServerTableKey(server.name)}]`);
+        lines.push(`command = "${escapeTomlString(server.command)}"`);
+        lines.push(`args = [${server.args
+            .map((arg) => `"${escapeTomlString(arg)}"`)
+            .join(", ")}]`);
+        lines.push(`enabled = ${server.enabled ? "true" : "false"}`);
+        if (typeof server.startupTimeoutSec === "number") {
+            lines.push(`startup_timeout_sec = ${server.startupTimeoutSec}`);
+        }
+        lines.push("");
+    }
+    lines.push("# ============================================================");
+    lines.push(SHARED_MCP_REGISTRY_END_MARKER);
+    return lines.join("\n");
+}
+export function mergeSharedMcpRegistryBlock(config, servers, sourcePath) {
+    const stripped = stripExistingSharedMcpRegistryBlock(config);
+    const existing = stripped.cleaned;
+    const sharedRegistryBlock = getSharedMcpRegistryBlock(servers, sourcePath, existing);
+    const body = existing.trimEnd();
+    const merged = sharedRegistryBlock
+        ? body
+            ? `${body}\n\n${sharedRegistryBlock}\n`
+            : `${sharedRegistryBlock}\n`
+        : body
+            ? `${body}\n`
+            : "";
+    return addDefaultLauncherMcpStartupTimeouts(merged);
+}
+/**
+ * OMX table-section block (MCP servers, TUI).
+ * Contains ONLY [table] sections — no bare keys.
+ */
+function getOmxTablesBlock(pkgRoot, includeTui = true, statusLinePreset = DEFAULT_STATUS_LINE_PRESET, codexHooksFile, hookOptions = {}, includeFirstPartyMcp = false, excludedHookTrustStateKeys = new Set()) {
+    const lines = [
+        "",
+        "# ============================================================",
+        "# oh-my-codex (OMX) Configuration",
+        "# Managed by omx setup - manual edits preserved on next setup",
+        "# ============================================================",
+    ];
+    if (includeFirstPartyMcp) {
+        for (const server of getOmxFirstPartySetupMcpServers(pkgRoot)) {
+            lines.push("");
+            lines.push(server.title);
+            lines.push(`[mcp_servers.${server.name}]`);
+            lines.push(`command = "${escapeTomlString(server.command)}"`);
+            lines.push(`args = [${server.args
+                .map((arg) => `"${escapeTomlString(arg)}"`)
+                .join(", ")}]`);
+            lines.push(`enabled = ${server.enabled ? "true" : "false"}`);
+            if (typeof server.startupTimeoutSec === "number") {
+                lines.push(`startup_timeout_sec = ${server.startupTimeoutSec}`);
+            }
+        }
+    }
+    const hookTrustToml = renderManagedCodexHookTrustToml(buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, hookOptions), excludedHookTrustStateKeys);
+    if (hookTrustToml) {
+        lines.push("");
+        lines.push("# OMX-owned Codex hook trust state");
+        lines.push("# Trusts only setup-managed native hook wrappers.");
+        lines.push(hookTrustToml);
+        lines.push("# End OMX-owned Codex hook trust state");
+    }
+    lines.push(...(includeTui
+        ? [
+            "",
+            "# OMX TUI StatusLine (Codex CLI v0.101.0+)",
+            "[tui]",
+            OMX_MANAGED_STATUS_LINE_MARKER,
+            statusLineForPreset(statusLinePreset),
+            "",
+        ]
+        : [""]));
+    lines.push("# ============================================================");
+    lines.push("# End oh-my-codex");
+    lines.push("");
+    return lines.join("\n");
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Merge OMX config into existing config.toml
+ * Preserves existing user settings, appends OMX block if not present.
+ *
+ * Layout:
+ *   1. OMX top-level keys (notify, model_reasoning_effort, developer_instructions)
+ *   2. [features] with multi_agent + child_agents_md + hooks + goals
+ *   3. [shell_environment_policy.set] with defaulted deprecated explore-routing opt-out
+ *   4. … user sections …
+ *   5. OMX [table] sections (mcp_servers, tui)
+ */
+export function buildMergedConfig(existingConfig, pkgRoot, options = {}) {
+    let existing = existingConfig;
+    const preservedFirstPartyMcpSections = options.preserveExistingFirstPartyMcp === true &&
+        options.includeFirstPartyMcp !== true
+        ? extractFirstPartyOmxMcpSections(existing)
+        : "";
+    const includeTui = options.includeTui !== false;
+    const statusLinePreset = options.statusLinePreset ?? DEFAULT_STATUS_LINE_PRESET;
+    const customizedManagedTuiSections = extractCustomizedTuiSectionsFromOmxBlocks(existing);
+    if (existing.includes(OMX_CONFIG_MARKER)) {
+        const stripped = stripExistingOmxBlocks(existing);
+        existing = stripped.cleaned;
+        if (customizedManagedTuiSections.length > 0) {
+            existing = `${existing.trimEnd()}\n\n${customizedManagedTuiSections.join("\n\n")}\n`;
+        }
+    }
+    if (existing.includes(SHARED_MCP_REGISTRY_MARKER)) {
+        const stripped = stripExistingSharedMcpRegistryBlock(existing);
+        existing = stripped.cleaned;
+    }
+    const userNotifyToPreserve = options.notifyCommand === false &&
+        !isOmxManagedNotifyCommand(getRootTomlArray(existing, "notify"), pkgRoot)
+        ? getRootTomlArray(existing, "notify")
+        : null;
+    existing = stripOmxTopLevelKeys(existing);
+    if (userNotifyToPreserve) {
+        existing = `${`notify = ${formatTomlStringArray(userNotifyToPreserve)}`}\n${existing.trimStart()}`;
+    }
+    existing = stripOrphanedManagedNotify(existing, pkgRoot);
+    const managedTrustState = buildManagedCodexHookTrustStateForConfig(options.codexHooksFile, pkgRoot, {
+        codexHomeDir: options.codexHomeDir,
+        platform: options.hookCommandPlatform,
+    });
+    const hookTrustStrip = stripManagedCodexHookTrustStateWithResult(existing, {
+        managedTrustState,
+    });
+    existing = hookTrustStrip.config;
+    if (options.modelOverride) {
+        existing = stripRootLevelKeys(existing, ["model"]);
+    }
+    existing = stripOrphanedOmxSections(existing);
+    if (preservedFirstPartyMcpSections) {
+        existing = `${existing.trimEnd()}\n\n${preservedFirstPartyMcpSections}\n`;
+    }
+    existing = upsertFeatureFlags(existing, options.codexHookFeatureFlag);
+    existing = upsertEnvSettings(existing);
+    existing = upsertAgentsSettings(existing);
+    const tuiUpsert = includeTui
+        ? upsertTuiStatusLine(existing, statusLinePreset, {
+            forceStatusLinePreset: options.forceStatusLinePreset,
+        })
+        : { cleaned: existing, hadExistingTui: false };
+    existing = tuiUpsert.cleaned;
+    const topLines = getOmxTopLevelLines(pkgRoot, existing, options.modelOverride, options.notifyCommand === undefined
+        ? getDefaultNotifyCommand(pkgRoot)
+        : options.notifyCommand);
+    const tablesBlock = getOmxTablesBlock(pkgRoot, includeTui && !tuiUpsert.hadExistingTui, statusLinePreset, options.codexHooksFile, {
+        codexHomeDir: options.codexHomeDir,
+        platform: options.hookCommandPlatform,
+    }, options.includeFirstPartyMcp === true, hookTrustStrip.preservedConflictKeys);
+    const sharedRegistryBlock = getSharedMcpRegistryBlock(options.sharedMcpServers ?? [], options.sharedMcpRegistrySource, existing);
+    let body = existing.trimEnd();
+    if (sharedRegistryBlock) {
+        body = body ? `${body}\n\n${sharedRegistryBlock}` : sharedRegistryBlock;
+    }
+    return addDefaultLauncherMcpStartupTimeouts(topLines.join("\n") + "\n\n" + body + "\n" + tablesBlock);
+}
+/**
+ * Detect and repair upgrade-era managed config incompatibilities in config.toml.
+ *
+ * After an omx version upgrade the OLD setup code (still loaded in memory)
+ * may leave a config with duplicate [tui] sections or the retired
+ * [mcp_servers.omx_team_run] table. Codex rejects duplicate tables and newer
+ * OMX builds no longer ship the team MCP entrypoint, so we repair both before
+ * the CLI is spawned.
+ *
+ * Returns `true` if a repair was performed.
+ */
+export async function repairConfigIfNeeded(configPath, pkgRoot, options = {}) {
+    if (!existsSync(configPath))
+        return false;
+    const content = await readFile(configPath, "utf-8");
+    const tuiCount = (content.match(/^\s*\[tui\]\s*$/gm) || []).length;
+    const hasLegacyTeamRunTable = hasLegacyOmxTeamRunTable(content);
+    const hasLauncherTimeoutGap = findLauncherTimeoutRepairTargets(content).length > 0;
+    if (tuiCount <= 1 && !hasLegacyTeamRunTable && !hasLauncherTimeoutGap)
+        return false;
+    // Managed config compatibility issue detected — run full merge to repair
+    const repaired = buildMergedConfig(content, pkgRoot, options);
+    if (repaired === content)
+        return false;
+    await writeFile(configPath, repaired);
+    return true;
+}
+export async function mergeConfig(configPath, pkgRoot, options = {}) {
+    let existing = "";
+    if (existsSync(configPath)) {
+        existing = await readFile(configPath, "utf-8");
+    }
+    if (existing.includes("oh-my-codex (OMX) Configuration")) {
+        const stripped = stripExistingOmxBlocks(existing);
+        if (options.verbose && stripped.removed > 0) {
+            console.log("  Updating existing OMX config block.");
+        }
+    }
+    const finalConfig = buildMergedConfig(existing, pkgRoot, options);
+    await writeFile(configPath, finalConfig);
+    if (options.verbose) {
+        console.log(`  Written to ${configPath}`);
+    }
+}
+//# sourceMappingURL=generator.js.map