oh-my-codex 0.16.3 → 0.17.0

package/dist/cli/setup.js

@@ -9,8 +9,8 @@ import { spawnSync } from "child_process";
 import { createInterface } from "readline/promises";
 import { homedir } from "os";
 import { codexHome, codexConfigPath, codexPromptsDir, codexAgentsDir, userSkillsDir, omxStateDir, detectLegacySkillRootOverlap, omxPlansDir, omxLogsDir, } from "../utils/paths.js";
-import { buildMergedConfig, getRootModelName, getRootTomlArray, hasLegacyOmxTeamRunTable, isOmxManagedNotifyCommand, stripExistingOmxBlocks, stripExistingSharedMcpRegistryBlock, stripOmxEnvSettings, stripOmxFeatureFlags, stripOmxSeededBehavioralDefaults, upsertPluginModeRuntimeFeatureFlags, upsertManagedCodexHookTrustState, stripManagedCodexHookTrustState, OMX_PLUGIN_DEVELOPER_INSTRUCTIONS, } from "../config/generator.js";
-import { mergeManagedCodexHooksConfig } from "../config/codex-hooks.js";
+import { buildMergedConfig, getRootModelName, getRootTomlArray, hasLegacyOmxTeamRunTable, isOmxManagedNotifyCommand, sanitizePreviousNotifyCommand, stripExistingOmxBlocks, stripExistingSharedMcpRegistryBlock, mergeSharedMcpRegistryBlock, stripOmxEnvSettings, stripOmxFeatureFlags, stripOmxSeededBehavioralDefaults, upsertPluginModeRuntimeFeatureFlags, upsertManagedCodexHookTrustState, stripManagedCodexHookTrustState, OMX_PLUGIN_DEVELOPER_INSTRUCTIONS, } from "../config/generator.js";
+import { buildManagedCodexNativeHookWindowsShimContent, buildManagedCodexNativeHookWindowsShimPath, mergeManagedCodexHooksConfig, } from "../config/codex-hooks.js";
 import { getLegacyUnifiedMcpRegistryCandidate, getUnifiedMcpRegistryCandidates, loadUnifiedMcpRegistry, planClaudeCodeMcpSettingsSync, } from "../config/mcp-registry.js";
 import { generateAgentToml } from "../agents/native-config.js";
 import { AGENT_DEFINITIONS } from "../agents/definitions.js";
@@ -22,8 +22,9 @@ import { tryReadCatalogManifest } from "../catalog/reader.js";
 import { DEFAULT_FRONTIER_MODEL } from "../config/models.js";
 import { addGeneratedAgentsMarker, hasOmxManagedAgentsSections, isOmxGeneratedAgentsMd, upsertManagedAgentsBlock, } from "../utils/agents-md.js";
 import { DEFAULT_HUD_CONFIG } from "../hud/types.js";
