ccjk 16.0.7 → 16.3.0

package/dist/cli.mjs

@@ -1,20 +1,21 @@
 #!/usr/bin/env node
 import cac from 'cac';
 import ansis from 'ansis';
-import { aq as ensureI18nInitialized, as as i18n, aZ as readCcrConfig, aU as isCcrInstalled, aV as installCcr, a_ as configureCcrFeature, av as promptBoolean, a$ as handleExitPromptError, b0 as handleGeneralError, b1 as checkAndUpdateTools, b2 as runCodexUpdate, b3 as resolveCodeType$1, aB as readJsonConfig, b4 as writeJsonConfig, c as CCJK_CONFIG_FILE, aO as readCcjkConfig, D as DEFAULT_CODE_TOOL_TYPE, a2 as isCodeToolType, at as addNumbersToChoices, b5 as displayBanner, aK as updateCcjkConfig, b6 as version, b7 as resolveAiOutputLanguage, aQ as isClaudeFamilyCodeTool, b8 as updatePromptOnly, b9 as selectAndInstallWorkflows, ba as checkClaudeCodeVersionAndPrompt, af as resolveCodeToolType$1, v as activeSettingsFile, C as CCJK_CONFIG_DIR, aL as changeLanguage, u as SUPPORTED_LANGS, L as LANG_LABELS, bb as STARTUP_CODE_TOOL_CHOICES, bc as displayBannerWithInfo, q as CODE_TOOL_BANNERS, _ as init, bd as runCodexUninstall, be as manageCodexMcp, bf as configureCodexApi, bg as runCodexWorkflowImportWithLanguageSelection, bh as runCodexFullInit, bi as switchCodexProvider, bj as listCodexProviders, aH as readCodexConfig, bk as switchToOfficialLogin, bl as switchToProvider, bm as readCcjkConfigAsync, bn as initI18n, bo as selectScriptLanguage } from './chunks/simple-config.mjs';
+import { as as ensureI18nInitialized, au as i18n, b2 as readCcrConfig, aZ as isCcrInstalled, a_ as installCcr, b3 as configureCcrFeature, ax as promptBoolean, b4 as handleExitPromptError, b5 as handleGeneralError, o as CODEX_DIR, d as CLAUDE_DIR, i as CLAVUE_DIR, al as settingsFileForTool, b6 as MCP_SERVICE_CONFIGS, av as addNumbersToChoices, aT as readCcjkConfig, aM as backupCodexComplete, b7 as getBackupMessage, b8 as deleteAllCodexMcpServices, aL as readCodexConfig, ad as readMcpConfig, az as exists, b9 as readDir, ba as isDirectory, aB as readFile, p as CODEX_PROMPTS_DIR, bb as deleteCodexMcpService, ar as writeMcpConfig, bc as listCodexMcpServiceIds, l as CODEX_AGENTS_FILE, ag as resolveCodeToolType$1, w as activeSettingsFile, aF as readJsonConfig, bd as displayBanner, be as runCodexUpdate, aP as updateCcjkConfig, bf as version, bg as resolveAiOutputLanguage, aV as isClaudeFamilyCodeTool, bh as updatePromptOnly, bi as selectAndInstallWorkflows, bj as checkClaudeCodeVersionAndPrompt, D as DEFAULT_CODE_TOOL_TYPE, a3 as isCodeToolType, bk as runCodexWorkflowImportWithLanguageSelection, bl as runCodexFullInit, $ as init, bm as manageCodexMcp, bn as configureCodexApi, bo as checkAndUpdateTools, bp as resolveCodeType$1, bq as writeJsonConfig, c as CCJK_CONFIG_FILE, C as CCJK_CONFIG_DIR, aQ as changeLanguage, v as SUPPORTED_LANGS, L as LANG_LABELS, br as STARTUP_CODE_TOOL_CHOICES, bs as displayBannerWithInfo, r as CODE_TOOL_BANNERS, bt as runCodexUninstall, bu as switchCodexProvider, bv as listCodexProviders, bw as switchToOfficialLogin, bx as switchToProvider, by as listProviderProfiles, bz as getActiveProviderProfileId, bA as getProviderProfile, bB as readCredentials, bC as readCcjkConfigAsync, bD as initI18n, bE as selectScriptLanguage } from './chunks/simple-config.mjs';
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { homedir } from 'node:os';
 import inquirer from 'inquirer';
 import { join } from 'pathe';
 import { runCcrStop, runCcrStart, runCcrRestart, runCcrStatus, runCcrUi } from './chunks/commands.mjs';
-import { changeScriptLanguageFeature, configureEnvPermissionFeature, configureAiMemoryFeature, configureDefaultModelFeature, configureMcpFeature, configureApiFeature, configureCodexAiMemoryFeature, configureCodexDefaultModelFeature } from './chunks/features.mjs';
-import process$1 from 'node:process';
-import { pathExists } from 'fs-extra';
-import { exec, x } from 'tinyexec';
+import { detectCodexRuntimes, scanCodexConfigDoctorFindings, printCodexReloadHint } from './chunks/codex-runtime.mjs';
 import { m as moveToTrash } from './shared/ccjk.DGjQxTq_.mjs';
-import { g as getClaudeFamilyRuntimeLabel } from './shared/ccjk.BSLlI-JL.mjs';
+import { g as getClaudeFamilyRuntimeLabel } from './shared/ccjk.TC1_-qhV.mjs';
 import { execSync, spawnSync } from 'node:child_process';
 import { ClaudeCodeConfigManager } from './chunks/claude-code-config-manager.mjs';
+import { configureCodexAiMemoryFeature, configureCodexDefaultModelFeature, configureEnvPermissionFeature, configureAiMemoryFeature, configureDefaultModelFeature, configureMcpFeature, configureApiFeature, changeScriptLanguageFeature } from './chunks/features.mjs';
+import process$1 from 'node:process';
+import { pathExists } from 'fs-extra';
+import { exec, x } from 'tinyexec';
 import 'node:util';
 import 'dayjs';
 import 'node:url';
@@ -148,6 +149,1334 @@ ${ansis.dim("\u2500".repeat(50))}
   }
 }
 
