ccjk 14.2.2 → 15.0.0

package/dist/cli.mjs

@@ -1,2684 +0,0 @@
-#!/usr/bin/env node
-import process__default from 'node:process';
-import { spawn } from 'node:child_process';
-
-function parseOptionalNumber(value, flag) {
-  if (value === void 0) {
-    return void 0;
-  }
-  const parsed = Number(value);
-  if (!Number.isFinite(parsed)) {
-    throw new TypeError(`${flag} must be a valid number`);
-  }
-  return parsed;
-}
-function parseOptionalPositiveNumber(value, flag) {
-  const parsed = parseOptionalNumber(value, flag);
-  if (parsed === void 0) {
-    return void 0;
-  }
-  if (parsed <= 0) {
-    throw new TypeError(`${flag} must be greater than 0`);
-  }
-  return parsed;
-}
-function parseOptionalPositiveInteger(value, flag) {
-  const parsed = parseOptionalPositiveNumber(value, flag);
-  if (parsed === void 0) {
-    return void 0;
-  }
-  if (!Number.isInteger(parsed)) {
-    throw new TypeError(`${flag} must be an integer`);
-  }
-  return parsed;
-}
-const COMMANDS = [
-  // ==================== Core Commands ====================
-  {
-    name: "",
-    description: "Show interactive menu (default)",
-    tier: "core",
-    options: [
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" }
-    ],
-    loader: async () => {
-      const { showMainMenu } = await import('./chunks/index9.mjs').then(function (n) { return n.i; });
-      return async (options) => {
-        await showMainMenu({ codeType: options.codeType });
-      };
-    }
-  },
-  {
-    name: "init",
-    description: "Initialize Claude Code configuration",
-    aliases: ["i"],
-    tier: "core",
-    options: [
-      { flags: "--lang, -l <lang>", description: "Display language" },
-      { flags: "--config-lang, -c <lang>", description: "Configuration language" },
-      { flags: "--force, -f", description: "Force overwrite" },
-      { flags: "--skip-prompt, -s", description: "Skip prompts" },
-      { flags: "--silent", description: "Silent mode - fully non-interactive with smart defaults" },
-      { flags: "--api-type, -t <type>", description: "API type" },
-      { flags: "--api-key, -k <key>", description: "API key" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" },
-      { flags: "--orchestration <level>", description: "Workflow orchestration level (off|minimal|standard|max)" },
-      { flags: "--install-agent-browser <boolean>", description: "Install Agent Browser during init (default: true)" },
-      { flags: "--smart", description: "Smart generation mode - auto-detect project and generate agents/skills" },
-      { flags: "--dry-run", description: "Preview changes without writing files" },
-      { flags: "--yes, -y", description: "Skip confirmation prompts (auto-confirm)" }
-    ],
-    loader: async () => {
-      const { init } = await import('./chunks/init.mjs').then(function (n) { return n.c; });
-      return async (options) => {
-        await init(options);
-      };
-    }
-  },
-  {
-    name: "quick-setup",
-    description: "One-click configuration for CCJK",
-    aliases: ["quick", "qs"],
-    tier: "core",
-    options: [
-      { flags: "--api-key <key>", description: "API key" },
-      { flags: "--provider <provider>", description: "API provider" },
-      { flags: "--skip-prompt, -s", description: "Skip all prompts" },
-      { flags: "--lang, -l <lang>", description: "Display language" }
-    ],
-    loader: async () => {
-      const { quickSetup } = await import('./chunks/quick-setup.mjs');
-      return async (options) => {
-        await quickSetup(options);
-      };
-    }
-  },
-  {
-    name: "update",
-    description: "Update Claude Code prompts",
-    aliases: ["u"],
-    tier: "core",
-    options: [
-      { flags: "--lang, -l <lang>", description: "Display language" },
-      { flags: "--config-lang, -c <lang>", description: "Configuration language" }
-    ],
-    loader: async () => {
-      const { update } = await import('./chunks/update.mjs');
-      return async (options) => {
-        await update({
-          codeType: options.codeType,
-          configLang: options.configLang,
-          aiOutputLang: options.aiOutputLang
-        });
-      };
-    }
-  },
-  {
-    name: "upgrade",
-    description: "Upgrade CCJK to the latest version",
-    tier: "core",
-    options: [],
-    loader: async () => {
-      const { upgrade } = await import('./chunks/upgrade.mjs');
-      return async () => {
-        await upgrade();
-      };
-    }
-  },
-  {
-    name: "doctor",
-    description: "Run environment health check",
-    tier: "core",
-    options: [
-      { flags: "--check-providers", description: "Check API provider health" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" },
-      { flags: "--fix-settings", description: "Fix settings.json validation issues" },
-      { flags: "--json", description: "Output in JSON format" }
-    ],
-    loader: async () => {
-      const { doctor } = await import('./chunks/doctor.mjs');
-      return async (options) => {
-        await doctor({
-          checkProviders: options.checkProviders,
-          codeType: options.codeType,
-          fixSettings: options.fixSettings,
-          json: options.json
-        });
-      };
-    }
-  },
-  {
-    name: "help [topic]",
-    description: "Show help and quick reference",
-    aliases: ["h", "?"],
-    tier: "core",
-    loader: async () => {
-      const { help } = await import('./chunks/help.mjs');
-      return async (_options, topic) => {
-        await help(topic);
-      };
-    }
-  },
-  // ==================== Extended Commands ====================
-  {
-    name: "mcp <action> [...args]",
-    description: "MCP Server management",
-    tier: "extended",
-    options: [
-      { flags: "--tool, -T <type>", description: "Target tool (claude-code, codex)" },
-      { flags: "--verbose, -v", description: "Verbose output" },
-      { flags: "--dry-run, -d", description: "Preview changes" },
-      { flags: "--yes, -y", description: "Skip confirmation prompts" },
-      { flags: "--installed", description: "Show only installed services" },
-      { flags: "--json", description: "Output in JSON format" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        if (actionStr === "status" || !actionStr) {
-          const { mcpStatus } = await import('./chunks/mcp.mjs');
-          await mcpStatus(options);
-        } else if (actionStr === "doctor") {
-          const { mcpDoctor } = await import('./chunks/mcp.mjs');
-          await mcpDoctor(options);
-        } else if (actionStr === "profile") {
-          const { listProfiles, showCurrentProfile, useProfile } = await import('./chunks/mcp.mjs');
-          if (!argsArr[0] || argsArr[0] === "list" || argsArr[0] === "ls") {
-            await listProfiles(options);
-          } else if (argsArr[0] === "current" || argsArr[0] === "status") {
-            await showCurrentProfile(options);
-          } else if (argsArr[0] === "use" || argsArr[0] === "switch") {
-            await useProfile(argsArr[1] || "", options);
-          } else {
-            await useProfile(argsArr[0], options);
-          }
-        } else if (actionStr === "release") {
-          const { mcpRelease } = await import('./chunks/mcp.mjs');
-          await mcpRelease(options);
-        } else if (actionStr === "help") {
-          const { mcpHelp } = await import('./chunks/mcp.mjs');
-          mcpHelp(options);
-        } else if (actionStr === "list") {
-          if (options.json || options.installed) {
-            const { mcpListCli } = await import('./chunks/mcp-cli.mjs');
-            await mcpListCli({
-              json: options.json,
-              installed: options.installed,
-              tool: options.tool,
-              lang: options.lang
-            });
-          } else {
-            const { mcpList } = await import('./chunks/mcp.mjs');
-            await mcpList(options);
-          }
-        } else if (actionStr === "search") {
-          const { mcpSearch } = await import('./chunks/mcp.mjs');
-          await mcpSearch(argsArr[0] || "", options);
-        } else if (actionStr === "install") {
-          if (argsArr.length > 1 || options.yes) {
-            const { mcpInstallCli } = await import('./chunks/mcp-cli.mjs');
-            await mcpInstallCli({
-              services: argsArr,
-              yes: options.yes,
-              tool: options.tool,
-              lang: options.lang
-            });
-          } else {
-            const { mcpInstall } = await import('./chunks/mcp.mjs');
-            await mcpInstall(argsArr[0] || "", options);
-          }
-        } else if (actionStr === "uninstall") {
-          if (argsArr.length > 1 || options.yes) {
-            const { mcpUninstallCli } = await import('./chunks/mcp-cli.mjs');
-            await mcpUninstallCli({
-              services: argsArr,
-              yes: options.yes,
-              tool: options.tool,
-              lang: options.lang
-            });
-          } else {
-            const { mcpUninstall } = await import('./chunks/mcp.mjs');
-            await mcpUninstall(argsArr[0] || "", options);
-          }
-        } else {
-          const { mcpHelp } = await import('./chunks/mcp.mjs');
-          mcpHelp(options);
-        }
-      };
-    }
-  },
-  {
-    name: "memory",
-    description: "Manage Claude Code memory (view/edit/sync)",
-    aliases: ["mem"],
-    tier: "core",
-    options: [
-      { flags: "--status", description: "Show memory status without changing files" },
-      { flags: "--doctor", description: "Run memory health diagnostics" },
-      { flags: "-v, --view", description: "View memory content" },
-      { flags: "-e, --edit", description: "Edit memory interactively" },
-      { flags: "-s, --sync", description: "Sync memory using AutoMemoryBridge" },
-      { flags: "-p, --project <path>", description: "Project-specific memory path" }
-    ],
-    loader: async () => {
-      const { memoryCommand } = await import('./chunks/memory.mjs');
-      return async (options) => {
-        await memoryCommand(options);
-      };
-    }
-  },
-  {
-    name: "agents <action> [...args]",
-    description: "Agent Teams - Multi-agent orchestration",
-    aliases: ["team", "teams"],
-    tier: "extended",
-    options: [
-      { flags: "--task <task>", description: "Task description" },
-      { flags: "--workflow <id>", description: "Workflow preset (analyze, fix, test, optimize)" },
-      { flags: "--verbose, -v", description: "Verbose output" },
-      { flags: "--json", description: "JSON output" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        const { handleAgentsCommand } = await import('./chunks/agents.mjs');
-        await handleAgentsCommand([actionStr, ...argsArr], {
-          task: options.task,
-          workflow: options.workflow,
-          verbose: options.verbose,
-          json: options.json
-        });
-      };
-    }
-  },
-  {
-    name: "browser <action> [...args]",
-    description: "Agent Browser management",
-    aliases: ["ab"],
-    tier: "extended",
-    options: [
-      { flags: "--verbose, -v", description: "Verbose output" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        if (actionStr === "install") {
-          const { installAgentBrowser } = await import('./chunks/installer2.mjs');
-          await installAgentBrowser();
-        } else if (actionStr === "uninstall") {
-          const { uninstallAgentBrowser } = await import('./chunks/installer2.mjs');
-          await uninstallAgentBrowser();
-        } else if (actionStr === "status") {
-          const { agentBrowserStatus } = await import('./chunks/commands2.mjs');
-          await agentBrowserStatus(options);
-        } else if (actionStr === "start") {
-          const { startBrowserSession } = await import('./chunks/commands2.mjs');
-          await startBrowserSession(argsArr[0], options);
-        } else if (actionStr === "stop") {
-          const { stopBrowserSession } = await import('./chunks/commands2.mjs');
-          await stopBrowserSession(options);
-        } else if (actionStr === "config") {
-          const { configureBrowser } = await import('./chunks/commands2.mjs');
-          await configureBrowser(options);
-        } else {
-          const { agentBrowserHelp } = await import('./chunks/commands2.mjs');
-          agentBrowserHelp(options);
-        }
-      };
-    }
-  },
-  {
-    name: "interview [specFile]",
-    description: "Interview-Driven Development",
-    aliases: ["iv"],
-    tier: "extended",
-    options: [
-      { flags: "--template, -t <template>", description: "Interview template" },
-      { flags: "--depth, -d <depth>", description: "Interview depth" },
-      { flags: "--resume, -r", description: "Resume session" },
-      { flags: "--list", description: "List sessions" }
-    ],
-    loader: async () => {
-      const { interview, quickInterview, deepInterview, listInterviewSessions, resumeInterview } = await import('./chunks/interview.mjs');
-      return async (options, specFile) => {
-        if (options.list) {
-          await listInterviewSessions();
-        } else if (options.resume) {
-          await resumeInterview();
-        } else if (options.depth === "quick") {
-          await quickInterview(specFile, {
-            specFile,
-            depth: "quick",
-            resume: !!options.resume,
-            lang: options.lang
-          });
-        } else if (options.depth === "deep") {
-          await deepInterview(specFile, {
-            specFile,
-            depth: "deep",
-            resume: !!options.resume,
-            lang: options.lang
-          });
-        } else {
-          await interview({
-            specFile,
-            depth: options.depth,
-            template: options.template,
-            resume: !!options.resume,
-            lang: options.lang
-          });
-        }
-      };
-    }
-  },
-  {
-    name: "commit",
-    description: "Smart git commit",
-    tier: "extended",
-    options: [
-      { flags: "--auto, -a", description: "Auto-generate message" },
-      { flags: "--dry-run, -d", description: "Preview only" },
-      { flags: "--message, -m <msg>", description: "Custom message" }
-    ],
-    loader: async () => {
-      const { commit } = await import('./chunks/commit.mjs');
-      return async (options) => {
-        await commit({
-          auto: options.auto,
-          dryRun: options.dryRun,
-          message: options.message
-        });
-      };
-    }
-  },
-  {
-    name: "memory",
-    description: "Manage Claude auto-memory and CCJK Brain memory",
-    aliases: ["mem"],
-    tier: "extended",
-    options: [
-      { flags: "--status", description: "Show memory status without changing files" },
-      { flags: "--doctor", description: "Run memory health diagnostics" },
-      { flags: "-v, --view", description: "View memory content" },
-      { flags: "-e, --edit", description: "Edit memory interactively" },
-      { flags: "-s, --sync", description: "Sync memory using AutoMemoryBridge" },
-      { flags: "-p, --project <path>", description: "Project-specific memory path" }
-    ],
-    loader: async () => {
-      const { memoryCommand } = await import('./chunks/memory.mjs');
-      return async (options) => {
-        await memoryCommand(options);
-      };
-    }
-  },
-  {
-    name: "generate [projectPath]",
-    description: "Smart agent/skill generation \u2014 auto-detect project and generate configs",
-    aliases: ["gen"],
-    tier: "extended",
-    options: [
-      { flags: "--dry-run, -d", description: "Preview without writing files" },
-      { flags: "--verbose, -v", description: "Verbose output" }
-    ],
-    loader: async () => {
-      return async (_options, projectPath) => {
-        const { smartGenerateAndInstall } = await import('./chunks/index13.mjs');
-        await smartGenerateAndInstall(projectPath);
-      };
-    }
-  },
-  {
-    name: "config [action] [...args]",
-    description: "Manage CCJK configuration",
-    tier: "extended",
-    options: [
-      { flags: "--format, -f <format>", description: "Output format (table|json|yaml)" },
-      { flags: "--global, -g", description: "Use global config" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        const configOptions = {
-          global: !!options.global,
-          json: options.format === "json",
-          codeType: options.codeType
-        };
-        if (!actionStr || actionStr === "list") {
-          const { listConfig } = await import('./chunks/config3.mjs');
-          await listConfig(configOptions);
-        } else if (actionStr === "get") {
-          const { getConfig } = await import('./chunks/config3.mjs');
-          await getConfig(argsArr[0] || "", configOptions);
-        } else if (actionStr === "set") {
-          const { setConfig } = await import('./chunks/config3.mjs');
-          await setConfig(argsArr[0] || "", argsArr[1] || "", configOptions);
-        } else if (actionStr === "unset") {
-          const { unsetConfig } = await import('./chunks/config3.mjs');
-          await unsetConfig(argsArr[0] || "", configOptions);
-        } else if (actionStr === "reset") {
-          const { resetConfig } = await import('./chunks/config3.mjs');
-          await resetConfig(configOptions);
-        } else if (actionStr === "edit") {
-          const { editConfig } = await import('./chunks/config3.mjs');
-          await editConfig(configOptions);
-        } else if (actionStr === "validate") {
-          const { validateConfig } = await import('./chunks/config3.mjs');
-          await validateConfig(configOptions);
-        } else {
-          console.error(`Unknown config action: ${actionStr}`);
-          console.log("Available actions: list, get, set, unset, reset, edit, validate");
-        }
-      };
-    }
-  },
-  {
-    name: "providers [action] [...args]",
-    description: "Manage API providers",
-    tier: "extended",
-    options: [
-      { flags: "--format, -f <format>", description: "Output format (table|json)" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" },
-      { flags: "--verbose, -v", description: "Verbose output" }
-    ],
-    loader: async () => {
-      return async (options, action) => {
-        const actionStr = action;
-        const { providersCommand } = await import('./chunks/providers.mjs');
-        await providersCommand(actionStr || "list", {
-          lang: options.lang,
-          codeType: options.codeType,
-          verbose: options.verbose
-        });
-      };
-    }
-  },
-  {
-    name: "research <action> [...args]",
-    description: "Run persisted research experiments with explicit metric comparison",
-    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: "--objective <mode>", description: "Metric objective (auto|maximize|minimize)" },
-      { flags: "--baseline <sessionId>", description: "Baseline session id to compare against" },
-      { flags: "--program <path>", description: "Research program file path" },
-      { flags: "--db-path <path>", description: "Research database path" },
-      { 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" },
-      { flags: "--max-rounds <n>", description: "Maximum loop rounds" },
-      { flags: "--max-no-improve-rounds <n>", description: "Maximum no-improve rounds before stop" },
-      { flags: "--target-metric <value>", description: "Stop the loop when target metric is reached" }
-    ],
-    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,
-          objective: options.objective,
-          baseline: options.baseline,
-          program: options.program,
-          dbPath: options.dbPath,
-          budgetMs: parseOptionalPositiveNumber(options.budgetMs, "--budget-ms"),
-          cwd: options.cwd,
-          limit: parseOptionalPositiveInteger(options.limit, "--limit"),
-          maxRounds: parseOptionalPositiveInteger(options.maxRounds, "--max-rounds"),
-          maxNoImproveRounds: parseOptionalPositiveInteger(options.maxNoImproveRounds, "--max-no-improve-rounds"),
-          targetMetric: parseOptionalNumber(options.targetMetric, "--target-metric")
-        });
-      };
-    }
-  },
-  // ==================== 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
-  // {
-  //   name: 'task [action]',
-  //   description: 'Task management (create, list, update, delete, graph, stats, schedule)',
-  //   aliases: ['tasks'],
-  //   tier: 'extended',
-  //   options: [
-  //     { flags: '--lang, -l <lang>', description: 'Display language' },
-  //   ],
-  //   loader: async () => {
-  //     // Task command handler - future enhancement
-  //     return async () => {
-  //       console.log('Task command not yet implemented for CAC')
-  //     }
-  //   },
-  // },
-  // ========================================================================
-  {
-    name: "ccr",
-    description: "Configure Claude Code Router",
-    tier: "extended",
-    loader: async () => {
-      const { ccr } = await import('./chunks/ccr.mjs');
-      return async () => {
-        await ccr();
-      };
-    }
-  },
-  {
-    name: "zero-config [preset]",
-    description: "Apply zero-config permission presets (max, dev, safe)",
-    aliases: ["zc"],
-    tier: "extended",
-    options: [
-      { flags: "--preset, -p <preset>", description: "Preset to apply (max, dev, safe)" },
-      { flags: "--list, -l", description: "List available presets" },
-      { flags: "--skip-backup", description: "Skip backup before applying" },
-      { flags: "--dry-run", description: "Preview the full config plan without writing files" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" },
-      { flags: "--skip-ccr", description: "Do not install CCR while applying core features" }
-    ],
-    loader: async () => {
-      const { zeroConfig } = await import('./chunks/zero-config.mjs');
-      return async (options, preset) => {
-        await zeroConfig({
-          preset: preset || options.preset,
-          list: options.list,
-          skipBackup: options.skipBackup,
-          dryRun: options.dryRun,
-          codeTool: options.codeType,
-          installCcr: options.skipCcr ? false : void 0
-        });
-      };
-    }
-  },
-  {
-    name: "snapshot [action] [id]",
-    description: "List or inspect config snapshots",
-    tier: "extended",
-    options: [
-      { flags: "--json", description: "Output in JSON format" }
-    ],
-    loader: async () => {
-      const { snapshotCommand } = await import('./chunks/snapshot.mjs');
-      return async (options, action, id) => {
-        await snapshotCommand(action, id, {
-          json: options.json
-        });
-      };
-    }
-  },
-  {
-    name: "rollback <id>",
-    description: "Rollback config files from a snapshot",
-    tier: "extended",
-    options: [
-      { flags: "--json", description: "Output in JSON format" }
-    ],
-    loader: async () => {
-      const { rollbackCommand } = await import('./chunks/rollback.mjs');
-      return async (options, id) => {
-        await rollbackCommand(id, {
-          json: options.json
-        });
-      };
-    }
-  },
-  {
-    name: "context-opt [action] [...args]",
-    description: "Context optimization tools (stats/search/decay/config)",
-    tier: "extended",
-    options: [
-      { flags: "--top-k, -k <number>", description: "Number of search results" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        if (actionStr === "stats") {
-          const { contextOptStats } = await import('./chunks/context-opt.mjs');
-          await contextOptStats();
-        } else if (actionStr === "search") {
-          const { contextOptSearch } = await import('./chunks/context-opt.mjs');
-          await contextOptSearch(argsArr[0] || "", { topK: options.topK });
-        } else if (actionStr === "decay") {
-          const { contextOptDecay } = await import('./chunks/context-opt.mjs');
-          await contextOptDecay();
-        } else if (actionStr === "config") {
-          const { contextOptConfig } = await import('./chunks/context-opt.mjs');
-          await contextOptConfig();
-        } else {
-          console.log("\n\u{1F9E0} Context Optimization Commands:");
-          console.log("  ccjk context-opt stats   - Show memory tree statistics");
-          console.log("  ccjk context-opt search  - Search memory tree");
-          console.log("  ccjk context-opt decay   - Run confidence decay");
-          console.log("  ccjk context-opt config  - Show configuration\n");
-        }
-      };
-    }
-  },
-  {
-    name: "vim",
-    description: "Vim mode configuration and keybindings",
-    tier: "extended",
-    options: [
-      { flags: "--enable, -e", description: "Enable Vim mode" },
-      { flags: "--disable, -d", description: "Disable Vim mode" },
-      { flags: "--toggle, -t", description: "Toggle Vim mode" },
-      { flags: "--status, -s", description: "Show status" },
-      { flags: "--install", description: "Install keybindings" },
-      { flags: "--uninstall", description: "Uninstall keybindings" },
-      { flags: "--keys, -k", description: "Show keybinding reference" },
-      { flags: "--test <cmd>", description: "Test command parsing" },
-      { flags: "--lang, -l <lang>", description: "Language (en, zh-CN)" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { vimCommand } = await import('./chunks/vim.mjs');
-        await vimCommand({
-          lang: options.lang,
-          enable: options.enable,
-          disable: options.disable,
-          toggle: options.toggle,
-          status: options.status,
-          install: options.install,
-          uninstall: options.uninstall,
-          keys: options.keys,
-          test: options.test
-        });
-      };
-    }
-  },
-  {
-    name: "permissions [action] [...args]",
-    description: "Manage CCJK permissions",
-    aliases: ["perm"],
-    tier: "extended",
-    options: [
-      { flags: "--format, -f <format>", description: "Output format (table|json|list)" },
-      { flags: "--verbose, -v", description: "Verbose output" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        if (!actionStr || actionStr === "list") {
-          const { listPermissions } = await import('./chunks/permissions.mjs');
-          await listPermissions(options);
-        } else if (actionStr === "check") {
-          const { checkPermission } = await import('./chunks/permissions.mjs');
-          await checkPermission(argsArr[0] || "", options);
-        } else if (actionStr === "grant") {
-          const { grantPermission } = await import('./chunks/permissions.mjs');
-          await grantPermission(argsArr[0] || "", options);
-        } else if (actionStr === "revoke") {
-          const { revokePermission } = await import('./chunks/permissions.mjs');
-          await revokePermission(argsArr[0] || "", options);
-        } else if (actionStr === "reset") {
-          const { resetPermissions } = await import('./chunks/permissions.mjs');
-          await resetPermissions(options);
-        } else if (actionStr === "export") {
-          const { exportPermissions } = await import('./chunks/permissions.mjs');
-          await exportPermissions(argsArr[0], options);
-        } else if (actionStr === "import") {
-          const { importPermissions } = await import('./chunks/permissions.mjs');
-          await importPermissions(argsArr[0] || "", options);
-        } else {
-          const { permissionsHelp } = await import('./chunks/permissions.mjs');
-          permissionsHelp(options);
-        }
-      };
-    }
-  },
-  {
-    name: "skills [action] [...args]",
-    description: "Manage CCJK skills",
-    aliases: ["sk"],
-    tier: "extended",
-    options: [
-      { flags: "--category, -c <category>", description: "Filter by category" },
-      { flags: "--show-disabled", description: "Show disabled skills" },
-      { flags: "--format, -f <format>", description: "Output format (table|json|list)" },
-      { flags: "--batch", description: "Batch create skills" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const { initI18n } = await import('./chunks/index2.mjs');
-        await initI18n(options.lang || "zh-CN");
-        const actionStr = action;
-        const argsArr = args;
-        if (!actionStr) {
-          const { skillsMenu } = await import('./chunks/skills.mjs');
-          await skillsMenu(options);
-        } else if (actionStr === "list" || actionStr === "ls") {
-          const { listSkills } = await import('./chunks/skills.mjs');
-          await listSkills(options);
-        } else if (actionStr === "run") {
-          const { runSkill } = await import('./chunks/skills.mjs');
-          await runSkill(argsArr[0] || "", options);
-        } else if (actionStr === "info") {
-          const { showSkillInfo } = await import('./chunks/skills.mjs');
-          await showSkillInfo(argsArr[0] || "", options);
-        } else if (actionStr === "create") {
-          const { createSkill } = await import('./chunks/skills.mjs');
-          await createSkill(argsArr[0] || "", options);
-        } else if (actionStr === "enable") {
-          const { enableSkill } = await import('./chunks/skills.mjs');
-          await enableSkill(argsArr[0] || "", options);
-        } else if (actionStr === "disable") {
-          const { disableSkill } = await import('./chunks/skills.mjs');
-          await disableSkill(argsArr[0] || "", options);
-        } else if (actionStr === "delete" || actionStr === "remove" || actionStr === "rm") {
-          const { deleteSkill } = await import('./chunks/skills.mjs');
-          await deleteSkill(argsArr[0] || "", options);
-        } else {
-          const { runSkill } = await import('./chunks/skills.mjs');
-          await runSkill(actionStr, options);
-        }
-      };
-    }
-  },
-  // ==================== Plugins-v2 Commands ====================
-  {
-    name: "skill [action] [...args]",
-    description: "Manage plugins-v2 skills (SKILL.md based)",
-    tier: "extended",
-    options: [
-      { flags: "--force, -f", description: "Force reinstall" },
-      { flags: "--json", description: "Output as JSON" }
-    ],
-    loader: async () => {
-      const { handleSkillCommand } = await import('./chunks/skill2.mjs');
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        await handleSkillCommand([actionStr, ...argsArr], {
-          force: options.force,
-          json: options.json
-        });
-      };
-    }
-  },
-  {
-    name: "agent [action] [...args]",
-    description: "Manage AI agents (Skills + MCP composition)",
-    aliases: ["ag"],
-    tier: "extended",
-    options: [
-      { flags: "--template, -t <template>", description: "Use agent template" },
-      { flags: "--skills, -s <skills>", description: "Comma-separated skill IDs" },
-      { flags: "--mcp, -m <servers>", description: "Comma-separated MCP servers" },
-      { flags: "--persona, -p <persona>", description: "Custom persona" },
-      { flags: "--json", description: "Output as JSON" }
-    ],
-    loader: async () => {
-      const { handleAgentCommand } = await import('./chunks/agent.mjs');
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args;
-        await handleAgentCommand([actionStr, ...argsArr], {
-          template: options.template,
-          skills: options.skills ? options.skills.split(",") : void 0,
-          mcp: options.mcp ? options.mcp.split(",") : void 0,
-          persona: options.persona,
-          json: options.json
-        });
-      };
-    }
-  },
-  {
-    name: "ccu [...args]",
-    description: "Claude Code usage analysis",
-    tier: "extended",
-    loader: async () => {
-      const { executeCcusage } = await import('./chunks/ccu.mjs');
-      return async (_options, args) => {
-        await executeCcusage(args);
-      };
-    }
-  },
-  {
-    name: "impact",
-    description: "Usage impact page with daily tokens, savings, and before/after trends",
-    aliases: ["gain"],
-    tier: "extended",
-    options: [
-      { flags: "--days <days>", description: "Number of days to include (7-90)" },
-      { flags: "--json", description: "Output as JSON" },
-      { flags: "--output <file>", description: "Custom HTML output path" }
-    ],
-    loader: async () => {
-      const { impactCommand } = await import('./chunks/impact.mjs');
-      return async (options) => {
-        await impactCommand({
-          json: options.json,
-          days: options.days ? Number(options.days) : void 0,
-          output: options.output
-        });
-      };
-    }
-  },
-  {
-    name: "stats [action]",
-    description: "Usage statistics and analytics",
-    tier: "extended",
-    options: [
-      { flags: "--period, -p <period>", description: "Time period (1d, 7d, 30d, 90d, all)" },
-      { flags: "--format, -f <format>", description: "Output format (table, json, csv)" },
-      { flags: "--export, -e <file>", description: "Export to file" },
-      { flags: "--provider <provider>", description: "Filter by provider" },
-      { flags: "--days <days>", description: "Days to keep for cleanup action" }
-    ],
-    loader: async () => {
-      return async (options, action) => {
-        const actionStr = action;
-        if (actionStr === "dates") {
-          const { listStatsDates } = await import('./chunks/stats.mjs');
-          await listStatsDates();
-        } else if (actionStr === "storage") {
-          const { storageStats } = await import('./chunks/stats.mjs');
-          await storageStats();
-        } else if (actionStr === "cleanup") {
-          const { cleanupStats } = await import('./chunks/stats.mjs');
-          const days = options.days ? Number.parseInt(options.days, 10) : 90;
-          await cleanupStats(days);
-        } else {
-          const { stats } = await import('./chunks/stats.mjs');
-          await stats(options);
-        }
-      };
-    }
-  },
-  {
-    name: "uninstall",
-    description: "Remove CCJK configurations",
-    tier: "extended",
-    options: [
-      { flags: "--mode, -m <mode>", description: "Uninstall mode" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" }
-    ],
-    loader: async () => {
-      const { uninstall } = await import('./chunks/uninstall.mjs');
-      return async (options) => {
-        await uninstall(options);
-      };
-    }
-  },
-  {
-    name: "check-updates",
-    description: "Check for updates",
-    aliases: ["check"],
-    tier: "extended",
-    options: [
-      { flags: "--code-type, -T <type>", description: "Code tool type" },
-      { flags: "--skip-prompt, -s", description: "Skip prompts" }
-    ],
-    loader: async () => {
-      const { checkUpdates } = await import('./chunks/check-updates.mjs');
-      return async (options) => {
-        await checkUpdates(options);
-      };
-    }
-  },
-  {
-    name: "config-switch [target]",
-    description: "Switch configuration",
-    aliases: ["cs"],
-    tier: "extended",
-    options: [
-      { flags: "--code-type, -T <type>", description: "Code tool type" },
-      { flags: "--list, -l", description: "List configurations" }
-    ],
-    loader: async () => {
-      const { configSwitchCommand } = await import('./chunks/config-switch.mjs');
-      return async (options, target) => {
-        await configSwitchCommand({
-          target,
-          codeType: options.codeType,
-          list: options.list
-        });
-      };
-    }
-  },
-  {
-    name: "workflows",
-    description: "Manage workflows",
-    aliases: ["wf"],
-    tier: "extended",
-    loader: async () => {
-      const { listWorkflowsQuick } = await import('./chunks/workflows.mjs');
-      return async () => {
-        await listWorkflowsQuick();
-      };
-    }
-  },
-  {
-    name: "notification [action]",
-    description: "Task notifications",
-    aliases: ["notify"],
-    tier: "extended",
-    loader: async () => {
-      const { notificationCommand } = await import('./chunks/notification.mjs');
-      return async (_options, action) => {
-        await notificationCommand(action);
-      };
-    }
-  },
-  {
-    name: "session <action> [id]",
-    description: "Session management (save, restore, list, delete)",
-    tier: "extended",
-    options: [
-      { flags: "--name, -n <name>", description: "Session name" }
-    ],
-    loader: async () => {
-      const { handleSessionCommand } = await import('./chunks/session.mjs');
-      return async (_options, action, id) => {
-        const args = [];
-        if (action)
-          args.push(action);
-        if (id)
-          args.push(id);
-        await handleSessionCommand(args);
-      };
-    }
-  },
-  {
-    name: "context <action> [id]",
-    description: "Context management (analyze, compress, optimize, status)",
-    aliases: ["ctx"],
-    tier: "extended",
-    options: [
-      { flags: "--verbose, -v", description: "Verbose output" },
-      { flags: "--show", description: "Show context layers" },
-      { flags: "--layers <layers>", description: "Specific layers to show" },
-      { flags: "--task <task>", description: "Preview context for task" },
-      { flags: "--clear", description: "Clear context cache" },
-      { flags: "--health", description: "Run database health check" },
-      { flags: "--alerts", description: "Show current health alerts" },
-      { flags: "--alert-history", description: "Show alert history" },
-      { flags: "--checkpoint", description: "Checkpoint WAL file" },
-      { flags: "--vacuum", description: "Vacuum database" },
-      { flags: "--backup", description: "Create database backup" },
-      { flags: "--recover", description: "Attempt database recovery" }
-    ],
-    loader: async () => {
-      const { contextCommand } = await import('./chunks/context.mjs');
-      return async (options, action) => {
-        await contextCommand({
-          ...options,
-          action
-        });
-      };
-    }
-  },
-  {
-    name: "api [action] [...args]",
-    description: "Configure API providers",
-    tier: "extended",
-    options: [
-      { flags: "--provider, -p <provider>", description: "Provider ID" },
-      { flags: "--key, -k <key>", description: "API key" },
-      { flags: "--url <url>", description: "API URL" },
-      { flags: "--model <model>", description: "Default model" },
-      { flags: "--fast-model <model>", description: "Fast model" },
-      { flags: "--yes, -y", description: "Skip confirmation prompts" },
-      { flags: "--json", description: "Output in JSON format" },
-      { flags: "--test, -t", description: "Test connection" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action || "wizard";
-        const argsArr = args || [];
-        if (actionStr === "configure" || actionStr === "setup" && (options.provider || options.yes)) {
-          const { apiConfigure } = await import('./chunks/api-cli.mjs');
-          await apiConfigure({
-            provider: options.provider,
-            key: options.key,
-            url: options.url,
-            model: options.model,
-            fastModel: options.fastModel,
-            yes: options.yes,
-            lang: options.lang
-          });
-        } else if (actionStr === "list" && options.json) {
-          const { apiList } = await import('./chunks/api-cli.mjs');
-          await apiList({
-            json: options.json,
-            lang: options.lang
-          });
-        } else {
-          const { apiCommand } = await import('./chunks/api.mjs');
-          await apiCommand(actionStr, argsArr, options);
-        }
-      };
-    }
-  },
-  {
-    name: "team <action>",
-    description: "Team collaboration",
-    tier: "extended",
-    loader: async () => {
-      const { teamInit, teamShare, teamSync } = await import('./chunks/team.mjs');
-      return async (_options, action) => {
-        const actionStr = action;
-        if (actionStr === "init")
-          await teamInit();
-        else if (actionStr === "share")
-          await teamShare();
-        else if (actionStr === "sync")
-          await teamSync();
-      };
-    }
-  },
-  // ==================== Thinking Mode Commands ====================
-  {
-    name: "agent-teams",
-    description: "Toggle Claude Code Agent Teams (experimental)",
-    aliases: ["teams"],
-    tier: "extended",
-    options: [
-      { flags: "--on", description: "Enable Agent Teams" },
-      { flags: "--off", description: "Disable Agent Teams" },
-      { flags: "--status", description: "Show current status" },
-      { flags: "--mode <mode>", description: "Set teammate mode (auto/in-process/tmux)" }
-    ],
-    loader: async () => {
-      const { agentTeamsCommand } = await import('./chunks/agent-teams.mjs');
-      return async (options) => {
-        await agentTeamsCommand(options);
-      };
-    }
-  },
-  {
-    name: "thinking [action] [...args]",
-    description: "Thinking Mode (Opus 4.5+ extended reasoning)",
-    aliases: ["think"],
-    tier: "extended",
-    options: [
-      { flags: "--json", description: "Output in JSON format" },
-      { flags: "--verbose, -v", description: "Verbose output" }
-    ],
-    loader: async () => {
-      const { thinking } = await import('./chunks/thinking.mjs');
-      return async (options, action, args) => {
-        await thinking(action, args, options);
-      };
-    }
-  },
-  // ==================== Postmortem System ====================
-  {
-    name: "postmortem <action> [...args]",
-    description: "\u{1F52C} Postmortem Intelligence - Learn from historical bugs",
-    aliases: ["pm"],
-    tier: "extended",
-    options: [
-      { flags: "--severity <level>", description: "Filter by severity (critical/high/medium/low)" },
-      { flags: "--category <cat>", description: "Filter by category" },
-      { flags: "--status <status>", description: "Filter by status" },
-      { flags: "--staged", description: "Check staged files only" },
-      { flags: "--ci", description: "CI mode, exit with error on issues" },
-      { flags: "--since <tag>", description: "Start version/commit" },
-      { flags: "--until <tag>", description: "End version/commit" },
-      { flags: "--version <ver>", description: "Associated version" }
-    ],
-    loader: async () => {
-      return async (options, action, args) => {
-        const actionStr = action;
-        const argsArr = args || [];
-        const { getPostmortemManager } = await import('./chunks/index11.mjs');
-        const manager = getPostmortemManager(process.cwd());
-        if (actionStr === "init") {
-          const ora = (await import('./chunks/index8.mjs')).default;
-          const ansis = (await import('./chunks/index5.mjs')).default;
-          const spinner = ora("Analyzing historical fix commits...").start();
-          try {
-            const result = await manager.init();
-            spinner.succeed(ansis.green("Postmortem system initialized"));
-            console.log(`
-   ${ansis.yellow("Reports generated:")} ${result.created}`);
-            console.log(`   ${ansis.yellow("Directory:")} ${result.directory}
-`);
-          } catch (error) {
-            spinner.fail(ansis.red("Initialization failed"));
-            console.error(error);
-          }
-        } else if (actionStr === "generate" || actionStr === "gen") {
-          const ora = (await import('./chunks/index8.mjs')).default;
-          const ansis = (await import('./chunks/index5.mjs')).default;
-          const spinner = ora("Analyzing commits...").start();
-          try {
-            if (options.version) {
-              const summary = await manager.generateReleaseSummary({
-                version: options.version,
-                since: options.since,
-                until: options.until
-              });
-              spinner.succeed(ansis.green("Release summary generated"));
-              console.log(`
-   ${ansis.yellow("Version:")} ${summary.version}`);
-              console.log(`   ${ansis.yellow("Fix commits:")} ${summary.fixCommitCount}`);
-              console.log(`   ${ansis.yellow("New postmortems:")} ${summary.newPostmortems.length}
-`);
-            } else {
-              const result = await manager.init();
-              spinner.succeed(ansis.green("Postmortem generation complete"));
-              console.log(`
-   ${ansis.yellow("Reports:")} ${result.created}
-`);
-            }
-          } catch (error) {
-            spinner.fail(ansis.red("Generation failed"));
-            console.error(error);
-          }
-        } else if (actionStr === "list" || actionStr === "ls") {
-          const ansis = (await import('./chunks/index5.mjs')).default;
-          let reports = manager.listReports();
-          if (options.severity)
-            reports = reports.filter((r) => r.severity === options.severity);
-          if (options.category)
-            reports = reports.filter((r) => r.category === options.category);
-          if (options.status)
-            reports = reports.filter((r) => r.status === options.status);
-          if (reports.length === 0) {
-            console.log(ansis.yellow("\nNo postmortem reports found"));
-            console.log(ansis.gray('Run "ccjk postmortem init" to initialize\n'));
-            return;
-          }
-          const severityEmoji = { critical: "\u{1F534}", high: "\u{1F7E0}", medium: "\u{1F7E1}", low: "\u{1F7E2}" };
-          console.log(ansis.cyan.bold("\n\u{1F4CB} Postmortem Reports"));
-          console.log(ansis.gray("\u2500".repeat(50)));
-          for (const r of reports) {
-            console.log(`
-${severityEmoji[r.severity] || "\u26AA"} ${ansis.bold(r.id)}: ${r.title}`);
-            console.log(`   ${ansis.gray("Category:")} ${r.category}  ${ansis.gray("Status:")} ${r.status}`);
-          }
-          console.log(ansis.gray(`
-\u2500 Total: ${reports.length} reports \u2500
-`));
-        } else if (actionStr === "show") {
-          const ansis = (await import('./chunks/index5.mjs')).default;
-          const id = argsArr[0];
-          if (!id) {
-            console.log(ansis.red("Please specify a postmortem ID"));
-            return;
-          }
-          const report = manager.getReport(id);
-          if (!report) {
-            console.log(ansis.red(`Postmortem not found: ${id}`));
-            return;
-          }
-          console.log(ansis.cyan.bold(`
-\u2550\u2550\u2550 ${report.id}: ${report.title} \u2550\u2550\u2550
-`));
-          console.log(`${ansis.yellow("Severity:")} ${report.severity.toUpperCase()}`);
-          console.log(`${ansis.yellow("Category:")} ${report.category}`);
-          console.log(`${ansis.yellow("Status:")} ${report.status}`);
-          console.log(`
-${ansis.cyan("Description:")}
-${report.description}`);
-          console.log(`
-${ansis.cyan("Root Cause:")}
-${report.rootCause.map((c) => `  \u2022 ${c}`).join("\n")}`);
-          console.log(`
-${ansis.cyan("Prevention:")}
-${report.preventionMeasures.map((m) => `  \u2022 ${m}`).join("\n")}`);
-          console.log(`
-${ansis.cyan("AI Directives:")}
-${report.aiDirectives.map((d) => `  \u2022 ${d}`).join("\n")}
-`);
-        } else if (actionStr === "check") {
-          const ora = (await import('./chunks/index8.mjs')).default;
-          const ansis = (await import('./chunks/index5.mjs')).default;
-          const spinner = ora("Checking code...").start();
-          try {
-            const result = await manager.checkCode({
-              staged: options.staged,
-              files: argsArr.length > 0 ? argsArr : void 0
-            });
-            spinner.stop();
-            console.log(ansis.cyan.bold("\n\u{1F50D} Postmortem Code Check"));
-            console.log(ansis.gray("\u2500".repeat(40)));
-            console.log(`   Files checked: ${result.filesChecked}`);
-            console.log(`   Issues found: ${result.issuesFound.length}`);
-            console.log(`
-   \u{1F534} Critical: ${result.summary.critical}`);
-            console.log(`   \u{1F7E0} High: ${result.summary.high}`);
-            console.log(`   \u{1F7E1} Medium: ${result.summary.medium}`);
-            console.log(`   \u{1F7E2} Low: ${result.summary.low}`);
-            if (result.issuesFound.length > 0) {
-              console.log(ansis.yellow("\n\u26A0\uFE0F Issues:"));
-              for (const issue of result.issuesFound.slice(0, 10)) {
-                console.log(`
-   ${issue.file}:${issue.line}`);
-                console.log(`   ${issue.message}`);
-              }
-            }
-            console.log(result.passed ? ansis.green("\n\u2705 Check passed\n") : ansis.red("\n\u274C Check failed\n"));
-            if (!result.passed && options.ci)
-              process.exit(1);
-          } catch (error) {
-            spinner.fail(ansis.red("Check failed"));
-            console.error(error);
-          }
-        } else if (actionStr === "sync") {
-          const ora = (await import('./chunks/index8.mjs')).default;
-          const ansis = (await import('./chunks/index5.mjs')).default;
-          const spinner = ora("Syncing to CLAUDE.md...").start();
-          try {
-            const result = await manager.syncToClaudeMd();
-            spinner.succeed(ansis.green("Sync complete"));
-            console.log(`
-   ${ansis.yellow("Synced:")} ${result.synced} items`);
-            console.log(`   ${ansis.yellow("File:")} ${result.claudeMdPath}
-`);
-          } catch (error) {
-            spinner.fail(ansis.red("Sync failed"));
-            console.error(error);
-          }
-        } else if (actionStr === "stats") {
-          const ansis = (await import('./chunks/index5.mjs')).default;
-          const index = manager.loadIndex();
-          if (!index) {
-            console.log(ansis.yellow("\nNo statistics available"));
-            console.log(ansis.gray('Run "ccjk postmortem init" to initialize\n'));
-            return;
-          }
-          console.log(ansis.cyan.bold("\n\u{1F4CA} Postmortem Statistics"));
-          console.log(ansis.gray("\u2500".repeat(40)));
-          console.log(`
-${ansis.yellow("Total:")} ${index.stats.total} reports`);
-          console.log(`
-${ansis.yellow("By Severity:")}`);
-          console.log(`   \u{1F534} Critical: ${index.stats.bySeverity.critical}`);
-          console.log(`   \u{1F7E0} High: ${index.stats.bySeverity.high}`);
-          console.log(`   \u{1F7E1} Medium: ${index.stats.bySeverity.medium}`);
-          console.log(`   \u{1F7E2} Low: ${index.stats.bySeverity.low}`);
-          console.log(`
-${ansis.yellow("By Status:")}`);
-          console.log(`   \u26A1 Active: ${index.stats.byStatus.active}`);
-          console.log(`   \u2705 Resolved: ${index.stats.byStatus.resolved}`);
-          console.log(`   \u{1F440} Monitoring: ${index.stats.byStatus.monitoring}`);
-          console.log(`   \u{1F4E6} Archived: ${index.stats.byStatus.archived}
-`);
-        } else {
-          console.log("\n\u{1F52C} Postmortem Commands:");
-          console.log("  ccjk postmortem init          - Initialize system");
-          console.log("  ccjk postmortem generate      - Generate from commits");
-          console.log("  ccjk postmortem list          - List all reports");
-          console.log("  ccjk postmortem show <id>     - Show report details");
-          console.log("  ccjk postmortem check         - Check code for issues");
-          console.log("  ccjk postmortem sync          - Sync to CLAUDE.md");
-          console.log("  ccjk postmortem stats         - Show statistics\n");
-        }
-      };
-    }
-  },
-  // ==================== Context Compression System ====================
-  {
-    name: "claude",
-    description: "Transparent claude command wrapper with context compression",
-    tier: "extended",
-    options: [
-      { flags: "--debug", description: "Enable debug output" },
-      { flags: "--no-wrap", description: "Disable wrapping (pass through)" }
-    ],
-    loader: async () => {
-      const { claudeWrapper } = await import('./chunks/claude-wrapper.mjs');
-      return async (options) => {
-        const argv = process.argv;
-        const claudeIndex = argv.findIndex((arg) => arg === "claude");
-        const rawArgs = claudeIndex >= 0 ? argv.slice(claudeIndex + 1) : [];
-        const args = rawArgs.filter((arg) => arg !== "--debug" && arg !== "--no-wrap");
-        await claudeWrapper(args, {
-          debug: options.debug,
-          noWrap: options.noWrap
-        });
-      };
-    }
-  },
-  // ==================== Performance Monitoring ====================
-  {
-    name: "monitor [action]",
-    description: "Real-time performance monitoring dashboard",
-    tier: "extended",
-    options: [
-      { flags: "--refresh, -r <ms>", description: "Refresh interval (milliseconds)" },
-      { flags: "--range <timeRange>", description: "Report time range (hourly|daily|weekly|monthly)" },
-      { flags: "--format, -f <format>", description: "Export format (json|csv|html)" },
-      { flags: "--output, -o <file>", description: "Output file path" },
-      { flags: "--json", description: "Also output JSON format" },
-      { flags: "--no-banner", description: "Do not display banner" }
-    ],
-    loader: async () => {
-      return async (options, action) => {
-        const { monitor } = await import('./chunks/monitor.mjs');
-        await monitor(action || void 0, options);
-      };
-    }
-  },
-  // ==================== Configuration Management ====================
-  {
-    name: "config [action] [key] [value]",
-    description: "Manage configuration",
-    tier: "extended",
-    options: [
-      { flags: "--json", description: "Output in JSON format" },
-      { flags: "--code-type, -T <type>", description: "Code tool type" }
-    ],
-    loader: async () => {
-      const { configCommand } = await import('./chunks/config3.mjs');
-      return async (options, action, key, value) => {
-        const args = [];
-        if (action !== void 0)
-          args.push(action);
-        if (key !== void 0)
-          args.push(key);
-        if (value !== void 0)
-          args.push(value);
-        await configCommand(args[0] || "list", args.slice(1), {
-          lang: options.lang,
-          codeType: options.codeType,
-          global: options.global,
-          json: options.json
-        });
-      };
-    }
-  },
-  // context 命令已在上面定义（第 435 行），使用 context-compression/commands/context.ts
-  // shell hook 管理功能通过 'ccjk context hook install/uninstall' 子命令访问
-  // Deprecated commands removed in v2.x cleanup
-  // - shencha: replaced by 'ccjk doctor'
-  // - features: replaced by 'ccjk' menu
-  // - tools: replaced by 'ccjk' menu
-  // ==================== CCJK v8.0.0 Commands ====================
-  {
-    name: "ccjk:mcp",
-    description: "Intelligent MCP service management based on project analysis",
-    aliases: ["ccjk-mcp"],
-    tier: "extended",
-    options: [
-      { flags: "--tier <tier>", description: "Service tier filter (core, ondemand, scenario, all)" },
-      { flags: "--services <services>", description: "Specific services to install (comma-separated)" },
-      { flags: "--exclude <services>", description: "Services to exclude (comma-separated)" },
-      { flags: "--auto-install", description: "Auto-install dependencies" },
-      { flags: "--skip-verification", description: "Skip service verification" },
-      { flags: "--dry-run", description: "Preview without installing" },
-      { flags: "--json", description: "JSON output for automation" },
-      { flags: "--force", description: "Force reinstallation" },
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { ccjkMcp, formatResultAsJson, formatResultForConsole } = await import('./chunks/ccjk-mcp.mjs');
-        const services = options.services ? options.services.split(",").map((s) => s.trim()) : void 0;
-        const exclude = options.exclude ? options.exclude.split(",").map((s) => s.trim()) : void 0;
-        const result = await ccjkMcp({
-          interactive: !options.json && !options.dryRun,
-          tier: options.tier,
-          services,
-          exclude,
-          autoInstall: options.autoInstall,
-          skipVerification: options.skipVerification,
-          dryRun: options.dryRun,
-          json: options.json,
-          lang: options.lang,
-          force: options.force
-        });
-        if (options.json) {
-          console.log(formatResultAsJson(result));
-        } else {
-          console.log(formatResultForConsole(result));
-        }
-      };
-    }
-  },
-  {
-    name: "ccjk:skills",
-    description: "Auto-recommend and install CCJK skills based on project analysis",
-    aliases: ["ccjk-skills"],
-    tier: "extended",
-    options: [
-      { flags: "--category <category>", description: "Filter by skill category" },
-      { flags: "--tags <tags>", description: "Filter by tags (comma-separated)" },
-      { flags: "--exclude <skills>", description: "Exclude specific skills (comma-separated)" },
-      { flags: "--dry-run", description: "Show recommendations without installing" },
-      { flags: "--force", description: "Force installation even if already installed" },
-      { flags: "--json", description: "JSON output" },
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { ccjkSkills } = await import('./chunks/ccjk-skills.mjs');
-        await ccjkSkills({
-          category: options.category,
-          tags: options.tags ? options.tags.split(",") : void 0,
-          exclude: options.exclude ? options.exclude.split(",") : void 0,
-          dryRun: options.dryRun,
-          force: options.force,
-          json: options.json,
-          lang: options.lang
-        });
-      };
-    }
-  },
-  {
-    name: "ccjk:agents",
-    description: "Create and manage CCJK agents",
-    aliases: ["ccjk-agents"],
-    tier: "extended",
-    options: [
-      { flags: "--create <name>", description: "Create a new agent" },
-      { flags: "--list", description: "List available agents" },
-      { flags: "--delete <name>", description: "Delete an agent" },
-      { flags: "--template <template>", description: "Use specific template" },
-      { flags: "--json", description: "JSON output" },
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { ccjkAgents } = await import('./chunks/ccjk-agents.mjs');
-        await ccjkAgents({
-          create: options.create,
-          list: options.list,
-          delete: options.delete,
-          template: options.template,
-          json: options.json,
-          lang: options.lang
-        });
-      };
-    }
-  },
-  {
-    name: "ccjk:persistence",
-    description: "Manage context persistence and storage tiers",
-    aliases: ["ccjk-persistence", "persistence"],
-    tier: "extended",
-    options: [
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      return async (_options) => {
-        const { persistenceManager } = await import('./chunks/persistence-manager.mjs');
-        await persistenceManager();
-      };
-    }
-  },
-  {
-    name: "ccjk:hooks",
-    description: "Auto-recommend and configure CCJK hooks based on project analysis",
-    aliases: ["ccjk-hooks"],
-    tier: "extended",
-    options: [
-      { flags: "--type <type>", description: "Filter by hook type (pre-commit, post-commit, etc.)" },
-      { flags: "--category <category>", description: "Filter by category (quality, security, etc.)" },
-      { flags: "--exclude <hooks>", description: "Exclude specific hooks (comma-separated)" },
-      { flags: "--enabled", description: "Only show enabled hooks" },
-      { flags: "--dry-run", description: "Show recommendations without installing" },
-      { flags: "--json", description: "JSON output" },
-      { flags: "--verbose", description: "Verbose output" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { ccjkHooks } = await import('./chunks/ccjk-hooks.mjs');
-        await ccjkHooks({
-          type: options.type,
-          category: options.category,
-          exclude: options.exclude ? options.exclude.split(",") : void 0,
-          enabled: options.enabled,
-          dryRun: options.dryRun,
-          json: options.json,
-          verbose: options.verbose
-        });
-      };
-    }
-  },
-  {
-    name: "ccjk:skills",
-    description: "Auto-install skills based on project analysis",
-    aliases: ["ccjk-skills"],
-    tier: "extended",
-    options: [
-      { flags: "--interactive, -i", description: "Interactive mode (default: true)" },
-      { flags: "--category <category>", description: "Filter by skill category" },
-      { flags: "--tags <tags>", description: "Filter by tags (comma-separated)" },
-      { flags: "--exclude <skills>", description: "Exclude specific skills (comma-separated)" },
-      { flags: "--dry-run", description: "Show what would be installed without installing" },
-      { flags: "--json", description: "Output in JSON format" },
-      { flags: "--force", description: "Force installation (overwrite existing)" },
-      { flags: "--target-dir <dir>", description: "Target directory (default: current)" },
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { ccjkSkills } = await import('./chunks/ccjk-skills.mjs');
-        await ccjkSkills({
-          interactive: options.interactive !== false,
-          category: options.category,
-          tags: options.tags ? options.tags.split(",") : void 0,
-          exclude: options.exclude ? options.exclude.split(",") : void 0,
-          dryRun: options.dryRun,
-          json: options.json,
-          force: options.force,
-          targetDir: options.targetDir,
-          lang: options.lang
-        });
-      };
-    }
-  },
-  // ==================== CCJK v8.0.0 Setup Commands ====================
-  {
-    name: "ccjk:all",
-    description: "Cloud AI-powered complete setup (Recommended)",
-    aliases: ["ccjk-all"],
-    tier: "extended",
-    options: [
-      { flags: "--strategy <type>", description: "Cloud strategy (cloud-smart/cloud-conservative/local-fallback)" },
-      { flags: "--use-cloud", description: "Use cloud recommendations" },
-      { flags: "--cloud-endpoint <url>", description: "Cloud API endpoint" },
-      { flags: "--cache-strategy <type>", description: "Cache strategy" },
-      { flags: "--show-reasons", description: "Show recommendation reasons" },
-      { flags: "--show-confidence", description: "Show confidence scores" },
-      { flags: "--show-comparison", description: "Show community comparison" },
-      { flags: "--submit-telemetry", description: "Submit anonymous telemetry" },
-      { flags: "--dry-run", description: "Preview without installing" },
-      { flags: "--json", description: "JSON output" },
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { ccjkAll } = await import('./chunks/ccjk-all.mjs');
-        await ccjkAll({
-          strategy: options.strategy,
-          useCloud: options.useCloud,
-          cloudEndpoint: options.cloudEndpoint,
-          cacheStrategy: options.cacheStrategy,
-          showRecommendationReason: options.showReasons,
-          showConfidence: options.showConfidence,
-          showComparison: options.showComparison,
-          submitTelemetry: options.submitTelemetry,
-          dryRun: options.dryRun,
-          json: options.json,
-          lang: options.lang
-        });
-      };
-    }
-  },
-  {
-    name: "ccjk:setup",
-    description: "Complete local setup with project analysis",
-    aliases: ["ccjk-setup"],
-    tier: "extended",
-    options: [
-      { flags: "--profile <profile>", description: "Setup profile (minimal/recommended/full/custom)" },
-      { flags: "--resources <resources>", description: "Resources to install (comma-separated)" },
-      { flags: "--parallel", description: "Enable parallel execution" },
-      { flags: "--max-concurrency <number>", description: "Maximum parallel operations" },
-      { flags: "--interactive", description: "Interactive mode" },
-      { flags: "--auto-confirm, -y", description: "Auto-confirm all prompts" },
-      { flags: "--dry-run", description: "Preview without installing" },
-      { flags: "--json", description: "JSON output" },
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      return async (options) => {
-        const { ccjkSetup } = await import('./chunks/ccjk-setup.mjs');
-        const exitCode = await ccjkSetup({
-          profile: options.profile,
-          resources: options.resources ? options.resources.split(",") : void 0,
-          parallel: options.parallel,
-          maxConcurrency: options.maxConcurrency ? Number(options.maxConcurrency) : void 0,
-          interactive: options.interactive !== false,
-          autoConfirm: options.autoConfirm,
-          dryRun: options.dryRun,
-          json: options.json,
-          lang: options.lang
-        });
-        if (exitCode !== 0) {
-          process.exit(exitCode);
-        }
-      };
-    }
-  },
-  // ==================== Brain Dashboard ====================
-  {
-    name: "sessions",
-    description: "Manage and restore Brain System sessions",
-    tier: "extended",
-    options: [
-      { flags: "--list", description: "List all sessions" },
-      { flags: "--show <id>", description: "Show session details" },
-      { flags: "--restore <id>", description: "Restore incomplete session" },
-      { flags: "--cleanup", description: "Clean up old sessions" }
-    ],
-    loader: async () => {
-      const { sessionsCommand } = await import('./chunks/sessions.mjs');
-      return async (options) => {
-        await sessionsCommand({
-          list: options.list,
-          show: options.show,
-          restore: options.restore,
-          cleanup: options.cleanup
-        });
-      };
-    }
-  },
-  // ==================== Evaluation System ====================
-  {
-    name: "eval",
-    description: "Run evaluation scenarios and benchmarks",
-    tier: "extended",
-    options: [
-      { flags: "--scenario <id>", description: "Run specific scenario" },
-      { flags: "--suite <name>", description: "Run specific suite" },
-      { flags: "--runs <n>", description: "Number of runs per scenario" },
-      { flags: "--verbose, -v", description: "Verbose output" },
-      { flags: "--html", description: "Generate HTML dashboard" },
-      { flags: "--json", description: "Generate JSON reports" },
-      { flags: "--baseline <path>", description: "Baseline report path" },
-      { flags: "--candidate <path>", description: "Candidate report path" },
-      { flags: "--compare", description: "Compare baseline and candidate" }
-    ],
-    loader: async () => {
-      const { evalCommand } = await import('./chunks/eval.mjs');
-      return async (options) => {
-        await evalCommand({
-          scenario: options.scenario,
-          suite: options.suite,
-          runs: options.runs ? parseInt(options.runs, 10) : 1,
-          verbose: options.verbose,
-          html: options.html !== false,
-          json: options.json !== false,
-          baseline: options.baseline,
-          candidate: options.candidate,
-          compare: options.compare
-        });
-      };
-    }
-  },
-  {
-    name: "context",
-    description: "View and manage hierarchical context loading",
-    tier: "extended",
-    options: [
-      { flags: "--show", description: "Show loaded context" },
-      { flags: "--layers <layers>", description: "Specify layers (comma-separated)" },
-      { flags: "--task <name>", description: "Preview context for task" },
-      { flags: "--clear", description: "Clear context cache" }
-    ],
-    loader: async () => {
-      const { contextCommand } = await import('./chunks/context.mjs');
-      return async (options) => {
-        await contextCommand({
-          show: options.show,
-          layers: options.layers,
-          task: options.task,
-          clear: options.clear
-        });
-      };
-    }
-  },
-  {
-    name: "paradigm",
-    description: "Detect and display project file system paradigm",
-    tier: "extended",
-    options: [
-      { flags: "--verbose", description: "Show detailed information" },
-      { flags: "--role <role>", description: "Show files for specific role" }
-    ],
-    loader: async () => {
-      const { paradigmCommand } = await import('./chunks/paradigm.mjs');
-      return async (options) => {
-        await paradigmCommand({
-          verbose: options.verbose,
-          role: options.role
-        });
-      };
-    }
-  },
-  {
-    name: "trace",
-    description: "View execution traces for Brain System operations",
-    tier: "extended",
-    options: [
-      { flags: "--list", description: "List all traces" },
-      { flags: "--last", description: "Show last trace" },
-      { flags: "--session-id <id>", description: "Show specific trace" },
-      { flags: "--cleanup", description: "Clean up old traces" }
-    ],
-    loader: async () => {
-      const { traceCommand } = await import('./chunks/trace.mjs');
-      return async (options) => {
-        await traceCommand({
-          list: options.list,
-          last: options.last,
-          sessionId: options.sessionId,
-          cleanup: options.cleanup
-        });
-      };
-    }
-  },
-  {
-    name: "status",
-    description: "Brain Dashboard - setup health score and recommendations",
-    aliases: ["st", "brain"],
-    tier: "core",
-    options: [
-      { flags: "--json", description: "Output as JSON" },
-      { flags: "--compact", description: "Compact output" },
-      { flags: "--fix", description: "Run fixable recommendations" },
-      { flags: "--yes, -y", description: "Auto-confirm fixes" },
-      { flags: "--dry-run", description: "Preview fix commands without executing" }
-    ],
-    loader: async () => {
-      const { statusCommand } = await import('./chunks/status.mjs');
-      return async (options) => {
-        await statusCommand({
-          json: options.json,
-          compact: options.compact,
-          fix: options.fix,
-          yes: options.yes,
-          dryRun: options.dryRun
-        });
-      };
-    }
-  },
-  {
-    name: "dashboard",
-    description: "Brain Dashboard - context compression and persistence monitoring",
-    aliases: ["dash", "db"],
-    tier: "core",
-    options: [
-      { flags: "--json", description: "Output as JSON" },
-      { flags: "--compact", description: "Compact output" }
-    ],
-    loader: async () => {
-      const { dashboardCommand } = await import('./chunks/dashboard.mjs');
-      return async (options) => {
-        await dashboardCommand({
-          json: options.json,
-          compact: options.compact
-        });
-      };
-    }
-  },
-  {
-    name: "remote",
-    description: "Remote control management",
-    tier: "core",
-    options: [
-      { flags: "setup", description: "One-command remote setup" },
-      { flags: "doctor", description: "Diagnose remote setup" },
-      { flags: "enable", description: "Enable remote control" },
-      { flags: "disable", description: "Disable remote control" },
-      { flags: "status", description: "Show remote status" },
-      { flags: "qr", description: "Show pairing QR code" },
-      { flags: "--json", description: "Output as JSON" },
-      { flags: "--non-interactive", description: "Fail instead of prompting" },
-      { flags: "--server-url <url>", description: "Remote server URL for setup" },
-      { flags: "--auth-token <token>", description: "Remote auth token for setup" },
-      { flags: "--binding-code <code>", description: "Binding code for setup" }
-    ],
-    loader: async () => {
-      const { doctorRemote, enableRemote, disableRemote, remoteStatus, setupRemote, showQRCode } = await import('./chunks/remote.mjs');
-      return async (options, ...args) => {
-        const action = args[0];
-        switch (action) {
-          case "setup":
-            await setupRemote({
-              json: options.json,
-              nonInteractive: options.nonInteractive,
-              serverUrl: options.serverUrl,
-              authToken: options.authToken,
-              bindingCode: options.bindingCode
-            });
-            break;
-          case "doctor":
-            await doctorRemote({
-              json: options.json
-            });
-            break;
-          case "enable":
-            await enableRemote();
-            break;
-          case "disable":
-            await disableRemote();
-            break;
-          case "status":
-            await remoteStatus();
-            break;
-          case "qr":
-            await showQRCode();
-            break;
-          default:
-            await remoteStatus();
-        }
-      };
-    }
-  },
-  {
-    name: "evolution",
-    description: "Evolution Layer - AI knowledge sharing",
-    tier: "core",
-    options: [
-      { flags: "top", description: "Show top capabilities" },
-      { flags: "search <query>", description: "Search for solutions" },
-      { flags: "show <geneId>", description: "Show gene details" },
-      { flags: "stats", description: "Show statistics" }
-    ],
-    loader: async () => {
-      const { handleEvolutionCommand } = await import('./chunks/evolution.mjs');
-      return async (options, ...args) => {
-        const action = args[0];
-        const restArgs = args.slice(1);
-        await handleEvolutionCommand(action, restArgs, options);
-      };
-    }
-  },
-  {
-    name: "daemon",
-    description: "Daemon management",
-    tier: "core",
-    options: [
-      { flags: "start", description: "Start daemon" },
-      { flags: "stop", description: "Stop daemon" },
-      { flags: "status", description: "Daemon status" }
-    ],
-    loader: async () => {
-      const { startDaemon, stopDaemon, remoteStatus } = await import('./chunks/remote.mjs');
-      return async (options, ...args) => {
-        const action = args[0];
-        switch (action) {
-          case "start":
-            await startDaemon();
-            break;
-          case "stop":
-            await stopDaemon();
-            break;
-          case "status":
-            await remoteStatus();
-            break;
-          default:
-            await remoteStatus();
-        }
-      };
-    }
-  },
-  {
-    name: "morning",
-    description: "Morning health check + stats summary",
-    tier: "core",
-    options: [
-      { flags: "--json", description: "Output as JSON" },
-      { flags: "--silent", description: "Silent mode" }
-    ],
-    loader: async () => {
-      const { morningCommand } = await import('./chunks/quick-actions.mjs');
-      return async (options) => {
-        await morningCommand({
-          json: options.json,
-          silent: options.silent
-        });
-      };
-    }
-  },
-  {
-    name: "review",
-    description: "Daily review - contexts used, tokens saved",
-    tier: "core",
-    options: [
-      { flags: "--json", description: "Output as JSON" },
-      { flags: "--silent", description: "Silent mode" }
-    ],
-    loader: async () => {
-      const { reviewCommand } = await import('./chunks/quick-actions.mjs');
-      return async (options) => {
-        await reviewCommand({
-          json: options.json,
-          silent: options.silent
-        });
-      };
-    }
-  },
-  {
-    name: "cleanup",
-    description: "Weekly cleanup - old contexts, VACUUM",
-    tier: "core",
-    options: [
-      { flags: "--json", description: "Output as JSON" },
-      { flags: "--silent", description: "Silent mode" }
-    ],
-    loader: async () => {
-      const { cleanupCommand } = await import('./chunks/quick-actions.mjs');
-      return async (options) => {
-        await cleanupCommand({
-          json: options.json,
-          silent: options.silent
-        });
-      };
-    }
-  },
-  {
-    name: "boost",
-    description: "One-click optimization - auto-apply all recommendations",
-    tier: "core",
-    options: [
-      { flags: "--dry-run, -d", description: "Preview without applying" },
-      { flags: "--yes, -y", description: "Skip confirmation" }
-    ],
-    loader: async () => {
-      const { boost } = await import('./chunks/boost.mjs');
-      return async (options) => {
-        await boost({
-          dryRun: options.dryRun,
-          yes: options.yes
-        });
-      };
-    }
-  },
-  {
-    name: "brain-status",
-    description: "Brain capability routing and telemetry stats",
-    aliases: ["bs"],
-    tier: "core",
-    options: [
-      { flags: "--detailed, -d", description: "Show detailed statistics" },
-      { flags: "--json, -j", description: "Output as JSON" }
-    ],
-    loader: async () => {
-      const { brainStatusCommand } = await import('./chunks/brain-status.mjs');
-      return async (options) => {
-        await brainStatusCommand({
-          detailed: options.detailed,
-          json: options.json
-        });
-      };
-    }
-  },
-  {
-    name: "brain-config",
-    description: "Configure Brain capability routing system",
-    aliases: ["bc"],
-    tier: "core",
-    options: [
-      { flags: "--preference, -p <level>", description: "Set capability preference (1-5)" },
-      { flags: "--threshold, -t <value>", description: "Set auto-subagent threshold (1-10)" },
-      { flags: "--max-agents, -m <count>", description: "Set max parallel agents" },
-      { flags: "--telemetry <on|off>", description: "Enable/disable telemetry" },
-      { flags: "--reasoning <on|off>", description: "Enable/disable reasoning display" },
-      { flags: "--show, -s", description: "Show current configuration" },
-      { flags: "--reset", description: "Reset to default configuration" }
-    ],
-    loader: async () => {
-      const { brainConfigCommand } = await import('./chunks/brain-config.mjs');
-      return async (options) => {
-        await brainConfigCommand({
-          preference: options.preference ? parseFloat(options.preference) : void 0,
-          threshold: options.threshold ? parseFloat(options.threshold) : void 0,
-          maxAgents: options.maxAgents ? parseInt(options.maxAgents, 10) : void 0,
-          telemetry: options.telemetry,
-          reasoning: options.reasoning,
-          show: options.show,
-          reset: options.reset
-        });
-      };
-    }
-  },
-  // ==================== Plugin Management ====================
-  {
-    name: "add <source>",
-    description: "Add plugins from GitHub, npm, or local path",
-    tier: "extended",
-    options: [
-      { flags: "--type, -t <type>", description: "Plugin type (skill, mcp, agent, hook)" },
-      { flags: "--force, -f", description: "Force overwrite existing" },
-      { flags: "--dry-run, -d", description: "Preview without installing" },
-      { flags: "--json", description: "JSON output" },
-      { flags: "--lang, -l <lang>", description: "Display language (zh-CN, en)" }
-    ],
-    loader: async () => {
-      const { addCommand } = await import('./chunks/index14.mjs');
-      return async (options, source) => {
-        await addCommand(source, {
-          type: options.type,
-          force: options.force,
-          dryRun: options.dryRun,
-          json: options.json,
-          lang: options.lang
-        });
-      };
-    }
-  }
-];
-
-const CLOUD_BOOTSTRAP_WORKER_ARG = "__ccjk-cloud-bootstrap";
-const CLOUD_BOOTSTRAP_WORKER_ENV = "CCJK_CLOUD_BOOTSTRAP_WORKER";
-const SPECIAL_STARTUP_COMMANDS = [
-  "cloud",
-  "c",
-  "system",
-  "sys",
-  "plugin",
-  "completion",
-  "skills-sync",
-  "agents-sync",
-  "marketplace",
-  "quick",
-  "deep",
-  "setup",
-  "sync",
-  "versions",
-  "permissions",
-  "config-scan",
-  "workspace"
-];
-const EXPLICIT_STARTUP_COMMANDS = /* @__PURE__ */ new Set([
-  ...COMMANDS.flatMap((command) => {
-    const primaryName = command.name.split(/[ <[]/, 1)[0]?.toLowerCase();
-    const aliases = command.aliases?.map((alias) => alias.toLowerCase()) || [];
-    return primaryName ? [primaryName, ...aliases] : aliases;
-  }),
-  ...SPECIAL_STARTUP_COMMANDS
-]);
-const CLOUD_BOOTSTRAP_COMMANDS = /* @__PURE__ */ new Set([
-  "cloud",
-  "c",
-  "skills-sync",
-  "agents-sync",
-  "marketplace",
-  "sync"
-]);
-function isExplicitStartupCommandToken(token) {
-  return EXPLICIT_STARTUP_COMMANDS.has(token.toLowerCase());
-}
-function shouldBootstrapCloudServicesForArgs(args) {
-  if (args.length === 0) {
-    return false;
-  }
-  const optionArgsWithValue = /* @__PURE__ */ new Set(["-l", "--lang", "-g", "--all-lang", "-T", "--code-type"]);
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (!arg) {
-      continue;
-    }
-    if (optionArgsWithValue.has(arg)) {
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--lang=") || arg.startsWith("--all-lang=") || arg.startsWith("--code-type=")) {
-      continue;
-    }
-    if (arg.startsWith("-") || arg.startsWith("/")) {
-      continue;
-    }
-    return CLOUD_BOOTSTRAP_COMMANDS.has(arg.toLowerCase());
-  }
-  return false;
-}
-function isCloudBootstrapWorkerArgs(args) {
-  return args[0] === CLOUD_BOOTSTRAP_WORKER_ARG;
-}
-async function registerSpecialCommands(cli) {
-  cli.command("cloud [resource] [action]", "Cloud sync (skills/agents/plugins)").alias("c").option("--dry-run, -d", "Preview changes").option("--force, -f", "Force sync").action(async (resource, action, options) => {
-    const resourceStr = resource || "menu";
-    if (resourceStr === "skills" || resourceStr === "sk") {
-      const { skillsSyncMenu, syncSkills, pushSkillsCommand, pullSkillsCommand } = await import('./chunks/skills-sync.mjs');
-      if (!action)
-        await skillsSyncMenu(options);
-      else if (action === "sync")
-        await syncSkills(options);
-      else if (action === "push")
-        await pushSkillsCommand(options);
-      else if (action === "pull")
-        await pullSkillsCommand(options);
-    } else if (resourceStr === "agents" || resourceStr === "ag") {
-      console.log("\n\u{1F916} Agent Commands:");
-      console.log("  ccjk agents list      - List installed agents");
-      console.log("  ccjk agents search    - Search agents in cloud");
-      console.log("  ccjk agents install   - Install an agent");
-      console.log("  ccjk agents sync      - Sync with cloud");
-      console.log("  ccjk agents templates - View templates\n");
-    } else if (resourceStr === "plugins" || resourceStr === "pl") {
-      const { marketplaceMenu } = await import('./chunks/marketplace.mjs');
-      await marketplaceMenu(action, options);
-    } else {
-      console.log("\n\u2601\uFE0F  Cloud Sync Commands:");
-      console.log("  ccjk cloud skills [action]  - Sync custom skills");
-      console.log("  ccjk cloud agents [action]  - Sync AI agents");
-      console.log("  ccjk cloud plugins [action] - Plugin marketplace\n");
-    }
-  });
-  cli.command("skills-sync [action]", '[DEPRECATED] Use "ccjk cloud skills"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  skills-sync \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk cloud skills" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk cloud skills\n");
-  });
-  cli.command("agents-sync [action]", '[DEPRECATED] Use "ccjk agents"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  agents-sync \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk agents" \u66FF\u4EE3\n');
-    console.log("\u{1F916} Agent Commands:");
-    console.log("  ccjk agents list      - List installed agents");
-    console.log("  ccjk agents search    - Search agents in cloud");
-    console.log("  ccjk agents install   - Install an agent");
-    console.log("  ccjk agents sync      - Sync with cloud\n");
-  });
-  cli.command("marketplace [action]", '[DEPRECATED] Use "ccjk cloud plugins"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  marketplace \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk cloud plugins" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk cloud plugins\n");
-  });
-  cli.command("plugin [action] [...args]", "Plugin marketplace (install/search/list)").option("--verbose, -v", "Show verbose output").option("--force, -f", "Force operation").option("--version, -V <version>", "Specify plugin version").action(async (action, args, _options) => {
-    const { handlePluginCommand } = await import('./chunks/plugin.mjs');
-    const allArgs = [action, ...args || []].filter(Boolean);
-    await handlePluginCommand(allArgs);
-  });
-  cli.command("quick [specFile]", '[DEPRECATED] Use "ccjk interview -d quick"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  quick \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk interview -d quick" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk interview -d quick\n");
-  });
-  cli.command("deep [specFile]", '[DEPRECATED] Use "ccjk interview -d deep"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  deep \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk interview -d deep" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk interview -d deep\n");
-  });
-  cli.command("system [action] [subaction]", "System management (setup/upgrade/info)").alias("sys").option("--target <target>", "Target runtime for repair commands").action(async (action, subaction, options) => {
-    const actionStr = action || "info";
-    const subactionStr = subaction;
-    if (actionStr === "setup" || actionStr === "s") {
-      const { runOnboarding } = await import('./chunks/onboarding.mjs');
-      await runOnboarding();
-    } else if (actionStr === "sync") {
-      const { quickSync } = await import('./chunks/onboarding.mjs');
-      await quickSync();
-    } else if (actionStr === "versions" || actionStr === "ver") {
-      const { checkAllVersions } = await import('./chunks/upgrade-manager.mjs');
-      await checkAllVersions();
-    } else if (actionStr === "upgrade" || actionStr === "up") {
-      const { upgradeAll } = await import('./chunks/upgrade-manager.mjs');
-      await upgradeAll();
-    } else if (actionStr === "permissions" || actionStr === "perm") {
-      const { displayPermissions, repairPermissions } = await import('./chunks/permission-manager.mjs');
-      if (subactionStr === "repair") {
-        if (options?.target && !["clavue", "claude-code"].includes(String(options.target))) {
-          console.error(`Unsupported permissions repair target: ${options.target}`);
-          return;
-        }
-        const repaired = repairPermissions(process.cwd());
-        if (repaired) {
-          console.log("\u2713 Repaired CCJK permission bridge at ~/.ccjk/permissions.json");
-        } else {
-          console.error("\u2717 Failed to repair CCJK permission bridge");
-        }
-      } else {
-        displayPermissions();
-      }
-    } else if (actionStr === "config" || actionStr === "cfg") {
-      const { detectAllConfigs, displayConfigScan } = await import('./chunks/config-consolidator.mjs');
-      const configs = detectAllConfigs();
-      displayConfigScan(configs);
-    } else if (actionStr === "workspace" || actionStr === "ws") {
-      const { workspaceDiagnostics } = await import('./chunks/doctor.mjs');
-      await workspaceDiagnostics();
-    } else {
-      console.log("\n\u{1F527} System Commands:");
-      console.log("  ccjk system setup      - First-time setup");
-      console.log("  ccjk system sync       - Quick knowledge sync");
-      console.log("  ccjk system versions   - Check all versions");
-      console.log("  ccjk system upgrade    - Upgrade all components");
-      console.log("  ccjk system permissions- Show permissions");
-      console.log("  ccjk system config     - Scan config files");
-      console.log("  ccjk system workspace  - Workspace diagnostics\n");
-    }
-  });
-  cli.command("setup", '[DEPRECATED] Use "ccjk system setup"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  setup \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk system setup" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk system setup\n");
-  });
-  cli.command("sync", '[DEPRECATED] Use "ccjk system sync"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  sync \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk system sync" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk system sync\n");
-  });
-  cli.command("versions", '[DEPRECATED] Use "ccjk system versions"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  versions \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk system versions" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk system versions\n");
-  });
-  cli.command("permissions", '[DEPRECATED] Use "ccjk system permissions"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  permissions \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk system permissions" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk system permissions\n");
-  });
-  cli.command("config-scan", '[DEPRECATED] Use "ccjk system config"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  config-scan \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk system config" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk system config\n");
-  });
-  cli.command("workspace [dir]", '[DEPRECATED] Use "ccjk system workspace"').action(async () => {
-    console.warn('\n\u26A0\uFE0F  workspace \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u4F7F\u7528 "ccjk system workspace" \u66FF\u4EE3\n');
-    console.log("\u{1F4A1} \u65B0\u547D\u4EE4\uFF1Accjk system workspace\n");
-  });
-  cli.command("completion <action> [shell]", "Shell completion management").option("--lang, -l <lang>", "Display language").action(async (action, shell, options) => {
-    const { completionCommand } = await import('./chunks/completion.mjs');
-    await completionCommand(action, shell, options);
-  });
-}
-function customizeHelpLazy(_sections, version) {
-  const cyan = (s) => `\x1B[36m${s}\x1B[0m`;
-  const yellow = (s) => `\x1B[33m${s}\x1B[0m`;
-  const gray = (s) => `\x1B[90m${s}\x1B[0m`;
-  const green = (s) => `\x1B[32m${s}\x1B[0m`;
-  const bold = (s) => `\x1B[1m${s}\x1B[0m`;
-  const cyanBold = (s) => bold(cyan(s));
-  const newSections = [];
-  newSections.push({
-    title: "",
-    body: cyanBold(`CCJK - Claude Code Jailbreak Kit v${version}
-`) + gray("Lightweight CLI for Claude Code enhancement")
-  });
-  newSections.push({
-    title: yellow("\u{1F4E6} Core Commands"),
-    body: [
-      `  ${cyan("ccjk")}                    Interactive menu ${green("(default)")}`,
-      `  ${cyan("ccjk quick-setup")}  ${gray("qs")}    One-click configuration ${green("NEW")}`,
-      `  ${cyan("ccjk status")}       ${gray("st")}    Brain Dashboard - health score ${green("NEW")}`,
-      `  ${cyan("ccjk boost")}              One-click optimization ${green("NEW")}`,
-      `  ${cyan("ccjk init")}         ${gray("i")}     Initialize configuration`,
-      `  ${cyan("ccjk update")}       ${gray("u")}     Update prompts & workflows`,
-      `  ${cyan("ccjk doctor")}             Health check & diagnostics`,
-      `  ${cyan("ccjk help")}         ${gray("h")}     Help center & quick reference ${green("NEW")}`
-    ].join("\n")
-  });
-  newSections.push({
-    title: yellow("\u{1F6E0}\uFE0F  Development"),
-    body: [
-      `  ${cyan("ccjk mcp")} <action>        MCP server management`,
-      `  ${cyan("ccjk browser")}      ${gray("ab")}    Agent Browser automation ${green("NEW")}`,
-      `  ${cyan("ccjk skills")}       ${gray("sk")}    Manage CCJK skills ${green("NEW")}`,
-      `  ${cyan("ccjk memory")}       ${gray("mem")}   Manage Claude Code memory ${green("NEW")}`,
-      `  ${cyan("ccjk monitor")}      ${gray("mon")}   Performance monitoring ${green("NEW")}`,
-      `  ${cyan("ccjk eval")}               Run evaluation scenarios ${green("NEW")}`,
-      `  ${cyan("ccjk interview")}    ${gray("iv")}    Interview-driven development`,
-      `  ${cyan("ccjk commit")}             Smart git commit`,
-      `  ${cyan("ccjk config-switch")} ${gray("cs")}   Switch configuration`,
-      `  ${cyan("ccjk postmortem")}   ${gray("pm")}    Postmortem intelligence`
-    ].join("\n")
-  });
-  newSections.push({
-    title: yellow("\u2601\uFE0F  Unified Commands") + green(" NEW"),
-    body: [
-      `  ${cyan("ccjk cloud")} <resource>    Cloud sync (skills/agents/plugins)`,
-      `  ${cyan("ccjk system")} <action>     System management (setup/upgrade)`,
-      "",
-      gray("  Examples:"),
-      gray("    ccjk cloud skills sync   - Sync custom skills"),
-      gray("    ccjk system upgrade      - Upgrade all components")
-    ].join("\n")
-  });
-  newSections.push({
-    title: yellow("\u{1F4CB} Other"),
-    body: [
-      `  ${cyan("ccjk workflows")}    ${gray("wf")}    Manage workflows`,
-      `  ${cyan("ccjk ccr")}               CCR proxy management`,
-      `  ${cyan("ccjk ccu")}               Usage statistics`,
-      `  ${cyan("ccjk impact")}            Usage impact page`,
-      `  ${cyan("ccjk completion")}        Shell completion ${green("NEW")}`,
-      `  ${cyan("ccjk uninstall")}         Remove configurations`
-    ].join("\n")
-  });
-  newSections.push({
-    title: yellow("\u2699\uFE0F  Options"),
-    body: [
-      `  ${green("--lang, -l")} <lang>       Display language (zh-CN, en)`,
-      `  ${green("--force, -f")}             Force overwrite`,
-      `  ${green("--help, -h")}              Show help`,
-      `  ${green("--version, -v")}           Show version`
-    ].join("\n")
-  });
-  newSections.push({
-    title: "",
-    body: [
-      gray("\u2500".repeat(50)),
-      gray('Run "ccjk <command> --help" for detailed usage'),
-      gray('Run "ccjk" for interactive menu')
-    ].join("\n")
-  });
-  return newSections;
-}
-async function runHealthAlertsCheck() {
-  try {
-    const args = process.argv.slice(2);
-    if (args.includes("--silent")) {
-      return;
-    }
-    const shouldCheck = args.length === 0 || args[0] === "status" || args[0] === "doctor";
-    if (!shouldCheck) {
-      return;
-    }
-    const { join } = await import('./chunks/index10.mjs');
-    const dbPath = join(
-      process.env.HOME || process.env.USERPROFILE || ".",
-      ".ccjk",
-      "context",
-      "contexts.db"
-    );
-    const { runStartupHealthCheck } = await import('./chunks/health-alerts.mjs');
-    await runStartupHealthCheck(dbPath, { silent: false });
-  } catch {
-  }
-}
-async function showCommandDiscoveryBanner() {
-  try {
-    const args = process.argv.slice(2);
-    if (args.includes("--no-banner")) {
-      return;
-    }
-    if (args.length > 0 && !args[0].startsWith("-")) {
-      return;
-    }
-    const { join } = await import('./chunks/index10.mjs');
-    const { existsSync, writeFileSync } = await import('node:fs');
-    const markerPath = join(
-      process.env.HOME || process.env.USERPROFILE || ".",
-      ".ccjk",
-      ".banner-shown"
-    );
-    const isFirstRun = !existsSync(markerPath);
-    const showHelp = args.includes("--help") || args.includes("-h");
-    if (isFirstRun || showHelp) {
-      const envLang = process.env.CCJK_LANG;
-      if (envLang) {
-        const { initI18nLazy } = await Promise.resolve().then(function () { return cliLazy; });
-        await initI18nLazy(envLang);
-      }
-      const { displayCommandDiscovery } = await import('./chunks/banner.mjs');
-      displayCommandDiscovery();
-      if (isFirstRun) {
-        try {
-          const { ensureDir } = await import('./chunks/fs-operations.mjs');
-          await ensureDir(join(process.env.HOME || process.env.USERPROFILE || ".", ".ccjk"));
-          writeFileSync(markerPath, (/* @__PURE__ */ new Date()).toISOString());
-        } catch {
-        }
-      }
-    }
-  } catch {
-  }
-}
-async function showStartupSpinner() {
-  const args = process.argv.slice(2);
-  const quickFlags = ["--help", "-h", "--version", "-v", "-V"];
-  if (args.some((arg) => quickFlags.includes(arg))) {
-    return null;
-  }
-  try {
-    const ora = (await import('./chunks/index8.mjs')).default;
-    const isZh = process.env.CCJK_LANG === "zh-CN" || process.env.LANG?.includes("zh");
-    const spinner = ora({
-      text: isZh ? "\u6B63\u5728\u542F\u52A8 CCJK..." : "Starting CCJK...",
-      spinner: "dots"
-    }).start();
-    return {
-      stop: () => {
-        spinner.stop();
-        spinner.clear();
-      }
-    };
-  } catch {
-    const isZh = process.env.CCJK_LANG === "zh-CN" || process.env.LANG?.includes("zh");
-    process.stdout.write(isZh ? "\u6B63\u5728\u542F\u52A8 CCJK...\r" : "Starting CCJK...\r");
-    return {
-      stop: () => {
-        process.stdout.write("\x1B[2K\r");
-      }
-    };
-  }
-}
-async function tryQuickProviderLaunch() {
-  const args = process.argv.slice(2);
-  if (args.length === 0 || args[0].startsWith("-")) {
-    return false;
-  }
-  const firstArg = args[0].toLowerCase();
-  const { couldBeShortcode, isKnownCommand } = await import('./chunks/quick-provider.mjs');
-  if (isKnownCommand(firstArg)) {
-    return false;
-  }
-  if (!couldBeShortcode(firstArg)) {
-    return false;
-  }
-  const { quickProviderLaunch } = await import('./chunks/quick-provider.mjs');
-  try {
-    const handled = await quickProviderLaunch(firstArg, {
-      lang: process.env.CCJK_LANG
-    });
-    if (handled) {
-      return true;
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-async function runCloudBootstrapTasks() {
-  try {
-    const { initializeContextFeatures } = await import('./chunks/startup.mjs');
-    await initializeContextFeatures();
-    const { autoBootstrap } = await import('./chunks/auto-bootstrap.mjs');
-    await autoBootstrap();
-    const { autoUpgrade } = await import('./chunks/silent-updater.mjs');
-    await autoUpgrade();
-    const { activateSuperpowers } = await import('./chunks/index15.mjs');
-    await activateSuperpowers("zh-CN");
-    const { setupBrainHook } = await import('./chunks/cli-hook.mjs');
-    await setupBrainHook({
-      enabled: true,
-      silent: true,
-      // 静默模式，不打扰用户
-      fallbackToClaudeCode: true
-    });
-  } catch {
-  }
-}
-async function runCloudBootstrapWorker() {
-  await runCloudBootstrapTasks();
-}
-function bootstrapCloudServices() {
-  const args = process.argv.slice(2);
-  if (!shouldBootstrapCloudServicesForArgs(args) || isCloudBootstrapWorkerArgs(args)) {
-    return;
-  }
-  if (process.env[CLOUD_BOOTSTRAP_WORKER_ENV] === "1") {
-    return;
-  }
-  const entrypoint = process.argv[1];
-  if (!entrypoint || entrypoint.endsWith(".ts")) {
-    return;
-  }
-  try {
-    const child = spawn(process.execPath, [entrypoint, CLOUD_BOOTSTRAP_WORKER_ARG], {
-      detached: true,
-      stdio: "ignore",
-      env: {
-        ...process.env,
-        [CLOUD_BOOTSTRAP_WORKER_ENV]: "1"
-      }
-    });
-    child.unref();
-  } catch {
-  }
-}
-
-let i18nInitialized = false;
-let currentLang = "en";
-async function initI18nLazy(lang) {
-  if (i18nInitialized && lang === currentLang)
-    return;
-  const { initI18n, changeLanguage } = await import('./chunks/index2.mjs');
-  if (!i18nInitialized) {
-    await initI18n(lang || "en");
-    i18nInitialized = true;
-  } else if (lang && lang !== currentLang) {
-    await changeLanguage(lang);
-  }
-  currentLang = lang || "en";
-}
-async function resolveLanguage(options) {
-  const envLang = process__default.env.CCJK_LANG;
-  if (options?.allLang)
-    return options.allLang;
-  if (options?.lang)
-    return options.lang;
-  if (envLang)
-    return envLang;
-  try {
-    const { readZcfConfigAsync } = await import('./chunks/ccjk-config.mjs');
-    const config = await readZcfConfigAsync();
-    if (config?.preferredLang)
-      return config.preferredLang;
-  } catch {
-  }
-  if (!options?.skipPrompt) {
-    const { selectScriptLanguage } = await import('./chunks/prompts.mjs');
-    return await selectScriptLanguage();
-  }
-  return "en";
-}
-function extractLanguageOptions(options) {
-  if (!options || typeof options !== "object")
-    return {};
-  const obj = options;
-  return {
-    lang: typeof obj.lang === "string" ? obj.lang : void 0,
-    allLang: typeof obj.allLang === "string" ? obj.allLang : void 0,
-    skipPrompt: typeof obj.skipPrompt === "boolean" ? obj.skipPrompt : void 0
-  };
-}
-function classifyStartupPath(args) {
-  const positionalArgs = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (!arg)
-      continue;
-    if (arg === "-l" || arg === "--lang" || arg === "-g" || arg === "--all-lang" || arg === "-T" || arg === "--code-type") {
-      index += 1;
-      continue;
-    }
-    if (arg.startsWith("--lang=") || arg.startsWith("--all-lang=") || arg.startsWith("--code-type=")) {
-      continue;
-    }
-    positionalArgs.push(arg);
-  }
-  const firstToken = positionalArgs[0];
-  if (!firstToken) {
-    return { args, kind: "interactive" };
-  }
-  if (firstToken === "-h" || firstToken === "--help" || firstToken === "help") {
-    return { args, kind: "help" };
-  }
-  if (firstToken === "-v" || firstToken === "--version") {
-    return { args, kind: "version" };
-  }
-  if (firstToken.startsWith("/")) {
-    return { args, kind: "slash" };
-  }
-  if (firstToken.startsWith("-")) {
-    return { args, kind: "plain-args" };
-  }
-  if (isExplicitStartupCommandToken(firstToken)) {
-    return { args, kind: "command" };
-  }
-  if (positionalArgs.length === 1) {
-    return { args, kind: "quick-provider" };
-  }
-  return { args, kind: "plain-args" };
-}
-async function setupCommandsLazy(cli) {
-  const envLang = process__default.env.CCJK_LANG;
-  if (envLang) {
-    await initI18nLazy(envLang);
-  }
-  for (const cmd of COMMANDS) {
-    const command = cli.command(cmd.name, cmd.description);
-    if (cmd.aliases) {
-      for (const alias of cmd.aliases) {
-        command.alias(alias);
-      }
-    }
-    if (cmd.options) {
-      for (const opt of cmd.options) {
-        command.option(opt.flags, opt.description);
-      }
-    }
-    if (cmd.name !== "claude") {
-      command.option("--lang, -l <lang>", "Display language (zh-CN, en)");
-      command.option("--all-lang, -g <lang>", "Set all language parameters");
-      command.option("--no-banner", "Skip command discovery banner");
-    } else {
-      command.allowUnknownOptions();
-    }
-    command.action(async (...args) => {
-      const options = args[args.length - 1];
-      if (cmd.name !== "claude") {
-        const langOptions = extractLanguageOptions(options);
-        const lang = await resolveLanguage(langOptions);
-        await initI18nLazy(lang);
-      }
-      if (cmd.tier === "deprecated" && cmd.deprecationMessage) {
-        console.warn(`
-${cmd.deprecationMessage}
-`);
-      }
-      const handler = await cmd.loader();
-      await handler(options, ...args.slice(0, -1));
-    });
-  }
-  await registerSpecialCommands(cli);
-  const { version } = await import('./chunks/package.mjs');
-  cli.help((sections) => customizeHelpLazy(sections, version));
-  cli.version(version);
-}
-async function runLazyCli() {
-  if (isCloudBootstrapWorkerArgs(process__default.argv.slice(2))) {
-    await runCloudBootstrapWorker();
-    return;
-  }
-  const spinner = await showStartupSpinner();
-  const startupPath = classifyStartupPath(process__default.argv.slice(2));
-  try {
-    if (shouldBootstrapCloudServicesForArgs(startupPath.args)) {
-      bootstrapCloudServices();
-    }
-    if (startupPath.kind === "quick-provider") {
-      const handled = await tryQuickProviderLaunch();
-      if (handled) {
-        spinner?.stop();
-        return;
-      }
-    }
-    if (startupPath.kind === "slash") {
-      spinner?.stop();
-      const { executeSlashCommand } = await import('./chunks/slash-commands.mjs');
-      const slashHandled = await executeSlashCommand(startupPath.args.join(" "));
-      if (slashHandled) {
-        return;
-      }
-    }
-    const cac = (await import('./chunks/index7.mjs')).default;
-    const cli = cac("ccjk");
-    await setupCommandsLazy(cli);
-    spinner?.stop();
-    await runHealthAlertsCheck();
-    await showCommandDiscoveryBanner();
-    await cli.parse();
-  } catch (error) {
-    spinner?.stop();
-    throw error;
-  }
-}
-
-const cliLazy = {
-  __proto__: null,
-  initI18nLazy: initI18nLazy,
-  runLazyCli: runLazyCli,
-  setupCommandsLazy: setupCommandsLazy
-};
-
-runLazyCli().catch(console.error);