-import { SETUP_INSTALL_MODES, SETUP_SCOPES, getSetupScopeFilePath, readPersistedSetupPreferences, } from "./setup-preferences.js";
-import { OMX_LOCAL_MARKETPLACE_NAME, resolvePackagedOmxMarketplace, upsertLocalOmxMarketplaceRegistration, } from "./plugin-marketplace.js";
+import { SETUP_INSTALL_MODES, SETUP_MCP_MODES, SETUP_SCOPES, getSetupScopeFilePath, readPersistedSetupPreferences, } from "./setup-preferences.js";
+import { OMX_LOCAL_MARKETPLACE_NAME, OMX_PLUGIN_NAME, materializePackagedOmxPluginCache, resolvePackagedOmxMarketplace, upsertLocalOmxMarketplaceRegistration, upsertLocalOmxPluginEnablement, upsertLocalOmxPluginMcpServerEnablement, } from "./plugin-marketplace.js";
+import { resolveCodexHookFeatureFlagForCli } from "./codex-feature-probe.js";
 async function resolveStatusLinePresetForSetup(projectRoot, options) {
     if (options.force) {
         return DEFAULT_HUD_CONFIG.statusLine.preset;
@@ -44,7 +45,7 @@ async function resolveStatusLinePresetForSetup(projectRoot, options) {
     return undefined;
 }
 import { resolveAgentsModelTableContext, upsertAgentsModelTable, } from "../utils/agents-model-table.js";
-export { SETUP_INSTALL_MODES, SETUP_SCOPES };
+export { SETUP_INSTALL_MODES, SETUP_MCP_MODES, SETUP_SCOPES };
 const PROJECT_GITIGNORE_ENTRIES = [
     ".omx/",
     ".codex/*",
@@ -58,6 +59,7 @@ const PROJECT_GITIGNORE_ENTRIES = [
 ];
 const LEGACY_PROJECT_GITIGNORE_ENTRIES = [".codex/"];
 const SETUP_ONLY_INSTALLABLE_SKILLS = new Set(["wiki"]);
+const DEFAULT_SETUP_MCP_MODE = "none";
 const HARD_DEPRECATED_SKILL_NAMES = new Set(["web-clone"]);
 function isCatalogInstallableStatus(status) {
     return status === "active" || status === "internal";
@@ -354,6 +356,7 @@ function formatPersistedSetupPreferenceSummary(preferences) {
     return [
         `scope=${preferences.scope ?? "not recorded"}`,
         `installMode=${preferences.installMode ?? "not recorded"}`,
+        `mcpMode=${preferences.mcpMode ?? "not recorded"}`,
     ].join(", ");
 }
 async function promptForPersistedSetupReview(preferences) {
@@ -582,7 +585,7 @@ async function discoverOmxPluginCacheDirs(cacheRoot = join(codexHome(), "plugins
 async function discoverOmxPluginCacheDir(cacheRoot = join(codexHome(), "plugins", "cache")) {
     return (await discoverOmxPluginCacheDirs(cacheRoot))[0] ?? null;
 }
-async function refreshOmxPluginDiscoveryCache(pkgRoot, options) {
+async function refreshOmxPluginDiscoveryCache(pkgRoot, options, codexHomeDir = codexHome()) {
     const packagedMarketplace = await resolvePackagedOmxMarketplace(pkgRoot);
     if (!packagedMarketplace) {
         return { status: "unavailable", staleDirs: [] };
@@ -590,7 +593,7 @@ async function refreshOmxPluginDiscoveryCache(pkgRoot, options) {
     const [pkg, expectedSkillNames, cachedDirs] = await Promise.all([
         readFile(join(pkgRoot, "package.json"), "utf-8").then((raw) => JSON.parse(raw)),
         listChildDirectoryNames(join(packagedMarketplace.pluginRoot, "skills")),
-        discoverOmxPluginCacheDirs(),
+        discoverOmxPluginCacheDirs(join(codexHomeDir, "plugins", "cache")),
     ]);
     const expectedVersion = typeof pkg.version === "string" ? pkg.version : null;
     const staleDirs = [];
@@ -628,6 +631,17 @@ async function refreshOmxPluginDiscoveryCache(pkgRoot, options) {
         staleDirs,
     };
 }
+function resolveSetupMcpMode(scope, requestedMcpMode, persistedReviewDecision, persistedPreferences) {
+    if (requestedMcpMode) {
+        return { mcpMode: requestedMcpMode, source: "cli" };
+    }
+    if (persistedPreferences?.mcpMode &&
+        persistedReviewDecision === "keep" &&
+        persistedPreferences.scope === scope) {
+        return { mcpMode: persistedPreferences.mcpMode, source: "persisted" };
+    }
+    return { mcpMode: DEFAULT_SETUP_MCP_MODE, source: "default" };
+}
 async function resolveSetupInstallMode(projectRoot, scope, requestedInstallMode, installModePrompt, persistedReviewDecision = "keep", persistedPreferences) {
     if (requestedInstallMode) {
         return { installMode: requestedInstallMode, source: "cli" };
@@ -888,7 +902,7 @@ function insertRootTomlKey(config, line) {
     const after = lines.slice(firstTableIndex);
     return [...before, line, "", ...after].join("\n") + "\n";
 }
-async function ensurePluginMarketplaceRegistration(configPath, pkgRoot, backupContext, summary, options) {
+async function ensurePluginMarketplaceRegistration(configPath, pkgRoot, mcpMode, backupContext, summary, options) {
     const packagedMarketplace = await resolvePackagedOmxMarketplace(pkgRoot);
     if (!packagedMarketplace) {
         summary.skipped += 1;
@@ -897,7 +911,7 @@ async function ensurePluginMarketplaceRegistration(configPath, pkgRoot, backupCo
     const existingConfig = existsSync(configPath)
         ? await readFile(configPath, "utf-8")
         : "";
-    const nextConfig = upsertLocalOmxMarketplaceRegistration(existingConfig, pkgRoot);
+    const nextConfig = upsertLocalOmxMarketplaceRegistration(upsertLocalOmxPluginMcpServerEnablement(upsertLocalOmxPluginEnablement(existingConfig), mcpMode === "compat"), pkgRoot);
     const destinationExists = existsSync(configPath);
     if (nextConfig === existingConfig) {
         summary.unchanged += 1;
@@ -916,11 +930,11 @@ async function ensurePluginMarketplaceRegistration(configPath, pkgRoot, backupCo
     }
     return "updated";
 }
-async function applyPluginModeHooksConfig(configPath, hooksPath, pkgRoot, backupContext, summary, options) {
+async function applyPluginModeHooksConfig(configPath, hooksPath, pkgRoot, codexHomeDir, backupContext, summary, options) {
     const existingConfig = existsSync(configPath)
         ? await readFile(configPath, "utf-8")
         : "";
-    const nextConfig = upsertManagedCodexHookTrustState(upsertPluginModeRuntimeFeatureFlags(stripManagedCodexHookTrustState(existingConfig)), pkgRoot, hooksPath);
+    const nextConfig = upsertManagedCodexHookTrustState(upsertPluginModeRuntimeFeatureFlags(stripManagedCodexHookTrustState(existingConfig), options.codexHookFeatureFlag), pkgRoot, hooksPath, { platform: process.platform, codexHomeDir });
     if (nextConfig !== existingConfig) {
         if (await ensureBackup(configPath, existsSync(configPath), backupContext, options)) {
             summary.backedUp += 1;
@@ -937,8 +951,9 @@ async function applyPluginModeHooksConfig(configPath, hooksPath, pkgRoot, backup
     const existingHooksContent = existsSync(hooksPath)
         ? await readFile(hooksPath, "utf-8")
         : null;
-    const hooksConfig = mergeManagedCodexHooksConfig(existingHooksContent, pkgRoot, hooksPath);
+    const hooksConfig = mergeManagedCodexHooksConfig(existingHooksContent, pkgRoot, hooksPath, { platform: process.platform, codexHomeDir });
     await syncManagedContent(hooksConfig, hooksPath, summary, backupContext, options, `native hooks ${hooksPath}`);
+    await syncManagedWindowsNativeHookShim(codexHomeDir, pkgRoot, summary, backupContext, options);
     if (options.verbose) {
         console.log(`  ${options.dryRun ? "would configure" : "configured"} plugin-mode native hooks and runtime feature flags at ${hooksPath}`);
     }
@@ -1028,7 +1043,7 @@ async function cleanupPluginModeLegacyAgentsMd(agentsMdPath, backupContext, opti
     return true;
 }
 export async function setup(options = {}) {
-    const { force = false, dryRun = false, installMode: requestedInstallMode, scope: requestedScope, verbose = false, setupScopePrompt, persistedSetupReviewPrompt, installModePrompt, modelUpgradePrompt, pluginAgentsMdPrompt, pluginDeveloperInstructionsPrompt, pluginDeveloperInstructionsOverwritePrompt, } = options;
+    const { force = false, dryRun = false, installMode: requestedInstallMode, mcpMode: requestedMcpMode, scope: requestedScope, verbose = false, setupScopePrompt, persistedSetupReviewPrompt, installModePrompt, modelUpgradePrompt, pluginAgentsMdPrompt, pluginDeveloperInstructionsPrompt, pluginDeveloperInstructionsOverwritePrompt, } = options;
     const pkgRoot = getPackageRoot();
     const projectRoot = process.cwd();
     const persistedPreferences = await readPersistedSetupPreferences(projectRoot, { warnOnLegacyScope: true });
@@ -1039,8 +1054,12 @@ export async function setup(options = {}) {
         Boolean(persistedPreferences?.installMode) &&
         (!persistedPreferences?.scope ||
             persistedPreferences.scope === effectiveScopeForInstallMode);
+    const wouldUsePersistedMcpMode = !requestedMcpMode &&
+        Boolean(persistedPreferences?.mcpMode) &&
+        (!persistedPreferences?.scope ||
+            persistedPreferences.scope === effectiveScopeForInstallMode);
     const shouldReviewPersistedSetup = hasPersistedSetupPreferences(persistedPreferences) &&
-        (wouldUsePersistedScope || wouldUsePersistedInstallMode) &&
+        (wouldUsePersistedScope || wouldUsePersistedInstallMode || wouldUsePersistedMcpMode) &&
         (typeof persistedSetupReviewPrompt === "function" ||
             (process.stdin.isTTY && process.stdout.isTTY));
     if (shouldReviewPersistedSetup) {
@@ -1051,6 +1070,7 @@ export async function setup(options = {}) {
     }
     const resolvedScope = await resolveSetupScope(projectRoot, requestedScope, persistedReviewDecision, persistedPreferences, setupScopePrompt);
     const resolvedInstallMode = await resolveSetupInstallMode(projectRoot, resolvedScope.scope, requestedInstallMode, installModePrompt, persistedReviewDecision, persistedPreferences);
+    const resolvedMcpMode = resolveSetupMcpMode(resolvedScope.scope, requestedMcpMode, persistedReviewDecision, persistedPreferences);
     const scopeDirs = resolveScopeDirectories(resolvedScope.scope, projectRoot);
     const scopeSourceMessage = resolvedScope.source === "persisted" ? " (from .omx/setup-scope.json)" : "";
     const backupContext = getBackupContext(resolvedScope.scope, projectRoot);
@@ -1077,6 +1097,10 @@ export async function setup(options = {}) {
             : "";
         console.log(`Using setup install mode: ${resolvedInstallMode.installMode}${installModeSourceMessage}\n`);
     }
+    const mcpModeSourceMessage = resolvedMcpMode.source === "persisted"
+        ? " (from .omx/setup-scope.json)"
+        : "";
+    console.log(`Using setup MCP mode: ${resolvedMcpMode.mcpMode}${mcpModeSourceMessage}\n`);
     // Step 1: Ensure directories exist
     console.log("[1/8] Creating directories...");
     const dirs = isPluginInstallMode
@@ -1102,16 +1126,15 @@ export async function setup(options = {}) {
         if (verbose)
             console.log(`  mkdir ${dir}`);
     }
-    const setupPreferencesToPersist = resolvedInstallMode &&
-        (resolvedScope.scope === "user" ||
-            resolvedInstallMode.installMode === "plugin")
-        ? {
-            scope: resolvedScope.scope,
-            installMode: resolvedInstallMode.installMode,
-        }
-        : {
-            scope: resolvedScope.scope,
-        };
+    const setupPreferencesToPersist = {
+        scope: resolvedScope.scope,
+        mcpMode: resolvedMcpMode.mcpMode,
+        ...(resolvedInstallMode &&
+            (resolvedScope.scope === "user" ||
+                resolvedInstallMode.installMode === "plugin")
+            ? { installMode: resolvedInstallMode.installMode }
+            : {}),
+    };
     await persistSetupPreferences(projectRoot, setupPreferencesToPersist, {
         dryRun,
         verbose,
@@ -1217,6 +1240,35 @@ export async function setup(options = {}) {
     console.log("[5/8] Updating config.toml...");
     let resolvedConfig = "";
     let omxManagesTui = false;
+    const codexHookFeatureFlag = resolveCodexHookFeatureFlagForCli({
+        codexFeaturesProbe: options.codexFeaturesProbe,
+        codexVersionProbe: options.codexVersionProbe,
+    });
+    if (verbose) {
+        console.log(`  Native Codex hook feature flag: [features].${codexHookFeatureFlag}`);
+    }
+    const shouldSyncSharedMcpRegistry = resolvedMcpMode.mcpMode === "compat";
+    const registryCandidates = getUnifiedMcpRegistryCandidates();
+    const defaultRegistryCandidates = registryCandidates.slice(0, 1);
+    const sharedMcpRegistry = shouldSyncSharedMcpRegistry
+        ? await loadUnifiedMcpRegistry({
+            candidates: options.mcpRegistryCandidates ?? defaultRegistryCandidates,
+        })
+        : { servers: [], warnings: [] };
+    const legacyRegistryCandidate = getLegacyUnifiedMcpRegistryCandidate();
+    if (shouldSyncSharedMcpRegistry &&
+        !options.mcpRegistryCandidates &&
+        !sharedMcpRegistry.sourcePath &&
+        existsSync(legacyRegistryCandidate) &&
+        !existsSync(defaultRegistryCandidates[0])) {
+        console.log(`  warning: legacy shared MCP registry detected at ${legacyRegistryCandidate} but ignored by default; move or copy it to ${defaultRegistryCandidates[0]} and rerun setup with --mcp compat if you still want setup to sync those servers`);
+    }
+    if (verbose && sharedMcpRegistry.sourcePath) {
+        console.log(`  shared MCP registry: ${sharedMcpRegistry.sourcePath} (${sharedMcpRegistry.servers.length} servers)`);
+    }
+    for (const warning of sharedMcpRegistry.warnings) {
+        console.log(`  warning: ${warning}`);
+    }
     if (isPluginInstallMode) {
         const configCleaned = await cleanupPluginModeLegacyConfig(scopeDirs.codexConfigFile, backupContext, { dryRun, verbose });
         if (configCleaned)
@@ -1224,8 +1276,8 @@ export async function setup(options = {}) {
         console.log(configCleaned
             ? `  ${dryRun ? "Would clean" : "Cleaned"} legacy OMX config entries for plugin mode.\n`
             : "  Config refresh skipped; no legacy OMX config entries found.\n");
-        await applyPluginModeHooksConfig(scopeDirs.codexConfigFile, scopeDirs.codexHooksFile, pkgRoot, backupContext, summary.config, { dryRun, verbose });
-        const pluginMarketplaceResult = await ensurePluginMarketplaceRegistration(scopeDirs.codexConfigFile, pkgRoot, backupContext, summary.config, { dryRun, verbose });
+        await applyPluginModeHooksConfig(scopeDirs.codexConfigFile, scopeDirs.codexHooksFile, pkgRoot, scopeDirs.codexHomeDir, backupContext, summary.config, { dryRun, verbose, codexHookFeatureFlag });
+        const pluginMarketplaceResult = await ensurePluginMarketplaceRegistration(scopeDirs.codexConfigFile, pkgRoot, resolvedMcpMode.mcpMode, backupContext, summary.config, { dryRun, verbose });
         if (pluginMarketplaceResult === "unavailable") {
             console.log(`  warning: packaged ${OMX_LOCAL_MARKETPLACE_NAME} Codex plugin marketplace metadata not found; /skills plugin discovery was not registered.`);
         }
@@ -1235,16 +1287,30 @@ export async function setup(options = {}) {
         else {
             console.log(`  Local Codex plugin marketplace ${OMX_LOCAL_MARKETPLACE_NAME} already registered (${pkgRoot}).`);
         }
+        const packagedMarketplace = await resolvePackagedOmxMarketplace(pkgRoot);
         const pluginCacheRefresh = await refreshOmxPluginDiscoveryCache(pkgRoot, {
             dryRun,
             verbose,
-        });
+        }, scopeDirs.codexHomeDir);
         if (pluginCacheRefresh.status === "refreshed") {
             console.log(`  ${dryRun ? "Would invalidate" : "Invalidated"} ${pluginCacheRefresh.staleDirs.length} stale Codex plugin discovery cache entr${pluginCacheRefresh.staleDirs.length === 1 ? "y" : "ies"} so plugin skills refresh from the packaged manifest.`);
         }
         else if (pluginCacheRefresh.status === "unchanged") {
             console.log("  Codex plugin discovery cache already matches packaged plugin metadata.");
         }
+        const pluginCacheMaterialize = await materializePackagedOmxPluginCache(scopeDirs.codexHomeDir, packagedMarketplace, { dryRun });
+        if (pluginCacheMaterialize.status === "materialized") {
+            console.log(`  ${dryRun ? "Would install" : "Installed"} local Codex plugin cache for ${OMX_LOCAL_MARKETPLACE_NAME}/${OMX_PLUGIN_NAME} at ${pluginCacheMaterialize.cacheDir}.`);
+        }
+        else if (pluginCacheMaterialize.status === "unchanged") {
+            console.log("  Local Codex plugin cache already exposes packaged OMX skills.");
+        }
+        if (shouldSyncSharedMcpRegistry) {
+            resolvedConfig = await syncSharedMcpRegistryIntoConfig(scopeDirs.codexConfigFile, sharedMcpRegistry, summary.config, backupContext, { dryRun, verbose });
+            if (resolvedScope.scope === "user") {
+                await syncClaudeCodeMcpSettings(sharedMcpRegistry, summary.config, backupContext, { dryRun, verbose });
+            }
+        }
         resolvedConfig = existsSync(scopeDirs.codexConfigFile)
             ? await readFile(scopeDirs.codexConfigFile, "utf-8")
             : "";
@@ -1270,46 +1336,30 @@ export async function setup(options = {}) {
         }
     }
     else {
-        const registryCandidates = getUnifiedMcpRegistryCandidates();
-        const defaultRegistryCandidates = registryCandidates.slice(0, 1);
-        const legacyRegistryCandidate = getLegacyUnifiedMcpRegistryCandidate();
-        const sharedMcpRegistry = await loadUnifiedMcpRegistry({
-            candidates: options.mcpRegistryCandidates ?? defaultRegistryCandidates,
-        });
-        if (!options.mcpRegistryCandidates &&
-            !sharedMcpRegistry.sourcePath &&
-            existsSync(legacyRegistryCandidate) &&
-            !existsSync(defaultRegistryCandidates[0])) {
-            console.log(`  warning: legacy shared MCP registry detected at ${legacyRegistryCandidate} but ignored by default; move it to ${defaultRegistryCandidates[0]} if you still want setup to sync those servers`);
-        }
-        if (verbose && sharedMcpRegistry.sourcePath) {
-            console.log(`  shared MCP registry: ${sharedMcpRegistry.sourcePath} (${sharedMcpRegistry.servers.length} servers)`);
-        }
-        for (const warning of sharedMcpRegistry.warnings) {
-            console.log(`  warning: ${warning}`);
-        }
         const statusLinePreset = await resolveStatusLinePresetForSetup(projectRoot, { force });
-        const managedConfig = await updateManagedConfig(scopeDirs.codexConfigFile, scopeDirs.codexHooksFile, pkgRoot, sharedMcpRegistry, resolvedScope.scope, scopeDirs.codexHomeDir, summary.config, backupContext, {
+        const managedConfig = await updateManagedConfig(scopeDirs.codexConfigFile, scopeDirs.codexHooksFile, pkgRoot, sharedMcpRegistry, resolvedMcpMode.mcpMode, resolvedScope.scope, scopeDirs.codexHomeDir, summary.config, backupContext, {
             dryRun,
             modelUpgradePrompt,
             verbose,
             statusLinePreset,
             forceStatusLinePreset: force,
+            codexHookFeatureFlag,
         });
         resolvedConfig = managedConfig.finalConfig;
         omxManagesTui = managedConfig.omxManagesTui;
         if (managedConfig.repairedLegacyTeamRunTable) {
             console.log("  Removed retired [mcp_servers.omx_team_run] config during refresh.");
         }
-        if (resolvedScope.scope === "user") {
+        if (shouldSyncSharedMcpRegistry && resolvedScope.scope === "user") {
             await syncClaudeCodeMcpSettings(sharedMcpRegistry, summary.config, backupContext, { dryRun, verbose });
         }
         console.log(`  Config refresh complete (${scopeDirs.codexConfigFile}).\n`);
         const existingHooksContent = existsSync(scopeDirs.codexHooksFile)
             ? await readFile(scopeDirs.codexHooksFile, "utf-8")
             : null;
-        const hooksConfig = mergeManagedCodexHooksConfig(existingHooksContent, pkgRoot);
+        const hooksConfig = mergeManagedCodexHooksConfig(existingHooksContent, pkgRoot, scopeDirs.codexHooksFile, { platform: process.platform, codexHomeDir: scopeDirs.codexHomeDir });
         await syncManagedContent(hooksConfig, scopeDirs.codexHooksFile, summary.config, backupContext, { dryRun, verbose }, `native hooks ${scopeDirs.codexHooksFile}`);
+        await syncManagedWindowsNativeHookShim(scopeDirs.codexHomeDir, pkgRoot, summary.config, backupContext, { dryRun, verbose });
         console.log(`  Native Codex hooks refresh complete (${scopeDirs.codexHooksFile}).\n`);
     }
     // Step 5.5: Verify team CLI interop surface is available.
@@ -1616,6 +1666,13 @@ async function syncManagedContent(content, dstPath, summary, backupContext, opti
         console.log(`  ${options.dryRun ? "would update" : "updated"} ${verboseLabel}`);
     }
 }
+async function syncManagedWindowsNativeHookShim(codexHomeDir, pkgRoot, summary, backupContext, options) {
+    if (process.platform !== "win32")
+        return;
+    const shimPath = buildManagedCodexNativeHookWindowsShimPath(codexHomeDir);
+    const shimContent = buildManagedCodexNativeHookWindowsShimContent(pkgRoot);
+    await syncManagedContent(shimContent, shimPath, summary, backupContext, options, `native hook Windows shim ${shimPath}`);
+}
 async function syncManagedAgentsContent(content, dstPath, summary, backupContext, options) {
     const destinationExists = existsSync(dstPath);
     let existing = "";
@@ -2059,13 +2116,17 @@ async function buildNotifyMergePlan(existingConfig, pkgRoot, codexHomeDir, scope
             const previousNotify = metadata.previousNotify;
             if (Array.isArray(previousNotify) &&
                 previousNotify.every((item) => typeof item === "string")) {
+                const sanitizedPreviousNotify = sanitizePreviousNotifyCommand(previousNotify, pkgRoot);
+                if (!sanitizedPreviousNotify) {
+                    return { notifyCommand: omxNotify };
+                }
                 return {
                     notifyCommand: dispatcherNotify,
                     metadataPath,
                     metadata: {
                         managedBy: "oh-my-codex",
                         version: 1,
-                        previousNotify,
+                        previousNotify: sanitizedPreviousNotify,
                         omxNotify,
                         dispatcherNotify,
                     },
@@ -2083,13 +2144,13 @@ async function buildNotifyMergePlan(existingConfig, pkgRoot, codexHomeDir, scope
         metadata: {
             managedBy: "oh-my-codex",
             version: 1,
-            previousNotify: existingNotify,
+            previousNotify: sanitizePreviousNotifyCommand(existingNotify, pkgRoot),
             omxNotify,
             dispatcherNotify,
         },
     };
 }
-async function updateManagedConfig(configPath, hooksPath, pkgRoot, sharedMcpRegistry, scope, codexHomeDir, summary, backupContext, options) {
+async function updateManagedConfig(configPath, hooksPath, pkgRoot, sharedMcpRegistry, mcpMode, scope, codexHomeDir, summary, backupContext, options) {
     const existing = existsSync(configPath)
         ? await readFile(configPath, "utf-8")
         : "";
@@ -2113,6 +2174,9 @@ async function updateManagedConfig(configPath, hooksPath, pkgRoot, sharedMcpRegi
     const finalConfig = buildMergedConfig(existing, pkgRoot, {
         includeTui: omxManagesTui,
         codexHooksFile: hooksPath,
+        codexHomeDir,
+        hookCommandPlatform: process.platform,
+        codexHookFeatureFlag: options.codexHookFeatureFlag,
         modelOverride,
         sharedMcpServers: sharedMcpRegistry.servers,
         sharedMcpRegistrySource: sharedMcpRegistry.sourcePath,
@@ -2120,6 +2184,7 @@ async function updateManagedConfig(configPath, hooksPath, pkgRoot, sharedMcpRegi
         statusLinePreset: options.statusLinePreset,
         forceStatusLinePreset: options.forceStatusLinePreset,
         notifyCommand: notifyPlan.notifyCommand,
+        includeFirstPartyMcp: mcpMode === "compat",
     });
     const changed = existing !== finalConfig;
     if (!changed) {
@@ -2156,6 +2221,30 @@ async function updateManagedConfig(configPath, hooksPath, pkgRoot, sharedMcpRegi
         repairedLegacyTeamRunTable: hadLegacyTeamRunTable && !hasLegacyOmxTeamRunTable(finalConfig),
     };
 }
+async function syncSharedMcpRegistryIntoConfig(configPath, sharedMcpRegistry, summary, backupContext, options) {
+    if (sharedMcpRegistry.servers.length === 0) {
+        return existsSync(configPath) ? await readFile(configPath, "utf-8") : "";
+    }
+    const existing = existsSync(configPath)
+        ? await readFile(configPath, "utf-8")
+        : "";
+    const finalConfig = mergeSharedMcpRegistryBlock(existing, sharedMcpRegistry.servers, sharedMcpRegistry.sourcePath);
+    if (existing === finalConfig) {
+        summary.unchanged += 1;
+        return finalConfig;
+    }
+    if (await ensureBackup(configPath, existsSync(configPath), backupContext, options)) {
+        summary.backedUp += 1;
+    }
+    if (!options.dryRun) {
+        await writeFile(configPath, finalConfig);
+    }
+    summary.updated += 1;
+    if (options.verbose) {
+        console.log(`  ${options.dryRun ? "would sync" : "synced"} shared MCP registry servers into ${configPath}`);
+    }
+    return finalConfig;
+}
 function getClaudeCodeSettingsPath(homeDir = homedir()) {
     return join(homeDir, ".claude", "settings.json");
 }