+const GROK_DIR = join(homedir(), ".grok");
+const AGENTS_SKILLS_DIR = join(homedir(), ".agents", "skills");
+const CLAUDE_FAMILY_CAPABILITIES = {
+  fullInit: true,
+  updateWorkflow: true,
+  configureApi: true,
+  configureMcp: true,
+  configureModel: true,
+  configureAiMemory: true,
+  configureEnvPermission: true,
+  cleanEnvironment: true,
+  uninstall: true,
+  checkUpdates: true,
+  setupPresets: false
+};
+const CLAUDE_FAMILY_DOCTOR = [
+  "mcp-unmanaged",
+  "mcp-broken",
+  "mcp-bloat",
+  "skill-missing-file",
+  "skill-empty"
+];
+const CLAUDE_FAMILY_OPERATOR$1 = [
+  "init-full",
+  "update-workflow",
+  "configure-api",
+  "configure-mcp",
+  "configure-model",
+  "configure-ai-memory",
+  "configure-env-permission",
+  "clean-environment"
+];
+const TOOL_MATRIX = {
+  clavue: {
+    id: "clavue",
+    displayName: "Clavue",
+    configRoot: CLAVUE_DIR,
+    configFile: settingsFileForTool("clavue"),
+    skillsDirs: [join(CLAVUE_DIR, "skills"), AGENTS_SKILLS_DIR],
+    mcpFormat: "settings-json",
+    profileStorage: "settings-json",
+    roles: ["both"],
+    capabilities: { ...CLAUDE_FAMILY_CAPABILITIES },
+    doctorChecks: [...CLAUDE_FAMILY_DOCTOR],
+    operatorActions: [...CLAUDE_FAMILY_OPERATOR$1]
+  },
+  "claude-code": {
+    id: "claude-code",
+    displayName: "Claude Code",
+    configRoot: CLAUDE_DIR,
+    configFile: settingsFileForTool("claude-code"),
+    skillsDirs: [join(CLAUDE_DIR, "skills"), AGENTS_SKILLS_DIR],
+    mcpFormat: "settings-json",
+    profileStorage: "settings-json",
+    roles: ["both"],
+    capabilities: { ...CLAUDE_FAMILY_CAPABILITIES },
+    doctorChecks: [...CLAUDE_FAMILY_DOCTOR],
+    operatorActions: [...CLAUDE_FAMILY_OPERATOR$1]
+  },
+  codex: {
+    id: "codex",
+    displayName: "Codex (CLI / \u684C\u9762 / IDE)",
+    configRoot: CODEX_DIR,
+    configFile: settingsFileForTool("codex"),
+    skillsDirs: [join(CODEX_DIR, "skills")],
+    mcpFormat: "config-toml",
+    profileStorage: "config-toml",
+    roles: ["both"],
+    capabilities: {
+      fullInit: true,
+      updateWorkflow: true,
+      configureApi: true,
+      configureMcp: true,
+      configureModel: true,
+      configureAiMemory: true,
+      configureEnvPermission: false,
+      cleanEnvironment: true,
+      uninstall: true,
+      checkUpdates: true,
+      setupPresets: true
+    },
+    doctorChecks: [
+      "runtime-status",
+      "config-feature-risk",
+      "mcp-unmanaged",
+      "mcp-broken",
+      "mcp-orphan-toml",
+      "mcp-bloat",
+      "skill-missing-file",
+      "skill-empty",
+      "prompt-stale",
+      "agents-file-stale"
+    ],
+    operatorActions: [
+      "init-preset-clean",
+      "init-preset-optimized",
+      "init-preset-custom",
+      "update-workflow",
+      "configure-api",
+      "configure-mcp",
+      "configure-model",
+      "configure-ai-memory",
+      "clean-environment"
+    ]
+  },
+  grok: {
+    id: "grok",
+    displayName: "Grok CLI",
+    configRoot: GROK_DIR,
+    configFile: join(GROK_DIR, "config.toml"),
+    skillsDirs: [
+      join(GROK_DIR, "skills"),
+      join(GROK_DIR, "bundled", "skills")
+    ],
+    mcpFormat: "none",
+    profileStorage: "ccjk-profile",
+    roles: ["both"],
+    capabilities: {
+      fullInit: true,
+      updateWorkflow: false,
+      configureApi: true,
+      configureMcp: false,
+      configureModel: false,
+      configureAiMemory: false,
+      configureEnvPermission: false,
+      cleanEnvironment: true,
+      uninstall: false,
+      checkUpdates: false,
+      setupPresets: false
+    },
+    doctorChecks: [
+      "skill-purge-all",
+      "grok-auth-status"
+    ],
+    operatorActions: [
+      "save-ccjk-profile",
+      "launch-with-profile",
+      "clean-environment"
+    ]
+  }
+};
+
+const MANAGED_MCP_IDS = new Set(MCP_SERVICE_CONFIGS.map((service) => service.id.toLowerCase()));
+function skillDirsForTool(tool) {
+  if (tool === "agents")
+    return TOOL_MATRIX.clavue.skillsDirs.filter((dir) => dir.includes(".agents"));
+  if (tool === "grok")
+    return TOOL_MATRIX.grok.skillsDirs;
+  if (tool === "codex")
+    return TOOL_MATRIX.codex.skillsDirs;
+  if (tool === "claude")
+    return TOOL_MATRIX["claude-code"].skillsDirs.filter((dir) => !dir.includes(".agents"));
+  return [];
+}
+function scanSkillDirectory(baseDir, tool) {
+  const results = [];
+  if (!exists(baseDir))
+    return results;
+  for (const entry of readDir(baseDir)) {
+    const fullPath = join(baseDir, entry);
+    if (!isDirectory(fullPath))
+      continue;
+    const skillFile = join(fullPath, "SKILL.md");
+    if (!exists(skillFile)) {
+      results.push({
+        id: `skill:${tool}:${entry}:missing-skill-md`,
+        category: "skill",
+        tool,
+        label: entry,
+        path: fullPath,
+        reason: i18n.t("clean:reason.skillMissingFile"),
+        checked: true
+      });
+      continue;
+    }
+    const content = readFile(skillFile).trim();
+    if (content.length < 40) {
+      results.push({
+        id: `skill:${tool}:${entry}:empty-skill`,
+        category: "skill",
+        tool,
+        label: entry,
+        path: fullPath,
+        reason: i18n.t("clean:reason.skillEmpty"),
+        checked: true
+      });
+    }
+  }
+  return results;
+}
+function scanCodexMcpCandidates() {
+  const config = readCodexConfig();
+  if (!config?.mcpServices?.length)
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const service of config.mcpServices) {
+    const id = service.id.toLowerCase();
+    if (seen.has(id)) {
+      results.push({
+        id: `mcp:codex:${id}:duplicate`,
+        category: "mcp",
+        tool: "codex",
+        label: service.id,
+        configKey: service.id,
+        reason: i18n.t("clean:reason.mcpDuplicate"),
+        checked: true
+      });
+    }
+    seen.add(id);
+    const hasCommand = Boolean(service.command?.trim());
+    const hasUrl = Boolean(service.url?.trim());
+    if (!hasCommand && !hasUrl) {
+      results.push({
+        id: `mcp:codex:${id}:broken`,
+        category: "mcp",
+        tool: "codex",
+        label: service.id,
+        configKey: service.id,
+        reason: i18n.t("clean:reason.mcpBroken"),
+        checked: true
+      });
+      continue;
+    }
+    if (!MANAGED_MCP_IDS.has(id)) {
+      results.push({
+        id: `mcp:codex:${id}:unmanaged`,
+        category: "mcp",
+        tool: "codex",
+        label: service.id,
+        configKey: service.id,
+        reason: i18n.t("clean:reason.mcpUnmanaged"),
+        checked: true
+      });
+    }
+  }
+  if (config.mcpServices.length > 3) {
+    for (const service of config.mcpServices) {
+      const id = service.id.toLowerCase();
+      if (results.some((item) => item.configKey === service.id))
+        continue;
+      results.push({
+        id: `mcp:codex:${id}:bloat`,
+        category: "mcp",
+        tool: "codex",
+        label: service.id,
+        configKey: service.id,
+        reason: i18n.t("clean:reason.mcpBloat", { count: config.mcpServices.length }),
+        checked: false
+      });
+    }
+  }
+  return results;
+}
+function scanClaudeMcpCandidates() {
+  const config = readMcpConfig("claude-code");
+  if (!config?.mcpServers)
+    return [];
+  const results = [];
+  const entries = Object.entries(config.mcpServers);
+  if (entries.length > 3) {
+    for (const [name] of entries) {
+      results.push({
+        id: `mcp:claude:${name}:bloat`,
+        category: "mcp",
+        tool: "claude",
+        label: name,
+        configKey: name,
+        reason: i18n.t("clean:reason.mcpBloat", { count: entries.length }),
+        checked: false
+      });
+    }
+  }
+  for (const [name, server] of entries) {
+    const hasCommand = Boolean(server.command?.trim());
+    const hasUrl = Boolean(server.url?.trim());
+    if (!hasCommand && !hasUrl) {
+      results.push({
+        id: `mcp:claude:${name}:broken`,
+        category: "mcp",
+        tool: "claude",
+        label: name,
+        configKey: name,
+        reason: i18n.t("clean:reason.mcpBroken"),
+        checked: true
+      });
+      continue;
+    }
+    if (!MANAGED_MCP_IDS.has(name.toLowerCase())) {
+      const already = results.some((item) => item.configKey === name);
+      if (!already) {
+        results.push({
+          id: `mcp:claude:${name}:unmanaged`,
+          category: "mcp",
+          tool: "claude",
+          label: name,
+          configKey: name,
+          reason: i18n.t("clean:reason.mcpUnmanaged"),
+          checked: true
+        });
+      }
+    }
+  }
+  return results;
+}
+function scanCodexPromptCandidates() {
+  if (!exists(CODEX_PROMPTS_DIR))
+    return [];
+  return readDir(CODEX_PROMPTS_DIR).filter((file) => file.endsWith(".md")).map((file) => {
+    const fullPath = join(CODEX_PROMPTS_DIR, file);
+    return {
+      id: `prompt:codex:${file}`,
+      category: "prompt",
+      tool: "codex",
+      label: file,
+      path: fullPath,
+      reason: i18n.t("clean:reason.promptInstalled"),
+      checked: false
+    };
+  });
+}
+function scanAllSkillDirectories(baseDir, tool) {
+  if (!exists(baseDir))
+    return [];
+  const results = [];
+  for (const entry of readDir(baseDir)) {
+    if (entry === "." || entry === "..")
+      continue;
+    const fullPath = join(baseDir, entry);
+    if (!isDirectory(fullPath))
+      continue;
+    results.push({
+      id: `skill:${tool}:${entry}:all`,
+      category: "skill",
+      tool,
+      label: entry,
+      path: fullPath,
+      reason: i18n.t("clean:reason.skillPurgeAll"),
+      checked: true
+    });
+  }
+  return results;
+}
+function scanAgentsFileCandidates() {
+  const files = [
+    CODEX_AGENTS_FILE,
+    join(TOOL_MATRIX.codex.configRoot, "AGENTS.override.md")
+  ];
+  const results = [];
+  for (const filePath of files) {
+    if (!exists(filePath))
+      continue;
+    const name = filePath.split("/").pop() || filePath;
+    results.push({
+      id: `agents-file:codex:${name}`,
+      category: "agents-file",
+      tool: "codex",
+      label: name,
+      path: filePath,
+      reason: i18n.t("clean:reason.agentsFileStale"),
+      checked: true
+    });
+  }
+  return results;
+}
+function scanAllCodexMcpCandidates() {
+  const parsedIds = new Set(
+    (readCodexConfig()?.mcpServices || []).map((service) => service.id.toLowerCase())
+  );
+  const rawIds = listCodexMcpServiceIds();
+  const ids = /* @__PURE__ */ new Set();
+  for (const id of rawIds)
+    ids.add(id);
+  for (const id of parsedIds)
+    ids.add(id);
+  return Array.from(ids).map((id) => ({
+    id: `mcp:codex:${id.toLowerCase()}:all`,
+    category: "mcp",
+    tool: "codex",
+    label: id,
+    configKey: id,
+    reason: parsedIds.has(id.toLowerCase()) ? i18n.t("clean:reason.mcpPurgeAll") : i18n.t("clean:reason.mcpOrphan"),
+    checked: true
+  }));
+}
+function scanAllClaudeMcpCandidates() {
+  const config = readMcpConfig("claude-code");
+  if (!config?.mcpServers)
+    return [];
+  return Object.keys(config.mcpServers).map((name) => ({
+    id: `mcp:claude:${name}:all`,
+    category: "mcp",
+    tool: "claude",
+    label: name,
+    configKey: name,
+    reason: i18n.t("clean:reason.mcpPurgeAll"),
+    checked: true
+  }));
+}
+function scanPurgeAllEnvironment() {
+  ensureI18nInitialized();
+  const candidates = [
+    ...scanAllCodexMcpCandidates(),
+    ...scanAllClaudeMcpCandidates(),
+    ...scanAllSkillDirectories(skillDirsForTool("codex")[0], "codex"),
+    ...skillDirsForTool("claude").flatMap((dir) => scanAllSkillDirectories(dir, "claude")),
+    ...skillDirsForTool("agents").flatMap((dir) => scanAllSkillDirectories(dir, "agents")),
+    ...skillDirsForTool("grok").flatMap((dir) => scanAllSkillDirectories(dir, "grok")),
+    ...scanCodexPromptCandidates().map((item) => ({ ...item, checked: true, reason: i18n.t("clean:reason.promptPurgeAll") })),
+    ...scanAgentsFileCandidates()
+  ];
+  const unique = /* @__PURE__ */ new Map();
+  for (const item of candidates)
+    unique.set(item.id, item);
+  return { candidates: Array.from(unique.values()) };
+}
+const SCAN_SECTION_KEYS = {
+  mcp: "hub:doctor.scanSection.mcp",
+  skill: "hub:doctor.scanSection.skill",
+  prompt: "hub:doctor.scanSection.prompt",
+  "agents-file": "hub:doctor.scanSection.agents",
+  config: "hub:doctor.scanSection.config"
+};
+function scanCodexConfigCandidates() {
+  const findings = scanCodexConfigDoctorFindings();
+  return findings.filter((finding) => finding.severity === "warn").map((finding) => {
+    const label = finding.messageParams ? i18n.t(finding.messageKey, finding.messageParams) : i18n.t(finding.messageKey);
+    return {
+      id: `config:codex:${finding.id}`,
+      category: "config",
+      tool: "codex",
+      label,
+      reason: i18n.t("clean:reason.configDoctor"),
+      checked: true
+    };
+  });
+}
+function printCodexRuntimeStatus() {
+  ensureI18nInitialized();
+  const summary = detectCodexRuntimes();
+  console.log(ansis.white(`  ${i18n.t("hub:doctor.scanSection.runtime")}`));
+  console.log(ansis.gray(`    ${i18n.t("codex:runtime.sharedConfig", { path: summary.configHome })}`));
+  if (summary.configHomeFromEnv)
+    console.log(ansis.gray(`    ${i18n.t("codex:runtime.codexHomeEnv")}`));
+  for (const runtime of summary.runtimes) {
+    const label = i18n.t(`codex:runtime.kind.${runtime.kind}`);
+    if (!runtime.detected) {
+      console.log(ansis.dim(`    ${label}: ${i18n.t("codex:runtime.notDetected")}`));
+      continue;
+    }
+    const pathText = runtime.path ? ansis.gray(` (${runtime.path})`) : "";
+    const weak = runtime.weakSignal ? ansis.yellow(` \u2014 ${i18n.t("codex:runtime.weakDesktopSignal")}`) : "";
+    console.log(`    ${label}: ${ansis.green(i18n.t("codex:runtime.detected"))}${pathText}${weak}`);
+  }
+  console.log("");
+}
+function printEnvironmentScanReport() {
+  ensureI18nInitialized();
+  const smart = scanEnvironmentIssues(false).candidates;
+  const all = scanEnvironmentIssues(true).candidates;
+  const configFindings = scanCodexConfigCandidates();
+  console.log(ansis.cyan(`
+${i18n.t("hub:doctor.scanReport")}
+`));
+  printCodexRuntimeStatus();
+  console.log(ansis.gray(`  ${i18n.t("hub:doctor.scanHint", { smart: smart.length, all: all.length })}
+`));
+  if (configFindings.length > 0) {
+    console.log(ansis.white(`  ${i18n.t("hub:doctor.scanSection.config")} (${configFindings.length})`));
+    for (const item of configFindings)
+      console.log(`    ${ansis.yellow("[codex]")} ${item.label}`);
+    console.log("");
+  }
+  if (smart.length === 0 && configFindings.length === 0) {
+    console.log(ansis.green(`  ${i18n.t("clean:nothingFound")}
+`));
+    return false;
+  }
+  if (smart.length === 0) {
+    console.log(ansis.green(`  ${i18n.t("clean:nothingFound")}
+`));
+    return configFindings.length > 0;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const item of smart) {
+    const list = grouped.get(item.category) || [];
+    list.push(item);
+    grouped.set(item.category, list);
+  }
+  for (const [category, items] of grouped) {
+    console.log(ansis.white(`  ${i18n.t(SCAN_SECTION_KEYS[category])} (${items.length})`));
+    for (const item of items) {
+      console.log(
+        `    ${ansis.cyan(`[${item.tool}]`)} ${item.label} ${ansis.gray(`\u2014 ${item.reason}`)}`
+      );
+    }
+    console.log("");
+  }
+  return true;
+}
+function scanEnvironmentIssues(purgeAll = false) {
+  ensureI18nInitialized();
+  if (purgeAll)
+    return scanPurgeAllEnvironment();
+  const candidates = [
+    ...scanCodexMcpCandidates(),
+    ...scanClaudeMcpCandidates(),
+    ...skillDirsForTool("agents").flatMap((dir) => scanSkillDirectory(dir, "agents")),
+    ...skillDirsForTool("claude").flatMap((dir) => scanSkillDirectory(dir, "claude")),
+    ...skillDirsForTool("codex").flatMap((dir) => scanSkillDirectory(dir, "codex")),
+    ...scanCodexPromptCandidates()
+  ];
+  const unique = /* @__PURE__ */ new Map();
+  for (const item of candidates)
+    unique.set(item.id, item);
+  return { candidates: Array.from(unique.values()) };
+}
+async function removeCodexMcp(serviceId) {
+  deleteCodexMcpService(serviceId);
+}
+async function removeClaudeMcp(serviceId) {
+  const config = readMcpConfig("claude-code");
+  if (!config?.mcpServers?.[serviceId])
+    return;
+  const next = { ...config, mcpServers: { ...config.mcpServers } };
+  delete next.mcpServers[serviceId];
+  writeMcpConfig(next, "claude-code");
+}
+async function executeCleanup(selected, options = {}) {
+  const removed = [];
+  const errors = [];
+  const backupPath = backupCodexComplete();
+  if (backupPath)
+    console.log(ansis.gray(getBackupMessage(backupPath)));
+  const codexMcpItems = selected.filter((item) => item.category === "mcp" && item.tool === "codex");
+  if (options.purgeAllMcp && codexMcpItems.length > 0) {
+    try {
+      deleteAllCodexMcpServices();
+      for (const item of codexMcpItems)
+        removed.push(`codex MCP: ${item.label}`);
+    } catch (error) {
+      errors.push(`codex MCP: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  for (const item of selected) {
+    if (options.purgeAllMcp && item.category === "mcp" && item.tool === "codex")
+      continue;
+    try {
+      if (item.category === "mcp" && item.configKey) {
+        if (item.tool === "codex")
+          await removeCodexMcp(item.configKey);
+        else if (item.tool === "claude")
+          await removeClaudeMcp(item.configKey);
+        removed.push(`${item.tool} MCP: ${item.label}`);
+      } else if ((item.category === "skill" || item.category === "prompt" || item.category === "agents-file") && item.path) {
+        const result = await moveToTrash(item.path);
+        if (result[0]?.success)
+          removed.push(`${item.category === "agents-file" ? "AGENTS" : item.category}: ${item.label}`);
+        else
+          errors.push(result[0]?.error || item.path);
+      }
+    } catch (error) {
+      errors.push(`${item.label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return { removed, errors };
+}
+function resolveCodeTool() {
+  const config = readCcjkConfig();
+  if (config?.codeToolType === "claude-code" || config?.codeToolType === "codex")
+    return config.codeToolType;
+  return "codex";
+}
+async function runEnvironmentCleanup(options = {}) {
+  ensureI18nInitialized();
+  void resolveCodeTool();
+  void options.codeToolType;
+  if (options.purgeAll && !options.skipPrompt) {
+    console.log(ansis.yellow(`
+${i18n.t("clean:purgeAllWarning")}
+`));
+  }
+  const { candidates } = scanEnvironmentIssues(options.purgeAll);
+  if (candidates.length === 0) {
+    console.log(ansis.green(i18n.t("clean:nothingFound")));
+    return { removed: [], errors: [] };
+  }
+  let selected = candidates;
+  if (options.aggressive)
+    selected = candidates;
+  if (!options.skipPrompt) {
+    console.log(ansis.cyan(`
+${i18n.t("clean:scanSummary", { count: candidates.length })}
+`));
+    const { picked } = await inquirer.prompt({
+      type: "checkbox",
+      name: "picked",
+      message: `${i18n.t("clean:selectItems")}${i18n.t("common:multiSelectHint")}`,
+      choices: addNumbersToChoices(candidates.map((item) => ({
+        name: `${ansis.cyan(`[${item.tool}]`)} ${item.label} - ${ansis.gray(item.reason)}`,
+        value: item.id,
+        checked: options.purgeAll || options.aggressive ? true : item.checked
+      })))
+    });
+    if (!picked?.length) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      return { removed: [], errors: [] };
+    }
+    selected = candidates.filter((item) => picked.includes(item.id));
+    const { confirmed } = await inquirer.prompt({
+      type: "confirm",
+      name: "confirmed",
+      message: i18n.t("clean:confirmCleanup", { count: selected.length }),
+      default: false
+    });
+    if (!confirmed) {
+      console.log(ansis.yellow(i18n.t("common:cancelled")));
+      return { removed: [], errors: [] };
+    }
+  } else if (options.purgeAll || options.aggressive) {
+    selected = candidates;
+  } else {
+    selected = candidates.filter((item) => item.checked);
+  }
+  const result = await executeCleanup(selected, { purgeAllMcp: options.purgeAll });
+  if (result.removed.length > 0) {
+    console.log(ansis.green(`
+${i18n.t("clean:cleanupDone", { count: result.removed.length })}`));
+    for (const line of result.removed)
+      console.log(ansis.gray(`  \u2714 ${line}`));
+  }
+  if (result.errors.length > 0) {
+    console.log(ansis.red(`
+${i18n.t("clean:cleanupErrors", { count: result.errors.length })}`));
+    for (const line of result.errors)
+      console.log(ansis.red(`  \u2717 ${line}`));
+  }
+  return result;
+}
+
+async function cleanCommand(options = {}) {
+  ensureI18nInitialized();
+  const codeToolType = options.codeType ? resolveCodeToolType$1(options.codeType) : void 0;
+  await runEnvironmentCleanup({
+    codeToolType,
+    skipPrompt: options.skipPrompt,
+    aggressive: options.aggressive,
+    purgeAll: options.purgeAll
+  });
+}
+
+const TIMEOUT_MS = 1e4;
+const EXIT_CODE = {
+  ok: 0,
+  "auth-failed": 1,
+  unreachable: 2,
+  unexpected: 3
+};
+async function probeCommand(opts = {}) {
+  const creds = readActiveApiCreds();
+  if (!creds.baseUrl) {
+    throw new Error("\u672A\u627E\u5230 API \u914D\u7F6E\uFF0C\u8BF7\u5148\u8FD0\u884C ccjk init \u6216\u83DC\u5355 3 \u914D\u7F6E API");
+  }
+  const result = await runProbe(creds.baseUrl, creds.apiKey, creds.authToken);
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    const color = result.status === "ok" ? ansis.green : ansis.red;
+    console.log(`
+\u63A2\u6D3B ${creds.baseUrl}`);
+    console.log(color(`  \u72B6\u6001: ${result.status}`));
+    if (result.httpStatus) console.log(ansis.dim(`  HTTP: ${result.httpStatus}`));
+    if (result.latencyMs) console.log(ansis.dim(`  \u5EF6\u8FDF: ${result.latencyMs}ms`));
+    if (result.error) console.log(ansis.dim(`  \u9519\u8BEF: ${result.error}`));
+    console.log();
+  }
+  process.exitCode = EXIT_CODE[result.status];
+}
+function readActiveApiCreds() {
+  const tool = readCcjkConfig()?.codeToolType ?? "clavue";
+  const file = activeSettingsFile(tool === "codex" || tool === "grok" ? "claude-code" : tool);
+  const settings = readJsonConfig(file) || {};
+  const env = settings.env || {};
+  return {
+    baseUrl: env.ANTHROPIC_BASE_URL || "",
+    apiKey: env.ANTHROPIC_API_KEY || "",
+    authToken: env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || ""
+  };
+}
+async function runProbe(baseUrl, apiKey, authToken) {
+  const url = `${baseUrl.replace(/\/$/, "")}/v1/messages`;
+  const headers = {
+    "content-type": "application/json",
+    "anthropic-version": "2023-06-01"
+  };
+  if (authToken) headers.authorization = `Bearer ${authToken}`;
+  else if (apiKey) headers["x-api-key"] = apiKey;
+  const body = JSON.stringify({
+    model: "claude-3-5-haiku-20241022",
+    max_tokens: 1,
+    messages: [{ role: "user", content: "ping" }]
+  });
+  const t0 = Date.now();
+  try {
+    const res = await fetch(url, { method: "POST", headers, body, signal: AbortSignal.timeout(TIMEOUT_MS) });
+    const latencyMs = Date.now() - t0;
+    if (res.status === 401 || res.status === 403) {
+      return { baseUrl, status: "auth-failed", httpStatus: res.status, latencyMs };
+    }
+    if (res.ok) return { baseUrl, status: "ok", httpStatus: res.status, latencyMs };
+    return { baseUrl, status: "unexpected", httpStatus: res.status, latencyMs };
+  } catch (e) {
+    return { baseUrl, status: "unreachable", error: e.message, latencyMs: Date.now() - t0 };
+  }
+}
+
+async function runDoctorHub(tool) {
+  ensureI18nInitialized();
+  const supportsProbe = tool !== "grok";
+  let exitHub = false;
+  while (!exitHub) {
+    console.log(ansis.cyan(`
+${i18n.t("hub:doctor.title")}`));
+    console.log(ansis.gray(`  ${i18n.t("hub:doctor.subtitle")}`));
+    console.log(ansis.dim(`  ${TOOL_MATRIX[tool].displayName}
+`));
+    if (tool === "codex")
+      printCodexRuntimeStatus();
+    const choices = addNumbersToChoices([
+      {
+        name: `${i18n.t("hub:doctor.scanReport")} \u2014 ${ansis.gray(i18n.t("hub:doctor.scanReportDesc"))}`,
+        value: "scan",
+        short: i18n.t("hub:doctor.scanReport")
+      },
+      ...supportsProbe ? [{
+        name: i18n.t("hub:doctor.probeApi"),
+        value: "probe",
+        short: i18n.t("hub:doctor.probeApi")
+      }] : [],
+      {
+        name: `${i18n.t("hub:doctor.smartClean")} \u2014 ${ansis.gray(i18n.t("hub:doctor.smartCleanDesc"))}`,
+        value: "smart",
+        short: i18n.t("hub:doctor.smartClean")
+      },
+      {
+        name: `${i18n.t("hub:doctor.purgeAll")} \u2014 ${ansis.gray(i18n.t("hub:doctor.purgeAllDesc"))}`,
+        value: "purge",
+        short: i18n.t("hub:doctor.purgeAll")
+      },
+      {
+        name: i18n.t("common:back"),
+        value: "back",
+        short: i18n.t("common:back")
+      }
+    ]);
+    const { action } = await inquirer.prompt({
+      type: "list",
+      name: "action",
+      message: i18n.t("menu:selectFunction"),
+      choices
+    });
+    switch (action) {
+      case "scan":
+        printEnvironmentScanReport();
+        break;
+      case "probe":
+        await probeCommand();
+        break;
+      case "smart":
+        await cleanCommand({ codeType: tool });
+        break;
+      case "purge":
+        await cleanCommand({ codeType: tool, purgeAll: true });
+        break;
+      case "back":
+        exitHub = true;
+        break;
+    }
+  }
+}
+
+function resolveCodeToolType(optionValue, savedValue) {
+  if (optionValue !== void 0) {
+    const resolved = resolveCodeToolType$1(optionValue);
+    if (resolved !== DEFAULT_CODE_TOOL_TYPE || optionValue === DEFAULT_CODE_TOOL_TYPE) {
+      return resolved;
+    }
+  }
+  if (savedValue && isCodeToolType(savedValue)) {
+    return savedValue;
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+async function update(options = {}) {
+  try {
+    if (!options.skipBanner) {
+      displayBanner(i18n.t("cli:banner.updateSubtitle"));
+    }
+    const ccjkConfig = readCcjkConfig();
+    const codeToolType = resolveCodeToolType(options.codeType, ccjkConfig?.codeToolType);
+    options.codeType = codeToolType;
+    if (codeToolType === "codex") {
+      await runCodexUpdate();
+      const newPreferredLang = options.configLang || ccjkConfig?.preferredLang;
+      if (newPreferredLang) {
+        updateCcjkConfig({
+          version,
+          preferredLang: newPreferredLang,
+          codeToolType
+        });
+      } else {
+        updateCcjkConfig({
+          version,
+          codeToolType
+        });
+      }
+      return;
+    }
+    const { resolveTemplateLanguage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bN; });
+    const configLang = await resolveTemplateLanguage(
+      options.configLang,
+      // Command line option
+      ccjkConfig,
+      options.skipPrompt
+      // Non-interactive mode flag
+    );
+    const aiOutputLang = await resolveAiOutputLanguage(i18n.language, options.aiOutputLang, ccjkConfig, options.skipPrompt);
+    const runtimeLabel = isClaudeFamilyCodeTool(codeToolType) ? getClaudeFamilyRuntimeLabel(codeToolType) : "Claude Code";
+    console.log(ansis.cyan(`
+${i18n.t("configuration:updatingPrompts", { runtime: runtimeLabel })}
+`));
+    await updatePromptOnly(aiOutputLang);
+    await selectAndInstallWorkflows(configLang, void 0, { codeToolType: isClaudeFamilyCodeTool(codeToolType) ? codeToolType : "claude-code" });
+    if (codeToolType === "claude-code") {
+      await checkClaudeCodeVersionAndPrompt(false);
+    }
+    updateCcjkConfig({
+      version,
+      templateLang: configLang,
+      // 保存模板语言选择
+      aiOutputLang,
+      codeToolType
+    });
+  } catch (error) {
+    if (!handleExitPromptError(error)) {
+      handleGeneralError(error);
+    }
+  }
+}
+
+const LEGACY_PROFILES_DIR = join(homedir(), ".ccjk", "profiles");
+function fromClaudeProfile(profile) {
+  return {
+    name: profile.name,
+    baseUrl: profile.baseUrl,
+    apiKey: profile.apiKey,
+    model: profile.primaryModel
+  };
+}
+function readLegacyJsonProfile(name) {
+  const profilePath = join(LEGACY_PROFILES_DIR, `${name}.json`);
+  if (!existsSync(profilePath)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(readFileSync(profilePath, "utf-8"));
+    return data.name ? data : { ...data, name };
+  } catch {
+    return null;
+  }
+}
+function readCcjkProfileByName(name) {
+  const byName = ClaudeCodeConfigManager.getProfileByName(name);
+  if (byName) {
+    return fromClaudeProfile(byName);
+  }
+  const byId = ClaudeCodeConfigManager.getProfileById(name);
+  if (byId) {
+    return fromClaudeProfile(byId);
+  }
+  return readLegacyJsonProfile(name);
+}
+function listCcjkProfileNames() {
+  return ClaudeCodeConfigManager.listProfiles().map((profile) => profile.name);
+}
+
+const GROK_AUTH_FILE = join(homedir(), ".grok", "auth.json");
+function isGrokInstalled() {
+  try {
+    execSync("command -v grok", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGrokLoggedIn() {
+  if (!existsSync(GROK_AUTH_FILE)) return false;
+  try {
+    const data = JSON.parse(readFileSync(GROK_AUTH_FILE, "utf-8"));
+    return Object.keys(data).some((k) => k.includes("auth.x.ai"));
+  } catch {
+    return false;
+  }
+}
+function getGrokQuickStatus() {
+  if (!isGrokInstalled()) {
+    return {
+      installed: false,
+      loggedIn: false,
+      hint: "\u672A\u5B89\u88C5\uFF1Acurl -fsSL https://x.ai/cli/install.sh | bash"
+    };
+  }
+  const loggedIn = isGrokLoggedIn();
+  return {
+    installed: true,
+    loggedIn,
+    hint: loggedIn ? "\u5DF2\u767B\u5F55\uFF08OAuth\uFF0C~/.grok/auth.json\uFF09" : "\u672A\u767B\u5F55\uFF0C\u8FD0\u884C `grok login`"
+  };
+}
+function buildGrokHints() {
+  const s = getGrokQuickStatus();
+  const lines = [];
+  if (!s.installed) {
+    lines.push(ansis.dim("  \u5B89\u88C5: ") + ansis.cyan("curl -fsSL https://x.ai/cli/install.sh | bash"));
+    return lines;
+  }
+  if (!s.loggedIn) {
+    lines.push(ansis.yellow("  \u767B\u5F55: ") + ansis.cyan("grok login"));
+  }
+  lines.push(ansis.dim("  \u542F\u52A8: ") + ansis.cyan("grok"));
+  lines.push(ansis.dim("  \u6A21\u578B: ") + ansis.cyan("grok models"));
+  return lines;
+}
+
+async function grokCommand(profileName) {
+  if (profileName) {
+    await launchWithProfile$1(profileName);
+    return;
+  }
+  const status = getGrokQuickStatus();
+  console.log(ansis.bold("\nGrok CLI"));
+  console.log(`  \u5B89\u88C5: ${status.installed ? ansis.green("\u662F") : ansis.gray("\u5426")}  \u767B\u5F55: ${status.loggedIn ? ansis.green("\u662F") : ansis.yellow("\u5426")}`);
+  for (const line of buildGrokHints()) console.log(line);
+  const names = listCcjkProfileNames();
+  if (names.length > 0) {
+    console.log(ansis.dim(`
+  \u53EF\u7528 profile: ${names.join(", ")}`));
+  }
+  console.log(ansis.dim("  ccjk grok <profile> \u2014 \u7528 ~/.ccjk/config.toml \u4E2D\u7684 profile \u542F\u52A8\n"));
+}
+async function launchWithProfile$1(name) {
+  const profile = readCcjkProfileByName(name);
+  if (!profile) {
+    console.log(ansis.red(`Profile "${name}" \u4E0D\u5B58\u5728`));
+    console.log(ansis.dim("  \u5148\u8FD0\u884C ccjk init -T grok \u6216\u83DC\u5355\u914D\u7F6E API\uFF08profile \u4FDD\u5B58\u5728 ~/.ccjk/config.toml\uFF09\n"));
+    return;
+  }
+  const env = { ...process.env };
+  if (profile.baseUrl) {
+    env.OPENAI_BASE_URL = profile.baseUrl;
+    env.ANTHROPIC_BASE_URL = profile.baseUrl;
+  }
+  if (profile.apiKey) {
+    env.OPENAI_API_KEY = profile.apiKey;
+    env.ANTHROPIC_API_KEY = profile.apiKey;
+    env.ANTHROPIC_AUTH_TOKEN = profile.apiKey;
+  }
+  console.log(ansis.cyan(`
+\u4F7F\u7528 profile "${name}" \u542F\u52A8 grok...
+`));
+  const res = spawnSync("grok", [], { stdio: "inherit", env });
+  if (res.error) console.log(ansis.red(`\u542F\u52A8\u5931\u8D25: ${res.error.message}`));
+}
+
+function line(key, labelKey, descKey) {
+  return { key, labelKey, descKey };
+}
+const CROSS_TOOL_LINES = [
+  line("g", "menu:menuOptions.grokCrossTool", "menu:menuDescriptions.grokCrossTool"),
+  line("x", "menu:menuOptions.reasonixCrossTool", "menu:menuDescriptions.reasonixCrossTool")
+];
+const DOCTOR_HUB = line("h", "menu:menuOptions.doctorHub", "menu:menuDescriptions.doctorHub");
+const OPERATOR_HUB = line("w", "menu:menuOptions.operatorHub", "menu:menuDescriptions.operatorHub");
+const CLAUDE_FAMILY_OPERATOR = [
+  line("1", "menu:menuOptions.fullInit", "menu:menuDescriptions.fullInit"),
+  line("2", "menu:menuOptions.importWorkflow", "menu:menuDescriptions.importWorkflow"),
+  line("3", "menu:menuOptions.configureApiOrCcr", "menu:menuDescriptions.configureApiOrCcr"),
+  line("4", "menu:menuOptions.configureMcp", "menu:menuDescriptions.configureMcp"),
+  line("5", "menu:menuOptions.configureModel", "menu:menuDescriptions.configureModel"),
+  line("6", "menu:menuOptions.configureAiMemory", "menu:menuDescriptions.configureAiMemory"),
+  line("7", "menu:menuOptions.configureEnvPermission", "menu:menuDescriptions.configureEnvPermission")
+];
+const TOOL_MENU_LAYOUTS = {
+  clavue: {
+    toolLabelKey: "menu:toolHeaders.clavue",
+    operatorLines: [
+      line("1", "menu:menuOptions.clavueFullInit", "menu:menuDescriptions.clavueFullInit"),
+      line("2", "menu:menuOptions.clavueUpdateWorkflow", "menu:menuDescriptions.clavueUpdateWorkflow"),
+      line("3", "menu:menuOptions.clavueConfigureApi", "menu:menuDescriptions.clavueConfigureApi"),
+      line("4", "menu:menuOptions.clavueConfigureMcp", "menu:menuDescriptions.clavueConfigureMcp"),
+      line("5", "menu:menuOptions.clavueConfigureModel", "menu:menuDescriptions.clavueConfigureModel"),
+      line("6", "menu:menuOptions.clavueConfigureAiMemory", "menu:menuDescriptions.clavueConfigureAiMemory"),
+      line("7", "menu:menuOptions.clavueConfigureEnvPermission", "menu:menuDescriptions.clavueConfigureEnvPermission")
+    ],
+    doctorLines: [DOCTOR_HUB],
+    ccjkUninstallKey: "menu:menuOptions.clavueUninstall",
+    ccjkUninstallDescKey: "menu:menuDescriptions.clavueUninstall",
+    ccjkUpdateKey: "menu:menuOptions.clavueCheckUpdates",
+    ccjkUpdateDescKey: "menu:menuDescriptions.clavueCheckUpdates"
+  },
+  "claude-code": {
+    toolLabelKey: "menu:toolHeaders.claudeCode",
+    operatorLines: CLAUDE_FAMILY_OPERATOR,
+    doctorLines: [DOCTOR_HUB],
+    ccjkUninstallKey: "menu:menuOptions.uninstall",
+    ccjkUninstallDescKey: "menu:menuDescriptions.uninstall",
+    ccjkUpdateKey: "menu:menuOptions.checkUpdates",
+    ccjkUpdateDescKey: "menu:menuDescriptions.checkUpdates"
+  },
+  codex: {
+    toolLabelKey: "menu:toolHeaders.codex",
+    operatorLines: [
+      line("1", "menu:menuOptions.codexFullInit", "menu:menuDescriptions.codexFullInitWithPreset"),
+      line("2", "menu:menuOptions.codexImportWorkflow", "menu:menuDescriptions.codexImportWorkflow"),
+      line("3", "menu:menuOptions.codexConfigureApi", "menu:menuDescriptions.codexConfigureApi"),
+      line("4", "menu:menuOptions.codexConfigureMcp", "menu:menuDescriptions.codexConfigureMcp"),
+      line("5", "menu:menuOptions.codexConfigureModel", "menu:menuDescriptions.codexConfigureModel"),
+      line("6", "menu:menuOptions.codexConfigureAiMemory", "menu:menuDescriptions.codexConfigureAiMemory")
+    ],
+    doctorLines: [DOCTOR_HUB],
+    ccjkUninstallKey: "menu:menuOptions.codexUninstall",
+    ccjkUninstallDescKey: "menu:menuDescriptions.codexUninstall",
+    ccjkUpdateKey: "menu:menuOptions.codexCheckUpdates",
+    ccjkUpdateDescKey: "menu:menuDescriptions.codexCheckUpdates"
+  },
+  grok: {
+    toolLabelKey: "menu:toolHeaders.grok",
+    operatorLines: [
+      line("1", "menu:menuOptions.grokInit", "menu:menuDescriptions.grokInit"),
+      line("2", "menu:menuOptions.grokStatus", "menu:menuDescriptions.grokStatus")
+    ],
+    doctorLines: [DOCTOR_HUB],
+    ccjkUninstallKey: "menu:menuOptions.uninstall",
+    ccjkUninstallDescKey: "menu:menuDescriptions.uninstall",
+    ccjkUpdateKey: "menu:menuOptions.checkUpdates",
+    ccjkUpdateDescKey: "menu:menuDescriptions.checkUpdates"
+  }
+};
+function shortenHomePath(path) {
+  const home = homedir();
+  if (path.startsWith(home))
+    return `~${path.slice(home.length)}`;
+  return path;
+}
+function formatChoiceLabel(item) {
+  return `${item.key.toUpperCase()}. ${i18n.t(item.labelKey)} ${ansis.gray(`\u2014 ${i18n.t(item.descKey)}`)}`;
+}
+function sectionSeparator(titleKey) {
+  return {
+    name: ansis.dim(`\u2500\u2500 ${i18n.t(titleKey)} \u2500\u2500`),
+    value: `__section_${titleKey}`,
+    disabled: true
+  };
+}
+function buildMenuListChoices(tool) {
+  const layout = TOOL_MENU_LAYOUTS[tool];
+  const choices = [
+    sectionSeparator("menu:menuSections.operator"),
+    {
+      name: formatChoiceLabel(OPERATOR_HUB),
+      value: OPERATOR_HUB.key
+    },
+    ...layout.operatorLines.map((item) => ({
+      name: formatChoiceLabel(item),
+      value: item.key
+    })),
+    sectionSeparator("menu:menuSections.doctor"),
+    ...layout.doctorLines.map((item) => ({
+      name: formatChoiceLabel(item),
+      value: item.key
+    })),
+    sectionSeparator("menu:menuSections.crossTool"),
+    ...CROSS_TOOL_LINES.map((item) => ({
+      name: formatChoiceLabel(item),
+      value: item.key
+    })),
+    sectionSeparator("menu:menuSections.ccjk"),
+    {
+      name: formatChoiceLabel(line("0", "menu:menuOptions.changeLanguage", "menu:menuDescriptions.changeLanguage")),
+      value: "0"
+    },
+    {
+      name: formatChoiceLabel(line("s", "menu:menuOptions.switchCodeTool", "menu:menuDescriptions.switchCodeTool")),
+      value: "s"
+    },
+    {
+      name: formatChoiceLabel(line("-", layout.ccjkUninstallKey, layout.ccjkUninstallDescKey)),
+      value: "-"
+    },
+    {
+      name: formatChoiceLabel(line("+", layout.ccjkUpdateKey, layout.ccjkUpdateDescKey)),
+      value: "+"
+    },
+    {
+      name: `${ansis.red("Q.")} ${ansis.red(i18n.t("menu:menuOptions.exit"))}`,
+      value: "q"
+    }
+  ];
+  return choices;
+}
+function printToolMenuHeader(tool) {
+  const entry = TOOL_MATRIX[tool];
+  const layout = TOOL_MENU_LAYOUTS[tool];
+  const configRoot = shortenHomePath(entry.configRoot);
+  const roles = entry.roles.includes("both") ? i18n.t("menu:roleBadge.both") : entry.roles.includes("doctor") ? i18n.t("menu:roleBadge.doctor") : i18n.t("menu:roleBadge.operator");
+  console.log(ansis.dim(`
+  ${i18n.t("menu:tagline")}`));
+  console.log(
+    ansis.white(
+      `  ${i18n.t(layout.toolLabelKey)}  ${ansis.dim("|")}  ${ansis.gray(i18n.t("menu:configRoot", { path: configRoot }))}  ${ansis.dim("|")}  ${roles}`
+    )
+  );
+  console.log("");
+}
+function getToolMenuLayout(tool) {
+  return TOOL_MENU_LAYOUTS[tool];
+}
+
+async function finishCodexOperatorAction() {
+  printCodexReloadHint();
+}
+async function promptTuneSingle(tool) {
+  const layout = getToolMenuLayout(tool);
+  const tuneLines = layout.operatorLines.filter((line) => !["1", "2"].includes(line.key));
+  const { picked } = await inquirer.prompt({
+    type: "list",
+    name: "picked",
+    message: i18n.t("hub:operator.pickTune"),
+    choices: addNumbersToChoices(tuneLines.map((line) => ({
+      name: `${i18n.t(line.labelKey)} \u2014 ${ansis.gray(i18n.t(line.descKey))}`,
+      value: line.key,
+      short: i18n.t(line.labelKey)
+    })))
+  });
+  if (tool === "codex") {
+    switch (picked) {
+      case "3":
+        await configureCodexApi();
+        break;
+      case "4":
+        await manageCodexMcp();
+        break;
+      case "5":
+        await configureCodexDefaultModelFeature();
+        break;
+      case "6":
+        await configureCodexAiMemoryFeature();
+        break;
+    }
+    await finishCodexOperatorAction();
+    return;
+  }
+  if (tool === "clavue" || tool === "claude-code") {
+    switch (picked) {
+      case "3":
+        await configureApiFeature();
+        break;
+      case "4":
+        await configureMcpFeature();
+        break;
+      case "5":
+        await configureDefaultModelFeature();
+        break;
+      case "6":
+        await configureAiMemoryFeature();
+        break;
+      case "7":
+        await configureEnvPermissionFeature();
+        break;
+    }
+  }
+}
+async function runCodexFreshStart() {
+  const { confirmed } = await inquirer.prompt({
+    type: "confirm",
+    name: "confirmed",
+    message: i18n.t("hub:operator.freshStartConfirm"),
+    default: false
+  });
+  if (!confirmed) {
+    console.log(ansis.yellow(i18n.t("common:cancelled")));
+    return;
+  }
+  await cleanCommand({ codeType: "codex", purgeAll: true, skipPrompt: true });
+  const { applyCodexSetupPreset, getCodexPresetChoices } = await import('./chunks/codex-presets.mjs');
+  const { preset } = await inquirer.prompt({
+    type: "list",
+    name: "preset",
+    message: i18n.t("codex:preset.selectPrompt"),
+    choices: addNumbersToChoices(
+      getCodexPresetChoices().filter((choice) => choice.id !== "custom").map((choice) => ({
+        name: `${choice.name} \u2014 ${ansis.gray(choice.description)}`,
+        value: choice.id,
+        short: choice.name
+      }))
+    ),
+    default: "optimized"
+  });
+  const presetOptions = applyCodexSetupPreset(preset, { setupPreset: preset, skipPrompt: true });
+  await runCodexFullInit(presetOptions);
+  await finishCodexOperatorAction();
+}
+async function runCodexOperatorHub() {
+  const { action } = await inquirer.prompt({
+    type: "list",
+    name: "action",
+    message: i18n.t("menu:selectFunction"),
+    choices: addNumbersToChoices([
+      {
+        name: `${i18n.t("hub:operator.fullInit")} \u2014 ${ansis.gray(i18n.t("menu:menuDescriptions.codexFullInitWithPreset"))}`,
+        value: "init"
+      },
+      {
+        name: i18n.t("hub:operator.updateWorkflow"),
+        value: "workflow"
+      },
+      {
+        name: `${i18n.t("hub:operator.tuneSingle")} \u2014 ${ansis.gray(i18n.t("hub:operator.tuneSingleDesc"))}`,
+        value: "tune"
+      },
+      {
+        name: `${i18n.t("hub:operator.freshStart")} \u2014 ${ansis.gray(i18n.t("hub:operator.freshStartDesc"))}`,
+        value: "fresh"
+      },
+      { name: i18n.t("common:back"), value: "back" }
+    ])
+  });
+  switch (action) {
+    case "init":
+      await runCodexFullInit();
+      await finishCodexOperatorAction();
+      break;
+    case "workflow":
+      await runCodexWorkflowImportWithLanguageSelection();
+      await finishCodexOperatorAction();
+      break;
+    case "tune":
+      await promptTuneSingle("codex");
+      break;
+    case "fresh":
+      await runCodexFreshStart();
+      break;
+  }
+}
+async function runClaudeFamilyOperatorHub(tool) {
+  const initDesc = tool === "clavue" ? i18n.t("menu:menuDescriptions.clavueFullInit") : i18n.t("menu:menuDescriptions.fullInit");
+  const { action } = await inquirer.prompt({
+    type: "list",
+    name: "action",
+    message: i18n.t("menu:selectFunction"),
+    choices: addNumbersToChoices([
+      {
+        name: `${i18n.t("hub:operator.fullInit")} \u2014 ${ansis.gray(initDesc)}`,
+        value: "init"
+      },
+      {
+        name: i18n.t("hub:operator.updateWorkflow"),
+        value: "workflow"
+      },
+      {
+        name: `${i18n.t("hub:operator.tuneSingle")} \u2014 ${ansis.gray(i18n.t("hub:operator.tuneSingleDesc"))}`,
+        value: "tune"
+      },
+      { name: i18n.t("common:back"), value: "back" }
+    ])
+  });
+  switch (action) {
+    case "init":
+      await init({ skipBanner: true, codeType: tool });
+      break;
+    case "workflow":
+      await update({ skipBanner: true, codeType: tool });
+      break;
+    case "tune":
+      await promptTuneSingle(tool);
+      break;
+  }
+}
+async function runGrokOperatorHub() {
+  const { action } = await inquirer.prompt({
+    type: "list",
+    name: "action",
+    message: i18n.t("menu:selectFunction"),
+    choices: addNumbersToChoices([
+      {
+        name: `${i18n.t("hub:operator.grokProfile")} \u2014 ${ansis.gray(i18n.t("menu:menuDescriptions.grokInit"))}`,
+        value: "profile"
+      },
+      {
+        name: `${i18n.t("hub:operator.grokLaunch")} \u2014 ${ansis.gray(i18n.t("menu:menuDescriptions.grokStatus"))}`,
+        value: "launch"
+      },
+      { name: i18n.t("common:back"), value: "back" }
+    ])
+  });
+  switch (action) {
+    case "profile":
+      await init({ skipBanner: true, codeType: "grok" });
+      break;
+    case "launch":
+      await grokCommand();
+      break;
+  }
+}
+async function runOperatorHub(tool) {
+  ensureI18nInitialized();
+  console.log(ansis.cyan(`
+${i18n.t("hub:operator.title")}`));
+  console.log(ansis.gray(`  ${i18n.t("hub:operator.subtitle")}`));
+  console.log(ansis.dim(`  ${TOOL_MATRIX[tool].displayName}
+`));
+  if (tool === "codex")
+    return runCodexOperatorHub();
+  if (tool === "grok")
+    return runGrokOperatorHub();
+  return runClaudeFamilyOperatorHub(tool);
+}
+
 class ToolUpdateScheduler {
   /**
    * Update tools based on code type
@@ -491,7 +1820,7 @@ class CcjkUninstaller {
         result.removed.push(".claude.json (includes MCP configuration)");
       }
       try {
-        const { uninstallCodeTool } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bz; });
+        const { uninstallCodeTool } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bR; });
         const success = await uninstallCodeTool("claude-code");
         if (success) {
           result.removed.push("@anthropic-ai/claude-code");
@@ -727,7 +2056,7 @@ async function uninstall(options = {}) {
     }
     const uninstaller = new CcjkUninstaller(options.lang || "en");
     if (codeType === "codex") {
-      const { runCodexUninstall } = await import('./chunks/simple-config.mjs').then(function (n) { return n.by; });
+      const { runCodexUninstall } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bQ; });
       await runCodexUninstall();
       return;
     }
@@ -901,256 +2230,63 @@ function displayUninstallResult(mode, results) {
       result.removed.forEach((item) => {
         console.log(ansis.gray(`  \u2022 ${item}`));
       });
-    }
-    if (result.removedConfigs && result.removedConfigs.length > 0) {
-      console.log(ansis.green(`\u2714 ${i18n.t("uninstall:removedConfigs")}:`));
-      result.removedConfigs.forEach((item) => {
-        console.log(ansis.gray(`  \u2022 ${item}`));
-      });
-    }
-    if (result.errors && result.errors.length > 0) {
-      totalErrors += result.errors.length;
-      console.log(ansis.red(`\u2716 ${i18n.t("uninstall:errors")}:`));
-      result.errors.forEach((error) => {
-        console.log(ansis.red(`  \u2022 ${error}`));
-      });
-    }
-    if (result.warnings && result.warnings.length > 0) {
-      totalWarnings += result.warnings.length;
-      console.log(ansis.yellow(`\u26A0 ${i18n.t("uninstall:warnings")}:`));
-      result.warnings.forEach((warning) => {
-        console.log(ansis.yellow(`  \u2022 ${warning}`));
-      });
-    }
-  });
-  const totalRemovedFiles = results.reduce((count, result) => count + (result.removed?.length || 0), 0);
-  const totalRemovedConfigs = results.reduce((count, result) => count + (result.removedConfigs?.length || 0), 0);
-  console.log("");
-  console.log(ansis.cyan("\u2500".repeat(50)));
-  if (mode === "complete") {
-    if (totalErrors === 0) {
-      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:completeSuccess")}`));
-    } else {
-      console.log(ansis.yellow.bold(`\u26A0 ${i18n.t("uninstall:completePartialSuccess")}`));
-    }
-  } else {
-    if (totalRemovedFiles > 0 && totalRemovedConfigs > 0) {
-      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessBoth", {
-        fileCount: totalRemovedFiles,
-        configCount: totalRemovedConfigs
-      })}`));
-    } else if (totalRemovedFiles > 0) {
-      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessFiles", {
-        count: totalRemovedFiles
-      })}`));
-    } else if (totalRemovedConfigs > 0) {
-      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessConfigs", {
-        count: totalRemovedConfigs
-      })}`));
-    } else {
-      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccess", { count: totalSuccess })}`));
-    }
-    if (totalErrors > 0) {
-      console.log(ansis.red(`\u2716 ${i18n.t("uninstall:errorsCount", { count: totalErrors })}`));
-    }
-    if (totalWarnings > 0) {
-      console.log(ansis.yellow(`\u26A0 ${i18n.t("uninstall:warningsCount", { count: totalWarnings })}`));
-    }
-  }
-  console.log("");
-}
-
-function resolveCodeToolType(optionValue, savedValue) {
-  if (optionValue !== void 0) {
-    const resolved = resolveCodeToolType$1(optionValue);
-    if (resolved !== DEFAULT_CODE_TOOL_TYPE || optionValue === DEFAULT_CODE_TOOL_TYPE) {
-      return resolved;
-    }
-  }
-  if (savedValue && isCodeToolType(savedValue)) {
-    return savedValue;
-  }
-  return DEFAULT_CODE_TOOL_TYPE;
-}
-async function update(options = {}) {
-  try {
-    if (!options.skipBanner) {
-      displayBanner(i18n.t("cli:banner.updateSubtitle"));
-    }
-    const ccjkConfig = readCcjkConfig();
-    const codeToolType = resolveCodeToolType(options.codeType, ccjkConfig?.codeToolType);
-    options.codeType = codeToolType;
-    if (codeToolType === "codex") {
-      await runCodexUpdate();
-      const newPreferredLang = options.configLang || ccjkConfig?.preferredLang;
-      if (newPreferredLang) {
-        updateCcjkConfig({
-          version,
-          preferredLang: newPreferredLang,
-          codeToolType
-        });
-      } else {
-        updateCcjkConfig({
-          version,
-          codeToolType
-        });
-      }
-      return;
-    }
-    const { resolveTemplateLanguage } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bv; });
-    const configLang = await resolveTemplateLanguage(
-      options.configLang,
-      // Command line option
-      ccjkConfig,
-      options.skipPrompt
-      // Non-interactive mode flag
-    );
-    const aiOutputLang = await resolveAiOutputLanguage(i18n.language, options.aiOutputLang, ccjkConfig, options.skipPrompt);
-    const runtimeLabel = isClaudeFamilyCodeTool(codeToolType) ? getClaudeFamilyRuntimeLabel(codeToolType) : "Claude Code";
-    console.log(ansis.cyan(`
-${i18n.t("configuration:updatingPrompts", { runtime: runtimeLabel })}
-`));
-    await updatePromptOnly(aiOutputLang);
-    await selectAndInstallWorkflows(configLang, void 0, { codeToolType: isClaudeFamilyCodeTool(codeToolType) ? codeToolType : "claude-code" });
-    if (codeToolType === "claude-code") {
-      await checkClaudeCodeVersionAndPrompt(false);
-    }
-    updateCcjkConfig({
-      version,
-      templateLang: configLang,
-      // 保存模板语言选择
-      aiOutputLang,
-      codeToolType
-    });
-  } catch (error) {
-    if (!handleExitPromptError(error)) {
-      handleGeneralError(error);
-    }
-  }
-}
-
-const LEGACY_PROFILES_DIR = join(homedir(), ".ccjk", "profiles");
-function fromClaudeProfile(profile) {
-  return {
-    name: profile.name,
-    baseUrl: profile.baseUrl,
-    apiKey: profile.apiKey,
-    model: profile.primaryModel
-  };
-}
-function readLegacyJsonProfile(name) {
-  const profilePath = join(LEGACY_PROFILES_DIR, `${name}.json`);
-  if (!existsSync(profilePath)) {
-    return null;
-  }
-  try {
-    const data = JSON.parse(readFileSync(profilePath, "utf-8"));
-    return data.name ? data : { ...data, name };
-  } catch {
-    return null;
-  }
-}
-function readCcjkProfileByName(name) {
-  const byName = ClaudeCodeConfigManager.getProfileByName(name);
-  if (byName) {
-    return fromClaudeProfile(byName);
-  }
-  const byId = ClaudeCodeConfigManager.getProfileById(name);
-  if (byId) {
-    return fromClaudeProfile(byId);
-  }
-  return readLegacyJsonProfile(name);
-}
-function listCcjkProfileNames() {
-  return ClaudeCodeConfigManager.listProfiles().map((profile) => profile.name);
-}
-
-const GROK_AUTH_FILE = join(homedir(), ".grok", "auth.json");
-function isGrokInstalled() {
-  try {
-    execSync("command -v grok", { stdio: "ignore" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isGrokLoggedIn() {
-  if (!existsSync(GROK_AUTH_FILE)) return false;
-  try {
-    const data = JSON.parse(readFileSync(GROK_AUTH_FILE, "utf-8"));
-    return Object.keys(data).some((k) => k.includes("auth.x.ai"));
-  } catch {
-    return false;
-  }
-}
-function getGrokQuickStatus() {
-  if (!isGrokInstalled()) {
-    return {
-      installed: false,
-      loggedIn: false,
-      hint: "\u672A\u5B89\u88C5\uFF1Acurl -fsSL https://x.ai/cli/install.sh | bash"
-    };
-  }
-  const loggedIn = isGrokLoggedIn();
-  return {
-    installed: true,
-    loggedIn,
-    hint: loggedIn ? "\u5DF2\u767B\u5F55\uFF08OAuth\uFF0C~/.grok/auth.json\uFF09" : "\u672A\u767B\u5F55\uFF0C\u8FD0\u884C `grok login`"
-  };
-}
-function buildGrokHints() {
-  const s = getGrokQuickStatus();
-  const lines = [];
-  if (!s.installed) {
-    lines.push(ansis.dim("  \u5B89\u88C5: ") + ansis.cyan("curl -fsSL https://x.ai/cli/install.sh | bash"));
-    return lines;
-  }
-  if (!s.loggedIn) {
-    lines.push(ansis.yellow("  \u767B\u5F55: ") + ansis.cyan("grok login"));
-  }
-  lines.push(ansis.dim("  \u542F\u52A8: ") + ansis.cyan("grok"));
-  lines.push(ansis.dim("  \u6A21\u578B: ") + ansis.cyan("grok models"));
-  return lines;
-}
-
-async function grokCommand(profileName) {
-  if (profileName) {
-    await launchWithProfile$1(profileName);
-    return;
-  }
-  const status = getGrokQuickStatus();
-  console.log(ansis.bold("\nGrok CLI"));
-  console.log(`  \u5B89\u88C5: ${status.installed ? ansis.green("\u662F") : ansis.gray("\u5426")}  \u767B\u5F55: ${status.loggedIn ? ansis.green("\u662F") : ansis.yellow("\u5426")}`);
-  for (const line of buildGrokHints()) console.log(line);
-  const names = listCcjkProfileNames();
-  if (names.length > 0) {
-    console.log(ansis.dim(`
-  \u53EF\u7528 profile: ${names.join(", ")}`));
-  }
-  console.log(ansis.dim("  ccjk grok <profile> \u2014 \u7528 ~/.ccjk/config.toml \u4E2D\u7684 profile \u542F\u52A8\n"));
-}
-async function launchWithProfile$1(name) {
-  const profile = readCcjkProfileByName(name);
-  if (!profile) {
-    console.log(ansis.red(`Profile "${name}" \u4E0D\u5B58\u5728`));
-    console.log(ansis.dim("  \u5148\u8FD0\u884C ccjk init -T grok \u6216\u83DC\u5355\u914D\u7F6E API\uFF08profile \u4FDD\u5B58\u5728 ~/.ccjk/config.toml\uFF09\n"));
-    return;
-  }
-  const env = { ...process.env };
-  if (profile.baseUrl) {
-    env.OPENAI_BASE_URL = profile.baseUrl;
-    env.ANTHROPIC_BASE_URL = profile.baseUrl;
-  }
-  if (profile.apiKey) {
-    env.OPENAI_API_KEY = profile.apiKey;
-    env.ANTHROPIC_API_KEY = profile.apiKey;
-    env.ANTHROPIC_AUTH_TOKEN = profile.apiKey;
+    }
+    if (result.removedConfigs && result.removedConfigs.length > 0) {
+      console.log(ansis.green(`\u2714 ${i18n.t("uninstall:removedConfigs")}:`));
+      result.removedConfigs.forEach((item) => {
+        console.log(ansis.gray(`  \u2022 ${item}`));
+      });
+    }
+    if (result.errors && result.errors.length > 0) {
+      totalErrors += result.errors.length;
+      console.log(ansis.red(`\u2716 ${i18n.t("uninstall:errors")}:`));
+      result.errors.forEach((error) => {
+        console.log(ansis.red(`  \u2022 ${error}`));
+      });
+    }
+    if (result.warnings && result.warnings.length > 0) {
+      totalWarnings += result.warnings.length;
+      console.log(ansis.yellow(`\u26A0 ${i18n.t("uninstall:warnings")}:`));
+      result.warnings.forEach((warning) => {
+        console.log(ansis.yellow(`  \u2022 ${warning}`));
+      });
+    }
+  });
+  const totalRemovedFiles = results.reduce((count, result) => count + (result.removed?.length || 0), 0);
+  const totalRemovedConfigs = results.reduce((count, result) => count + (result.removedConfigs?.length || 0), 0);
+  console.log("");
+  console.log(ansis.cyan("\u2500".repeat(50)));
+  if (mode === "complete") {
+    if (totalErrors === 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:completeSuccess")}`));
+    } else {
+      console.log(ansis.yellow.bold(`\u26A0 ${i18n.t("uninstall:completePartialSuccess")}`));
+    }
+  } else {
+    if (totalRemovedFiles > 0 && totalRemovedConfigs > 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessBoth", {
+        fileCount: totalRemovedFiles,
+        configCount: totalRemovedConfigs
+      })}`));
+    } else if (totalRemovedFiles > 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessFiles", {
+        count: totalRemovedFiles
+      })}`));
+    } else if (totalRemovedConfigs > 0) {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccessConfigs", {
+        count: totalRemovedConfigs
+      })}`));
+    } else {
+      console.log(ansis.green.bold(`\u2714 ${i18n.t("uninstall:customSuccess", { count: totalSuccess })}`));
+    }
+    if (totalErrors > 0) {
+      console.log(ansis.red(`\u2716 ${i18n.t("uninstall:errorsCount", { count: totalErrors })}`));
+    }
+    if (totalWarnings > 0) {
+      console.log(ansis.yellow(`\u26A0 ${i18n.t("uninstall:warningsCount", { count: totalWarnings })}`));
+    }
   }
-  console.log(ansis.cyan(`
-\u4F7F\u7528 profile "${name}" \u542F\u52A8 grok...
-`));
-  const res = spawnSync("grok", [], { stdio: "inherit", env });
-  if (res.error) console.log(ansis.red(`\u542F\u52A8\u5931\u8D25: ${res.error.message}`));
+  console.log("");
 }
 
 const REASONIX_GLOBAL_CONFIG = join(homedir(), ".config", "reasonix", "config.toml");
@@ -1400,71 +2536,6 @@ function buildRunArgs(model, prompt) {
   return args;
 }
 
-const TIMEOUT_MS = 1e4;
-const EXIT_CODE = {
-  ok: 0,
-  "auth-failed": 1,
-  unreachable: 2,
-  unexpected: 3
-};
-async function probeCommand(opts = {}) {
-  const creds = readActiveApiCreds();
-  if (!creds.baseUrl) {
-    throw new Error("\u672A\u627E\u5230 API \u914D\u7F6E\uFF0C\u8BF7\u5148\u8FD0\u884C ccjk init \u6216\u83DC\u5355 3 \u914D\u7F6E API");
-  }
-  const result = await runProbe(creds.baseUrl, creds.apiKey, creds.authToken);
-  if (opts.json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else {
-    const color = result.status === "ok" ? ansis.green : ansis.red;
-    console.log(`
-\u63A2\u6D3B ${creds.baseUrl}`);
-    console.log(color(`  \u72B6\u6001: ${result.status}`));
-    if (result.httpStatus) console.log(ansis.dim(`  HTTP: ${result.httpStatus}`));
-    if (result.latencyMs) console.log(ansis.dim(`  \u5EF6\u8FDF: ${result.latencyMs}ms`));
-    if (result.error) console.log(ansis.dim(`  \u9519\u8BEF: ${result.error}`));
-    console.log();
-  }
-  process.exitCode = EXIT_CODE[result.status];
-}
-function readActiveApiCreds() {
-  const tool = readCcjkConfig()?.codeToolType ?? "clavue";
-  const file = activeSettingsFile(tool === "codex" || tool === "grok" ? "claude-code" : tool);
-  const settings = readJsonConfig(file) || {};
-  const env = settings.env || {};
-  return {
-    baseUrl: env.ANTHROPIC_BASE_URL || "",
-    apiKey: env.ANTHROPIC_API_KEY || "",
-    authToken: env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || ""
-  };
-}
-async function runProbe(baseUrl, apiKey, authToken) {
-  const url = `${baseUrl.replace(/\/$/, "")}/v1/messages`;
-  const headers = {
-    "content-type": "application/json",
-    "anthropic-version": "2023-06-01"
-  };
-  if (authToken) headers.authorization = `Bearer ${authToken}`;
-  else if (apiKey) headers["x-api-key"] = apiKey;
-  const body = JSON.stringify({
-    model: "claude-3-5-haiku-20241022",
-    max_tokens: 1,
-    messages: [{ role: "user", content: "ping" }]
-  });
-  const t0 = Date.now();
-  try {
-    const res = await fetch(url, { method: "POST", headers, body, signal: AbortSignal.timeout(TIMEOUT_MS) });
-    const latencyMs = Date.now() - t0;
-    if (res.status === 401 || res.status === 403) {
-      return { baseUrl, status: "auth-failed", httpStatus: res.status, latencyMs };
-    }
-    if (res.ok) return { baseUrl, status: "ok", httpStatus: res.status, latencyMs };
-    return { baseUrl, status: "unexpected", httpStatus: res.status, latencyMs };
-  } catch (e) {
-    return { baseUrl, status: "unreachable", error: e.message, latencyMs: Date.now() - t0 };
-  }
-}
-
 const ONBOARDING_STATE_FILE = join(CCJK_CONFIG_DIR, "onboarding.json");
 const LANGUAGE_SELECTION_MESSAGES = {
   selectLanguage: "Select CCJK display language / \u9009\u62E9 CCJK \u663E\u793A\u8BED\u8A00"
@@ -1645,404 +2716,129 @@ function printSeparator() {
 ${ansis.dim("\u2500".repeat(50))}
 `);
 }
-function getCodeToolLabel(codeTool) {
-  return CODE_TOOL_LABELS[codeTool] || codeTool;
-}
-async function promptCodeToolSelection(current) {
-  const choices = addNumbersToChoices(Object.entries(CODE_TOOL_LABELS).map(([value, label]) => ({
-    name: label,
-    value,
-    short: label
-  })));
-  const { tool } = await inquirer.prompt({
-    type: "list",
-    name: "tool",
-    message: i18n.t("menu:switchCodeToolPrompt"),
-    default: current,
-    choices
-  });
-  if (!tool) {
-    console.log(ansis.yellow(i18n.t("common:cancelled")));
-    return null;
-  }
-  return tool;
-}
-async function handleCodeToolSwitch(current) {
-  const newTool = await promptCodeToolSelection(current);
-  if (!newTool || newTool === current) {
-    return false;
-  }
-  updateCcjkConfig({ codeToolType: newTool });
-  console.log(ansis.green(`\u2714 ${i18n.t("menu:codeToolSwitched", { tool: getCodeToolLabel(newTool) })}`));
-  return true;
-}
-function printOtherToolsSection() {
-  console.log(`  --------- ${i18n.t("menu:menuSections.otherTools")} ----------`);
-  console.log(
-    `  ${ansis.cyan("P.")} Probe API ${ansis.gray("- HTTP \u63A2\u6D3B\u5F53\u524D\u914D\u7F6E")}`
-  );
-  console.log(
-    `  ${ansis.cyan("G.")} Grok CLI ${ansis.gray("- \u72B6\u6001 / \u542F\u52A8\u6307\u5F15")}`
-  );
-  console.log(
-    `  ${ansis.cyan("X.")} Reasonix ${ansis.gray("- DeepSeek agent \u72B6\u6001 / \u542F\u52A8\u6307\u5F15")}`
-  );
-  console.log("");
-}
-function printCcjkSection(options) {
-  console.log("  ------------ CCJK ------------");
-  console.log(
-    `  ${ansis.cyan("0.")} ${i18n.t("menu:menuOptions.changeLanguage")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.changeLanguage")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("S.")} ${i18n.t("menu:menuOptions.switchCodeTool")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.switchCodeTool")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("-.")} ${options.uninstallOption} ${ansis.gray(`- ${options.uninstallDescription}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("+.")} ${options.updateOption} ${ansis.gray(`- ${options.updateDescription}`)}`
-  );
-  console.log(`  ${ansis.red("Q.")} ${ansis.red(i18n.t("menu:menuOptions.exit"))}`);
-  console.log("");
-}
-async function showClavueMenu() {
-  console.log(ansis.cyan(i18n.t("menu:selectFunction")));
-  console.log("  -------- Clavue --------");
-  console.log(
-    `  ${ansis.cyan("1.")} ${i18n.t("menu:menuOptions.clavueFullInit")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueFullInit")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("2.")} ${i18n.t("menu:menuOptions.clavueUpdateWorkflow")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueUpdateWorkflow")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("3.")} ${i18n.t("menu:menuOptions.clavueConfigureApi")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueConfigureApi")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("4.")} ${i18n.t("menu:menuOptions.clavueConfigureMcp")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueConfigureMcp")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("5.")} ${i18n.t("menu:menuOptions.clavueConfigureModel")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueConfigureModel")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("6.")} ${i18n.t("menu:menuOptions.clavueConfigureAiMemory")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueConfigureAiMemory")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("7.")} ${i18n.t("menu:menuOptions.clavueConfigureEnvPermission")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueConfigureEnvPermission")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("8.")} ${i18n.t("menu:menuOptions.clavueStatus")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.clavueStatus")}`)}`
-  );
-  console.log("");
-  printOtherToolsSection();
-  printCcjkSection({
-    uninstallOption: i18n.t("menu:menuOptions.clavueUninstall"),
-    uninstallDescription: i18n.t("menu:menuDescriptions.clavueUninstall"),
-    updateOption: i18n.t("menu:menuOptions.clavueCheckUpdates"),
-    updateDescription: i18n.t("menu:menuDescriptions.clavueCheckUpdates")
-  });
-  const { choice } = await inquirer.prompt({
-    type: "input",
-    name: "choice",
-    message: i18n.t("common:enterChoice"),
-    validate: (value) => {
-      const valid = ["1", "2", "3", "4", "5", "6", "7", "8", "p", "P", "g", "G", "x", "X", "0", "-", "+", "s", "S", "q", "Q"];
-      return valid.includes(value) || i18n.t("common:invalidChoice");
-    }
-  });
-  if (!choice) {
-    console.log(ansis.yellow(i18n.t("common:cancelled")));
-    return "exit";
-  }
-  const normalized = choice.toLowerCase();
-  switch (normalized) {
-    case "1":
-      await init({ skipBanner: true, codeType: "clavue" });
-      break;
-    case "2":
-      await update({ skipBanner: true, codeType: "clavue" });
-      break;
-    case "3":
-      await configureApiFeature();
-      break;
-    case "4":
-      await configureMcpFeature();
-      break;
-    case "5":
-      await configureDefaultModelFeature();
-      break;
-    case "6":
-      await configureAiMemoryFeature();
-      break;
-    case "7":
-      await configureEnvPermissionFeature();
-      break;
-    case "8":
-    case "p":
-      await probeCommand();
-      printSeparator();
-      return void 0;
-    case "g":
-      await grokCommand();
-      printSeparator();
-      return void 0;
-    case "x":
-      await reasonixCommand();
-      printSeparator();
-      return void 0;
-    case "0": {
-      const currentLang = i18n.language;
-      await changeScriptLanguageFeature(currentLang);
-      printSeparator();
-      return void 0;
-    }
-    case "-":
-      await uninstall();
-      printSeparator();
-      return void 0;
-    case "+":
-      await checkUpdates();
-      printSeparator();
-      return void 0;
-    case "s": {
-      const switched = await handleCodeToolSwitch("clavue");
-      if (switched) {
-        return "switch";
-      }
-      printSeparator();
-      return void 0;
-    }
-    case "q":
-      console.log(ansis.cyan(i18n.t("common:goodbye")));
-      return "exit";
-    default:
-      return void 0;
-  }
-  printSeparator();
-  const shouldContinue = await promptBoolean({
-    message: i18n.t("common:returnToMenu"),
-    defaultValue: true
-  });
-  if (!shouldContinue) {
-    console.log(ansis.cyan(i18n.t("common:goodbye")));
-    return "exit";
-  }
-  return void 0;
+function getCodeToolLabel(codeTool) {
+  return CODE_TOOL_LABELS[codeTool] || codeTool;
 }
-async function showClaudeCodeMenu() {
-  console.log(ansis.cyan(i18n.t("menu:selectFunction")));
-  console.log("  -------- Claude Code --------");
-  console.log(
-    `  ${ansis.cyan("1.")} ${i18n.t("menu:menuOptions.fullInit")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.fullInit")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("2.")} ${i18n.t("menu:menuOptions.importWorkflow")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.importWorkflow")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("3.")} ${i18n.t("menu:menuOptions.configureApiOrCcr")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureApiOrCcr")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("4.")} ${i18n.t("menu:menuOptions.configureMcp")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureMcp")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("5.")} ${i18n.t("menu:menuOptions.configureModel")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureModel")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("6.")} ${i18n.t("menu:menuOptions.configureAiMemory")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureAiMemory")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("7.")} ${i18n.t("menu:menuOptions.configureEnvPermission")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.configureEnvPermission")}`)}`
-  );
-  console.log("");
-  printOtherToolsSection();
-  printCcjkSection({
-    uninstallOption: i18n.t("menu:menuOptions.uninstall"),
-    uninstallDescription: i18n.t("menu:menuDescriptions.uninstall"),
-    updateOption: i18n.t("menu:menuOptions.checkUpdates"),
-    updateDescription: i18n.t("menu:menuDescriptions.checkUpdates")
-  });
-  const { choice } = await inquirer.prompt({
-    type: "input",
-    name: "choice",
-    message: i18n.t("common:enterChoice"),
-    validate: (value) => {
-      const valid = ["1", "2", "3", "4", "5", "6", "7", "p", "P", "g", "G", "x", "X", "0", "-", "+", "s", "S", "q", "Q"];
-      return valid.includes(value) || i18n.t("common:invalidChoice");
-    }
+async function promptCodeToolSelection(current) {
+  const { addNumbersToChoices } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bM; });
+  const choices = addNumbersToChoices(Object.entries(CODE_TOOL_LABELS).map(([value, label]) => ({
+    name: label,
+    value,
+    short: label
+  })));
+  const { tool } = await inquirer.prompt({
+    type: "list",
+    name: "tool",
+    message: i18n.t("menu:switchCodeToolPrompt"),
+    default: current,
+    choices
   });
-  if (!choice) {
+  if (!tool) {
     console.log(ansis.yellow(i18n.t("common:cancelled")));
-    return "exit";
+    return null;
+  }
+  return tool;
+}
+async function handleCodeToolSwitch(current) {
+  const newTool = await promptCodeToolSelection(current);
+  if (!newTool || newTool === current) {
+    return false;
   }
-  const normalized = choice.toLowerCase();
-  switch (normalized) {
+  updateCcjkConfig({ codeToolType: newTool });
+  console.log(ansis.green(`\u2714 ${i18n.t("menu:codeToolSwitched", { tool: getCodeToolLabel(newTool) })}`));
+  return true;
+}
+async function handleClaudeFamilyChoice(tool, choice) {
+  switch (choice) {
     case "1":
-      await init({ skipBanner: true });
-      break;
+      await init({ skipBanner: true, codeType: tool });
+      return "handled";
     case "2":
-      await update({ skipBanner: true });
-      break;
+      await update({ skipBanner: true, codeType: tool });
+      return "handled";
     case "3":
       await configureApiFeature();
-      break;
+      return "handled";
     case "4":
       await configureMcpFeature();
-      break;
+      return "handled";
     case "5":
       await configureDefaultModelFeature();
-      break;
+      return "handled";
     case "6":
       await configureAiMemoryFeature();
-      break;
+      return "handled";
     case "7":
       await configureEnvPermissionFeature();
-      break;
-    case "p":
-      await probeCommand();
-      printSeparator();
-      return void 0;
-    case "g":
-      await grokCommand();
-      printSeparator();
-      return void 0;
-    case "x":
-      await reasonixCommand();
-      printSeparator();
-      return void 0;
-    case "0": {
-      const currentLang = i18n.language;
-      await changeScriptLanguageFeature(currentLang);
-      printSeparator();
-      return void 0;
-    }
-    case "-":
-      await uninstall();
-      printSeparator();
-      return void 0;
-    case "+":
-      await checkUpdates();
-      printSeparator();
-      return void 0;
-    case "s": {
-      const switched = await handleCodeToolSwitch("claude-code");
-      if (switched) {
-        return "switch";
-      }
-      printSeparator();
-      return void 0;
-    }
-    case "q":
-      console.log(ansis.cyan(i18n.t("common:goodbye")));
-      return "exit";
+      return "handled";
     default:
       return void 0;
   }
-  printSeparator();
-  const shouldContinue = await promptBoolean({
-    message: i18n.t("common:returnToMenu"),
-    defaultValue: true
-  });
-  if (!shouldContinue) {
-    console.log(ansis.cyan(i18n.t("common:goodbye")));
-    return "exit";
-  }
-  return void 0;
 }
-async function showCodexMenu() {
-  console.log(ansis.cyan(i18n.t("menu:selectFunction")));
-  console.log("  -------- Codex --------");
-  console.log(
-    `  ${ansis.cyan("1.")} ${i18n.t("menu:menuOptions.codexFullInit")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexFullInit")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("2.")} ${i18n.t("menu:menuOptions.codexImportWorkflow")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexImportWorkflow")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("3.")} ${i18n.t("menu:menuOptions.codexConfigureApi")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureApi")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("4.")} ${i18n.t("menu:menuOptions.codexConfigureMcp")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureMcp")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("5.")} ${i18n.t("menu:menuOptions.codexConfigureModel")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureModel")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("6.")} ${i18n.t("menu:menuOptions.codexConfigureAiMemory")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.codexConfigureAiMemory")}`)}`
-  );
-  console.log("");
-  printOtherToolsSection();
-  printCcjkSection({
-    uninstallOption: i18n.t("menu:menuOptions.codexUninstall"),
-    uninstallDescription: i18n.t("menu:menuDescriptions.codexUninstall"),
-    updateOption: i18n.t("menu:menuOptions.codexCheckUpdates"),
-    updateDescription: i18n.t("menu:menuDescriptions.codexCheckUpdates")
-  });
-  const { choice } = await inquirer.prompt({
-    type: "input",
-    name: "choice",
-    message: i18n.t("common:enterChoice"),
-    validate: (value) => {
-      const valid = ["1", "2", "3", "4", "5", "6", "p", "P", "g", "G", "x", "X", "0", "-", "+", "s", "S", "q", "Q"];
-      return valid.includes(value) || i18n.t("common:invalidChoice");
-    }
-  });
-  if (!choice) {
-    console.log(ansis.yellow(i18n.t("common:cancelled")));
-    return "exit";
-  }
-  const normalized = choice.toLowerCase();
-  switch (normalized) {
+async function handleCodexChoice(choice) {
+  switch (choice) {
     case "1":
       await runCodexFullInit();
-      break;
+      return "handled";
     case "2":
       await runCodexWorkflowImportWithLanguageSelection();
-      break;
+      return "handled";
     case "3":
       await configureCodexApi();
-      break;
+      return "handled";
     case "4":
       await manageCodexMcp();
-      break;
+      return "handled";
     case "5":
       await configureCodexDefaultModelFeature();
-      break;
+      return "handled";
     case "6":
       await configureCodexAiMemoryFeature();
-      break;
-    case "p":
-      await probeCommand();
-      printSeparator();
+      return "handled";
+    default:
       return void 0;
-    case "g":
+  }
+}
+async function handleGrokChoice(choice) {
+  switch (choice) {
+    case "1":
+      await init({ skipBanner: true, codeType: "grok" });
+      return "handled";
+    case "2":
       await grokCommand();
-      printSeparator();
+      return "handled";
+    default:
+      return void 0;
+  }
+}
+async function handleHubChoice(tool, choice) {
+  switch (choice) {
+    case "h":
+      await runDoctorHub(tool);
+      return "continue";
+    case "w":
+      await runOperatorHub(tool);
+      return "handled";
+    default:
       return void 0;
+  }
+}
+async function handleSharedChoice(tool, choice) {
+  switch (choice) {
+    case "g":
+      await grokCommand();
+      return "continue";
     case "x":
       await reasonixCommand();
-      printSeparator();
-      return void 0;
+      return "continue";
     case "0": {
       const currentLang = i18n.language;
       await changeScriptLanguageFeature(currentLang);
-      printSeparator();
-      return void 0;
+      return "continue";
     }
-    case "-":
-      await runCodexUninstall();
-      printSeparator();
-      return void 0;
-    case "+":
-      await runCodexUpdate();
-      printSeparator();
-      return void 0;
     case "s": {
-      const switched = await handleCodeToolSwitch("codex");
-      if (switched) {
-        return "switch";
-      }
-      printSeparator();
-      return void 0;
+      const switched = await handleCodeToolSwitch(tool);
+      return switched ? "switch" : "continue";
     }
     case "q":
       console.log(ansis.cyan(i18n.t("common:goodbye")));
@@ -2050,94 +2846,69 @@ async function showCodexMenu() {
     default:
       return void 0;
   }
-  printSeparator();
-  const shouldContinue = await promptBoolean({
-    message: i18n.t("common:returnToMenu"),
-    defaultValue: true
-  });
-  if (!shouldContinue) {
-    console.log(ansis.cyan(i18n.t("common:goodbye")));
-    return "exit";
+}
+async function handleToolSpecificMaintenance(tool, choice) {
+  if (choice === "-") {
+    if (tool === "codex") {
+      await runCodexUninstall();
+    } else {
+      await uninstall();
+    }
+    return "continue";
+  }
+  if (choice === "+") {
+    if (tool === "codex") {
+      await runCodexUpdate();
+    } else {
+      await checkUpdates();
+    }
+    return "continue";
   }
   return void 0;
 }
-async function showGrokMenu() {
-  console.log(ansis.cyan(i18n.t("menu:selectFunction")));
-  console.log("  -------- Grok CLI --------");
-  console.log(
-    `  ${ansis.cyan("1.")} ${i18n.t("menu:menuOptions.grokInit")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.grokInit")}`)}`
-  );
-  console.log(
-    `  ${ansis.cyan("2.")} ${i18n.t("menu:menuOptions.grokStatus")} ${ansis.gray(`- ${i18n.t("menu:menuDescriptions.grokStatus")}`)}`
-  );
-  console.log("");
-  printOtherToolsSection();
-  printCcjkSection({
-    uninstallOption: i18n.t("menu:menuOptions.uninstall"),
-    uninstallDescription: i18n.t("menu:menuDescriptions.uninstall"),
-    updateOption: i18n.t("menu:menuOptions.checkUpdates"),
-    updateDescription: i18n.t("menu:menuDescriptions.checkUpdates")
-  });
+async function dispatchMenuChoice(tool, rawChoice) {
+  const choice = rawChoice.toLowerCase();
+  const hubResult = ["h", "w"].includes(choice) ? await handleHubChoice(tool, choice) : void 0;
+  if (hubResult)
+    return hubResult;
+  const sharedResult = await handleSharedChoice(tool, choice);
+  if (sharedResult)
+    return sharedResult;
+  const maintenanceResult = await handleToolSpecificMaintenance(tool, choice);
+  if (maintenanceResult)
+    return maintenanceResult;
+  const layout = getToolMenuLayout(tool);
+  if (!layout.operatorLines.some((item) => item.key === choice))
+    return void 0;
+  if (tool === "clavue" || tool === "claude-code")
+    return await handleClaudeFamilyChoice(tool, choice);
+  if (tool === "codex")
+    return await handleCodexChoice(choice);
+  if (tool === "grok")
+    return await handleGrokChoice(choice);
+  return void 0;
+}
+async function showToolMenu(tool) {
+  printToolMenuHeader(tool);
   const { choice } = await inquirer.prompt({
-    type: "input",
+    type: "list",
     name: "choice",
-    message: i18n.t("common:enterChoice"),
-    validate: (value) => {
-      const valid = ["1", "2", "p", "P", "g", "G", "x", "X", "0", "-", "+", "s", "S", "q", "Q"];
-      return valid.includes(value) || i18n.t("common:invalidChoice");
-    }
+    message: i18n.t("menu:selectFunction"),
+    choices: buildMenuListChoices(tool),
+    pageSize: 20
   });
   if (!choice) {
     console.log(ansis.yellow(i18n.t("common:cancelled")));
     return "exit";
   }
-  const normalized = choice.toLowerCase();
-  switch (normalized) {
-    case "1":
-      await init({ skipBanner: true, codeType: "grok" });
-      break;
-    case "2":
-      await grokCommand();
-      break;
-    case "p":
-      await probeCommand();
-      printSeparator();
-      return void 0;
-    case "g":
-      await grokCommand();
-      printSeparator();
-      return void 0;
-    case "x":
-      await reasonixCommand();
-      printSeparator();
-      return void 0;
-    case "0": {
-      const currentLang = i18n.language;
-      await changeScriptLanguageFeature(currentLang);
-      printSeparator();
-      return void 0;
-    }
-    case "-":
-      await uninstall();
-      printSeparator();
-      return void 0;
-    case "+":
-      await checkUpdates();
-      printSeparator();
-      return void 0;
-    case "s": {
-      const switched = await handleCodeToolSwitch("grok");
-      if (switched) {
-        return "switch";
-      }
-      printSeparator();
-      return void 0;
-    }
-    case "q":
-      console.log(ansis.cyan(i18n.t("common:goodbye")));
-      return "exit";
-    default:
-      return void 0;
+  const result = await dispatchMenuChoice(tool, choice);
+  if (result === "exit")
+    return "exit";
+  if (result === "switch")
+    return "switch";
+  if (result === "continue") {
+    printSeparator();
+    return void 0;
   }
   printSeparator();
   const shouldContinue = await promptBoolean({
@@ -2172,7 +2943,7 @@ async function showMainMenu(options = {}) {
     while (!exitMenu) {
       const codeTool = getCurrentCodeTool();
       displayBannerWithInfo(CODE_TOOL_BANNERS[codeTool] || "CCJK");
-      const result = codeTool === "clavue" ? await showClavueMenu() : codeTool === "codex" ? await showCodexMenu() : codeTool === "grok" ? await showGrokMenu() : await showClaudeCodeMenu();
+      const result = await showToolMenu(codeTool);
       if (result === "exit") {
         exitMenu = true;
       } else if (result === "switch") {
@@ -2281,7 +3052,7 @@ async function listCodexProvidersWithDisplay() {
     console.log(ansis.cyan(i18n.t("codex:currentProvider", { provider: currentProvider })));
     console.log();
   }
-  const { listCodexProfileFiles, codexProfileLaunchHint } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bw; });
+  const { listCodexProfileFiles, codexProfileLaunchHint } = await import('./chunks/simple-config.mjs').then(function (n) { return n.bO; });
   const profileFiles = listCodexProfileFiles();
   if (profileFiles.length > 0) {
     console.log(ansis.bold("Codex 0.135+ profiles (.config.toml):"));
@@ -2514,6 +3285,194 @@ async function benchCommand(opts = {}) {
   await probeCommand({ json: opts.json });
 }
 
+async function providerCommand(options) {
+  const { action, profileId, json } = options;
+  const subAction = action || "list";
+  if (subAction === "list") {
+    await listAction(json);
+  } else if (subAction === "current") {
+    await currentAction(json);
+  } else if (subAction === "validate") {
+    await validateAction(profileId, json);
+  } else {
+    await validateAction(subAction, json);
+  }
+}
+async function listAction(json) {
+  const profiles = listProviderProfiles();
+  const activeId = getActiveProviderProfileId();
+  if (json) {
+    console.log(JSON.stringify({ profiles, activeId }, null, 2));
+    return;
+  }
+  if (profiles.length === 0) {
+    console.log(ansis.dim("\n  No provider profiles found.\n"));
+    return;
+  }
+  console.log(ansis.bold("\nProvider Profiles (Clavue 9.x)"));
+  console.log(ansis.dim("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"));
+  for (const profile of profiles) {
+    const isActive = profile.id === activeId;
+    const prefix = isActive ? ansis.green("\u25B6") : " ";
+    const activeLabel = isActive ? ansis.green(" (active)") : "";
+    const modeLabel = profile.modelMode ? ansis.dim(`  ${profile.modelMode}`) : "";
+    console.log(`${prefix} ${ansis.cyan(profile.id)}${activeLabel}${modeLabel}`);
+    console.log(`  URL: ${ansis.dim(profile.baseUrl)}`);
+    console.log(`  Auth: ${ansis.dim(profile.authType)}`);
+    const mr = profile.modelRouting;
+    const parts = [];
+    if (mr.primaryModel) parts.push(`Primary: ${mr.primaryModel}`);
+    if (mr.smallFastModel) parts.push(`Haiku: ${mr.smallFastModel}`);
+    if (mr.subagentModel) parts.push(`Sonnet: ${mr.subagentModel}`);
+    if (mr.planModel) parts.push(`Opus: ${mr.planModel}`);
+    console.log(`  ${ansis.dim(parts.join(" | "))}`);
+    console.log();
+  }
+}
+async function currentAction(json) {
+  const activeId = getActiveProviderProfileId();
+  if (!activeId) {
+    if (json) {
+      console.log(JSON.stringify({ error: "No active profile" }));
+    } else {
+      console.log(ansis.yellow("\n  No active provider profile.\n"));
+    }
+    return;
+  }
+  const profile = getProviderProfile(activeId);
+  if (!profile) {
+    if (json) {
+      console.log(JSON.stringify({ error: `Active profile "${activeId}" not found` }));
+    } else {
+      console.log(ansis.red(`
+  Active profile "${activeId}" not found.
+`));
+    }
+    return;
+  }
+  if (json) {
+    console.log(JSON.stringify({ active: profile }, null, 2));
+    return;
+  }
+  renderProfileDetail(profile);
+}
+function renderProfileDetail(profile) {
+  console.log(ansis.bold(`
+Active Profile: ${ansis.cyan(profile.name)}`));
+  console.log(`  ID: ${ansis.dim(profile.id)}`);
+  if (profile.modelMode) {
+    console.log(`  Mode: ${ansis.dim(profile.modelMode)}`);
+  }
+  console.log(`  URL: ${ansis.dim(profile.baseUrl)}`);
+  console.log(`  Auth: ${ansis.dim(profile.authType)}`);
+  console.log("  Model Routing:");
+  const mr = profile.modelRouting;
+  console.log(`    Primary:      ${ansis.dim(mr.primaryModel || "-")}`);
+  console.log(`    Haiku:        ${ansis.dim(mr.smallFastModel || "-")}`);
+  console.log(`    Sonnet:       ${ansis.dim(mr.subagentModel || "-")}`);
+  console.log(`    Opus/Plan:    ${ansis.dim(mr.planModel || "-")}`);
+  if (mr.subagentModel) {
+    console.log(`    Subagent:     ${ansis.dim(mr.subagentModel)}`);
+  }
+  if (mr.generalModel) {
+    console.log(`    General:      ${ansis.dim(mr.generalModel)}`);
+  }
+  const created = new Date(profile.createdAt).toISOString().slice(0, 10);
+  const updated = new Date(profile.updatedAt).toISOString().slice(0, 10);
+  console.log(`  Created: ${ansis.dim(created)}`);
+  console.log(`  Updated: ${ansis.dim(updated)}`);
+  console.log();
+}
+const PROBE_TIMEOUT_MS = 1e4;
+async function validateAction(profileId, json) {
+  const targetId = profileId || getActiveProviderProfileId();
+  if (!targetId) {
+    if (json) {
+      console.log(JSON.stringify({ error: "No profile specified and no active profile" }));
+    } else {
+      console.log(ansis.yellow("\n  Please specify a profile ID or set an active profile.\n"));
+    }
+    return;
+  }
+  const profile = getProviderProfile(targetId);
+  if (!profile) {
+    if (json) {
+      console.log(JSON.stringify({ error: `Profile "${targetId}" not found` }));
+    } else {
+      console.log(ansis.red(`
+  Profile "${targetId}" not found.
+`));
+    }
+    return;
+  }
+  if (json) {
+    const result = await buildValidationResultJson(profile);
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(ansis.bold(`
+Validating ${ansis.cyan(targetId)}...`));
+  let probeOk = false;
+  let probeDisplay = "";
+  try {
+    const probeUrl = profile.baseUrl.replace(/\/$/, "");
+    const res = await fetch(probeUrl, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
+    probeOk = res.ok;
+    probeDisplay = res.ok ? ansis.green(`OK (${res.status})`) : ansis.red(`${res.status}`);
+  } catch (e) {
+    probeDisplay = ansis.red(`Unreachable: ${e.message}`);
+  }
+  console.log(`  Probe ${ansis.dim(profile.baseUrl)}... ${probeDisplay}`);
+  console.log(`  Auth type: ${ansis.dim(profile.authType)}`);
+  const mr = profile.modelRouting;
+  console.log(`  Primary model: ${renderSlot(mr.primaryModel)}`);
+  console.log(`  Haiku model: ${renderSlot(mr.smallFastModel)}`);
+  console.log(`  Sonnet model: ${renderSlot(mr.subagentModel)}`);
+  console.log(`  Opus model: ${renderSlot(mr.planModel)}`);
+  const credentials = readCredentials();
+  const hasCredential = !!credentials.providerProfiles[profile.id];
+  console.log(`  Credential: ${hasCredential ? ansis.green("stored \u2713") : ansis.red("missing")}`);
+  const issues = [];
+  if (!probeOk) issues.push("base URL unreachable");
+  if (!mr.primaryModel) issues.push("primary model unset");
+  if (!hasCredential) issues.push("credential missing");
+  const statusLabel = issues.length === 0 ? ansis.green("Healthy") : ansis.yellow(`Issues: ${issues.join(", ")}`);
+  console.log(`Status: ${statusLabel}`);
+  console.log();
+}
+function renderSlot(value) {
+  if (value) return ansis.green(`${value} (set)`);
+  return ansis.yellow("(unset)");
+}
+async function buildValidationResultJson(profile) {
+  let probe = { ok: false };
+  try {
+    const probeUrl = profile.baseUrl.replace(/\/$/, "");
+    const res = await fetch(probeUrl, { signal: AbortSignal.timeout(PROBE_TIMEOUT_MS) });
+    probe = { ok: res.ok, status: res.status };
+  } catch (e) {
+    probe = { ok: false, error: e.message };
+  }
+  const credentials = readCredentials();
+  const hasCredential = !!credentials.providerProfiles[profile.id];
+  const mr = profile.modelRouting;
+  const probeOk = probe.ok;
+  return {
+    profile: profile.id,
+    baseUrl: profile.baseUrl,
+    probe,
+    authType: profile.authType,
+    modelRouting: {
+      primaryModel: { value: mr.primaryModel || null, set: !!mr.primaryModel },
+      haikuModel: { value: mr.smallFastModel || null, set: !!mr.smallFastModel },
+      sonnetModel: { value: mr.subagentModel || null, set: !!mr.subagentModel },
+      opusModel: { value: mr.planModel || null, set: !!mr.planModel }
+    },
+    credentialStored: hasCredential,
+    healthy: probeOk && !!mr.primaryModel && hasCredential
+  };
+}
+
 async function resolveAndSwitchLanguage(lang, options, skipPrompt = false) {
   const ccjkConfig = await readCcjkConfigAsync();
   const targetLang = options?.allLang || lang || options?.lang || ccjkConfig?.preferredLang || (skipPrompt ? "en" : await selectScriptLanguage());
@@ -2648,7 +3607,7 @@ async function setupCommands(cli) {
   cli.command("", "Show interactive menu (default)").option("--lang, -l <lang>", "CCJK display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--force, -f", "Force overwrite existing configuration").option("--code-type, -T <codeType>", "Select code tool type (clavue, claude-code, codex, grok, cv, cc, cx, gk)").action(await withLanguageResolution(async (options) => {
     await showMainMenu({ codeType: options.codeType });
   }, true));
-  cli.command("init", "Initialize Claude Code configuration").alias("i").option("--lang, -l <lang>", "CCJK display language (zh-CN, en)").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--ai-output-lang, -a <lang>", "AI output language").option("--force, -f", "Force overwrite existing configuration").option("--skip-prompt, -s", "Skip all interactive prompts (non-interactive mode)").option("--config-action, -r <action>", `Config handling (new/backup/merge/docs-only/skip), ${i18n.t("cli:help.defaults.prefix")} backup`).option("--api-type, -t <type>", "API type (auth_token/api_key/ccr_proxy/skip)").option("--api-key, -k <key>", "API key (used for both API key and auth token types)").option("--api-url, -u <url>", "Custom API URL").option("--api-model, -M <model>", "Primary API model (e.g., claude-sonnet-4-5)").option("--api-haiku-model, -H <model>", "Default Haiku model (e.g., claude-haiku-4-5)").option("--api-sonnet-model, -S <model>", "Default Sonnet model (e.g., claude-sonnet-4-5)").option("--api-opus-model, -O <model>", "Default Opus model (e.g., claude-opus-4-5)").option("--provider, -p <provider>", "API provider preset (302ai, glm, minimax, kimi, custom)").option("--mcp-services, -m <services>", `Comma-separated MCP services to install (context7,mcp-deepwiki,Playwright,exa), "skip" to skip all, "all" for all non-key services, ${i18n.t("cli:help.defaults.prefix")} all`).option("--workflows, -w <workflows>", `Comma-separated workflows to install (sixStepsWorkflow,featPlanUx,gitWorkflow,bmadWorkflow), "skip" to skip all, "all" for all workflows, ${i18n.t("cli:help.defaults.prefix")} all`).option("--output-styles, -o <styles>", `Comma-separated output styles (linus-mode,uncle-bob-mode,dhh-mode,carmack-mode,jobs-mode,evan-you-mode,default,explanatory,learning), "skip" to skip all, "all" for zcf curated styles, ${i18n.t("cli:help.defaults.prefix")} none`).option("--default-output-style, -d <style>", `Default output style (or "none" to keep original behavior), ${i18n.t("cli:help.defaults.prefix")} none`).option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--code-type, -T <codeType>", "Select code tool type (clavue, claude-code, codex, grok, cv, cc, cx, gk)").option("--install-cometix-line, -x <value>", `Install CCometixLine statusline tool (true/false), ${i18n.t("cli:help.defaults.prefix")} true`).option("--api-configs <configs>", "API configurations as JSON string for multiple profiles").option("--api-configs-file <file>", "Path to JSON file containing API configurations").action(await withLanguageResolution(async (options) => {
+  cli.command("init", "Initialize Claude Code configuration").alias("i").option("--lang, -l <lang>", "CCJK display language (zh-CN, en)").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").option("--ai-output-lang, -a <lang>", "AI output language").option("--force, -f", "Force overwrite existing configuration").option("--skip-prompt, -s", "Skip all interactive prompts (non-interactive mode)").option("--config-action, -r <action>", `Config handling (new/backup/merge/docs-only/skip), ${i18n.t("cli:help.defaults.prefix")} backup`).option("--api-type, -t <type>", "API type (auth_token/api_key/ccr_proxy/skip)").option("--api-key, -k <key>", "API key (used for both API key and auth token types)").option("--api-url, -u <url>", "Custom API URL").option("--api-model, -M <model>", "Primary API model (e.g., claude-sonnet-4-5)").option("--api-haiku-model, -H <model>", "Default Haiku model (e.g., claude-haiku-4-5)").option("--api-sonnet-model, -S <model>", "Default Sonnet model (e.g., claude-sonnet-4-5)").option("--api-opus-model, -O <model>", "Default Opus model (e.g., claude-opus-4-5)").option("--provider, -p <provider>", "API provider preset (302ai, glm, minimax, kimi, custom)").option("--mcp-services, -m <services>", `Comma-separated MCP services to install (context7,mcp-deepwiki,Playwright,exa), "skip" to skip all, "all" for all non-key services, ${i18n.t("cli:help.defaults.prefix")} all`).option("--workflows, -w <workflows>", `Comma-separated workflows to install (sixStepsWorkflow,featPlanUx,gitWorkflow,bmadWorkflow), "skip" to skip all, "all" for all workflows, ${i18n.t("cli:help.defaults.prefix")} all`).option("--output-styles, -o <styles>", `Comma-separated output styles (agents-md-baseline,plan-first,verify-and-ship,surgical-diff,engineer-professional,default,explanatory,learning), "skip" to skip all, "all" for practical engineering styles, ${i18n.t("cli:help.defaults.prefix")} none`).option("--default-output-style, -d <style>", `Default output style (or "none" to keep original behavior), ${i18n.t("cli:help.defaults.prefix")} none`).option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--code-type, -T <codeType>", "Select code tool type (clavue, claude-code, codex, grok, cv, cc, cx, gk)").option("--install-cometix-line, -x <value>", `Install CCometixLine statusline tool (true/false), ${i18n.t("cli:help.defaults.prefix")} true`).option("--api-configs <configs>", "API configurations as JSON string for multiple profiles").option("--api-configs-file <file>", "Path to JSON file containing API configurations").action(await withLanguageResolution(async (options) => {
     await init(options);
   }));
   cli.command("update", "Update Claude Code prompts only").alias("u").option("--lang, -l <lang>", "CCJK display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--config-lang, -c <lang>", "Configuration language (zh-CN, en)").action(await withLanguageResolution(async (options) => {
@@ -2667,6 +3626,14 @@ async function setupCommands(cli) {
       list: options.list
     });
   }));
+  cli.command("clean", "Clean dirty MCP servers, skills, and redundant prompts").option("--code-type, -T <codeType>", "Code tool context (clavue, claude-code, codex, grok)").option("-s, --skip-prompt", "Non-interactive: clean only high-confidence items").option("--aggressive", "Select all detected issues in non-interactive mode").option("--purge-all", "Remove ALL MCP, skills, prompts, and ~/.codex/AGENTS.md").action(await withLanguageResolution(async (options) => {
+    await cleanCommand({
+      codeType: options.codeType,
+      skipPrompt: options.skipPrompt,
+      aggressive: options.aggressive,
+      purgeAll: options.purgeAll
+    });
+  }));
   cli.command("uninstall", "Remove CCJK configurations and tools").option("--lang, -l <lang>", "CCJK display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--code-type, -T <codeType>", "Select code tool type (clavue, claude-code, codex, grok, cv, cc, cx, gk)").option("--mode, -m <mode>", "Uninstall mode (complete/custom/interactive), default: interactive").option("--items, -i <items>", "Comma-separated items for custom uninstall mode").action(await withLanguageResolution(async (options) => {
     await uninstall(options);
   }));
@@ -2682,9 +3649,12 @@ async function setupCommands(cli) {
   }));
   cli.command("probe", "HTTP probe current API configuration").option("--json", "JSON output").action(await withLanguageResolution(async (options) => {
     await probeCommand({ json: options.json });
-  }));
+  }, true));
   cli.command("bench", "Lightweight latency benchmark (probe)").option("--json", "JSON output").action(await withLanguageResolution(async (options) => {
     await benchCommand({ json: options.json });
+  }, true));
+  cli.command("provider [action] [profileId]", "Manage Clavue provider profiles").option("--json", "JSON output").action(await withLanguageResolution(async (action, profileId, options) => {
+    await providerCommand({ action, profileId, json: options.json });
   }));
   cli.command("check-updates", "Check and update Claude Code and CCR to latest versions").alias("check").option("--lang, -l <lang>", "CCJK display language (zh-CN, en)").option("--all-lang, -g <lang>", "Set all language parameters to this value").option("--code-type, -T <codeType>", "Select code tool type (clavue, claude-code, codex, grok, cv, cc, cx, gk)").option("--skip-prompt, -s", "Skip all interactive prompts (non-interactive mode)").action(await withLanguageResolution(async (options) => {
     await checkUpdates(options);