minecodex 0.2.1 → 0.2.3

package/README.md

@@ -26,6 +26,8 @@ mcx install
 
 运行 `mcx install` 不会强制关闭或启动 Codex，也不会影响当前打开的窗口。安装完成后，终端会说明更改将在下一次重启 Codex 时生效，并询问是否立即重启；默认选项为 **No**。只有在您明确确认，或后续手动运行 `mcx restart` 时，才会重新打开 Codex。安装完成后，macOS 的“登录项与扩展”中会添加名为 **MineCodex** 的后台项目。
 
+`mcx install`、`mcx update`、`mcx restart` 和 `mcx uninstall` 会在终端持续显示当前阶段；`mcx open` 仅在需要启动后台服务时显示进度。查询类命令保持简洁，便于直接阅读或用于脚本。
+
 MineCodex 只以后台辅助服务运行，前台应用始终是 OpenAI 签名的官方 `ChatGPT.app`，并继续使用官方默认用户数据。通过 Dock、Finder、Spotlight、登录项或会话恢复打开 ChatGPT 时，后台服务会验证官方应用与对应进程；若该进程尚未开放兼容的本机调试端口，则确认其完整退出后再通过 LaunchServices 重新打开官方应用并注入功能。MineCodex 不修改 `ChatGPT.app`、`app.asar`、Dock 项目或默认打开方式。
 
 打开本地控制台：

package/features/hide-upsell-banner/src/hide-upsell-banner.mjs

@@ -15,7 +15,8 @@ function isUpsellBanner(element) {
   if (!text) return false;
   const isCard = element.classList.contains("rounded-2xl")
     && element.classList.contains("border")
-    && element.classList.contains("bg-token-main-surface-primary");
+    && (element.classList.contains("bg-token-main-surface-primary")
+      || element.classList.contains("bg-surface"));
   if (!isCard) return false;
   const titleMatch = /out of Codex and Work usage/i.test(text)
     || /out of Codex messages/i.test(text)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "minecodex",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Lightweight, local-first plugins for the Codex desktop app.",
   "license": "MIT",
   "type": "module",

package/packages/cli/src/commands.mjs

@@ -4,6 +4,7 @@ import { createInterface } from "node:readline/promises";
 import { assertNodeSupported, MacPlatformAdapter } from "./platform.mjs";
 import { ensureConfig, ensureControlToken, readConfig } from "./config.mjs";
 import { createControlServer } from "./control-server.mjs";
+import { createProgressReporter } from "./progress.mjs";
 import { createNpmAdapter } from "./npm-adapter.mjs";
 import { resolvePaths } from "./paths.mjs";
 import { RuntimeManager, writeServicePid } from "./runtime-manager.mjs";
@@ -118,20 +119,37 @@ export async function confirmRestartNow({ input = process.stdin, terminalOutput
 }
 
 async function installCommand({ paths, platform, cliPath, output, serviceProbe, fetchImpl, confirmRestart, nodeVersion = process.versions.node }) {
-  assertNodeSupported(nodeVersion);
-  platform.assertInstallSupported();
-  await platform.assertCodexInstalled();
-  const previousService = await serviceSnapshot(platform, paths);
-  await ensureConfig(paths.configPath);
-  await ensureControlToken(paths.tokenPath);
+  const reporter = createProgressReporter({ output });
+  reporter.heading("Installing MineCodex");
+  let previousService = null;
   try {
-    await platform.installService({ cliPath, paths, start: true });
-    const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
-    const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
-    if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))
-      || !(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
-      throw new Error(`MineCodex service did not become ready. Check ${paths.serviceErrorLogPath}`);
-    }
+    await reporter.step(1, 6, "Checking your system", async () => {
+      assertNodeSupported(nodeVersion);
+      platform.assertInstallSupported();
+      await platform.assertCodexInstalled();
+    });
+    await reporter.step(2, 6, "Preparing your settings", async () => {
+      await ensureConfig(paths.configPath);
+      await ensureControlToken(paths.tokenPath);
+    });
+    previousService = await reporter.step(3, 6, "Checking your current setup", async () => {
+      return serviceSnapshot(platform, paths);
+    });
+    await reporter.step(4, 6, "Installing the background helper", async () => {
+      await platform.installService({ cliPath, paths, start: true });
+    });
+    await reporter.step(5, 6, "Waiting for the background helper (up to 20 seconds)", async () => {
+      const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
+      if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))) {
+        throw new Error("MineCodex service did not become ready. Check " + paths.serviceErrorLogPath);
+      }
+    });
+    await reporter.step(6, 6, "Waiting for MineCodex to be ready (up to 30 seconds)", async () => {
+      const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
+      if (!(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
+        throw new Error("MineCodex service did not become ready. Check " + paths.serviceErrorLogPath);
+      }
+    });
   } catch (error) {
     let rollbackError = null;
     try {
@@ -141,29 +159,38 @@ async function installCommand({ paths, platform, cliPath, output, serviceProbe,
     }
     throw appendRollbackError(error, rollbackError);
   }
-  output("MineCodex installed. It will be enabled the next time Codex restarts.");
+  reporter.heading("MineCodex installed. It will be enabled the next time Codex restarts.");
   if (await confirmRestart()) {
     await restartCommand({ paths, output, fetchImpl });
   } else {
-    output("Run `mcx restart` when you are ready.");
-  }
+    reporter.heading("Run `mcx restart` when you are ready.");
+}
 }
 
