ccjk 13.6.4 → 13.6.5

package/dist/chunks/sessions.mjs

@@ -1,5 +1,5 @@
 import a from './index5.mjs';
-import { t as taskPersistence } from '../shared/ccjk.DwSebGy0.mjs';
+import { t as taskPersistence } from '../shared/ccjk.BOO14f66.mjs';
 import '../shared/ccjk.BAGoDD49.mjs';
 import 'node:fs';
 import 'better-sqlite3';

package/dist/chunks/smart-defaults.mjs

@@ -1,10 +1,10 @@
 import { execSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { CCJK_CONFIG_DIR } from './constants.mjs';
+import { CCJK_CONFIG_DIR, CODE_TOOL_INFO } from './constants.mjs';
 import { writeJsonConfig } from './json-config.mjs';
 import { j as join } from '../shared/ccjk.bQ7Dh1g4.mjs';
-import { g as getPlatform } from './platform.mjs';
+import { g as getPlatform, e as commandExists } from './platform.mjs';
 import { s as scanProject } from '../shared/ccjk.DJuyfrlL.mjs';
 
 const ORCHESTRATION_LEVELS = ["off", "minimal", "standard", "max"];
@@ -89,7 +89,7 @@ class SmartDefaultsDetector {
     const platform = getPlatform();
     const apiKey = this.detectApiKey();
     const apiProvider = this.detectApiProvider(apiKey);
-    const ccVersion = this.detectClaudeCodeVersion();
+    const ccVersion = await this.detectClaudeCodeVersion();
     const projectContext = scanProject(cwd);
     return {
       // Environment detection
@@ -142,17 +142,28 @@ class SmartDefaultsDetector {
   /**
    * Detect installed Claude Code version
    */
-  detectClaudeCodeVersion() {
-    try {
-      const output = execSync('claude --version 2>/dev/null || echo ""', {
-        encoding: "utf-8",
-        timeout: 5e3
-      }).trim();
-      const match = output.match(/(\d+\.\d+\.\d+)/);
-      return match ? match[1] : void 0;
-    } catch {
-      return void 0;
+  async detectClaudeCodeVersion() {
+    const candidateCommands = [
+      CODE_TOOL_INFO["claude-code"].runtimeCommand,
+      CODE_TOOL_INFO.myclaude.runtimeCommand
+    ];
+    for (const command of candidateCommands) {
+      try {
+        if (!await commandExists(command)) {
+          continue;
+        }
+        const output = execSync(`${command} --version 2>/dev/null || echo ""`, {
+          encoding: "utf-8",
+          timeout: 5e3
+        }).trim();
+        const match = output.match(/(\d+\.\d+\.\d+)/);
+        if (match) {
+          return match[1];
+        }
+      } catch {
+      }
     }
+    return void 0;
   }
   /**
    * Detect which Claude Code native features are available
@@ -235,6 +246,23 @@ class SmartDefaultsDetector {
    * This is a static method so it can be called without instantiating the full detector.
    */
   static detectCodeToolType() {
+    const myclaudeMarkers = [
+      join(homedir(), ".claude.json"),
+      join(homedir(), ".claude", "config.json")
+    ];
+    try {
+      if (myclaudeMarkers.some((p) => existsSync(p))) {
+        const globalConfigPath = join(homedir(), ".claude.json");
+        if (existsSync(globalConfigPath)) {
+          const configContent = readFileSync(globalConfigPath, "utf-8");
+          const config = JSON.parse(configContent);
+          if (config.myclaudeActiveProviderProfileId || config.myclaudeProviderProfiles) {
+            return "myclaude";
+          }
+        }
+      }
+    } catch {
+    }
     const claudeCodePaths = [
       join(homedir(), ".claude"),
       join(homedir(), ".config", "claude")

package/dist/chunks/uninstall.mjs

@@ -3,7 +3,7 @@ import { i as inquirer } from './index6.mjs';
 import { ZCF_CONFIG_FILE, DEFAULT_CODE_TOOL_TYPE, isCodeToolType } from './constants.mjs';
 import { i18n, ensureI18nInitialized, resolveSupportedLanguage } from './index2.mjs';
 import { readZcfConfig } from './ccjk-config.mjs';
-import { r as resolveCodeType } from '../shared/ccjk.CiKtBUW_.mjs';
+import { r as resolveCodeType } from '../shared/ccjk.yYQMbHH3.mjs';
 import { a as handleExitPromptError, h as handleGeneralError } from '../shared/ccjk.DGllfVCZ.mjs';
 import { a as addNumbersToChoices } from '../shared/ccjk.BFQ7yr5S.mjs';
 import { p as promptBoolean } from '../shared/ccjk.DZ2LLOa-.mjs';

package/dist/cli.mjs

@@ -461,6 +461,34 @@ const COMMANDS = [
       };
     }
   },
+  {
+    name: "research <action> [...args]",
+    description: "Run focused autoresearch-style experiments",
+    tier: "extended",
+    options: [
+      { flags: "--name <name>", description: "Experiment name" },
+      { flags: "--cmd <command>", description: "Shell command to execute" },
+      { flags: "--metric <name>", description: "Metric name to parse from output" },
+      { flags: "--budget-ms <ms>", description: "Execution budget in milliseconds" },
+      { flags: "--cwd <path>", description: "Working directory for the command" },
+      { flags: "--limit <n>", description: "Number of sessions to list" }
+    ],
+    loader: async () => {
+      return async (options, action, args) => {
+        const actionStr = action;
+        const argsArr = args;
+        const { researchCommand } = await import('./chunks/research.mjs');
+        await researchCommand(actionStr || "help", argsArr, {
+          name: options.name,
+          cmd: options.cmd,
+          metric: options.metric,
+          budgetMs: options.budgetMs ? Number(options.budgetMs) : void 0,
+          cwd: options.cwd,
+          limit: options.limit ? Number(options.limit) : void 0
+        });
+      };
+    }
+  },
   // ==================== New v8.0.0 Commands ====================
   // Note: task, keybinding, and history commands use Commander.js subcommand pattern
   // They are registered via registerSpecialCommands() instead of lazy loading

package/dist/index.d.mts

@@ -5002,7 +5002,7 @@ declare function findRealCommandPath(command: string): Promise<string | null>;
  * Get recommended install methods for a code tool based on current platform
  * Returns methods in priority order (most recommended first)
  */
-type CodeType = 'claude-code' | 'codex';
+type CodeType = 'claude-code' | 'myclaude' | 'codex';
 type InstallMethod = 'npm' | 'homebrew' | 'curl' | 'powershell' | 'cmd' | 'npm-global' | 'native';
 declare function getRecommendedInstallMethods(codeType: CodeType): InstallMethod[];
 

package/dist/index.d.ts

@@ -5002,7 +5002,7 @@ declare function findRealCommandPath(command: string): Promise<string | null>;
  * Get recommended install methods for a code tool based on current platform
  * Returns methods in priority order (most recommended first)
  */
-type CodeType = 'claude-code' | 'codex';
+type CodeType = 'claude-code' | 'myclaude' | 'codex';
 type InstallMethod = 'npm' | 'homebrew' | 'curl' | 'powershell' | 'cmd' | 'npm-global' | 'native';
 declare function getRecommendedInstallMethods(codeType: CodeType): InstallMethod[];
 

package/dist/index.mjs

@@ -5,7 +5,7 @@ import { CLOUD_ENDPOINTS } from './chunks/constants.mjs';
 export { C as CloudError, a as CloudErrorCode, b as CloudErrorFactory, f as formatErrorForLogging, g as getRetryDelay, h as handleCloudError, i as isAuthError, c as isRateLimitError, d as isRetryableError, e as isRetryableErrorCode } from './shared/ccjk.vO3d1ABk.mjs';
 import { e as extractString } from './shared/ccjk.C2jHOZVP.mjs';
 export { a as extractDisplayName, i as i18nHelpers, n as normalizeRecommendation, b as normalizeRecommendations } from './shared/ccjk.C2jHOZVP.mjs';
-import { exec, execSync, spawn } from 'node:child_process';
+import { exec, execSync } from 'node:child_process';
 import { promises, existsSync, readdirSync, readFileSync, statSync, createReadStream } from 'node:fs';
 import * as os from 'node:os';
 import { homedir } from 'node:os';
@@ -14,6 +14,7 @@ import { promisify } from 'node:util';
 import a from './chunks/index5.mjs';
 import { g as getRuntimeVersion } from './shared/ccjk.gDEDGD_t.mjs';
 import { j as join$1 } from './shared/ccjk.bQ7Dh1g4.mjs';
+import { b as buildCommand, c as commandExists, a as escapeArgument, e as executeCommand, d as executeCommandParallel, f as executeCommandSequence, g as executeCommandStream, h as getCommandPath, i as getCommandVersion, p as parseVersion } from './shared/ccjk.BnsY5WxD.mjs';
 export { j as config } from './chunks/config.mjs';
 export { a as loggerUtils } from './shared/ccjk.8oaxX4iR.mjs';
 export { p as platform } from './chunks/platform.mjs';
@@ -1036,7 +1037,7 @@ const userSkillsApi = {
   sortByLastUsed
 };
 
-const execAsync$1 = promisify(exec);
+const execAsync = promisify(exec);
 class BaseCodeTool {
   config;
   configPath;
@@ -1061,7 +1062,7 @@ class BaseCodeTool {
   async isInstalled() {
     try {
       const command = this.getInstallCheckCommand();
-      const { stdout, stderr } = await execAsync$1(command);
+      const { stdout, stderr } = await execAsync(command);
       const version = this.parseVersion(stdout || stderr);
       return {
         installed: true,
@@ -1081,7 +1082,7 @@ class BaseCodeTool {
   async install() {
     try {
       const command = this.getInstallCommand();
-      const { stdout, stderr } = await execAsync$1(command);
+      const { stdout, stderr } = await execAsync(command);
       return {
         success: true,
         output: stdout || stderr,
@@ -1101,7 +1102,7 @@ class BaseCodeTool {
   async uninstall() {
     try {
       const command = this.getUninstallCommand();
-      const { stdout, stderr } = await execAsync$1(command);
+      const { stdout, stderr } = await execAsync(command);
       await this.removeConfigFile();
       return {
         success: true,
@@ -1163,7 +1164,7 @@ class BaseCodeTool {
   async execute(command, args = []) {
     try {
       const fullCommand = this.buildCommand(command, args);
-      const { stdout, stderr } = await execAsync$1(fullCommand, {
+      const { stdout, stderr } = await execAsync(fullCommand, {
         env: { ...process.env, ...this.config.env }
       });
       return {
@@ -1258,7 +1259,7 @@ class BaseCodeTool {
    */
   async findToolPath() {
     try {
-      const { stdout } = await execAsync$1(`which ${this.getMetadata().name}`);
+      const { stdout } = await execAsync(`which ${this.getMetadata().name}`);
       return stdout.trim();
     } catch (_error) {
       return void 0;
@@ -2726,173 +2727,6 @@ function generateRecommendations(scanResult) {
   return recommendations;
 }
 
-const execAsync = promisify(exec);
-async function executeCommand(command, args = [], options = {}) {
-  try {
-    const fullCommand = buildCommand(command, args);
-    const execOptions = {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      timeout: options.timeout,
-      shell: typeof options.shell === "string" ? options.shell : options.shell ? "/bin/sh" : void 0,
-      encoding: options.encoding || "utf8",
-      maxBuffer: options.maxBuffer || 1024 * 1024 * 10
-      // 10MB default
-    };
-    const { stdout, stderr } = await execAsync(fullCommand, execOptions);
-    return {
-      success: true,
-      stdout: stdout.toString().trim(),
-      stderr: stderr.toString().trim(),
-      exitCode: 0
-    };
-  } catch (error) {
-    return {
-      success: false,
-      stdout: error.stdout?.toString().trim() || "",
-      stderr: error.stderr?.toString().trim() || "",
-      exitCode: error.code || 1,
-      error: error.message
-    };
-  }
-}
-function executeCommandStream(command, args = [], options = {}) {
-  return new Promise((resolve) => {
-    const spawnOptions = {
-      cwd: options.cwd,
-      env: { ...process.env, ...options.env },
-      shell: options.shell !== false
-    };
-    const child = spawn(command, args, spawnOptions);
-    let stdout = "";
-    let stderr = "";
-    child.stdout?.on("data", (data) => {
-      const text = data.toString();
-      stdout += text;
-      if (options.onStdout) {
-        options.onStdout(text);
-      }
-    });
-    child.stderr?.on("data", (data) => {
-      const text = data.toString();
-      stderr += text;
-      if (options.onStderr) {
-        options.onStderr(text);
-      }
-    });
-    child.on("close", (code) => {
-      resolve({
-        success: code === 0,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: code || 0,
-        error: code !== 0 ? `Command exited with code ${code}` : void 0
-      });
-    });
-    child.on("error", (error) => {
-      resolve({
-        success: false,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode: 1,
-        error: error.message
-      });
-    });
-    if (options.timeout) {
-      setTimeout(() => {
-        child.kill();
-        resolve({
-          success: false,
-          stdout: stdout.trim(),
-          stderr: stderr.trim(),
-          exitCode: 1,
-          error: `Command timed out after ${options.timeout}ms`
-        });
-      }, options.timeout);
-    }
-  });
-}
-function buildCommand(command, args) {
-  const escapedArgs = args.map(escapeArgument);
-  return [command, ...escapedArgs].join(" ");
-}
-function escapeArgument(arg) {
-  if (/[\s"'`$&|;<>(){}[\]\\]/.test(arg)) {
-    const escaped = arg.replace(/"/g, '\\"');
-    return `"${escaped}"`;
-  }
-  return arg;
-}
-async function commandExists(command) {
-  const isWindows = process.platform === "win32";
-  const checkCommand = isWindows ? "where" : "which";
-  try {
-    const result = await executeCommand(checkCommand, [command]);
-    return result.success;
-  } catch {
-    return false;
-  }
-}
-async function getCommandPath(command) {
-  const isWindows = process.platform === "win32";
-  const checkCommand = isWindows ? "where" : "which";
-  try {
-    const result = await executeCommand(checkCommand, [command]);
-    if (result.success) {
-      return result.stdout.split("\n")[0].trim();
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function parseVersion(output) {
-  const patterns = [
-    /version\s+v?(\d+\.\d+\.\d+)/i,
-    /v?(\d+\.\d+\.\d+)/,
-    /(\d+\.\d+\.\d+)/
-  ];
-  for (const pattern of patterns) {
-    const match = output.match(pattern);
-    if (match) {
-      return match[1];
-    }
-  }
-  return null;
-}
-async function getCommandVersion(command, versionFlag = "--version") {
-  try {
-    const result = await executeCommand(command, [versionFlag]);
-    if (result.success) {
-      return parseVersion(result.stdout || result.stderr);
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-async function executeCommandSequence(commands) {
-  const results = [];
-  for (const cmd of commands) {
-    const result = await executeCommand(
-      cmd.command,
-      cmd.args || [],
-      cmd.options || {}
-    );
-    results.push(result);
-    if (!result.success) {
-      break;
-    }
-  }
-  return results;
-}
-async function executeCommandParallel(commands) {
-  const promises = commands.map(
-    (cmd) => executeCommand(cmd.command, cmd.args || [], cmd.options || {})
-  );
-  return Promise.all(promises);
-}
-
 const index$4 = {
   __proto__: null,
   buildCommand: buildCommand,

package/dist/shared/{ccjk.DwSebGy0.mjs → ccjk.BOO14f66.mjs}

@@ -597,4 +597,4 @@ class TaskPersistence {
 }
 const taskPersistence = new TaskPersistence();
 
-export { taskPersistence as t };
+export { TaskPersistence as T, taskPersistence as t };

package/dist/shared/ccjk.BnsY5WxD.mjs

@@ -0,0 +1,171 @@
+import { exec, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execAsync = promisify(exec);
+async function executeCommand(command, args = [], options = {}) {
+  try {
+    const fullCommand = buildCommand(command, args);
+    const execOptions = {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      timeout: options.timeout,
+      shell: typeof options.shell === "string" ? options.shell : options.shell ? "/bin/sh" : void 0,
+      encoding: options.encoding || "utf8",
+      maxBuffer: options.maxBuffer || 1024 * 1024 * 10
+      // 10MB default
+    };
+    const { stdout, stderr } = await execAsync(fullCommand, execOptions);
+    return {
+      success: true,
+      stdout: stdout.toString().trim(),
+      stderr: stderr.toString().trim(),
+      exitCode: 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      stdout: error.stdout?.toString().trim() || "",
+      stderr: error.stderr?.toString().trim() || "",
+      exitCode: error.code || 1,
+      error: error.message
+    };
+  }
+}
+function executeCommandStream(command, args = [], options = {}) {
+  return new Promise((resolve) => {
+    const spawnOptions = {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      shell: options.shell !== false
+    };
+    const child = spawn(command, args, spawnOptions);
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      if (options.onStdout) {
+        options.onStdout(text);
+      }
+    });
+    child.stderr?.on("data", (data) => {
+      const text = data.toString();
+      stderr += text;
+      if (options.onStderr) {
+        options.onStderr(text);
+      }
+    });
+    child.on("close", (code) => {
+      resolve({
+        success: code === 0,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code || 0,
+        error: code !== 0 ? `Command exited with code ${code}` : void 0
+      });
+    });
+    child.on("error", (error) => {
+      resolve({
+        success: false,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: 1,
+        error: error.message
+      });
+    });
+    if (options.timeout) {
+      setTimeout(() => {
+        child.kill();
+        resolve({
+          success: false,
+          stdout: stdout.trim(),
+          stderr: stderr.trim(),
+          exitCode: 1,
+          error: `Command timed out after ${options.timeout}ms`
+        });
+      }, options.timeout);
+    }
+  });
+}
+function buildCommand(command, args) {
+  const escapedArgs = args.map(escapeArgument);
+  return [command, ...escapedArgs].join(" ");
+}
+function escapeArgument(arg) {
+  if (/[\s"'`$&|;<>(){}[\]\\]/.test(arg)) {
+    const escaped = arg.replace(/"/g, '\\"');
+    return `"${escaped}"`;
+  }
+  return arg;
+}
+async function commandExists(command) {
+  const isWindows = process.platform === "win32";
+  const checkCommand = isWindows ? "where" : "which";
+  try {
+    const result = await executeCommand(checkCommand, [command]);
+    return result.success;
+  } catch {
+    return false;
+  }
+}
+async function getCommandPath(command) {
+  const isWindows = process.platform === "win32";
+  const checkCommand = isWindows ? "where" : "which";
+  try {
+    const result = await executeCommand(checkCommand, [command]);
+    if (result.success) {
+      return result.stdout.split("\n")[0].trim();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function parseVersion(output) {
+  const patterns = [
+    /version\s+v?(\d+\.\d+\.\d+)/i,
+    /v?(\d+\.\d+\.\d+)/,
+    /(\d+\.\d+\.\d+)/
+  ];
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+async function getCommandVersion(command, versionFlag = "--version") {
+  try {
+    const result = await executeCommand(command, [versionFlag]);
+    if (result.success) {
+      return parseVersion(result.stdout || result.stderr);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function executeCommandSequence(commands) {
+  const results = [];
+  for (const cmd of commands) {
+    const result = await executeCommand(
+      cmd.command,
+      cmd.args || [],
+      cmd.options || {}
+    );
+    results.push(result);
+    if (!result.success) {
+      break;
+    }
+  }
+  return results;
+}
+async function executeCommandParallel(commands) {
+  const promises = commands.map(
+    (cmd) => executeCommand(cmd.command, cmd.args || [], cmd.options || {})
+  );
+  return Promise.all(promises);
+}
+
+export { escapeArgument as a, buildCommand as b, commandExists as c, executeCommandParallel as d, executeCommand as e, executeCommandSequence as f, executeCommandStream as g, getCommandPath as h, getCommandVersion as i, parseVersion as p };

package/dist/shared/ccjk.yYQMbHH3.mjs

@@ -0,0 +1,115 @@
+import { i as inquirer } from '../chunks/index6.mjs';
+import { a as detectCodeToolType } from '../chunks/smart-defaults.mjs';
+import { CODE_TOOL_ALIASES, DEFAULT_CODE_TOOL_TYPE, isCodeToolType } from '../chunks/constants.mjs';
+import { i18n } from '../chunks/index2.mjs';
+import { readZcfConfigAsync, updateZcfConfig } from '../chunks/ccjk-config.mjs';
+
+const CODE_TYPE_ABBREVIATIONS = {
+  cc: "claude-code",
+  mc: "myclaude",
+  mycode: "myclaude",
+  cx: "codex"
+};
+const STARTUP_CODE_TOOL_CHOICES = ["myclaude", "claude-code", "codex"];
+async function resolveCodeType(codeTypeParam) {
+  if (codeTypeParam) {
+    const normalizedParam = codeTypeParam.toLowerCase().trim();
+    if (normalizedParam in CODE_TYPE_ABBREVIATIONS) {
+      return CODE_TYPE_ABBREVIATIONS[normalizedParam];
+    }
+    if (normalizedParam in CODE_TOOL_ALIASES) {
+      return CODE_TOOL_ALIASES[normalizedParam];
+    }
+    if (isValidCodeType(normalizedParam)) {
+      return normalizedParam;
+    }
+    const validAbbreviations = Object.keys(CODE_TYPE_ABBREVIATIONS);
+    const validFullTypes = Object.values(CODE_TYPE_ABBREVIATIONS);
+    const validOptions = [...validAbbreviations, ...validFullTypes].join(", ");
+    let defaultValue = DEFAULT_CODE_TOOL_TYPE;
+    try {
+      const config = await readZcfConfigAsync();
+      if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
+        defaultValue = config.codeToolType;
+      }
+    } catch {
+    }
+    throw new Error(
+      i18n.t("errors:invalidCodeType", { value: codeTypeParam, validOptions, defaultValue })
+    );
+  }
+  const storedType = await getStoredCodeType();
+  if (storedType) {
+    return storedType;
+  }
+  try {
+    const freshDetected = detectCodeToolType();
+    if (isValidCodeType(freshDetected)) {
+      return freshDetected;
+    }
+  } catch {
+  }
+  return DEFAULT_CODE_TOOL_TYPE;
+}
+function isValidCodeType(value) {
+  return isCodeToolType(value);
+}
+async function getStoredCodeType() {
+  try {
+    const config = await readZcfConfigAsync();
+    if (config?.codeToolType && isValidCodeType(config.codeToolType)) {
+      return config.codeToolType;
+    }
+  } catch {
+  }
+  return null;
+}
+function persistCodeType(codeToolType) {
+  updateZcfConfig({ codeToolType });
+}
+async function promptStartupCodeType() {
+  const isZh = i18n.language === "zh-CN";
+  const { codeToolType } = await inquirer.prompt({
+    type: "list",
+    name: "codeToolType",
+    message: isZh ? "\u9009\u62E9\u4EE3\u7801\u5DE5\u5177" : "Choose your code tool",
+    choices: STARTUP_CODE_TOOL_CHOICES.map((tool) => {
+      if (tool === "myclaude") {
+        return {
+          name: isZh ? `${tool} - Provider-first \u63A7\u5236\u4E2D\u5FC3\uFF08\u9ED8\u8BA4\u63A8\u8350\uFF09` : `${tool} - Provider-first control center (recommended default)`,
+          value: tool
+        };
+      }
+      if (tool === "claude-code") {
+        return {
+          name: isZh ? "Claude Code - Claude \u5BB6\u65CF\u7ECF\u5178\u63A7\u5236\u4E2D\u5FC3" : "Claude Code - Classic Claude-family control center",
+          value: tool
+        };
+      }
+      return {
+        name: isZh ? "Codex - Codex \u4E13\u5C5E\u63A7\u5236\u4E2D\u5FC3\u3001Provider / MCP / Memory \u914D\u7F6E" : "Codex - Codex-specific control center for provider, MCP, and memory setup",
+        value: tool
+      };
+    }),
+    default: 0
+  });
+  persistCodeType(codeToolType);
+  return codeToolType;
+}
+async function resolveStartupCodeType(options = {}) {
+  if (options.codeTypeParam) {
+    const resolvedType = await resolveCodeType(options.codeTypeParam);
+    persistCodeType(resolvedType);
+    return resolvedType;
+  }
+  const storedType = await getStoredCodeType();
+  if (storedType) {
+    return storedType;
+  }
+  if (options.interactive) {
+    return await promptStartupCodeType();
+  }
+  return await resolveCodeType();
+}
+
+export { STARTUP_CODE_TOOL_CHOICES as S, resolveStartupCodeType as a, resolveCodeType as r };