-async function openCommand({ paths, platform, serviceProbe, fetchImpl }) {
+async function openCommand({ paths, platform, output, serviceProbe, fetchImpl }) {
   const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
+  let reporter = null;
   if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl, timeoutMs: 750 }))) {
     if (!(await serviceInstalled(platform, paths))) throw new Error("MineCodex is not installed. Run `mcx install` first.");
-    await platform.startService(paths);
-    if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))) throw new Error("MineCodex service could not be started.");
+    reporter = createProgressReporter({ output });
+    reporter.heading("Opening MineCodex");
+    await reporter.step(1, 2, "Starting the background helper", async () => {
+      await platform.startService(paths);
+      if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))) throw new Error("MineCodex service could not be started.");
+    });
   }
-  const exchangeResponse = await authorizedFetch(paths, "/api/auth/exchange", {
-    method: "POST",
-    body: "{}",
-  }, { fetchImpl });
-  if (!exchangeResponse.ok) throw new Error(`MineCodex browser exchange failed: HTTP ${exchangeResponse.status}`);
-  const { exchange } = await exchangeResponse.json();
-  if (!exchange) throw new Error("MineCodex browser exchange did not return a short-lived value.");
-  await platform.openBrowser(`${controlOrigin()}/auth?exchange=${encodeURIComponent(exchange)}`);
+  const openControlPanel = async () => {
+    const exchangeResponse = await authorizedFetch(paths, "/api/auth/exchange", {
+      method: "POST",
+      body: "{}",
+    }, { fetchImpl });
+    if (!exchangeResponse.ok) throw new Error(`MineCodex browser exchange failed: HTTP ${exchangeResponse.status}`);
+    const { exchange } = await exchangeResponse.json();
+    if (!exchange) throw new Error("MineCodex browser exchange did not return a short-lived value.");
+    await platform.openBrowser(`${controlOrigin()}/auth?exchange=${encodeURIComponent(exchange)}`);
+  };
+  if (reporter) await reporter.step(2, 2, "Opening the control panel", openControlPanel);
+  else await openControlPanel();
 }
 
 function featureStatusText(feature) {
@@ -221,95 +248,130 @@ async function statusCommand({ paths, platform, jsonOutput, output, fetchImpl })
 }
 
 async function restartCommand({ paths, output, fetchImpl }) {
-  const response = await authorizedFetch(paths, "/api/restart", { method: "POST", body: "{}" }, { fetchImpl });
-  if (!response.ok) throw new Error(`MineCodex restart failed: HTTP ${response.status}`);
-  output("MineCodex restarted and saved plugin switches are now applied.");
+  const reporter = createProgressReporter({ output });
+  reporter.heading("Restarting MineCodex");
+  await reporter.step(1, 1, "Restarting Codex and applying plugin changes", async () => {
+    const response = await authorizedFetch(paths, "/api/restart", { method: "POST", body: "{}" }, { fetchImpl });
+    if (!response.ok) throw new Error(`MineCodex restart failed: HTTP ${response.status}`);
+  });
+  reporter.heading("MineCodex restarted and saved plugin switches are now applied.");
 }
 
 async function uninstallCommand({ paths, platform, purge, output, cliPath }) {
-  platform.assertInstallSupported();
-  const previousService = await serviceSnapshot(platform, paths);
+  const reporter = createProgressReporter({ output });
+  reporter.heading("Uninstalling MineCodex");
+  const previousService = await reporter.step(1, 2, "Checking the current installation", async () => {
+    platform.assertInstallSupported();
+    return serviceSnapshot(platform, paths);
+  });
   let wasManaged = false;
   try {
-    await platform.removeService(paths);
-    wasManaged = await platform.terminateOwnedCodex(paths);
-    await platform.assertServiceStopped?.();
-    await platform.assertOwnedCodexStopped?.(paths);
-    if (purge) {
-      const targets = [paths.supportDir, paths.notesDataDir, paths.imagesDataDir];
-      for (const target of targets) {
-        if (!path.isAbsolute(target) || target === paths.homeDir || target.length <= paths.homeDir.length + 2) {
-          throw new Error(`Refusing unsafe purge target: ${target}`);
+    await reporter.step(2, 2, purge ? "Removing MineCodex and its data" : "Removing the MineCodex integration", async () => {
+      await platform.removeService(paths);
+      wasManaged = await platform.terminateOwnedCodex(paths);
+      await platform.assertServiceStopped?.();
+      await platform.assertOwnedCodexStopped?.(paths);
+      if (purge) {
+        const targets = [paths.supportDir, paths.notesDataDir, paths.imagesDataDir];
+        for (const target of targets) {
+          if (!path.isAbsolute(target) || target === paths.homeDir || target.length <= paths.homeDir.length + 2) {
+            throw new Error(`Refusing unsafe purge target: ${target}`);
+          }
         }
+        for (const target of targets) await rm(target, { recursive: true, force: true });
       }
-      for (const target of targets) await rm(target, { recursive: true, force: true });
-      output("MineCodex integration and MineCodex-owned data were removed.");
-    } else {
-      output("MineCodex integration was removed. Plugin data was preserved.");
-    }
+    });
   } catch (error) {
     let rollbackError = null;
+    reporter.heading("Uninstall failed. Restoring the background helper.");
     try {
-      await restoreService(platform, previousService, { cliPath, paths });
+      await reporter.step(1, 1, "Restoring the background helper", async () => {
+        await restoreService(platform, previousService, { cliPath, paths });
+      });
     } catch (failure) {
       rollbackError = failure;
     }
     throw appendRollbackError(error, rollbackError);
   }
-  if (wasManaged) await platform.openNativeCodex();
-  output("Codex generated images and files referenced by Notes were not modified.");
+  reporter.heading(purge
+    ? "MineCodex integration and MineCodex-owned data were removed."
+    : "MineCodex integration was removed. Plugin data was preserved.");
+  if (wasManaged) {
+    await reporter.step(1, 1, "Reopening Codex", async () => platform.openNativeCodex());
+  }
+  reporter.heading("Codex generated images and files referenced by Notes were not modified.");
 }
 
 async function updateCommand({ paths, platform, cliPath, output, npm = createNpmAdapter(), serviceProbe, fetchImpl }) {
-  platform.assertInstallSupported();
-  const latest = await npm.viewLatestVersion();
-  if (!latest) throw new Error("Could not resolve the latest MineCodex version.");
+  const reporter = createProgressReporter({ output });
+  reporter.heading("Updating MineCodex");
+  const latest = await reporter.step(1, 5, "Checking for updates", async () => {
+    platform.assertInstallSupported();
+    const version = await npm.viewLatestVersion();
+    if (!version) throw new Error("Could not resolve the latest MineCodex version.");
+    return version;
+  });
   if (latest === packageMetadata.version) {
-    output(`MineCodex ${packageMetadata.version} is already up to date.`);
+    reporter.heading(`MineCodex ${packageMetadata.version} is already up to date.`);
     return;
   }
-  const wasInstalled = await serviceInstalled(platform, paths);
-  const previousService = wasInstalled
-    ? (await serviceSnapshot(platform, paths) ?? { running: true, plist: { exists: true } })
-    : null;
-  const rollback = await npm.createRollbackArchive(paths.packageRoot);
+  let wasInstalled;
+  let previousService;
+  const rollback = await reporter.step(2, 5, "Backing up the current version", async () => {
+    wasInstalled = await serviceInstalled(platform, paths);
+    previousService = wasInstalled
+      ? (await serviceSnapshot(platform, paths) ?? { running: true, plist: { exists: true } })
+      : null;
+    return npm.createRollbackArchive(paths.packageRoot);
+  });
   const rollbackPath = typeof rollback === "string" ? rollback : rollback.archivePath;
   if (!rollbackPath) throw new Error("Could not create a rollback archive for the installed MineCodex version.");
   try {
-    if (wasInstalled && previousService?.running) {
-      await platform.stopService(paths, { ignoreErrors: false });
-      await platform.assertServiceStopped?.();
-    }
-    await npm.installGlobal("minecodex@latest");
-    if (wasInstalled) {
-      await platform.installService({ cliPath, paths, start: previousService.running });
-      if (previousService.running) {
-        const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
-        const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
-        if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))
-          || !(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
-          throw new Error("MineCodex service did not become ready after update.");
-        }
-      } else {
+    await reporter.step(3, 5, "Pausing the background helper", async () => {
+      if (wasInstalled && previousService?.running) {
+        await platform.stopService(paths, { ignoreErrors: false });
         await platform.assertServiceStopped?.();
       }
-    }
-    output(`MineCodex updated from ${packageMetadata.version} to ${latest}.`);
+    });
+    await reporter.step(4, 5, `Installing MineCodex ${latest}`, async () => {
+      await npm.installGlobal("minecodex@latest");
+    });
+    await reporter.step(5, 5, "Restoring the background helper", async () => {
+      if (wasInstalled) {
+        await platform.installService({ cliPath, paths, start: previousService.running });
+        if (previousService.running) {
+          const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
+          const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
+          if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))
+            || !(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
+            throw new Error("MineCodex service did not become ready after update.");
+          }
+        } else {
+          await platform.assertServiceStopped?.();
+        }
+      }
+    });
+    reporter.heading(`MineCodex updated from ${packageMetadata.version} to ${latest}.`);
   } catch (error) {
     let rollbackError = null;
+    reporter.heading("Update failed. Restoring the previous version.");
     try {
-      await npm.installGlobal(rollbackPath);
-      await restoreService(platform, previousService, { cliPath, paths });
-      if (wasInstalled && previousService?.running) {
-        const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
-        const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
-        if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))
-          || !(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
-          throw new Error("Rolled-back MineCodex service did not become ready.");
+      await reporter.step(1, 2, "Restoring the previous version", async () => {
+        await npm.installGlobal(rollbackPath);
+      });
+      await reporter.step(2, 2, "Restoring the background helper", async () => {
+        await restoreService(platform, previousService, { cliPath, paths });
+        if (wasInstalled && previousService?.running) {
+          const waitForServiceImpl = serviceProbe?.waitForService ?? waitForService;
+          const waitForManagedReadyImpl = serviceProbe?.waitForManagedReady ?? waitForManagedReady;
+          if (!(await waitForServiceImpl(DEFAULT_CONTROL_PORT, { fetchImpl }))
+            || !(await waitForManagedReadyImpl(paths, { fetchImpl }))) {
+            throw new Error("Rolled-back MineCodex service did not become ready.");
+          }
+        } else if (wasInstalled && !previousService?.running) {
+          await platform.assertServiceStopped?.();
         }
-      } else if (wasInstalled && !previousService?.running) {
-        await platform.assertServiceStopped?.();
-      }
+      });
     } catch (failure) {
       rollbackError = failure;
     }
@@ -379,7 +441,7 @@ export async function runCli(argv, {
   if (["--help", "-h", "help"].includes(command)) return printHelp(output);
   if (["--version", "-v"].includes(command)) return output(packageMetadata.version);
   if (command === "install") return installCommand({ paths, platform, cliPath, output, serviceProbe, fetchImpl, confirmRestart, nodeVersion });
-  if (command === "open" || command === "gui") return openCommand({ paths, platform, serviceProbe, fetchImpl });
+  if (command === "open" || command === "gui") return openCommand({ paths, platform, output, serviceProbe, fetchImpl });
   if (command === "status") return statusCommand({ paths, platform, jsonOutput: args.includes("--json"), output, fetchImpl });
   if (command === "restart") return restartCommand({ paths, output, fetchImpl });
   if (command === "uninstall" || command === "remove") {

package/packages/cli/src/progress.mjs

@@ -0,0 +1,56 @@
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+function createProgressReporter({ output = console.log, terminalOutput = process.stdout } = {}) {
+  // 只有真实终端才显示 spinner；测试或脚本环境保持普通逐行文本。
+  const interactive = output === console.log && Boolean(terminalOutput?.isTTY);
+  let timer = null;
+
+  function stopSpinner() {
+    if (timer) clearInterval(timer);
+    timer = null;
+  }
+
+  function writeLine(line) {
+    if (!interactive) {
+      output(line);
+      return;
+    }
+    terminalOutput.write(`\r\x1b[2K${line}\n`);
+  }
+
+  function startSpinner(line) {
+    if (!interactive) {
+      output(line);
+      return;
+    }
+    let frame = 0;
+    terminalOutput.write(`\r\x1b[2K${SPINNER_FRAMES[frame]} ${line}`);
+    timer = setInterval(() => {
+      frame = (frame + 1) % SPINNER_FRAMES.length;
+      terminalOutput.write(`\r\x1b[2K${SPINNER_FRAMES[frame]} ${line}`);
+    }, 80);
+  }
+
+  return {
+    heading(line) {
+      writeLine(line);
+    },
+
+    async step(index, total, label, action) {
+      const prefix = `[${index}/${total}] ${label}`;
+      startSpinner(prefix);
+      try {
+        const result = await action();
+        stopSpinner();
+        writeLine(`✓ ${prefix}`);
+        return result;
+      } catch (error) {
+        stopSpinner();
+        writeLine(`✗ ${prefix}`);
+        throw error;
+      }
+    },
+  };
+}
+
+export { createProgressReporter };

package/packages/runtime-host/src/codex-runtime.mjs

@@ -306,6 +306,7 @@ export function createInjectionSource(features, {
     let modelSelectorSuppressOutsidePointerSequence = false;
     let modelSelectorTriggerObserver = null;
     let modelSelectorObservedTrigger = null;
+    let modelSelectorControllerMenu = null;
     let modelSelectorNativeFastIcons = null;
     // Fast 图标来源标记：bundle 静态提取 vs DOM 克隆，DOM 克隆优先以保持像素一致。
     let modelSelectorNativeFastIconSources = null;
@@ -318,6 +319,7 @@ export function createInjectionSource(features, {
     modelSelectorStyle.setAttribute("data-codex-model-slider-style", "");
     modelSelectorStyle.textContent = `
       [data-codex-model-slider-menu] { width: 264px !important; min-width: 264px; overflow-x: hidden; }
+      [data-codex-model-slider-controller-menu] { position: absolute !important; right: 0; bottom: 0; z-index: 1; }
       [data-codex-model-slider-menu][data-codex-model-slider-overflow] {
         max-height: var(--codex-model-slider-menu-max-height) !important;
         overflow-y: auto;
@@ -952,10 +954,21 @@ export function createInjectionSource(features, {
         .trim();
     }
 
+    function currentReactFiber(element) {
+      const fiberKey = Object.getOwnPropertyNames(element ?? {}).find((key) => key.startsWith("__reactFiber$"));
+      const propsKey = Object.getOwnPropertyNames(element ?? {}).find((key) => key.startsWith("__reactProps$"));
+      let fiber = fiberKey ? element[fiberKey] : null;
+      if (
+        propsKey
+        && fiber?.alternate?.memoizedProps === element[propsKey]
+        && fiber.memoizedProps !== element[propsKey]
+      ) return fiber.alternate;
+      return fiber;
+    }
+
     function nativeComposerModelController() {
       const trigger = document.querySelector("[data-codex-intelligence-trigger]");
-      const fiberKey = Object.getOwnPropertyNames(trigger ?? {}).find((key) => key.startsWith("__reactFiber$"));
-      let fiber = fiberKey ? trigger[fiberKey] : null;
+      let fiber = currentReactFiber(trigger);
       for (let depth = 0; fiber && depth < 40; depth += 1, fiber = fiber.return) {
         const props = fiber.memoizedProps;
         if (Array.isArray(props?.models) && typeof props.onSelectReasoningEffort === "function") return props;
@@ -1093,6 +1106,19 @@ export function createInjectionSource(features, {
       return formatIdentifier(identity.backend).toLowerCase() === nativeLabel ? native : thirdParty;
     }
 
+    function visibleReasoningLevelsFor(model) {
+      if (!model) return [];
+      const capability = model.modelSelectorCapability;
+      if (capability && Array.isArray(capability.levels)) {
+        const allowed = new Set(capability.levels);
+        return (model.supportedReasoningLevels ?? []).filter((level) => {
+          const effort = String(level?.effort ?? level ?? "").toLowerCase();
+          return allowed.has(effort);
+        });
+      }
+      return model.supportedReasoningLevels ?? [];
+    }
+
     function loadModelFavorites(selector) {
       try {
         const value = JSON.parse(localStorage.getItem(selector.favoriteStorageKey) ?? "[]");
@@ -1467,8 +1493,12 @@ export function createInjectionSource(features, {
       renderEnhancedModelMenu(menu, selector);
     }
 
-    function enhanceModelItem(item, menu, selector, index) {
-      const observedRaw = modelItemRawValue(item);
+    function enhanceModelItem(item, menu, selector, index, {
+      rawValue = null,
+      selected = null,
+      scheduleReturn = true,
+    } = {}) {
+      const observedRaw = rawValue ?? modelItemRawValue(item);
       if (!observedRaw) return;
       const observedIdentity = modelIdentity(observedRaw);
       const nativeDescriptor = nativeModelDescriptorForItem(item, observedRaw);
@@ -1486,7 +1516,10 @@ export function createInjectionSource(features, {
       const display = modelDisplayLabel(identity, selector);
       const provider = providerLabel(identity.provider, selector);
       const brand = brandForModel(identity, selector);
-      item.toggleAttribute("data-codex-model-slider-selected", Boolean(item.querySelector("svg")));
+      item.toggleAttribute(
+        "data-codex-model-slider-selected",
+        selected ?? Boolean(item.querySelector("svg")),
+      );
       const favorites = loadModelFavorites(selector);
       const starred = favorites.has(raw);
       const row = document.createElement("span");
@@ -1515,7 +1548,7 @@ export function createInjectionSource(features, {
       star.append(createModelSelectorIcon(starred ? selector.icons.unstar : selector.icons.star));
       row.append(star);
       item.replaceChildren(row);
-      if (!item.hasAttribute("data-codex-model-slider-return-listener")) {
+      if (scheduleReturn && !item.hasAttribute("data-codex-model-slider-return-listener")) {
         item.setAttribute("data-codex-model-slider-return-listener", "");
         item.addEventListener("click", (event) => {
           if (!event.target.closest?.("[data-codex-model-slider-star]")) scheduleModelSliderReturn();
@@ -1652,6 +1685,106 @@ export function createInjectionSource(features, {
       }
     }
 
+    function closeControllerModelMenu() {
+      const record = modelSelectorControllerMenu;
+      if (!record) return false;
+      record.button.setAttribute("aria-expanded", "false");
+      record.parentMenu.style.position = record.position;
+      record.parentMenu.style.overflow = record.overflow;
+      for (const item of modelMenuItems(record.menu)) modelSelectorOriginalItems.delete(item);
+      record.menu.remove();
+      modelSelectorControllerMenu = null;
+      return true;
+    }
+
+    function controllerModelReasoningEffort(controller, model) {
+      const current = String(controller?.reasoningEffort ?? "").toLowerCase();
+      const supported = (model?.supportedReasoningEfforts ?? []).map((entry) => (
+        String(entry?.reasoningEffort ?? entry ?? "").toLowerCase()
+      )).filter(Boolean);
+      return supported.includes(current)
+        ? current
+        : String(model?.defaultReasoningEffort ?? supported[0] ?? "none").toLowerCase();
+    }
+
+    function openControllerModelMenu(parentMenu, modelButton, selector) {
+      if (modelSelectorControllerMenu) {
+        closeControllerModelMenu();
+        return;
+      }
+      const controller = nativeComposerModelController();
+      if (!Array.isArray(controller?.models) || typeof controller.onSelectModel !== "function") return;
+      const models = controller.models.filter((model) => !model.hidden && String(model.model ?? "").trim());
+      if (!models.length) return;
+
+      const menu = document.createElement("div");
+      menu.className = parentMenu.className;
+      menu.setAttribute("role", "menu");
+      menu.setAttribute("data-state", "open");
+      menu.setAttribute("data-codex-model-slider-menu", "");
+      menu.setAttribute("data-codex-model-slider-controller-menu", "");
+      models.forEach((model, index) => {
+        const item = document.createElement("div");
+        item.className = "no-drag outline-hidden rounded-lg px-[var(--padding-row-x)] py-[var(--padding-row-y)] text-sm text-default group hover:bg-primary-ghost-hover focus:bg-primary-ghost-hover cursor-interaction flex flex-col";
+        item.setAttribute("role", "menuitem");
+        item.setAttribute("tabindex", "-1");
+        enhanceModelItem(item, menu, selector, index, {
+          rawValue: String(model.model),
+          selected: String(model.model) === String(controller.model),
+          scheduleReturn: false,
+        });
+        menu.append(item);
+      });
+      menu.addEventListener("click", (event) => {
+        const star = event.target.closest?.("[data-codex-model-slider-star]");
+        const item = event.target.closest?.("[data-codex-model-slider-item]");
+        if (!item) return;
+        if (star) {
+          const raw = item.dataset.codexModelSliderRaw;
+          const label = item.querySelector("[data-codex-model-slider-name]")?.textContent ?? raw;
+          toggleModelFavorite(event, menu, selector, raw, label);
+          return;
+        }
+        const currentController = nativeComposerModelController();
+        const raw = item.dataset.codexModelSliderRaw;
+        const model = currentController?.models?.find((candidate) => String(candidate.model) === raw);
+        if (!model || typeof currentController.onSelectModel !== "function") return;
+        const reasoningEffort = controllerModelReasoningEffort(currentController, model);
+        currentController.onSelectModel(raw, reasoningEffort);
+        closeControllerModelMenu();
+        queueEnsure();
+      });
+      menu.addEventListener("keydown", (event) => {
+        if (event.key === "Escape") {
+          event.preventDefault();
+          closeControllerModelMenu();
+          modelButton.focus();
+          return;
+        }
+        if (event.key !== "Enter" && event.key !== " ") return;
+        const item = event.target.closest?.("[data-codex-model-slider-item]");
+        if (!item) return;
+        event.preventDefault();
+        item.click();
+      });
+      renderEnhancedModelMenu(menu, selector);
+
+      modelSelectorControllerMenu = {
+        menu,
+        parentMenu,
+        button: modelButton,
+        position: parentMenu.style.position,
+        overflow: parentMenu.style.overflow,
+      };
+      parentMenu.style.position = "relative";
+      parentMenu.style.overflow = "visible";
+      parentMenu.append(menu);
+      sizeModelMenuViewport(menu, selector.maxVisibleItems);
+      modelButton.setAttribute("aria-expanded", "true");
+      (menu.querySelector('[data-codex-model-slider-selected]')
+        ?? menu.querySelector('[role="menuitem"]'))?.focus();
+    }
+
     function openNativeModelSubmenu(parentMenu) {
       let attempts = 0;
       const open = () => {
@@ -1929,6 +2062,8 @@ export function createInjectionSource(features, {
       modelButton.setAttribute("tabindex", "0");
       modelButton.setAttribute("data-codex-model-slider-model-button", "");
       modelButton.setAttribute("aria-label", `Model ${modelDisplayLabel(identity, selector)}`);
+      modelButton.setAttribute("aria-haspopup", "menu");
+      modelButton.setAttribute("aria-expanded", "false");
       const buttonContent = document.createElement("span");
       buttonContent.className = classes.ViewToggleContent;
       const buttonLabel = document.createElement("span");
@@ -1942,7 +2077,7 @@ export function createInjectionSource(features, {
         buttonContent.append(buttonLabel);
       }
       modelButton.append(buttonContent);
-      const openModels = () => openNativeModelSubmenu(parentMenu);
+      const openModels = () => openControllerModelMenu(parentMenu, modelButton, selector);
       modelButton.addEventListener("click", openModels);
       modelButton.addEventListener("keydown", (event) => {
         if (event.key !== "Enter" && event.key !== " ") return;
@@ -1993,6 +2128,11 @@ export function createInjectionSource(features, {
         viewControls.append(modelButton);
       }
 
+      if (efforts.length < 2) {
+        shell.append(viewControls);
+        return shell;
+      }
+
       const nativeSlider = cloneNativePowerSlider(parentMenu, efforts.length, fastEnabled);
       const rail = nativeSlider?.querySelector('[role="slider"]') ?? document.createElement("div");
       rail.setAttribute("data-codex-model-slider-rail", "");
@@ -2106,8 +2246,14 @@ export function createInjectionSource(features, {
     function enhanceGenericModelPicker(parentMenu, selector) {
       const identity = modelIdentity(nativeModelValue(parentMenu));
       const model = modelDefinitionFor(identity, selector);
-      const efforts = model?.supportedReasoningLevels ?? [];
-      if (!model || efforts.length < 2) return false;
+      const catalogModel = catalogModelFor(identity, selector);
+      const modelWithCapability = model?.modelSelectorCapability ? model : {
+        ...(model ?? {}),
+        ...(catalogModel ?? {}),
+        supportedReasoningLevels: model?.supportedReasoningLevels ?? catalogModel?.supportedReasoningLevels ?? [],
+      };
+      const efforts = visibleReasoningLevelsFor(modelWithCapability);
+      if (!model) return false;
       // 控制器推导的任务内实际 effort 优先，避免子任务/主任务切换后触发器属性滞后；
       // 触发器属性仅在控制器无法解析时作为实时回退，静态目录默认值最后兜底。
       const nativeModel = nativeCatalogModelFor(identity);
@@ -2115,10 +2261,22 @@ export function createInjectionSource(features, {
         ?? document.querySelector("[data-codex-intelligence-trigger]")
           ?.getAttribute("data-selected-reasoning-effort")
         ?? model.defaultReasoningLevel
-        ?? efforts[0].effort;
+        ?? efforts[0]?.effort
+        ?? "none";
+      const effortRank = (value) => {
+        const order = ["none", "minimal", "low", "medium", "high", "xhigh", "max", "ultra"];
+        const index = order.indexOf(String(value ?? "").toLowerCase());
+        return index < 0 ? -1 : index;
+      };
+      const visibleEffort = efforts.find((level) => level.effort === selectedEffort)?.effort
+        ?? efforts.filter((level) => effortRank(level.effort) <= effortRank(selectedEffort))
+          .sort((left, right) => effortRank(right.effort) - effortRank(left.effort))[0]?.effort
+        ?? efforts[0]?.effort
+        ?? "none";
+      const selectedEffortValue = visibleEffort;
       const selectedServiceTier = nativeComposerModelController()?.selectedServiceTier;
       const serviceTierKey = selectedServiceTier?.id ?? selectedServiceTier ?? "standard";
-      const key = `${identity.raw}:${selectedEffort}:${serviceTierKey}:${efforts.map((level) => level.effort).join(",")}`;
+      const key = `${identity.raw}:${selectedEffortValue}:${serviceTierKey}:${efforts.map((level) => level.effort).join(",")}`;
       const existing = parentMenu.querySelector(":scope > [data-codex-model-slider-generic]");
       const nativeTemplateReady = Boolean(
         parentMenu.firstElementChild
@@ -2140,7 +2298,7 @@ export function createInjectionSource(features, {
       existing?.remove();
       const nativeContainer = parentMenu.firstElementChild;
       if (!nativeContainer) return false;
-      const shell = createGenericModelSlider(parentMenu, selector, identity, model, selectedEffort);
+      const shell = createGenericModelSlider(parentMenu, selector, identity, model, selectedEffortValue);
       if (!shell) return false;
       if (!modelSelectorGenericContainers.has(nativeContainer)) {
         modelSelectorGenericContainers.set(nativeContainer, nativeContainer.style.display);
@@ -2223,12 +2381,18 @@ export function createInjectionSource(features, {
       if (!modelSelectorStyle.isConnected) document.head?.append(modelSelectorStyle);
       enhanceComposerModelTrigger(selector);
       const parentMenu = nativeModelPickerMenu();
+      if (modelSelectorControllerMenu && modelSelectorControllerMenu.parentMenu !== parentMenu) {
+        closeControllerModelMenu();
+      }
       if (!parentMenu) {
-        if (modelSelectorPendingReturn && !visibleBlockingDialog() && modelSelectorReturnTimer == null) {
-          modelSelectorReturnTimer = setTimeout(() => {
-            modelSelectorReturnTimer = null;
-            returnToNativeModelSlider();
-          }, 80);
+        if (
+          modelSelectorPendingReturn
+          && !visibleBlockingDialog()
+          && nativeModelPickerSubmenus().length === 0
+        ) {
+          clearTimeout(modelSelectorReturnTimer);
+          modelSelectorReturnTimer = null;
+          returnToNativeModelSlider();
         }
       } else {
         enhanceNativeModelPicker(parentMenu, selector);
@@ -2244,6 +2408,7 @@ export function createInjectionSource(features, {
     }
 
     function restoreModelSelectorEnhancements() {
+      closeControllerModelMenu();
       clearTimeout(modelSelectorReturnTimer);
       clearTimeout(modelSelectorEffortTransactionTimer);
       modelSelectorTriggerObserver?.disconnect();
@@ -3834,6 +3999,11 @@ export function createInjectionSource(features, {
     document.addEventListener(
       "click",
       (event) => {
+        if (
+          modelSelectorControllerMenu
+          && !modelSelectorControllerMenu.menu.contains(event.target)
+          && !modelSelectorControllerMenu.button.contains(event.target)
+        ) closeControllerModelMenu();
         if (isNativeSummaryButton(event.target) && activePinnedFeatureId) hidePinnedSurfaces();
         if (activePinnedFeatureId && summaryDisplayMode() === "overlay") {
           const state = summaryState(activePinnedFeatureId);

package/packages/runtime-host/src/feature-registry.mjs

@@ -359,6 +359,12 @@ export async function loadConfiguredModelCatalog(
         id: String(tier.id ?? "").trim(),
         name: String(tier.name ?? "").trim(),
       })),
+      capabilityKey: [
+        model.opencodex_capability_provenance?.provider,
+        model.opencodex_capability_provenance?.model_id,
+      ].every((value) => typeof value === "string" && value.trim())
+        ? `${model.opencodex_capability_provenance.provider.trim()}/${model.opencodex_capability_provenance.model_id.trim()}`
+        : null,
     })).filter((model) => model.slug);
   } catch (error) {
     if (error.code === "ENOENT") return [];

package/packages/runtime-host/src/main.mjs

@@ -11,6 +11,7 @@ import {
   selectEnabledFeatures,
   startFeatureProcesses,
 } from "./feature-registry.mjs";
+import { applyVisibleReasoningLevels, loadModelCapabilities } from "./model-capabilities.mjs";
 
 const runtimeRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const featuresRoot = process.env.CODEX_FEATURES_ROOT ?? path.dirname(runtimeRoot);
@@ -22,8 +23,17 @@ const discoveredFeatures = await discoverFeatures(featuresRoot);
 if (!discoveredFeatures.length) throw new Error(`No codex-feature.json files found under ${featuresRoot}`);
 const features = selectEnabledFeatures(discoveredFeatures, process.env.MINECODEX_ENABLED_FEATURES);
 const modelCatalog = await loadConfiguredModelCatalog();
+const modelCapabilities = await loadModelCapabilities();
 for (const feature of features) {
-  if (feature.modelSelector) feature.modelSelector.models = modelCatalog;
+  if (feature.modelSelector) {
+    feature.modelSelector.models = modelCatalog.map((model) => (
+      applyVisibleReasoningLevels(
+        model,
+        modelCapabilities.get(String(model.capabilityKey ?? model.slug ?? "").toLowerCase()),
+        model.supportedReasoningLevels,
+      )
+    ));
+  }
 }
 
 let readyWritePromise = Promise.resolve();

package/packages/runtime-host/src/model-capabilities.mjs

@@ -0,0 +1,86 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const CODEX_REASONING_ORDER = ["low", "medium", "high", "xhigh", "max", "ultra"];
+
+function uniqueLevels(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+
+function normalizedEfforts(entry) {
+  if (!Array.isArray(entry)) return null;
+  const levels = entry.map(String).filter((value) => (
+    CODEX_REASONING_ORDER.includes(value) || value === "none" || value === "minimal"
+  ));
+  return levels.length ? uniqueLevels(levels) : null;
+}
+
+export function resolveModelRecord(records, modelId) {
+  if (!records || typeof records !== "object") return undefined;
+  if (Object.prototype.hasOwnProperty.call(records, modelId)) return records[modelId];
+  const folded = modelId.toLowerCase();
+  for (const [key, value] of Object.entries(records)) {
+    if (key.toLowerCase() === folded) return value;
+  }
+  return undefined;
+}
+
+export function mergeCapability(providerConfig, modelId) {
+  if (!providerConfig) return null;
+  const configuredEfforts = normalizedEfforts(
+    resolveModelRecord(providerConfig.modelReasoningEfforts, modelId),
+  );
+  if (configuredEfforts) {
+    return {
+      source: "opencodex",
+      kind: "effort",
+      levels: uniqueLevels(configuredEfforts),
+      map: resolveModelRecord(providerConfig.modelReasoningEffortMap, modelId) ?? null,
+      rawEfforts: configuredEfforts,
+    };
+  }
+  if (Array.isArray(providerConfig.noReasoningModels) && providerConfig.noReasoningModels.includes(modelId)) {
+    return { source: "opencodex", kind: "no-effort", levels: null, map: null, rawEfforts: [] };
+  }
+  return null;
+}
+
+export async function loadModelCapabilities({
+  opencodexConfigPath = process.env.OPENCODEX_CONFIG_PATH ?? path.join(os.homedir(), ".opencodex", "config.json"),
+  read = readFile,
+} = {}) {
+  const configPayload = await read(opencodexConfigPath, "utf8").then((value) => JSON.parse(value)).catch(() => null);
+  const providers = configPayload?.providers ?? {};
+  const result = new Map();
+  for (const [providerId, providerConfig] of Object.entries(providers)) {
+    const modelIds = new Set([
+      ...Object.keys(providerConfig?.modelReasoningEfforts ?? {}),
+      ...Object.keys(providerConfig?.modelReasoningEffortMap ?? {}),
+      ...Object.keys(providerConfig?.thinkingToggleModels ?? {}),
+      ...Object.keys(providerConfig?.thinkingBudgetModels ?? {}),
+      ...(Array.isArray(providerConfig?.noReasoningModels) ? providerConfig.noReasoningModels : []),
+    ]);
+    for (const modelId of modelIds) {
+      const capability = mergeCapability(providerConfig, modelId);
+      if (capability) result.set(`${providerId}/${modelId}`.toLowerCase(), capability);
+    }
+  }
+  return result;
+}
+
+export function applyVisibleReasoningLevels(catalogModel, capability, fallbackLevels) {
+  if (!catalogModel) return catalogModel;
+  const rawLevels = Array.isArray(fallbackLevels) ? fallbackLevels : (catalogModel.supportedReasoningLevels ?? []);
+  if (!Array.isArray(rawLevels)) return catalogModel;
+  if (capability && Array.isArray(capability.levels)) {
+    const allowed = new Set(capability.levels);
+    const visible = rawLevels.filter((level) => {
+      const effort = String(level?.effort ?? level ?? "").toLowerCase();
+      return allowed.has(effort);
+    });
+    return { ...catalogModel, supportedReasoningLevels: visible, modelSelectorCapability: capability };
+  }
+  return { ...catalogModel, modelSelectorCapability: capability ?? null };
+}