@cannbot-ai/install-helper 0.0.2-beta.3 → 0.0.2-beta.30

package/dist/index.js

@@ -4,116 +4,56 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { select as select3, Separator as Separator3 } from "@inquirer/prompts";
-import chalk5 from "chalk";
+import { select as select4, Separator as Separator3 } from "@inquirer/prompts";
+import chalk7 from "chalk";
 
 // src/ui/wizard.ts
 import { select, checkbox, Separator } from "@inquirer/prompts";
-import chalk2 from "chalk";
+import chalk3 from "chalk";
 
 // src/core/registry.ts
-var PLUGIN_REGISTRY = [
-  {
-    id: "ops-direct-invoke",
-    dir: "plugins-official/ops-direct-invoke",
-    displayName: "AscendC Kernel \u76F4\u8C03",
-    script: "init.sh",
-    aliases: ["ops-direct", "ascendc-direct", "direct", "kernel"],
-    skills: 16,
-    agents: 3,
-    description: "Ascend C Kernel <<<>>> \u76F4\u8C03\u7B97\u5B50\u5F00\u53D1\u5168\u6D41\u7A0B"
-  },
-  {
-    id: "ops-direct-invoke-flash",
-    dir: "plugins-official/ops-direct-invoke-flash",
-    displayName: "AscendC Kernel \u4ECE\u96F6\u6784\u5EFA",
-    script: "init.sh",
-    aliases: ["flash", "kernel-flash"],
-    skills: 1,
-    agents: 1,
-    description: "Ascend C / Ascend950 Reg API \u6838\u51FD\u6570\u4ECE\u96F6\u6784\u5EFA"
-  },
-  {
-    id: "ops-registry-invoke",
-    dir: "plugins-official/ops-registry-invoke",
-    displayName: "AscendC \u7B97\u5B50\u6CE8\u518C\u8C03\u7528",
-    script: "init.sh",
-    aliases: ["ops-registry", "ascendc-registry", "registry"],
-    skills: 12,
-    agents: 4,
-    description: "Ascend C \u7B97\u5B50\u6CE8\u518C\u8C03\u7528\u5F00\u53D1\u6D41\u7A0B"
-  },
-  {
-    id: "pypto-op-orchestrator",
-    dir: "plugins-official/pypto-op-orchestrator",
-    displayName: "PyPTO \u7B97\u5B50",
-    script: "init.sh",
-    aliases: ["pypto", "pytorch"],
-    skills: 8,
-    agents: 3,
-    description: "PyPTO \u7B97\u5B50\u7AEF\u5230\u7AEF\u5F00\u53D1\u7F16\u6392"
-  },
-  {
-    id: "triton-op-generator",
-    dir: "plugins-official/triton-op-generator",
-    displayName: "Triton \u7B97\u5B50\u751F\u6210",
-    script: "install.sh",
-    aliases: ["triton"],
-    skills: 6,
-    agents: 0,
-    description: "Triton-Ascend \u7B97\u5B50\u4EE3\u7801\u751F\u6210\u4E0E\u4F18\u5316"
-  },
-  {
-    id: "tilelang-op-orchestrator",
-    dir: "plugins-official/tilelang-op-orchestrator",
-    displayName: "TileLang \u7B97\u5B50",
-    script: "init.sh",
-    aliases: ["tilelang"],
-    skills: 9,
-    agents: 3,
-    description: "TileLang \u7B97\u5B50\u5F00\u53D1\u6D41\u7A0B"
-  },
-  {
-    id: "model-infer-optimize",
-    dir: "plugins-official/model-infer-optimize",
-    displayName: "NPU \u63A8\u7406\u4F18\u5316",
-    script: "init.sh",
-    aliases: ["model-infer", "infer", "inference"],
-    skills: 11,
-    agents: 3,
-    description: "NPU \u6A21\u578B\u63A8\u7406\u7AEF\u5230\u7AEF\u4F18\u5316"
-  },
-  {
-    id: "catlass-op-generator",
-    dir: "plugins-official/catlass-op-generator",
-    displayName: "Catlass \u7B97\u5B50\u76F4\u8C03",
-    script: "init.sh",
-    aliases: ["catlass"],
-    skills: 10,
-    agents: 3,
-    description: "Catlass \u7B97\u5B50\u76F4\u8C03\u5F00\u53D1"
-  },
-  {
-    id: "ops-code-reviewer",
-    dir: "plugins-official/ops-code-reviewer",
-    displayName: "\u4EE3\u7801\u68C0\u89C6",
-    script: "init.sh",
-    aliases: ["code-review", "reviewer", "review"],
-    skills: 5,
-    agents: 1,
-    description: "\u4EE3\u7801\u68C0\u89C6\u4E0E\u89C4\u8303\u68C0\u67E5"
-  },
-  {
-    id: "torch-compile",
-    dir: "plugins-official/torch-compile",
-    displayName: "torch.compile \u56FE\u6A21\u5F0F",
-    script: "init.sh",
-    aliases: ["torch", "compile", "graph"],
-    skills: 6,
-    agents: 1,
-    description: "PyTorch torch.compile \u56FE\u6A21\u5F0F\u9002\u914D"
+import { readdirSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function loadPluginsFromYaml() {
+  const pluginsDir = join(__dirname, "plugins.d");
+  const defaultsPath = join(pluginsDir, "_defaults.yml");
+  let defaults = {};
+  try {
+    defaults = parseYaml(readFileSync(defaultsPath, "utf-8")) || {};
+  } catch {
   }
-];
+  const plugins = [];
+  try {
+    for (const file of readdirSync(pluginsDir)) {
+      if (file.startsWith("_") || !file.endsWith(".yml")) continue;
+      try {
+        const content = parseYaml(readFileSync(join(pluginsDir, file), "utf-8"));
+        if (!content || !content.id) continue;
+        plugins.push({
+          id: content.id,
+          dir: content.dir,
+          displayName: content.displayName || content.id,
+          script: content.script || defaults.script || "init.sh",
+          aliases: content.aliases || [],
+          skills: content.skills ?? defaults.skills ?? 0,
+          agents: content.agents ?? defaults.agents ?? 0,
+          description: content.description || ""
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  plugins.sort(
+    (a, b) => a.displayName < b.displayName ? -1 : a.displayName > b.displayName ? 1 : 0
+  );
+  return plugins;
+}
+var PLUGIN_REGISTRY = loadPluginsFromYaml();
 function findPlugin(query) {
   const normalized = query.toLowerCase().trim();
   const exactMatch = PLUGIN_REGISTRY.find(
@@ -139,17 +79,68 @@ function getPluginById(id) {
 import { execa } from "execa";
 import { existsSync as existsSync2 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 
 // src/utils/paths.ts
 import { homedir } from "os";
-import { join } from "path";
+import { join as join3 } from "path";
 import { existsSync } from "fs";
+
+// src/utils/i18n.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = dirname2(__filename2);
+function loadLocale(locale) {
+  const localePath = join2(__dirname2, "locales", `${locale}.json`);
+  try {
+    const content = readFileSync2(localePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    const fallbackPath = join2(__dirname2, "locales", "zh_CN.json");
+    try {
+      const content = readFileSync2(fallbackPath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return {};
+    }
+  }
+}
+var currentLang = "zh_CN";
+var messages = loadLocale("zh_CN");
+function setLanguage(lang) {
+  currentLang = lang;
+  messages = loadLocale(lang);
+}
+function t(key) {
+  return messages[key] !== void 0 ? messages[key] : key;
+}
+
+// src/utils/paths.ts
+var VALID_TOOLS = ["opencode", "claude", "trae", "cursor", "copilot"];
+var VALID_LEVELS = ["project", "global"];
+function validateTool(tool) {
+  if (!VALID_TOOLS.includes(tool)) {
+    throw new Error(
+      t("error_invalid_tool").replace("{tool}", tool).replace("{tools}", VALID_TOOLS.join(", "))
+    );
+  }
+  return tool;
+}
+function validateLevel(level) {
+  if (!VALID_LEVELS.includes(level)) {
+    throw new Error(
+      t("error_invalid_level").replace("{level}", level).replace("{levels}", VALID_LEVELS.join(", "))
+    );
+  }
+  return level;
+}
 function detectTraeVariant() {
   const home = homedir();
-  if (existsSync(join(home, ".trae-cn"))) return "ide";
-  if (existsSync(join(home, ".marscode"))) return "plugin";
-  if (existsSync(join(home, ".traecli"))) return "cli";
+  if (existsSync(join3(home, ".trae-cn"))) return "ide";
+  if (existsSync(join3(home, ".marscode"))) return "plugin";
+  if (existsSync(join3(home, ".traecli"))) return "cli";
   return "unknown";
 }
 function getConfigRoot(tool, level, base) {
@@ -157,66 +148,74 @@ function getConfigRoot(tool, level, base) {
   if (level === "global") {
     switch (tool) {
       case "opencode":
-        return join(home, ".config", "opencode");
+        return join3(home, ".config", "opencode");
       case "claude":
-        return join(home, ".claude");
+        return join3(home, ".claude");
       case "trae": {
         const variant = detectTraeVariant();
         switch (variant) {
           case "plugin":
-            return join(home, ".marscode");
+            return join3(home, ".marscode");
           case "cli":
-            return join(home, ".traecli");
+            return join3(home, ".traecli");
           default:
-            return join(home, ".trae-cn");
+            return join3(home, ".trae-cn");
         }
       }
       case "cursor":
-        return join(home, ".cursor");
+        return join3(home, ".cursor");
       case "copilot":
-        return join(home, ".copilot");
+        return join3(home, ".copilot");
+      default:
+        throw new Error(
+          t("error_invalid_tool").replace("{tool}", tool).replace("{tools}", VALID_TOOLS.join(", "))
+        );
     }
   }
   const baseDir = base || process.cwd();
   switch (tool) {
     case "opencode":
-      return join(baseDir, ".opencode");
+      return join3(baseDir, ".opencode");
     case "claude":
-      return join(baseDir, ".claude");
+      return join3(baseDir, ".claude");
     case "trae": {
       const variant = detectTraeVariant();
       switch (variant) {
         case "plugin":
-          return join(baseDir, ".marscode");
+          return join3(baseDir, ".marscode");
         case "cli":
-          return join(baseDir, ".traecli");
+          return join3(baseDir, ".traecli");
         default:
-          return join(baseDir, ".trae");
+          return join3(baseDir, ".trae");
       }
     }
     case "cursor":
-      return join(baseDir, ".cursor");
+      return join3(baseDir, ".cursor");
     case "copilot":
-      return join(baseDir, ".github");
+      return join3(baseDir, ".github");
+    default:
+      throw new Error(
+        t("error_invalid_tool").replace("{tool}", tool).replace("{tools}", VALID_TOOLS.join(", "))
+      );
   }
 }
 function getConfigFileName(tool) {
   return tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
 }
 function getSkillsDir(configRoot) {
-  return join(configRoot, "skills");
+  return join3(configRoot, "skills");
 }
 function getAgentsDir(configRoot) {
-  return join(configRoot, "agents");
+  return join3(configRoot, "agents");
 }
 function getManifestPath(configRoot) {
-  return join(configRoot, "cannbot-manifest.json");
+  return join3(configRoot, "cannbot-manifest.json");
 }
 function getCannbotConfigDir() {
-  return join(homedir(), ".cannbot");
+  return join3(homedir(), ".cannbot");
 }
 function getCannbotRepoPath() {
-  return join(getCannbotConfigDir(), "repo");
+  return join3(getCannbotConfigDir(), "repo");
 }
 
 // src/core/detector.ts
@@ -232,7 +231,7 @@ async function getCommandVersion(cmd, args = ["--version"]) {
 }
 async function getCommandPath(cmd) {
   try {
-    const result = await execa("sh", ["-c", `command -v ${cmd}`], { timeout: 5e3 });
+    const result = await execa("which", [cmd], { timeout: 5e3 });
     return result.stdout.trim();
   } catch {
     return void 0;
@@ -254,12 +253,12 @@ async function detectTrae() {
   const home = homedir2();
   const variant = detectTraeVariant();
   let path;
-  if (variant === "ide" && existsSync2(join2(home, ".trae-cn"))) {
-    path = join2(home, ".trae-cn");
-  } else if (variant === "plugin" && existsSync2(join2(home, ".marscode"))) {
-    path = join2(home, ".marscode");
-  } else if (variant === "cli" && existsSync2(join2(home, ".traecli"))) {
-    path = join2(home, ".traecli");
+  if (variant === "ide" && existsSync2(join4(home, ".trae-cn"))) {
+    path = join4(home, ".trae-cn");
+  } else if (variant === "plugin" && existsSync2(join4(home, ".marscode"))) {
+    path = join4(home, ".marscode");
+  } else if (variant === "cli" && existsSync2(join4(home, ".traecli"))) {
+    path = join4(home, ".traecli");
   } else if (variant === "unknown") {
     const cmdPath = await getCommandPath("trae");
     if (cmdPath) path = cmdPath;
@@ -323,13 +322,13 @@ function getAllTools() {
 }
 
 // src/core/manifest.ts
-import { existsSync as existsSync3, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
 function readManifest(configRoot) {
   const manifestPath = getManifestPath(configRoot);
   if (existsSync3(manifestPath)) {
     try {
-      const content = readFileSync(manifestPath, "utf-8");
+      const content = readFileSync3(manifestPath, "utf-8");
       return JSON.parse(content);
     } catch {
     }
@@ -342,16 +341,16 @@ function readAllManifests(configRoot) {
   const standardPath = getManifestPath(configRoot);
   if (existsSync3(standardPath)) {
     try {
-      const content = readFileSync(standardPath, "utf-8");
+      const content = readFileSync3(standardPath, "utf-8");
       manifests.push(JSON.parse(content));
     } catch {
     }
   }
   for (const plugin of plugins) {
-    const pluginManifestPath = join3(configRoot, `${plugin.id}-manifest.json`);
+    const pluginManifestPath = join5(configRoot, `${plugin.id}-manifest.json`);
     if (existsSync3(pluginManifestPath)) {
       try {
-        const content = readFileSync(pluginManifestPath, "utf-8");
+        const content = readFileSync3(pluginManifestPath, "utf-8");
         manifests.push(JSON.parse(content));
       } catch {
       }
@@ -371,6 +370,9 @@ function scanInstalled() {
       for (const manifest of manifests) {
         const plugin = plugins.find((p) => p.id === manifest.team);
         if (!plugin) continue;
+        if (!verifyPluginFilesExist(configRoot, manifest, tool, level)) {
+          continue;
+        }
         const alreadyAdded = installed.some(
           (p) => p.id === plugin.id && p.tool === tool && p.level === level
         );
@@ -390,190 +392,31 @@ function scanInstalled() {
   }
   return installed;
 }
-
-// src/utils/i18n.ts
-var zh_CN = {
-  wizard_title: "CANNBot Install Helper",
-  wizard_detect: "\u6B63\u5728\u68C0\u6D4B\u5DF2\u5B89\u88C5\u7684 AI \u7F16\u7A0B\u5DE5\u5177...",
-  wizard_select_tool: "\u9009\u62E9 AI \u7F16\u7A0B\u5DE5\u5177",
-  wizard_select_level: "\u9009\u62E9\u5B89\u88C5\u4F4D\u7F6E",
-  wizard_select_plugins: "\u9009\u62E9\u8981\u5B89\u88C5\u7684\u63D2\u4EF6",
-  wizard_confirm: "\u786E\u8BA4\u5B89\u88C5",
-  wizard_detected_tool: "\u68C0\u6D4B\u5230",
-  wizard_confirm_tool: "\u4F7F\u7528",
-  wizard_last_used: "\u4E0A\u6B21\u4F7F\u7528",
-  wizard_already_installed: "\u5DF2\u5B89\u88C5",
-  install_cloning: "\u6B63\u5728\u514B\u9686 cannbot-skills \u4ED3\u5E93...",
-  install_repo_ready: "\u4ED3\u5E93\u5C31\u7EEA",
-  install_progress: "\u6B63\u5728\u5B89\u88C5",
-  install_done: "\u5B89\u88C5\u5B8C\u6210",
-  install_success: "\u6210\u529F",
-  install_failed: "\u5931\u8D25",
-  install_already_installed: "\u5DF2\u5B89\u88C5",
-  install_reinstall_confirm: "\u662F\u5426\u91CD\u65B0\u5B89\u88C5\uFF08\u8986\u76D6\uFF09",
-  install_skip: "\u8DF3\u8FC7",
-  install_enhanced_next_steps: "\u4E0B\u4E00\u6B65",
-  install_enhanced_launch: "\u542F\u52A8",
-  install_enhanced_try: "\u8BD5\u8BD5",
-  install_enhanced_more: "\u66F4\u591A",
-  install_enhanced_check: "\u68C0\u67E5",
-  install_enhanced_docs: "\u6587\u6863",
-  update_title: "\u66F4\u65B0\u5DF2\u5B89\u88C5\u7684 Skills",
-  update_updating: "\u6B63\u5728\u66F4\u65B0",
-  update_done: "\u66F4\u65B0\u5B8C\u6210",
-  update_no_plugins: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6",
-  doctor_title: "CANNBot Doctor",
-  doctor_tools: "AI \u5DE5\u5177",
-  doctor_plugins: "\u5DF2\u5B89\u88C5\u63D2\u4EF6",
-  doctor_links: "\u94FE\u63A5\u5B8C\u6574\u6027",
-  doctor_config: "\u914D\u7F6E\u6587\u4EF6",
-  doctor_result: "\u7ED3\u679C",
-  doctor_fix_title: "\u81EA\u52A8\u4FEE\u590D",
-  doctor_fix_cleaning: "\u6E05\u7406\u5931\u6548\u94FE\u63A5",
-  doctor_fix_rebuilding: "\u91CD\u5EFA\u76EE\u5F55",
-  doctor_fix_done: "\u4FEE\u590D\u5B8C\u6210",
-  info_title: "\u63D2\u4EF6\u8BE6\u60C5",
-  info_description: "\u63CF\u8FF0",
-  info_skills: "Skills",
-  info_agents: "Agents",
-  info_status: "\u72B6\u6001",
-  info_quickstart: "\u5FEB\u901F\u5F00\u59CB",
-  info_not_found: "\u672A\u627E\u5230\u63D2\u4EF6",
-  lang_title: "\u8BED\u8A00\u8BBE\u7F6E",
-  lang_current: "\u5F53\u524D\u8BED\u8A00",
-  lang_set: "\u8BED\u8A00\u5DF2\u8BBE\u7F6E\u4E3A",
-  lang_invalid: "\u65E0\u6548\u7684\u8BED\u8A00\uFF0C\u652F\u6301: zh_CN, en_US",
-  list_title: "\u53EF\u7528\u573A\u666F",
-  list_id: "\u5E8F\u53F7",
-  list_name: "\u573A\u666F\u540D",
-  list_status: "\u72B6\u6001",
-  list_skills: "Skills",
-  list_agents: "Agents",
-  status_installed: "\u5DF2\u88C5",
-  status_not_installed: "\u672A\u88C5",
-  error_tool_not_found: "\u672A\u68C0\u6D4B\u5230\u4EFB\u4F55 AI \u7F16\u7A0B\u5DE5\u5177",
-  error_plugin_not_found: "\u672A\u627E\u5230\u63D2\u4EF6",
-  error_repo_not_found: "\u4ED3\u5E93\u672A\u627E\u5230",
-  quick_start: "\u542F\u52A8\u547D\u4EE4",
-  quick_start_hint: "\u8BD5\u8BD5\u8F93\u5165: \u5E2E\u6211\u5F00\u53D1\u4E00\u4E2A Abs \u7B97\u5B50",
-  skill_select_category: "\u9009\u62E9 Skill \u7C7B\u522B",
-  skill_select_items: "\u9009\u62E9\u8981\u5B89\u88C5\u7684 Skills",
-  skill_already_installed: "\u5DF2\u5B89\u88C5",
-  skill_install_progress: "\u6B63\u5728\u5B89\u88C5",
-  skill_install_done: "Skill \u5B89\u88C5\u5B8C\u6210",
-  skill_uninstall_done: "Skill \u5378\u8F7D\u5B8C\u6210",
-  skill_list_title: "\u53EF\u7528 Skills",
-  wizard_select_mode: "\u9009\u62E9\u5B89\u88C5\u7C7B\u578B",
-  wizard_mode_plugin: "\u5B89\u88C5 Plugin",
-  wizard_mode_plugin_desc: "\u5B8C\u6574\u5F00\u53D1\u5DE5\u4F5C\u6D41\uFF08Skills + Agents + \u914D\u7F6E\u6587\u4EF6\uFF09",
-  wizard_mode_skill: "\u5B89\u88C5 Skill",
-  wizard_mode_skill_desc: "\u4EC5\u5B89\u88C5\u9886\u57DF\u77E5\u8BC6\u6280\u80FD\uFF0C\u8BA9 AI \u638C\u63E1\u7279\u5B9A\u80FD\u529B",
-  wizard_back: "\u8FD4\u56DE",
-  wizard_cancel: "\u9000\u51FA",
-  wizard_no_selection: "\u672A\u9009\u62E9\u4EFB\u4F55\u9879\uFF0C\u8BF7\u9009\u62E9\u64CD\u4F5C",
-  wizard_back_to_reselect: "\u8FD4\u56DE",
-  status_title: "\u5DF2\u5B89\u88C5\u63D2\u4EF6",
-  status_none: "\u6682\u65E0\u5DF2\u5B89\u88C5\u7684\u63D2\u4EF6",
-  status_hint: "\u8FD0\u884C install-helper init \u5F00\u59CB\u5B89\u88C5",
-  status_install_time: "\u5B89\u88C5\u65F6\u95F4",
-  install_installed_to: "\u5B89\u88C5\u5230",
-  install_skills_count: "Skills",
-  install_agents_count: "Agents"
-};
-var en_US = {
-  wizard_title: "CANNBot Skills Setup Wizard",
-  wizard_detect: "Detecting installed AI coding tools...",
-  wizard_select_tool: "Select AI coding tool",
-  wizard_select_level: "Select install level",
-  wizard_select_plugins: "Select scenarios to install",
-  wizard_confirm: "Confirm installation",
-  wizard_detected_tool: "Detected",
-  wizard_confirm_tool: "Confirm using",
-  wizard_last_used: "last used",
-  wizard_already_installed: "installed",
-  install_cloning: "Cloning cannbot-skills repository...",
-  install_repo_ready: "Repository ready",
-  install_progress: "Installing",
-  install_done: "Installation complete",
-  install_success: "success",
-  install_failed: "failed",
-  install_already_installed: "already installed",
-  install_reinstall_confirm: "Reinstall (overwrite)",
-  install_skip: "skipped",
-  install_enhanced_next_steps: "Next steps",
-  install_enhanced_launch: "Launch",
-  install_enhanced_try: "Try",
-  install_enhanced_more: "More",
-  install_enhanced_check: "Check",
-  install_enhanced_docs: "Docs",
-  update_title: "Update installed Skills",
-  update_updating: "Updating",
-  update_done: "Update complete",
-  update_no_plugins: "No installed plugins",
-  doctor_title: "CANNBot Doctor",
-  doctor_tools: "AI Tools",
-  doctor_plugins: "Installed Plugins",
-  doctor_links: "Link Integrity",
-  doctor_config: "Configuration",
-  doctor_result: "Result",
-  doctor_fix_title: "Auto-fix",
-  doctor_fix_cleaning: "Cleaning broken links",
-  doctor_fix_rebuilding: "Rebuilding directories",
-  doctor_fix_done: "Fix complete",
-  info_title: "Plugin Details",
-  info_description: "Description",
-  info_skills: "Skills",
-  info_agents: "Agents",
-  info_status: "Status",
-  info_quickstart: "Quick Start",
-  info_not_found: "Plugin not found",
-  lang_title: "Language Settings",
-  lang_current: "Current language",
-  lang_set: "Language set to",
-  lang_invalid: "Invalid language, supported: zh_CN, en_US",
-  list_title: "Available Scenarios",
-  list_id: "#",
-  list_name: "Name",
-  list_status: "Status",
-  list_skills: "Skills",
-  list_agents: "Agents",
-  status_installed: "installed",
-  status_not_installed: "not installed",
-  error_tool_not_found: "No AI coding tool detected",
-  error_plugin_not_found: "Plugin not found",
-  error_repo_not_found: "Repository not found",
-  quick_start: "Launch command",
-  quick_start_hint: "Try: help me develop an Abs operator",
-  skill_select_category: "Select Skill category",
-  skill_select_items: "Select Skills to install (space to toggle, enter to confirm)",
-  skill_already_installed: "installed",
-  skill_install_progress: "Installing",
-  skill_install_done: "Skill installation complete",
-  skill_uninstall_done: "Skill uninstallation complete",
-  skill_list_title: "Available Skills",
-  wizard_select_mode: "Select installation mode",
-  wizard_mode_plugin: "Install Plugin",
-  wizard_mode_plugin_desc: "Full development workflow (Skills + Agents + config)",
-  wizard_mode_skill: "Install Skill",
-  wizard_mode_skill_desc: "Domain knowledge only, give AI specific capabilities",
-  wizard_back: "Go back",
-  wizard_cancel: "Cancel installation",
-  wizard_no_selection: "No items selected, please choose an action",
-  wizard_back_to_reselect: "Go back",
-  status_title: "Installed Plugins",
-  status_none: "No installed plugins",
-  status_hint: "Run install-helper init to start",
-  status_install_time: "Installed at",
-  install_installed_to: "Installed to",
-  install_skills_count: "Skills",
-  install_agents_count: "Agents"
-};
-var currentLang = "zh_CN";
-function setLanguage(lang) {
-  currentLang = lang;
-}
-function t(key) {
-  return currentLang === "zh_CN" ? zh_CN[key] : en_US[key];
+function verifyPluginFilesExist(configRoot, manifest, tool, level) {
+  const skillsDir = join5(configRoot, "skills");
+  const agentsDir = join5(configRoot, "agents");
+  if (manifest.installed_skills && manifest.installed_skills.length > 0) {
+    const hasAnySkill = manifest.installed_skills.some((skillId) => {
+      const skillPath = join5(skillsDir, skillId);
+      return existsSync3(skillPath);
+    });
+    if (!hasAnySkill) return false;
+  }
+  if (manifest.installed_agents && manifest.installed_agents.length > 0) {
+    const hasAnyAgent = manifest.installed_agents.some((agentId) => {
+      const agentPath = join5(agentsDir, agentId);
+      return existsSync3(agentPath);
+    });
+    if (!hasAnyAgent) return false;
+  }
+  let agentsMdPath;
+  if (tool === "opencode" && level === "project") {
+    agentsMdPath = join5(configRoot, "..", "AGENTS.md");
+  } else {
+    agentsMdPath = join5(configRoot, "AGENTS.md");
+  }
+  if (!existsSync3(agentsMdPath)) return false;
+  return true;
 }
 
 // src/utils/logger.ts
@@ -630,24 +473,24 @@ function printBoxTitle(title, width = 65) {
 }
 function showOperationHints(isCheckbox = false) {
   if (isCheckbox) {
-    console.log(`  \u{1F4A1} \x1B[36m\u2191\u2193\x1B[0m \u79FB\u52A8 | \x1B[36m\u7A7A\u683C\x1B[0m \u9009\u62E9 | \x1B[36m\u23CE\x1B[0m \u786E\u8BA4
+    console.log(`  \u{1F4A1} \x1B[36m\u2191\u2193\x1B[0m ${t("hint_select_move")} | \x1B[36m${t("hint_select_space")}\x1B[0m ${t("hint_select_check")} | \x1B[36m\u23CE\x1B[0m ${t("hint_select_confirm")}\uFF08${t("hint_checkbox_suffix")}\uFF09
 `);
   } else {
-    console.log(`  \u{1F4A1} \x1B[36m\u2191\u2193\x1B[0m \u79FB\u52A8 | \x1B[36m\u23CE\x1B[0m \u786E\u8BA4
+    console.log(`  \u{1F4A1} \x1B[36m\u2191\u2193\x1B[0m ${t("hint_select_move")} | \x1B[36m\u23CE\x1B[0m ${t("hint_select_confirm")}
 `);
   }
 }
 
 // src/utils/config.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync4, writeFileSync } from "fs";
+import { join as join6 } from "path";
 import { homedir as homedir3 } from "os";
 import { parse, stringify } from "yaml";
 function getConfigDir() {
-  return join4(homedir3(), ".cannbot");
+  return join6(homedir3(), ".cannbot");
 }
 function getConfigPath() {
-  return join4(getConfigDir(), "config.yaml");
+  return join6(getConfigDir(), "config.yaml");
 }
 function readConfig() {
   const configPath = getConfigPath();
@@ -658,7 +501,7 @@ function readConfig() {
     };
   }
   try {
-    const content = readFileSync2(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     const parsed = parse(content);
     return {
       language: parsed.language || "zh_CN",
@@ -705,16 +548,78 @@ function removeInstalledPlugin(pluginId) {
 }
 
 // src/ui/theme.ts
+import chalk2 from "chalk";
 var selectTheme = {
   helpMode: "never"
 };
+function isCJK(code) {
+  return code >= 11904 && code <= 40959 || code >= 63744 && code <= 64255 || code >= 65072 && code <= 65103 || code >= 65280 && code <= 65519 || code >= 13312 && code <= 19903 || code >= 131072 && code <= 173791 || code >= 173824 && code <= 177983 || code >= 177984 && code <= 178207 || code >= 178208 && code <= 183983;
+}
+function isEmoji(code) {
+  return code >= 127744 && code <= 129791 || code >= 9728 && code <= 10175;
+}
+function getDisplayWidth2(str) {
+  let width = 0;
+  for (const ch of str) {
+    const code = ch.codePointAt(0);
+    if (isCJK(code) || isEmoji(code)) {
+      width += 2;
+    } else {
+      width += 1;
+    }
+  }
+  return width;
+}
+function wrapDescription(text) {
+  const prefix = "  \u{1F4A1} ";
+  const indent = "      ";
+  const cols = process.stdout.columns || 120;
+  const maxLen = Math.max(20, cols - getDisplayWidth2(prefix) - 2);
+  const tokens = [];
+  let i = 0;
+  while (i < text.length) {
+    const code = text[i].codePointAt(0);
+    if (isCJK(code)) {
+      tokens.push({ text: text[i], width: 2 });
+      i++;
+    } else {
+      let j = i;
+      while (j < text.length) {
+        const c = text[j].codePointAt(0);
+        if (isCJK(c)) break;
+        j++;
+      }
+      const word = text.slice(i, j);
+      tokens.push({ text: word, width: getDisplayWidth2(word) });
+      i = j;
+    }
+  }
+  const lines = [];
+  let line = "";
+  let lineWidth = 0;
+  for (const token of tokens) {
+    if (lineWidth + token.width > maxLen && line) {
+      lines.push(line.trimEnd());
+      line = token.text;
+      lineWidth = token.width;
+    } else {
+      line += token.text;
+      lineWidth += token.width;
+    }
+  }
+  if (line) lines.push(line.trimEnd());
+  return lines.map((l, i2) => chalk2.cyan(i2 === 0 ? prefix + l : indent + l)).join("\n");
+}
 var checkboxTheme = {
   icon: {
     checked: "\x1B[32m\u2611\x1B[22m",
     unchecked: "\u2610",
     cursor: "\u276F"
   },
-  helpMode: "never"
+  helpMode: "never",
+  style: {
+    description: (text) => wrapDescription(text)
+  }
 };
 
 // src/ui/wizard.ts
@@ -789,7 +694,7 @@ async function runWizard() {
           step = 2;
           break;
         }
-        if (result === CANCEL || result === false) {
+        if (result === CANCEL) {
           return { language: config.language || "zh_CN", tool: selectedTool, level, plugins: [], confirmed: false };
         }
         updateConfig({ lastTool: selectedTool, lastLevel: level });
@@ -799,7 +704,7 @@ async function runWizard() {
   }
 }
 async function stepTool(detectedTools, lastTool) {
-  printBoxTitle("[1/4] \u9009\u62E9 AI \u7F16\u7A0B\u5DE5\u5177");
+  printBoxTitle(t("wizard_step_1_title"));
   if (detectedTools.length === 0) {
     logger.error(t("error_tool_not_found"));
     const choices2 = [
@@ -874,10 +779,10 @@ async function stepToolManual(lastTool) {
   return result;
 }
 async function stepLevel(lastLevel) {
-  printBoxTitle("[2/4] \u9009\u62E9\u5B89\u88C5\u4F4D\u7F6E");
+  printBoxTitle(t("wizard_step_2_title"));
   const choices = [
-    { name: "> project \u2014 \u5B89\u88C5\u5230\u5F53\u524D\u76EE\u5F55\uFF08\u63A8\u8350\uFF0C\u4EC5\u5F53\u524D\u9879\u76EE\u53EF\u7528\uFF09", value: "project" },
-    { name: "> global \u2014 \u5B89\u88C5\u5230\u5168\u5C40\uFF08\u6240\u6709\u9879\u76EE\u5171\u4EAB\uFF09", value: "global" },
+    { name: `> project \u2014 ${t("install_level_project")}`, value: "project" },
+    { name: `> global \u2014 ${t("install_level_global")}`, value: "global" },
     new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
     { name: "<- " + t("wizard_back"), value: BACK },
     { name: "x  " + t("wizard_cancel"), value: CANCEL }
@@ -895,7 +800,7 @@ async function stepLevel(lastLevel) {
   return result;
 }
 async function stepPlugins(tool, level) {
-  printBoxTitle("[3/4] \u9009\u62E9\u8981\u5B89\u88C5\u7684\u63D2\u4EF6");
+  printBoxTitle(t("wizard_step_3_title"));
   const plugins = getAllPlugins();
   const configRoot = getConfigRoot(tool, level);
   const manifests = readAllManifests(configRoot);
@@ -904,25 +809,22 @@ async function stepPlugins(tool, level) {
     const isInstalled = installedSet.has(p.id);
     const suffix = isInstalled ? ` [${t("wizard_already_installed")}]` : "";
     return {
-      name: `${p.displayName}${suffix} \u2014 ${p.description}`,
+      name: `${chalk3.cyan(p.displayName)}${suffix}`,
       value: p.id,
-      checked: false
+      checked: false,
+      description: p.description
     };
   });
-  choices.push(new Separator("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  choices.push({ name: "<- " + t("wizard_back"), value: BACK, checked: false });
-  choices.push({ name: "x  " + t("wizard_cancel"), value: CANCEL, checked: false });
   showOperationHints(true);
   const selected = await checkbox({
     message: t("wizard_select_plugins"),
     choices,
     loop: false,
     instructions: false,
-    theme: checkboxTheme
+    theme: checkboxTheme,
+    pageSize: 15
   });
-  if (selected.includes(BACK)) return BACK;
-  if (selected.includes(CANCEL)) return CANCEL;
-  const pluginIds = selected.filter((v) => v !== BACK && v !== CANCEL);
+  const pluginIds = selected;
   if (pluginIds.length === 0) {
     const action = await select({
       message: t("wizard_no_selection"),
@@ -940,17 +842,17 @@ async function stepPlugins(tool, level) {
   return pluginIds;
 }
 async function stepConfirm(tool, level, plugins) {
-  printBoxTitle("[4/4] \u786E\u8BA4\u5B89\u88C5");
+  printBoxTitle(t("wizard_step_4_title"));
   const allPlugins = getAllPlugins();
   const selectedPlugins = plugins.map((id) => allPlugins.find((p) => p.id === id));
   const displayPath = getConfigRoot(tool, level);
   const toolName = getToolDisplayName(tool);
   const levelText = level === "project" ? "project" : "global";
-  logger.info(`\u5373\u5C06\u5B89\u88C5 ${chalk2.bold(plugins.length)} \u4E2A\u63D2\u4EF6\u5230 ${chalk2.green(toolName)}\uFF08${chalk2.cyan(levelText)} \u7EA7\u522B\uFF09\uFF1A`);
-  logger.info(`\u5B89\u88C5\u8DEF\u5F84: ${chalk2.cyan(displayPath)}`);
+  logger.info(t("wizard_confirm_install_format").replace("{count}", chalk3.bold(String(plugins.length))).replace("{tool}", chalk3.green(toolName)).replace("{level}", chalk3.cyan(levelText)));
+  logger.info(`${t("wizard_install_path")}: ${chalk3.cyan(displayPath)}`);
   for (const plugin of selectedPlugins) {
     if (plugin) {
-      logger.step(`  \u2022 ${chalk2.bold(plugin.displayName)}`);
+      logger.step(`  \u2022 ${chalk3.bold(plugin.displayName)}`);
     }
   }
   logger.blank();
@@ -968,14 +870,19 @@ async function stepConfirm(tool, level, plugins) {
 }
 
 // src/core/repository.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync6 } from "fs";
+import { join as join8, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 import { execa as execa2 } from "execa";
+import { parse as parseYaml3 } from "yaml";
 
 // src/core/scanner.ts
-import { existsSync as existsSync5, readdirSync, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join5, dirname } from "path";
-import { parse as parseYaml } from "yaml";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5, statSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join7, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import { parse as parseYaml2 } from "yaml";
+var __filename3 = fileURLToPath3(import.meta.url);
+var __dirname3 = dirname3(__filename3);
 var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -996,36 +903,43 @@ var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
   "docs",
   "scripts"
 ]);
-var SKILL_SCAN_DIRS = [
-  "ops",
-  "model",
-  "graph",
-  "infra",
-  "ops-lab"
-];
-var PLUGIN_SCAN_DIRS = [
-  "plugins-official",
-  "plugins-community"
-];
+function loadScanConfig() {
+  const configPath = join7(__dirname3, "config", "repository.yaml");
+  try {
+    const config = parseYaml2(readFileSync5(configPath, "utf-8"));
+    return {
+      skillDirs: config.scanDirs || ["ops", "model", "graph", "infra", "ops-lab"],
+      pluginDirs: config.pluginDirs || ["plugins-official", "plugins-community"]
+    };
+  } catch {
+    return {
+      skillDirs: ["ops", "model", "graph", "infra", "ops-lab"],
+      pluginDirs: ["plugins-official", "plugins-community"]
+    };
+  }
+}
+var scanConfig = loadScanConfig();
+var SKILL_SCAN_DIRS = scanConfig.skillDirs;
+var PLUGIN_SCAN_DIRS = scanConfig.pluginDirs;
 function scanSkills(repoPath) {
   const skills = [];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of SKILL_SCAN_DIRS) {
-    const fullPath = join5(repoPath, dir);
+    const fullPath = join7(repoPath, dir);
     if (!existsSync5(fullPath)) continue;
     scanDirectory(fullPath, repoPath, dir, skills, seen);
   }
   for (const pluginDir of PLUGIN_SCAN_DIRS) {
-    const pluginParent = join5(repoPath, pluginDir);
+    const pluginParent = join7(repoPath, pluginDir);
     if (!existsSync5(pluginParent)) continue;
     for (const plugin of safeReaddir(pluginParent)) {
-      const pluginPath = join5(pluginParent, plugin);
+      const pluginPath = join7(pluginParent, plugin);
       if (!isDirectory(pluginPath)) continue;
-      const skillsDir = join5(pluginPath, "skills");
+      const skillsDir = join7(pluginPath, "skills");
       if (existsSync5(skillsDir)) {
         scanDirectory(skillsDir, repoPath, `${pluginDir}/${plugin}/skills`, skills, seen);
       }
-      const skillDir = join5(pluginPath, "skill");
+      const skillDir = join7(pluginPath, "skill");
       if (existsSync5(skillDir)) {
         scanDirectory(skillDir, repoPath, `${pluginDir}/${plugin}/skill`, skills, seen);
       }
@@ -1035,7 +949,7 @@ function scanSkills(repoPath) {
 }
 function parseFrontmatter(filePath) {
   try {
-    const content = readFileSync3(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     const lines = content.split("\n");
     if (lines.length < 3) return null;
     if (lines[0].trim() !== "---") return null;
@@ -1048,7 +962,7 @@ function parseFrontmatter(filePath) {
     }
     if (endIndex === -1) return null;
     const yamlBlock = lines.slice(1, endIndex).map((l) => l.replace(/\r$/, "")).join("\n");
-    const parsed = parseYaml(yamlBlock);
+    const parsed = parseYaml2(yamlBlock);
     if (!parsed || typeof parsed !== "object") return null;
     if (!parsed.name || typeof parsed.name !== "string") return null;
     return {
@@ -1061,17 +975,17 @@ function parseFrontmatter(filePath) {
 }
 function getCurrentCommit(repoPath) {
   try {
-    const headFile = join5(repoPath, ".git", "HEAD");
+    const headFile = join7(repoPath, ".git", "HEAD");
     if (!existsSync5(headFile)) return "unknown";
-    const headContent = readFileSync3(headFile, "utf-8").trim();
+    const headContent = readFileSync5(headFile, "utf-8").trim();
     if (headContent.startsWith("ref: ")) {
-      const refPath = join5(repoPath, ".git", headContent.slice(5));
+      const refPath = join7(repoPath, ".git", headContent.slice(5));
       if (existsSync5(refPath)) {
-        return readFileSync3(refPath, "utf-8").trim();
+        return readFileSync5(refPath, "utf-8").trim();
       }
-      const packedRefsPath = join5(repoPath, ".git", "packed-refs");
+      const packedRefsPath = join7(repoPath, ".git", "packed-refs");
       if (existsSync5(packedRefsPath)) {
-        const packedRefs = readFileSync3(packedRefsPath, "utf-8");
+        const packedRefs = readFileSync5(packedRefsPath, "utf-8");
         const refName = headContent.slice(5);
         const lines = packedRefs.split("\n");
         for (const line of lines) {
@@ -1090,7 +1004,7 @@ function readScanCache() {
   try {
     const cachePath = getCachePath();
     if (!existsSync5(cachePath)) return null;
-    const content = readFileSync3(cachePath, "utf-8");
+    const content = readFileSync5(cachePath, "utf-8");
     const cache = JSON.parse(content);
     if (!cache.skills || !cache.timestamp) return null;
     const age = Date.now() - cache.timestamp;
@@ -1103,7 +1017,7 @@ function readScanCache() {
 function writeScanCache(cache) {
   try {
     const cachePath = getCachePath();
-    const cacheDir = dirname(cachePath);
+    const cacheDir = dirname3(cachePath);
     if (!existsSync5(cacheDir)) {
       mkdirSync2(cacheDir, { recursive: true });
     }
@@ -1112,29 +1026,14 @@ function writeScanCache(cache) {
   }
 }
 function getCachePath() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  return join5(homeDir, ".cannbot", "scan-cache.json");
+  return join7(getCannbotConfigDir(), "scan-cache.json");
 }
 function scanDirectory(dirPath, repoPath, sourcePrefix, skills, seen) {
-  const selfSkillMd = join5(dirPath, "SKILL.md");
-  if (existsSync5(selfSkillMd)) {
-    const frontmatter = parseFrontmatter(selfSkillMd);
-    if (frontmatter && !seen.has(frontmatter.name)) {
-      seen.add(frontmatter.name);
-      skills.push({
-        id: frontmatter.name,
-        description: frontmatter.description,
-        source: sourcePrefix,
-        filePath: selfSkillMd
-      });
-    }
-    return;
-  }
   for (const entry of safeReaddir(dirPath)) {
-    const fullPath = join5(dirPath, entry);
+    const fullPath = join7(dirPath, entry);
     if (EXCLUDE_DIRS.has(entry)) continue;
     if (!isDirectory(fullPath)) continue;
-    const skillMd = join5(fullPath, "SKILL.md");
+    const skillMd = join7(fullPath, "SKILL.md");
     if (existsSync5(skillMd)) {
       const frontmatter = parseFrontmatter(skillMd);
       if (frontmatter && !seen.has(frontmatter.name)) {
@@ -1148,12 +1047,12 @@ function scanDirectory(dirPath, repoPath, sourcePrefix, skills, seen) {
       }
       continue;
     }
-    scanDirectory(fullPath, repoPath, sourcePrefix, skills, seen);
+    scanDirectory(fullPath, repoPath, sourcePrefix + "/" + entry, skills, seen);
   }
 }
 function safeReaddir(dir) {
   try {
-    return readdirSync(dir);
+    return readdirSync2(dir);
   } catch {
     return [];
   }
@@ -1393,7 +1292,21 @@ function getAllCategories() {
 }
 
 // src/core/repository.ts
-var REPO_URL = "https://gitcode.com/cann/cannbot-skills.git";
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname4(__filename4);
+function loadRepoUrl() {
+  if (process.env.CANNBOT_REPO_URL) {
+    return process.env.CANNBOT_REPO_URL;
+  }
+  const configPath = join8(__dirname4, "config", "repository.yaml");
+  try {
+    const config = parseYaml3(readFileSync6(configPath, "utf-8"));
+    return config.repository?.url || "https://gitcode.com/cann/cannbot-skills.git";
+  } catch {
+    return "https://gitcode.com/cann/cannbot-skills.git";
+  }
+}
+var REPO_URL = loadRepoUrl();
 var RepositoryManager = class {
   repoPath;
   constructor(customPath) {
@@ -1451,8 +1364,8 @@ var RepositoryManager = class {
   }
   isValidRepo(path) {
     if (!existsSync6(path)) return false;
-    const gitDir = join6(path, ".git");
-    const pluginsDir = join6(path, "plugins-official");
+    const gitDir = join8(path, ".git");
+    const pluginsDir = join8(path, "plugins-official");
     return existsSync6(gitDir) && existsSync6(pluginsDir);
   }
   async cloneRepo() {
@@ -1487,18 +1400,18 @@ function createRepositoryManager(customPath) {
 }
 
 // src/core/installer.ts
-import { existsSync as existsSync8 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join11 } from "path";
 import { execa as execa3 } from "execa";
 
 // src/core/record.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4, lstatSync, unlinkSync } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync4, lstatSync, unlinkSync } from "fs";
+import { join as join9 } from "path";
 function getInstallsDir() {
-  return join7(getCannbotConfigDir(), "installs");
+  return join9(getCannbotConfigDir(), "installs");
 }
 function getRecordPath(pluginId) {
-  return join7(getInstallsDir(), `${pluginId}.json`);
+  return join9(getInstallsDir(), `${pluginId}.json`);
 }
 function readRecord(pluginId) {
   const recordPath = getRecordPath(pluginId);
@@ -1506,7 +1419,7 @@ function readRecord(pluginId) {
     return null;
   }
   try {
-    const content = readFileSync4(recordPath, "utf-8");
+    const content = readFileSync7(recordPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -1530,22 +1443,22 @@ function scanInstalledFiles(pluginId, displayName, tool, level, installPath, con
   const files = [];
   const directories = [];
   if (manifest) {
-    const skillsDir = join7(configRoot, "skills");
+    const skillsDir = join9(configRoot, "skills");
     if (existsSync7(skillsDir)) {
       directories.push(skillsDir);
       for (const skillName of manifest.installed_skills || []) {
-        const skillPath = join7(skillsDir, skillName);
+        const skillPath = join9(skillsDir, skillName);
         if (existsSync7(skillPath) || isSymlink(skillPath)) {
           files.push(skillPath);
         }
       }
     }
-    const agentsDir = join7(configRoot, "agents");
+    const agentsDir = join9(configRoot, "agents");
     if (existsSync7(agentsDir)) {
       directories.push(agentsDir);
       for (const agentName of manifest.installed_agents || []) {
-        const agentPath = join7(agentsDir, agentName);
-        const agentPathMd = join7(agentsDir, agentName + ".md");
+        const agentPath = join9(agentsDir, agentName);
+        const agentPathMd = join9(agentsDir, agentName + ".md");
         if (existsSync7(agentPath) || isSymlink(agentPath)) {
           files.push(agentPath);
         } else if (existsSync7(agentPathMd) || isSymlink(agentPathMd)) {
@@ -1554,35 +1467,34 @@ function scanInstalledFiles(pluginId, displayName, tool, level, installPath, con
       }
     }
   }
-  const workflowsLink = join7(configRoot, "workflows");
+  const workflowsLink = join9(configRoot, "workflows");
   if (isSymlink(workflowsLink)) {
     files.push(workflowsLink);
   }
-  const manifestPath = join7(configRoot, "cannbot-manifest.json");
+  const manifestPath = join9(configRoot, "cannbot-manifest.json");
   if (existsSync7(manifestPath)) {
     files.push(manifestPath);
   }
-  const pluginManifestPath = join7(configRoot, `${pluginId}-manifest.json`);
+  const pluginManifestPath = join9(configRoot, `${pluginId}-manifest.json`);
   if (existsSync7(pluginManifestPath)) {
     files.push(pluginManifestPath);
   }
   const configFileName = tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
-  const configFilePath = level === "project" ? join7(installPath, configFileName) : join7(configRoot, configFileName);
+  const configFilePath = level === "project" ? join9(installPath, configFileName) : join9(configRoot, configFileName);
   if (existsSync7(configFilePath)) {
     files.push(configFilePath);
   }
   const repoLinks = ["asc-devkit", "pypto", "tilelang-ascend", "cann-recipes-infer", "cann-samples"];
   for (const repoName of repoLinks) {
-    const repoLinkPath = join7(installPath, repoName);
+    const repoLinkPath = join9(installPath, repoName);
     if (isSymlink(repoLinkPath)) {
       files.push(repoLinkPath);
     }
-    const repoLinkInConfig = join7(configRoot, repoName);
+    const repoLinkInConfig = join9(configRoot, repoName);
     if (isSymlink(repoLinkInConfig)) {
       files.push(repoLinkInConfig);
     }
   }
-  directories.push(configRoot);
   return {
     pluginId,
     displayName,
@@ -1603,7 +1515,7 @@ function isSymlink(path) {
   }
 }
 function getSkillRecordPath() {
-  return join7(getInstallsDir(), "skills.json");
+  return join9(getInstallsDir(), "skills.json");
 }
 function readSkillRecord() {
   const recordPath = getSkillRecordPath();
@@ -1611,7 +1523,7 @@ function readSkillRecord() {
     return {};
   }
   try {
-    const content = readFileSync4(recordPath, "utf-8");
+    const content = readFileSync7(recordPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return {};
@@ -1659,7 +1571,186 @@ function removeSkillsFromRecord(skillIds, tool, level, installPath) {
 }
 function getInstalledSkills(tool, level, installPath) {
   const record = readSkillRecord();
-  return record[tool]?.[level]?.[installPath]?.skills || [];
+  const recordedSkills = record[tool]?.[level]?.[installPath]?.skills || [];
+  const configRoot = getConfigRoot(tool, level);
+  const skillsDir = join9(configRoot, "skills");
+  return recordedSkills.filter((skillId) => {
+    const skillPath = join9(skillsDir, skillId);
+    return existsSync7(skillPath) || isSymlink(skillPath);
+  });
+}
+
+// src/core/backup.ts
+import { existsSync as existsSync8, copyFileSync, readdirSync as readdirSync3, unlinkSync as unlinkSync2 } from "fs";
+import { join as join10 } from "path";
+function getAgentsFileName(tool) {
+  return tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
+}
+function detectCurrentPlugin(configRoot, tool) {
+  const manifest = readManifest(configRoot);
+  if (manifest?.team) {
+    const plugin = findPlugin(manifest.team);
+    if (plugin) {
+      return {
+        pluginId: plugin.id,
+        pluginName: plugin.displayName
+      };
+    }
+  }
+  const agentsFile = join10(configRoot, getAgentsFileName(tool));
+  if (!existsSync8(agentsFile)) {
+    return null;
+  }
+  const allRecords = readAllRecords();
+  for (const record of allRecords) {
+    if (record.configRoot === configRoot && record.tool === tool) {
+      const plugin = findPlugin(record.pluginId);
+      if (plugin) {
+        return {
+          pluginId: plugin.id,
+          pluginName: plugin.displayName
+        };
+      }
+    }
+  }
+  return null;
+}
+function createBackup(configRoot, tool, fromPluginId, fromPluginName) {
+  const agentsFile = join10(configRoot, getAgentsFileName(tool));
+  if (!existsSync8(agentsFile)) {
+    return null;
+  }
+  const timestamp = formatTimestamp(/* @__PURE__ */ new Date());
+  const backupFileName = `${getAgentsFileName(tool)}.cannbot-backup.${fromPluginId}.${timestamp}`;
+  const backupPath = join10(configRoot, backupFileName);
+  try {
+    copyFileSync(agentsFile, backupPath);
+    return {
+      filePath: backupPath,
+      pluginId: fromPluginId,
+      pluginName: fromPluginName,
+      backupTime: timestamp
+    };
+  } catch {
+    return null;
+  }
+}
+function findBackups(configRoot) {
+  if (!existsSync8(configRoot)) {
+    return [];
+  }
+  const files = readdirSync3(configRoot);
+  const backups = [];
+  for (const file of files) {
+    if (file.includes(".cannbot-backup.")) {
+      const parts = file.split(".cannbot-backup.");
+      if (parts.length === 2) {
+        const pluginIdAndTime = parts[1];
+        const lastDotIndex = pluginIdAndTime.lastIndexOf(".");
+        if (lastDotIndex > 0) {
+          const pluginId = pluginIdAndTime.substring(0, lastDotIndex);
+          const timestamp = pluginIdAndTime.substring(lastDotIndex + 1);
+          const plugin = findPlugin(pluginId);
+          backups.push({
+            filePath: join10(configRoot, file),
+            pluginId,
+            pluginName: plugin?.displayName || pluginId,
+            backupTime: timestamp
+          });
+        }
+      }
+    }
+  }
+  return backups.sort((a, b) => b.backupTime.localeCompare(a.backupTime));
+}
+function restoreBackup(backupPath, configRoot, tool) {
+  try {
+    const agentsFile = join10(configRoot, getAgentsFileName(tool));
+    copyFileSync(backupPath, agentsFile);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deleteBackup(backupPath) {
+  try {
+    if (existsSync8(backupPath)) {
+      unlinkSync2(backupPath);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+function formatTimestamp(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}${month}${day}-${hours}${minutes}${seconds}`;
+}
+function readAllRecords() {
+  const records = [];
+  const plugins = [
+    "ops-direct-invoke",
+    "ops-direct-invoke-flash",
+    "ops-registry-invoke",
+    "pypto-op-orchestrator",
+    "triton-op-generator",
+    "tilelang-op-orchestrator",
+    "model-infer-optimize",
+    "catlass-op-generator",
+    "ops-code-reviewer",
+    "torch-compile"
+  ];
+  for (const pluginId of plugins) {
+    const record = readRecord(pluginId);
+    if (record) {
+      records.push(record);
+    }
+  }
+  return records;
+}
+
+// src/ui/backup-prompts.ts
+import { select as select2 } from "@inquirer/prompts";
+import chalk4 from "chalk";
+async function showOverwriteWarning(currentPluginName, newPluginName) {
+  console.log();
+  console.log(chalk4.yellow(`  \u26A0\uFE0F  ${t("backup_detected")}`));
+  console.log();
+  console.log(`    ${t("backup_current")}: ${chalk4.cyan(currentPluginName)}`);
+  console.log(`    ${t("backup_installing")}: ${chalk4.cyan(newPluginName)}`);
+  console.log();
+  console.log(`    ${t("backup_overwrite_warning")}`);
+  console.log(`    ${t("backup_auto_create")}`);
+  console.log();
+  const choice = await select2({
+    message: t("backup_select_action"),
+    choices: [
+      { name: t("backup_overwrite"), value: "overwrite" },
+      { name: t("backup_cancel"), value: "cancel" }
+    ]
+  });
+  return choice;
+}
+async function showRestorePrompt(backups) {
+  console.log();
+  console.log(chalk4.cyan(`  ${t("backup_restore_prompt")}`));
+  console.log();
+  const choices = backups.map((b) => ({
+    name: `${t("backup_restore")} ${b.pluginName} (${b.backupTime})`,
+    value: b.filePath
+  }));
+  choices.push({ name: t("backup_only_uninstall"), value: "none" });
+  const choice = await select2({
+    message: t("backup_select_action"),
+    choices
+  });
+  return choice;
 }
 
 // src/core/installer.ts
@@ -1675,8 +1766,8 @@ async function installPlugin(opts) {
       warnings: []
     };
   }
-  const scriptPath = join8(opts.repoPath, plugin.dir, plugin.script);
-  if (!existsSync8(scriptPath)) {
+  const scriptPath = join11(opts.repoPath, plugin.dir, plugin.script);
+  if (!existsSync9(scriptPath)) {
     return {
       success: false,
       pluginId: opts.pluginId,
@@ -1691,13 +1782,49 @@ async function installPlugin(opts) {
     args.push(opts.installPath);
   }
   const cwd = opts.installPath || process.cwd();
+  const configRoot = getConfigRoot(opts.tool, opts.level, opts.installPath);
+  const agentsFile = join11(configRoot, getAgentsFileName(opts.tool));
+  let backupInfo = null;
+  if (existsSync9(agentsFile)) {
+    const currentPlugin = detectCurrentPlugin(configRoot, opts.tool);
+    if (currentPlugin && currentPlugin.pluginId !== opts.pluginId) {
+      let choice = "overwrite";
+      if (!opts.yes) {
+        choice = await showOverwriteWarning(
+          currentPlugin.pluginName,
+          plugin.displayName
+        );
+      }
+      if (choice === "cancel") {
+        logger.info(t("backup_cancel"));
+        return {
+          success: false,
+          pluginId: opts.pluginId,
+          skillsCount: 0,
+          agentsCount: 0,
+          errors: [t("backup_cancel")],
+          warnings: []
+        };
+      }
+      backupInfo = createBackup(
+        configRoot,
+        opts.tool,
+        currentPlugin.pluginId,
+        currentPlugin.pluginName
+      );
+      if (backupInfo) {
+        logger.success(`${t("backup_created")}: ${backupInfo.filePath}`);
+      }
+    }
+  }
   try {
-    await execa3("bash", [scriptPath, ...args], {
+    const execOptions = {
       cwd,
       timeout: 3e5,
-      stdio: "pipe"
-    });
-    const configRoot = getConfigRoot(opts.tool, opts.level, opts.installPath);
+      stdio: "pipe",
+      input: opts.yes ? "y\n" : void 0
+    };
+    await execa3("bash", [scriptPath, ...args], execOptions);
     const manifest = readManifest(configRoot);
     let skillsCount = 0;
     let agentsCount = 0;
@@ -1718,6 +1845,14 @@ async function installPlugin(opts) {
         configRoot,
         manifest
       );
+      if (backupInfo) {
+        record.backup = {
+          filePath: backupInfo.filePath,
+          fromPluginId: backupInfo.pluginId,
+          fromPluginName: backupInfo.pluginName,
+          backupTime: backupInfo.backupTime
+        };
+      }
       writeRecord(record);
     } catch {
     }
@@ -1743,16 +1878,16 @@ async function installPlugin(opts) {
 }
 
 // src/core/skill-installer.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, symlinkSync, unlinkSync as unlinkSync2, readdirSync as readdirSync3, rmdirSync, realpathSync, lstatSync as lstatSync2 } from "fs";
-import { join as join9 } from "path";
-import { select as select2, checkbox as checkbox2, Separator as Separator2 } from "@inquirer/prompts";
-import chalk3 from "chalk";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, symlinkSync, unlinkSync as unlinkSync3, readdirSync as readdirSync4, rmdirSync, realpathSync, lstatSync as lstatSync2 } from "fs";
+import { join as join12 } from "path";
+import { select as select3, checkbox as checkbox2, Separator as Separator2 } from "@inquirer/prompts";
+import chalk5 from "chalk";
 import Table from "cli-table3";
 async function installSkills(skillIds, tool, level, repoPath) {
   const configRoot = getConfigRoot(tool, level);
-  const skillsDir = join9(configRoot, "skills");
+  const skillsDir = join12(configRoot, "skills");
   const installPath = level === "project" ? process.cwd() : configRoot;
-  if (!existsSync9(skillsDir)) {
+  if (!existsSync10(skillsDir)) {
     mkdirSync5(skillsDir, { recursive: true });
   }
   const results = [];
@@ -1763,15 +1898,15 @@ async function installSkills(skillIds, tool, level, repoPath) {
       results.push({ skillId, success: false, error: "Skill not found in registry" });
       continue;
     }
-    const sourcePath = join9(repoPath, skill.source, skill.id);
-    const targetPath = join9(skillsDir, skillId);
-    if (!existsSync9(sourcePath)) {
+    const sourcePath = join12(repoPath, skill.source, skill.id);
+    const targetPath = join12(skillsDir, skillId);
+    if (!existsSync10(sourcePath)) {
       results.push({ skillId, success: false, error: `Source not found: ${sourcePath}` });
       continue;
     }
     try {
-      if (existsSync9(targetPath) || isSymlink2(targetPath)) {
-        unlinkSync2(targetPath);
+      if (existsSync10(targetPath) || isSymlink2(targetPath)) {
+        unlinkSync3(targetPath);
       }
       symlinkSync(realpathSync(sourcePath), targetPath);
       results.push({ skillId, success: true });
@@ -1787,21 +1922,21 @@ async function installSkills(skillIds, tool, level, repoPath) {
 }
 async function uninstallSkills(skillIds, tool, level) {
   const configRoot = getConfigRoot(tool, level);
-  const skillsDir = join9(configRoot, "skills");
+  const skillsDir = join12(configRoot, "skills");
   const installPath = level === "project" ? process.cwd() : configRoot;
   const results = [];
   const removedIds = [];
   for (const skillId of skillIds) {
-    const targetPath = join9(skillsDir, skillId);
+    const targetPath = join12(skillsDir, skillId);
     try {
-      if (existsSync9(targetPath) || isSymlink2(targetPath)) {
-        unlinkSync2(targetPath);
+      if (existsSync10(targetPath) || isSymlink2(targetPath)) {
+        unlinkSync3(targetPath);
         results.push({ skillId, success: true });
         removedIds.push(skillId);
-        logger.step(`  \u79FB\u9664: ${skillId}`);
+        logger.step(`  ${t("uninstall_remove_label")}: ${skillId}`);
       } else {
         results.push({ skillId, success: false, error: "Not installed" });
-        logger.warn(`${skillId} \u672A\u5B89\u88C5`);
+        logger.warn(`${skillId} ${t("uninstall_skill_not_installed")}`);
       }
     } catch (error) {
       results.push({ skillId, success: false, error: error instanceof Error ? error.message : "Unknown error" });
@@ -1810,103 +1945,121 @@ async function uninstallSkills(skillIds, tool, level) {
   if (removedIds.length > 0) {
     removeSkillsFromRecord(removedIds, tool, level, installPath);
   }
-  if (existsSync9(skillsDir)) {
+  if (existsSync10(skillsDir)) {
     try {
-      const entries = readdirSync3(skillsDir);
+      const entries = readdirSync4(skillsDir);
       if (entries.length === 0) {
         rmdirSync(skillsDir);
-        logger.step(`  \u6E05\u7406\u7A7A\u76EE\u5F55: skills/`);
-      }
-    } catch {
-    }
-  }
-  if (existsSync9(configRoot)) {
-    try {
-      const entries = readdirSync3(configRoot);
-      if (entries.length === 0) {
-        rmdirSync(configRoot);
-        logger.step(`  \u6E05\u7406\u7A7A\u76EE\u5F55: ${configRoot.split("/").pop()}/`);
+        logger.step(`  ${t("uninstall_clean_empty_dir")}: skills/`);
       }
     } catch {
     }
   }
   return results;
 }
-async function interactiveSkillSelect() {
+var SELECT_ALL = "__select_all__";
+var SELECT_ALL_CATEGORY = "__select_all_category__";
+var CONTINUE_SELECT = "__continue_select__";
+async function interactiveSkillSelect(tool, level) {
   const BACK3 = "__back__";
   const CANCEL3 = "__cancel__";
   const categories = getAllCategories();
+  const allSkillIds = getAllSkills().map((s) => s.id);
+  let accumulated = [];
   let step = 0;
   let selectedCategoryId = "";
   while (true) {
     switch (step) {
       case 0: {
-        printBoxTitle("[3/4] \u9009\u62E9 Skill \u7C7B\u522B");
+        const titleSuffix = accumulated.length > 0 ? `${t("wizard_step_3_skill_title")}\uFF08${t("skill_count_format").replace("{count}", String(accumulated.length))}\uFF09` : t("wizard_step_3_skill_title");
+        printBoxTitle(titleSuffix);
         const categoryChoices = [
+          {
+            name: `>> ${t("skill_select_all").replace("{count}", String(allSkillIds.length))}`,
+            value: SELECT_ALL
+          },
+          new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
           ...categories.map((cat) => ({
             name: `> ${cat.name} (${cat.skills.length} skills)`,
             value: cat.id
           })),
           new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+          ...accumulated.length > 0 ? [{ name: `>> ${t("skill_confirm_install_count").replace("{count}", String(accumulated.length))}`, value: "install" }] : [],
           { name: "<- " + t("wizard_back"), value: BACK3 },
           { name: "x  " + t("wizard_cancel"), value: CANCEL3 }
         ];
         showOperationHints();
-        selectedCategoryId = await select2({
+        selectedCategoryId = await select3({
           message: t("skill_select_category"),
           choices: categoryChoices,
           loop: false,
-          theme: selectTheme
+          theme: selectTheme,
+          pageSize: 15
         });
         if (selectedCategoryId === BACK3) return "back";
         if (selectedCategoryId === CANCEL3) return "cancel";
+        if (selectedCategoryId === SELECT_ALL) {
+          return allSkillIds;
+        }
+        if (selectedCategoryId === "install") {
+          return accumulated;
+        }
         step = 1;
         break;
       }
       case 1: {
         const category = categories.find((c) => c.id === selectedCategoryId);
         if (!category) return [];
-        printBoxTitle(`[4/4] \u9009\u62E9\u8981\u5B89\u88C5\u7684 Skills \u2014 ${category.name}`);
-        const tools = ["opencode", "claude", "trae", "cursor", "copilot"];
-        const levels = ["project", "global"];
-        const installedSkills = [];
-        for (const tk of tools) {
-          for (const l of levels) {
-            const path = l === "project" ? process.cwd() : getConfigRoot(tk, l);
-            installedSkills.push(...getInstalledSkills(tk, l, path));
-          }
-        }
+        printBoxTitle(t("wizard_step_4_skill_title").replace("{category}", category.name));
+        const installPath = level === "project" ? process.cwd() : getConfigRoot(tool, level);
+        const installedSkills = getInstalledSkills(tool, level, installPath);
         const installedSet = new Set(installedSkills);
-        const skillChoices = category.skills.map((skill) => {
-          const isInstalled = installedSet.has(skill.id);
-          const suffix = isInstalled ? ` [${t("skill_already_installed")}]` : "";
-          return {
-            name: `${skill.id}${suffix} \u2014 ${skill.description}`,
-            value: skill.id,
-            checked: false
-          };
-        });
-        skillChoices.push(new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-        skillChoices.push({ name: "<- " + t("wizard_back"), value: BACK3, checked: false });
-        skillChoices.push({ name: "x  " + t("wizard_cancel"), value: CANCEL3, checked: false });
+        const categorySkillIds = new Set(category.skills.map((s) => s.id));
+        const accumulatedInCategory = new Set(accumulated.filter((id) => categorySkillIds.has(id)));
+        const skillChoices = [
+          {
+            name: `>> ${t("skill_select_all_category")}`,
+            value: SELECT_ALL_CATEGORY,
+            checked: accumulatedInCategory.size === category.skills.length,
+            description: t("skill_select_all_category")
+          },
+          new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+          ...category.skills.map((skill) => {
+            const isInstalled = installedSet.has(skill.id);
+            const isAccumulated = accumulatedInCategory.has(skill.id);
+            const suffix = isInstalled ? ` [${t("skill_already_installed")}]` : isAccumulated ? " [+]" : "";
+            return {
+              name: `${chalk5.cyan(skill.id)}${suffix}`,
+              value: skill.id,
+              checked: isAccumulated,
+              description: skill.description
+            };
+          })
+        ];
         showOperationHints(true);
         const selectedSkills = await checkbox2({
           message: t("skill_select_items"),
           choices: skillChoices,
           loop: false,
           instructions: false,
-          theme: checkboxTheme
+          theme: checkboxTheme,
+          pageSize: 15
         });
-        if (selectedSkills.includes(BACK3)) {
-          step = 0;
-          break;
+        let skillIds;
+        if (selectedSkills.includes(SELECT_ALL_CATEGORY)) {
+          skillIds = category.skills.map((s) => s.id);
+        } else {
+          skillIds = selectedSkills.filter((id) => id !== SELECT_ALL_CATEGORY);
         }
-        if (selectedSkills.includes(CANCEL3)) return "cancel";
-        const skillIds = selectedSkills.filter((v) => v !== BACK3 && v !== CANCEL3);
         if (skillIds.length === 0) {
-          const action = await select2({
-            message: t("wizard_no_selection"),
-            choices: [
+          accumulated = accumulated.filter((id) => !categorySkillIds.has(id));
+          const action2 = await select3({
+            message: accumulated.length > 0 ? t("skill_continue_or_install").replace("{count}", String(accumulated.length)) : t("wizard_no_selection"),
+            choices: accumulated.length > 0 ? [
+              { name: ">> " + t("skill_confirm_install_count").replace("{count}", String(accumulated.length)), value: "install" },
+              { name: "<- " + t("wizard_back_to_reselect"), value: "back" },
+              { name: "x  " + t("wizard_cancel"), value: "cancel" }
+            ] : [
               new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
               { name: "<- " + t("wizard_back_to_reselect"), value: "back" },
               { name: "x  " + t("wizard_cancel"), value: "cancel" }
@@ -1914,13 +2067,38 @@ async function interactiveSkillSelect() {
             loop: false,
             theme: selectTheme
           });
-          if (action === "back") {
+          if (action2 === "install") return accumulated;
+          if (action2 === "back") {
             step = 0;
             break;
           }
           return "cancel";
         }
-        return skillIds;
+        accumulated = accumulated.filter((id) => !categorySkillIds.has(id));
+        for (const id of skillIds) {
+          if (!accumulated.includes(id)) {
+            accumulated.push(id);
+          }
+        }
+        const action = await select3({
+          message: t("skill_continue_or_install").replace("{count}", String(accumulated.length)),
+          choices: [
+            { name: ">> " + t("skill_confirm_install_count").replace("{count}", String(accumulated.length)), value: "install" },
+            { name: "> " + t("skill_continue_select"), value: CONTINUE_SELECT },
+            new Separator2("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"),
+            { name: "x  " + t("wizard_cancel"), value: "cancel" }
+          ],
+          loop: false,
+          theme: selectTheme
+        });
+        if (action === "install") {
+          return accumulated;
+        }
+        if (action === CONTINUE_SELECT) {
+          step = 0;
+          break;
+        }
+        return "cancel";
       }
     }
   }
@@ -1928,11 +2106,11 @@ async function interactiveSkillSelect() {
 function listAllSkills() {
   const categories = getAllCategories();
   console.log();
-  console.log(chalk3.bold(`  ${t("skill_list_title")}`));
-  console.log(chalk3.dim("  " + "\u2500".repeat(60)));
+  console.log(chalk5.bold(`  ${t("skill_list_title")}`));
+  console.log(chalk5.dim("  " + "\u2500".repeat(60)));
   for (const category of categories) {
     console.log();
-    console.log(chalk3.bold(`  ${category.name}`) + chalk3.dim(` (${category.skills.length} skills)`));
+    console.log(chalk5.bold(`  ${category.name}`) + chalk5.dim(` (${category.skills.length} skills)`));
     const table = new Table({
       style: { head: [], border: [] },
       colWidths: [35, 45],
@@ -1940,14 +2118,14 @@ function listAllSkills() {
     });
     for (const skill of category.skills) {
       table.push([
-        chalk3.cyan(skill.id),
+        chalk5.cyan(skill.id),
         skill.description
       ]);
     }
     console.log(table.toString());
   }
   console.log();
-  console.log(chalk3.dim(`  \u5171 ${getAllSkills().length} \u4E2A Skills`));
+  console.log(chalk5.dim(`  ${t("skill_total_count").replace("{count}", String(getAllSkills().length))}`));
   console.log();
 }
 function isSymlink2(path) {
@@ -1959,22 +2137,22 @@ function isSymlink2(path) {
 }
 
 // src/ui/display.ts
-import chalk4 from "chalk";
+import chalk6 from "chalk";
 import Table2 from "cli-table3";
 function printPluginList(plugins, installed) {
   const table = new Table2({
     head: [
-      chalk4.cyan(t("list_id")),
-      chalk4.cyan(t("list_name")),
-      chalk4.cyan(t("list_status")),
-      chalk4.cyan(t("list_skills")),
-      chalk4.cyan(t("list_agents"))
+      chalk6.cyan(t("list_id")),
+      chalk6.cyan(t("list_name")),
+      chalk6.cyan(t("list_status")),
+      chalk6.cyan(t("list_skills")),
+      chalk6.cyan(t("list_agents"))
     ],
     style: { head: [], border: [] }
   });
   plugins.forEach((plugin, index) => {
     const isInstalled = installed.has(plugin.id);
-    const status = isInstalled ? chalk4.green(`\u2713 ${t("status_installed")}`) : chalk4.dim(`\u2014`);
+    const status = isInstalled ? chalk6.green(`\u2713 ${t("status_installed")}`) : chalk6.dim(`\u2014`);
     table.push([
       String(index + 1),
       plugin.displayName,
@@ -1984,7 +2162,8 @@ function printPluginList(plugins, installed) {
     ]);
   });
   console.log();
-  console.log(chalk4.bold(`  ${t("list_title")} (${plugins.length} \u4E2A)`));
+  const countSuffix = t("count_suffix");
+  console.log(chalk6.bold(`  ${t("list_title")} (${plugins.length}${countSuffix ? " " + countSuffix : ""})`));
   console.log(table.toString());
   console.log();
 }
@@ -1993,7 +2172,7 @@ function printInstallSummary(results) {
   const totalCount = results.length;
   console.log();
   console.log(
-    chalk4.bold(
+    chalk6.bold(
       `  ${t("install_done")}! ${successCount}/${totalCount} ${t("install_success")}`
     )
   );
@@ -2001,10 +2180,10 @@ function printInstallSummary(results) {
   for (const result of results) {
     if (result.success) {
       console.log(
-        chalk4.green("  \u2713") + ` ${result.displayName} (${result.skillsCount} skills, ${result.agentsCount} agents)`
+        chalk6.green("  \u2713") + ` ${result.displayName} (${result.skillsCount} skills, ${result.agentsCount} agents)`
       );
     } else {
-      console.log(chalk4.red("  \u2717") + ` ${result.displayName}`);
+      console.log(chalk6.red("  \u2717") + ` ${result.displayName}`);
     }
   }
   console.log();
@@ -2017,22 +2196,25 @@ function printEnhancedSummary(results, tool, configRoot) {
     return;
   }
   const toolName = getToolDisplayName(tool);
+  const countSuffix = t("count_suffix");
   const lines = [
-    chalk4.bold(`  ${t("install_done")}!`),
+    chalk6.bold(`  ${t("install_done")}!`),
     "",
-    `  ${chalk4.dim(t("install_installed_to") + ":")} ${configRoot}`,
-    `  ${chalk4.dim(t("install_skills_count") + ":")} ${totalSkills} \u4E2A  ${chalk4.dim("|")}  ${chalk4.dim(t("install_agents_count") + ":")} ${totalAgents} \u4E2A`,
+    `  ${chalk6.dim(t("install_installed_to") + ":")} ${configRoot}`,
+    `  ${chalk6.dim(t("install_skills_count") + ":")} ${totalSkills}${countSuffix ? " " + countSuffix : ""}  ${chalk6.dim("|")}  ${chalk6.dim(t("install_agents_count") + ":")} ${totalAgents}${countSuffix ? " " + countSuffix : ""}`,
     "",
-    chalk4.bold(`  ${t("install_enhanced_next_steps")}:`),
-    `    ${chalk4.cyan("1.")} ${t("install_enhanced_launch")}: ${chalk4.green(toolName.toLowerCase())}`,
-    `    ${chalk4.cyan("2.")} ${t("install_enhanced_try")}: ${chalk4.green("\u5E2E\u6211\u5F00\u53D1\u4E00\u4E2A Abs \u7B97\u5B50")}`,
-    `    ${chalk4.cyan("3.")} ${t("install_enhanced_more")}: ${chalk4.green("install-helper list")}`,
-    `    ${chalk4.cyan("4.")} ${t("install_enhanced_check")}: ${chalk4.green("install-helper doctor")}`,
+    chalk6.bold(`  ${t("install_enhanced_next_steps")}:`),
+    `    ${chalk6.cyan("1.")} ${t("install_enhanced_launch")}: ${chalk6.green(toolName.toLowerCase())}`,
+    `    ${chalk6.cyan("2.")} ${t("install_enhanced_try")}: ${chalk6.green(t("try_prompt"))}`,
+    `    ${chalk6.cyan("3.")} ${t("install_enhanced_more")}: ${chalk6.green("install-helper list")}`,
+    `    ${chalk6.cyan("4.")} ${t("install_enhanced_check")}: ${chalk6.green("install-helper doctor")}`,
     ""
   ];
   if (successResults.length === 1) {
+    const plugin = findPlugin(successResults[0].pluginId);
+    const docsPath = plugin ? `${plugin.dir}/quickstart.md` : `${successResults[0].pluginId}/quickstart.md`;
     lines.push(
-      `  ${chalk4.dim(t("install_enhanced_docs"))}: ${chalk4.dim(`plugins-official/${successResults[0].pluginId}/quickstart.md`)}`
+      `  ${chalk6.dim(t("install_enhanced_docs"))}: ${chalk6.dim(docsPath)}`
     );
   }
   console.log();
@@ -2043,34 +2225,34 @@ function printEnhancedSummary(results, tool, configRoot) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { join as join13 } from "path";
 var BACK2 = "__back__";
 var CANCEL2 = "__cancel__";
 async function initCommand() {
   const cwd = process.cwd();
-  if (existsSync10(join10(cwd, "package.json")) && (() => {
+  if (existsSync11(join13(cwd, "package.json")) && (() => {
     try {
-      const pkg = JSON.parse(readFileSync5(join10(cwd, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync8(join13(cwd, "package.json"), "utf-8"));
       return pkg.name === "@cannbot-ai/install-helper";
     } catch {
       return false;
     }
   })()) {
-    logger.warn("\u5F53\u524D\u76EE\u5F55\u770B\u8D77\u6765\u662F install-helper \u5305\u76EE\u5F55");
-    logger.info("\u8BF7\u5728\u4F60\u7684\u9879\u76EE\u76EE\u5F55\u4E2D\u8FD0\u884C\u6B64\u547D\u4EE4\uFF0C\u800C\u4E0D\u662F\u5728 install-helper \u5B89\u88C5\u76EE\u5F55\u4E2D");
-    logger.info("\u793A\u4F8B\uFF1Acd ~/my-project && install-helper");
+    logger.warn(t("init_pkg_dir_warn"));
+    logger.info(t("init_pkg_dir_hint"));
+    logger.info(t("init_pkg_dir_example"));
     return;
   }
   printBanner(t("wizard_title"));
-  const spinner = createSpinner("\u6B63\u5728\u52A0\u8F7D Skills \u5217\u8868...");
+  const spinner = createSpinner(t("loading_skills_list"));
   spinner.start();
   try {
     const repoManager = createRepositoryManager();
     await repoManager.ensureRepoAndScan();
-    spinner.succeed("Skills \u5217\u8868\u52A0\u8F7D\u5B8C\u6210");
+    spinner.succeed(t("loading_skills_list_complete"));
   } catch {
-    spinner.warn("Skills \u5217\u8868\u52A0\u8F7D\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u6570\u636E");
+    spinner.warn(t("loading_skills_list_failed"));
   }
   let step = 0;
   let mode = "plugin";
@@ -2104,7 +2286,7 @@ async function initCommand() {
   }
 }
 async function selectMode() {
-  printBoxTitle("\u9009\u62E9\u5B89\u88C5\u7C7B\u578B");
+  printBoxTitle(t("wizard_select_mode_title"));
   const CANCEL3 = "__cancel__";
   const choices = [
     {
@@ -2119,7 +2301,7 @@ async function selectMode() {
     { name: "x  " + t("wizard_cancel"), value: CANCEL3 }
   ];
   showOperationHints();
-  const result = await select3({
+  const result = await select4({
     message: t("wizard_select_mode"),
     choices,
     loop: false,
@@ -2132,14 +2314,14 @@ async function pluginInstallFlow() {
   const answers = await runWizard();
   if (!answers.confirmed) {
     if (answers.back) return "back";
-    logger.info("\u5DF2\u53D6\u6D88\u5B89\u88C5");
+    logger.info(t("init_cancelled"));
     return "done";
   }
   const repoManager = createRepositoryManager();
-  const spinner = createSpinner("\u6B63\u5728\u52A0\u8F7D\u63D2\u4EF6\u6570\u636E...");
+  const spinner = createSpinner(t("loading_plugin_data"));
   spinner.start();
   const repoPath = await repoManager.ensureRepo();
-  spinner.succeed("\u63D2\u4EF6\u6570\u636E\u52A0\u8F7D\u5B8C\u6210");
+  spinner.succeed(t("loading_plugin_data_complete"));
   const allPlugins = getAllPlugins();
   const selectedPlugins = answers.plugins.map(
     (id) => allPlugins.find((p) => p.id === id)
@@ -2193,7 +2375,7 @@ async function skillInstallFlow() {
         const result = await selectToolWithDetection();
         if (result === "back") return "back";
         if (result === "cancel") {
-          logger.info("\u5DF2\u53D6\u6D88\u5B89\u88C5");
+          logger.info(t("init_cancelled"));
           return "done";
         }
         tool = result;
@@ -2207,7 +2389,7 @@ async function skillInstallFlow() {
           break;
         }
         if (result === CANCEL2) {
-          logger.info("\u5DF2\u53D6\u6D88\u5B89\u88C5");
+          logger.info(t("init_cancelled"));
           return "done";
         }
         level = result;
@@ -2215,25 +2397,25 @@ async function skillInstallFlow() {
         break;
       }
       case 2: {
-        const selectedSkills = await interactiveSkillSelect();
+        const selectedSkills = await interactiveSkillSelect(tool, level);
         if (selectedSkills === "back") {
           step = 1;
           break;
         }
         if (selectedSkills === "cancel") {
-          logger.info("\u5DF2\u53D6\u6D88\u5B89\u88C5");
+          logger.info(t("init_cancelled"));
           return "done";
         }
         if (selectedSkills.length === 0) {
-          logger.info("\u672A\u9009\u62E9\u4EFB\u4F55 Skill");
+          logger.info(t("install_no_skill_selected"));
           return "done";
         }
         const repoManager = createRepositoryManager();
-        const spinner = createSpinner("\u6B63\u5728\u52A0\u8F7D\u63D2\u4EF6\u6570\u636E...");
+        const spinner = createSpinner(t("loading_plugin_data"));
         spinner.start();
         const repoPath = await repoManager.ensureRepo();
-        spinner.succeed("\u63D2\u4EF6\u6570\u636E\u52A0\u8F7D\u5B8C\u6210");
-        logger.info(`${t("skill_install_progress")} ${chalk5.bold(selectedSkills.length)} \u4E2A Skills...`);
+        spinner.succeed(t("loading_plugin_data_complete"));
+        logger.info(`${t("skill_install_progress")} ${t("skill_count_format").replace("{count}", chalk7.bold(String(selectedSkills.length)))}...`);
         const results = await installSkills(selectedSkills, tool, level, repoPath);
         let successCount = 0;
         let failCount = 0;
@@ -2251,10 +2433,10 @@ async function skillInstallFlow() {
         }
         const configRoot = getConfigRoot(tool, level);
         logger.blank();
-        logger.success(`${t("skill_install_done")}: ${chalk5.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk5.red(failCount + " \u5931\u8D25") : chalk5.dim(failCount + " \u5931\u8D25")}`);
+        logger.success(`${t("skill_install_done")}: ${chalk7.green(t("result_success_format").replace("{count}", String(successCount)))}, ${failCount > 0 ? chalk7.red(t("result_failed_format").replace("{count}", String(failCount))) : chalk7.dim(t("result_failed_format").replace("{count}", String(failCount)))}`);
         logger.blank();
-        logger.info(`\u5B89\u88C5\u5230: ${chalk5.cyan(configRoot + "/skills/")}`);
-        logger.info(`\u542F\u52A8 ${chalk5.green(tool)} \u5373\u53EF\u4F7F\u7528`);
+        logger.info(`${t("install_to")}: ${chalk7.cyan(configRoot + "/skills/")}`);
+        logger.info(`${t("start_to_use").replace("{tool}", chalk7.green(tool))}`);
         logger.blank();
         return "done";
       }
@@ -2276,32 +2458,32 @@ async function listCommand() {
 }
 
 // src/commands/doctor.ts
-import chalk6 from "chalk";
-import { existsSync as existsSync11, readdirSync as readdirSync4, lstatSync as lstatSync3, unlinkSync as unlinkSync3, mkdirSync as mkdirSync6 } from "fs";
-import { join as join11 } from "path";
+import chalk8 from "chalk";
+import { existsSync as existsSync12, readdirSync as readdirSync5, lstatSync as lstatSync3, unlinkSync as unlinkSync4, mkdirSync as mkdirSync6 } from "fs";
+import { join as join14 } from "path";
 async function doctorCommand(options = {}) {
   console.log();
-  console.log(chalk6.bold(`  ${t("doctor_title")}`));
-  console.log(chalk6.dim("  " + "\u2500".repeat(46)));
+  console.log(chalk8.bold(`  ${t("doctor_title")}`));
+  console.log(chalk8.dim("  " + "\u2500".repeat(46)));
   let errors = 0;
   let warnings = 0;
   let fixes = 0;
   console.log();
-  console.log(chalk6.bold(`  ${t("doctor_tools")}`));
+  console.log(chalk8.bold(`  ${t("doctor_tools")}`));
   const detectedTools = await detectTools();
   const allTools = getAllTools();
   for (const tool of allTools) {
     const detected = detectedTools.find((d) => d.name === tool);
     if (detected) {
       console.log(
-        chalk6.green("  \u2713") + ` ${getToolDisplayName(tool)}${detected.version ? ` v${detected.version}` : ""}`
+        chalk8.green("  \u2713") + ` ${getToolDisplayName(tool)}${detected.version ? ` v${detected.version}` : ""}`
       );
     } else {
-      console.log(chalk6.dim("  \u2014") + ` ${getToolDisplayName(tool)} \u2014 \u672A\u5B89\u88C5`);
+      console.log(chalk8.dim("  \u2014") + ` ${getToolDisplayName(tool)} \u2014 ${t("doctor_not_installed")}`);
     }
   }
   console.log();
-  console.log(chalk6.bold(`  ${t("doctor_plugins")}`));
+  console.log(chalk8.bold(`  ${t("doctor_plugins")}`));
   const plugins = getAllPlugins();
   const installed = scanInstalled();
   const installedMap = new Map(installed.map((p) => [p.id, p]));
@@ -2309,80 +2491,80 @@ async function doctorCommand(options = {}) {
     const inst = installedMap.get(plugin.id);
     if (inst) {
       console.log(
-        chalk6.green("  \u2713") + ` ${plugin.id.padEnd(30)} ${inst.skillsCount} skills, ${inst.agentsCount} agents`
+        chalk8.green("  \u2713") + ` ${plugin.id.padEnd(30)} ${inst.skillsCount} skills, ${inst.agentsCount} agents`
       );
     } else {
-      console.log(chalk6.dim("  \u2014") + ` ${plugin.id.padEnd(30)} \u2014 \u672A\u5B89\u88C5`);
+      console.log(chalk8.dim("  \u2014") + ` ${plugin.id.padEnd(30)} \u2014 ${t("doctor_not_installed")}`);
     }
   }
   console.log();
-  console.log(chalk6.bold(`  ${t("doctor_links")}`));
+  console.log(chalk8.bold(`  ${t("doctor_links")}`));
   const primaryTool = detectedTools[0]?.name || "opencode";
   const configRoot = getConfigRoot(primaryTool, "project");
   const skillsDir = getSkillsDir(configRoot);
   const agentsDir = getAgentsDir(configRoot);
-  if (existsSync11(skillsDir)) {
+  if (existsSync12(skillsDir)) {
     const brokenLinks = checkBrokenLinks(skillsDir);
     if (brokenLinks === 0) {
-      const count = readdirSync4(skillsDir).length;
-      console.log(chalk6.green("  \u2713") + ` ${skillsDir} \u2014 ${count} \u4E2A\u8F6F\u94FE\u63A5\u5747\u6709\u6548`);
+      const count = readdirSync5(skillsDir).length;
+      console.log(chalk8.green("  \u2713") + ` ${skillsDir} \u2014 ${t("doctor_links_valid").replace("{count}", String(count))}`);
     } else {
-      console.log(chalk6.yellow("  \u26A0") + ` ${skillsDir} \u2014 ${brokenLinks} \u4E2A\u5931\u6548\u94FE\u63A5`);
+      console.log(chalk8.yellow("  \u26A0") + ` ${skillsDir} \u2014 ${t("doctor_broken_links").replace("{count}", String(brokenLinks))}`);
       warnings++;
       if (options.fix) {
         const fixed = fixBrokenLinks(skillsDir);
         fixes += fixed;
-        console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_cleaning")}: \u5DF2\u6E05\u7406 ${fixed} \u4E2A\u5931\u6548\u94FE\u63A5`);
+        console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_cleaning")}: ${t("doctor_fixed").replace("{count}", String(fixed))}`);
       }
     }
   } else {
-    console.log(chalk6.dim("  \u2014") + ` ${skillsDir} \u2014 \u4E0D\u5B58\u5728`);
+    console.log(chalk8.dim("  \u2014") + ` ${skillsDir} \u2014 ${t("doctor_not_exist")}`);
     if (options.fix) {
       mkdirSync6(skillsDir, { recursive: true });
       fixes++;
-      console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: \u5DF2\u521B\u5EFA ${skillsDir}`);
+      console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: ${t("doctor_created").replace("{path}", skillsDir)}`);
     }
   }
-  if (existsSync11(agentsDir)) {
+  if (existsSync12(agentsDir)) {
     const brokenLinks = checkBrokenLinks(agentsDir);
     if (brokenLinks === 0) {
-      const count = readdirSync4(agentsDir).length;
-      console.log(chalk6.green("  \u2713") + ` ${agentsDir} \u2014 ${count} \u4E2A\u8F6F\u94FE\u63A5\u5747\u6709\u6548`);
+      const count = readdirSync5(agentsDir).length;
+      console.log(chalk8.green("  \u2713") + ` ${agentsDir} \u2014 ${t("doctor_links_valid").replace("{count}", String(count))}`);
     } else {
-      console.log(chalk6.yellow("  \u26A0") + ` ${agentsDir} \u2014 ${brokenLinks} \u4E2A\u5931\u6548\u94FE\u63A5`);
+      console.log(chalk8.yellow("  \u26A0") + ` ${agentsDir} \u2014 ${t("doctor_broken_links").replace("{count}", String(brokenLinks))}`);
       warnings++;
       if (options.fix) {
         const fixed = fixBrokenLinks(agentsDir);
         fixes += fixed;
-        console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_cleaning")}: \u5DF2\u6E05\u7406 ${fixed} \u4E2A\u5931\u6548\u94FE\u63A5`);
+        console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_cleaning")}: ${t("doctor_fixed").replace("{count}", String(fixed))}`);
       }
     }
   } else {
-    console.log(chalk6.dim("  \u2014") + ` ${agentsDir} \u2014 \u4E0D\u5B58\u5728`);
+    console.log(chalk8.dim("  \u2014") + ` ${agentsDir} \u2014 ${t("doctor_not_exist")}`);
     if (options.fix) {
       mkdirSync6(agentsDir, { recursive: true });
       fixes++;
-      console.log(chalk6.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: \u5DF2\u521B\u5EFA ${agentsDir}`);
+      console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: ${t("doctor_created").replace("{path}", agentsDir)}`);
     }
   }
   console.log();
-  console.log(chalk6.bold(`  ${t("doctor_config")}`));
+  console.log(chalk8.bold(`  ${t("doctor_config")}`));
   const configFile = getConfigFileName(primaryTool);
-  const configPath = join11(process.cwd(), configFile);
-  if (existsSync11(configPath)) {
-    console.log(chalk6.green("  \u2713") + ` ${configFile} \u5B58\u5728`);
+  const configPath = join14(process.cwd(), configFile);
+  if (existsSync12(configPath)) {
+    console.log(chalk8.green("  \u2713") + ` ${configFile} ${t("doctor_config_exists")}`);
   } else {
-    console.log(chalk6.dim("  \u2014") + ` ${configFile} \u4E0D\u5B58\u5728`);
+    console.log(chalk8.dim("  \u2014") + ` ${configFile} ${t("doctor_config_not_exist")}`);
   }
   console.log();
-  console.log(chalk6.dim("  " + "\u2500".repeat(46)));
+  console.log(chalk8.dim("  " + "\u2500".repeat(46)));
   if (options.fix && fixes > 0) {
     console.log(
-      `  ${t("doctor_result")}: ${warnings} \u4E2A\u8B66\u544A, ${errors} \u4E2A\u9519\u8BEF, ${fixes} \u9879\u5DF2\u4FEE\u590D`
+      `  ${t("doctor_result")}: ${t("doctor_result_with_fix").replace("{warnings}", String(warnings)).replace("{errors}", String(errors)).replace("{fixes}", String(fixes))}`
     );
   } else {
     console.log(
-      `  ${t("doctor_result")}: ${warnings} \u4E2A\u8B66\u544A, ${errors} \u4E2A\u9519\u8BEF`
+      `  ${t("doctor_result")}: ${t("doctor_result_without_fix").replace("{warnings}", String(warnings)).replace("{errors}", String(errors))}`
     );
   }
   console.log();
@@ -2390,13 +2572,13 @@ async function doctorCommand(options = {}) {
 function checkBrokenLinks(dir) {
   let broken = 0;
   try {
-    const entries = readdirSync4(dir);
+    const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join11(dir, entry);
+      const fullPath = join14(dir, entry);
       try {
         const stats = lstatSync3(fullPath);
         if (stats.isSymbolicLink()) {
-          if (!existsSync11(fullPath)) {
+          if (!existsSync12(fullPath)) {
             broken++;
           }
         }
@@ -2411,14 +2593,14 @@ function checkBrokenLinks(dir) {
 function fixBrokenLinks(dir) {
   let fixed = 0;
   try {
-    const entries = readdirSync4(dir);
+    const entries = readdirSync5(dir);
     for (const entry of entries) {
-      const fullPath = join11(dir, entry);
+      const fullPath = join14(dir, entry);
       try {
         const stats = lstatSync3(fullPath);
         if (stats.isSymbolicLink()) {
-          if (!existsSync11(fullPath)) {
-            unlinkSync3(fullPath);
+          if (!existsSync12(fullPath)) {
+            unlinkSync4(fullPath);
             fixed++;
           }
         }
@@ -2431,36 +2613,36 @@ function fixBrokenLinks(dir) {
 }
 
 // src/commands/status.ts
-import chalk7 from "chalk";
+import chalk9 from "chalk";
 async function statusCommand() {
   const plugins = getAllPlugins();
   const installed = scanInstalled();
   const installedMap = new Map(installed.map((p) => [p.id, p]));
   console.log();
-  console.log(chalk7.bold(`  ${t("status_title")}`));
+  console.log(chalk9.bold(`  ${t("status_title")}`));
   console.log();
   if (installed.length === 0) {
-    console.log(chalk7.dim(`  ${t("status_none")}`));
-    console.log(chalk7.dim(`  ${t("status_hint")}`));
+    console.log(chalk9.dim(`  ${t("status_none")}`));
+    console.log(chalk9.dim(`  ${t("status_hint")}`));
     console.log();
     return;
   }
   for (const inst of installed) {
     console.log(
-      chalk7.green("  \u2713") + ` ${inst.displayName}` + chalk7.dim(` (${inst.tool}, ${inst.level})`)
+      chalk9.green("  \u2713") + ` ${inst.displayName}` + chalk9.dim(` (${inst.tool}, ${inst.level})`)
     );
     console.log(
-      chalk7.dim(`    ${inst.skillsCount} skills, ${inst.agentsCount} agents`)
+      chalk9.dim(`    ${inst.skillsCount} skills, ${inst.agentsCount} agents`)
     );
-    console.log(chalk7.dim(`    ${inst.configRoot}`));
-    console.log(chalk7.dim(`    ${t("status_install_time")}: ${inst.installTime}`));
+    console.log(chalk9.dim(`    ${inst.configRoot}`));
+    console.log(chalk9.dim(`    ${t("status_install_time")}: ${inst.installTime}`));
     console.log();
   }
 }
 
 // src/commands/install.ts
 import { confirm } from "@inquirer/prompts";
-import chalk8 from "chalk";
+import chalk10 from "chalk";
 async function installCommand(names, options) {
   if (options.list) {
     try {
@@ -2471,79 +2653,138 @@ async function installCommand(names, options) {
     listAllSkills();
     return;
   }
+  if (options.all) {
+    const scanSpinner2 = createSpinner(t("loading_skills_list"));
+    scanSpinner2.start();
+    try {
+      const scanRepoManager = createRepositoryManager();
+      await scanRepoManager.ensureRepoAndScan();
+      scanSpinner2.succeed(t("loading_skills_list_complete"));
+    } catch {
+      scanSpinner2.warn(t("loading_skills_list_failed"));
+    }
+    const allSkills = getAllSkills();
+    const skillIds = allSkills.map((s) => s.id);
+    if (skillIds.length === 0) {
+      logger.error(t("install_no_skill_selected"));
+      return;
+    }
+    let tool2;
+    if (options.tool) {
+      tool2 = validateTool(options.tool);
+    } else {
+      const detected = await selectToolWithDetection();
+      if (detected === "back" || detected === "cancel") return;
+      tool2 = detected;
+    }
+    const level2 = options.level ? validateLevel(options.level) : "project";
+    const repoManager = createRepositoryManager();
+    const spinner = createSpinner(t("loading_plugin_data"));
+    spinner.start();
+    const repoPath = await repoManager.ensureRepo();
+    spinner.succeed(t("loading_plugin_data_complete"));
+    logger.info(`${t("skill_all_install_progress").replace("{count}", chalk10.bold(String(skillIds.length)))}`);
+    const results = await installSkills(skillIds, tool2, level2, repoPath);
+    let successCount = 0;
+    let failCount = 0;
+    const total = results.length;
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const progress = `[${i + 1}/${total}]`;
+      if (result.success) {
+        logger.success(`${progress} ${result.skillId}`);
+        successCount++;
+      } else {
+        logger.error(`${progress} ${result.skillId}: ${result.error}`);
+        failCount++;
+      }
+    }
+    const configRoot = getConfigRoot(tool2, level2);
+    logger.blank();
+    logger.success(`${t("skill_install_done")}: ${chalk10.green(t("result_success_format").replace("{count}", String(successCount)))}, ${failCount > 0 ? chalk10.red(t("result_failed_format").replace("{count}", String(failCount))) : chalk10.dim(t("result_failed_format").replace("{count}", String(failCount)))}`);
+    logger.blank();
+    logger.info(`${t("install_to")}: ${chalk10.cyan(configRoot + "/skills/")}`);
+    logger.info(`${t("start_to_use").replace("{tool}", chalk10.green(tool2))}`);
+    logger.blank();
+    return;
+  }
   if (names.length === 0) {
-    const scanSpinner2 = createSpinner("\u6B63\u5728\u52A0\u8F7D Skills \u5217\u8868...");
+    const scanSpinner2 = createSpinner(t("loading_skills_list"));
     scanSpinner2.start();
     try {
       const scanRepoManager = createRepositoryManager();
       await scanRepoManager.ensureRepoAndScan();
-      scanSpinner2.succeed("Skills \u5217\u8868\u52A0\u8F7D\u5B8C\u6210");
+      scanSpinner2.succeed(t("loading_skills_list_complete"));
     } catch {
-      scanSpinner2.warn("Skills \u5217\u8868\u52A0\u8F7D\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u6570\u636E");
+      scanSpinner2.warn(t("loading_skills_list_failed"));
     }
     let tool2;
     if (options.tool) {
-      tool2 = options.tool;
+      tool2 = validateTool(options.tool);
     } else {
       const detected = await selectToolWithDetection();
-      if (detected === "back") return;
+      if (detected === "back" || detected === "cancel") return;
       tool2 = detected;
     }
+    const level2 = options.level ? validateLevel(options.level) : "project";
     let step = 1;
     while (true) {
       switch (step) {
         case 1: {
-          const selectedSkills = await interactiveSkillSelect();
+          const selectedSkills = await interactiveSkillSelect(tool2, level2);
           if (selectedSkills === "back") {
             const redetected = await selectToolWithDetection();
-            if (redetected === "back") return;
+            if (redetected === "back" || redetected === "cancel") return;
             tool2 = redetected;
             break;
           }
+          if (selectedSkills === "cancel") return;
           if (selectedSkills.length === 0) {
-            logger.info("\u672A\u9009\u62E9\u4EFB\u4F55 Skill");
+            logger.info(t("install_no_skill_selected"));
             return;
           }
           names = selectedSkills;
           const repoManager = createRepositoryManager();
-          const spinner = createSpinner(t("install_cloning"));
+          const spinner = createSpinner(t("loading_plugin_data"));
           spinner.start();
           const repoPath = await repoManager.ensureRepo();
-          spinner.succeed(t("install_repo_ready"));
-          logger.info(`${t("skill_install_progress")} ${chalk8.bold(names.length)} \u4E2A Skills...`);
-          const level2 = options.level || "project";
+          spinner.succeed(t("loading_plugin_data_complete"));
+          logger.info(`${t("skill_install_progress")} ${t("skill_count_format").replace("{count}", chalk10.bold(String(names.length)))}...`);
           const results = await installSkills(names, tool2, level2, repoPath);
           let successCount = 0;
           let failCount = 0;
-          for (const result of results) {
+          const total = results.length;
+          for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const progress = `[${i + 1}/${total}]`;
             if (result.success) {
-              logger.success(`${result.skillId}`);
+              logger.success(`${progress} ${result.skillId}`);
               successCount++;
             } else {
-              logger.error(`${result.skillId}: ${result.error}`);
+              logger.error(`${progress} ${result.skillId}: ${result.error}`);
               failCount++;
             }
           }
           const configRoot = getConfigRoot(tool2, level2);
           logger.blank();
-          logger.success(`${t("skill_install_done")}: ${chalk8.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk8.red(failCount + " \u5931\u8D25") : chalk8.dim(failCount + " \u5931\u8D25")}`);
+          logger.success(`${t("skill_install_done")}: ${chalk10.green(t("result_success_format").replace("{count}", String(successCount)))}, ${failCount > 0 ? chalk10.red(t("result_failed_format").replace("{count}", String(failCount))) : chalk10.dim(t("result_failed_format").replace("{count}", String(failCount)))}`);
           logger.blank();
-          logger.info(`\u5B89\u88C5\u5230: ${chalk8.cyan(configRoot + "/skills/")}`);
-          logger.info(`\u542F\u52A8 ${chalk8.green(tool2)} \u5373\u53EF\u4F7F\u7528`);
+          logger.info(`${t("install_to")}: ${chalk10.cyan(configRoot + "/skills/")}`);
+          logger.info(`${t("start_to_use").replace("{tool}", chalk10.green(tool2))}`);
           logger.blank();
           return;
         }
       }
     }
   }
-  const scanSpinner = createSpinner("\u6B63\u5728\u52A0\u8F7D Skills \u5217\u8868...");
+  const scanSpinner = createSpinner(t("loading_skills_list"));
   scanSpinner.start();
   try {
     const scanRepoManager = createRepositoryManager();
     await scanRepoManager.ensureRepoAndScan();
-    scanSpinner.succeed("Skills \u5217\u8868\u52A0\u8F7D\u5B8C\u6210");
+    scanSpinner.succeed(t("loading_skills_list_complete"));
   } catch {
-    scanSpinner.warn("Skills \u5217\u8868\u52A0\u8F7D\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528\u5185\u7F6E\u6570\u636E");
+    scanSpinner.warn(t("loading_skills_list_failed"));
   }
   const plugins = [];
   const skills = [];
@@ -2560,22 +2801,22 @@ async function installCommand(names, options) {
     }
     logger.error(`${t("error_plugin_not_found")}: ${name}`);
     const allPlugins = getAllPlugins();
-    logger.info("\u53EF\u7528\u63D2\u4EF6:");
+    logger.info(t("available_plugins") + ":");
     for (const p of allPlugins) {
       logger.step(`  ${p.id} (${p.aliases.join(", ")})`);
     }
-    logger.info(`\u53EF\u7528 Skills: ${chalk8.cyan("install-helper install --list")}`);
+    logger.info(`${t("available_skills")}: ${chalk10.cyan("install-helper install --list")}`);
     return;
   }
   let tool;
   if (options.tool) {
-    tool = options.tool;
+    tool = validateTool(options.tool);
   } else {
     const detected = await selectToolWithDetection();
-    if (detected === "back") return;
+    if (detected === "back" || detected === "cancel") return;
     tool = detected;
   }
-  const level = options.level || "project";
+  const level = options.level ? validateLevel(options.level) : "project";
   if (plugins.length > 0) {
     const configRoot = getConfigRoot(tool, level);
     const manifests = readAllManifests(configRoot);
@@ -2603,16 +2844,18 @@ async function installCommand(names, options) {
     }
     if (pluginsToInstall.length > 0) {
       const repoManager = createRepositoryManager();
-      const spinner = createSpinner(t("install_cloning"));
+      const spinner = createSpinner(t("loading_plugin_data"));
       spinner.start();
       const repoPath = await repoManager.ensureRepo();
-      spinner.succeed(t("install_repo_ready"));
+      spinner.succeed(t("loading_plugin_data_complete"));
       const allPlugins = getAllPlugins();
       const results = await installPlugins(
         pluginsToInstall,
         tool,
         level,
-        repoPath
+        repoPath,
+        void 0,
+        options.yes
       );
       const summary = results.map((result) => {
         const plugin = allPlugins.find((p) => p.id === result.pluginId);
@@ -2630,32 +2873,35 @@ async function installCommand(names, options) {
   }
   if (skills.length > 0) {
     const repoManager = createRepositoryManager();
-    const spinner = createSpinner(t("install_cloning"));
+    const spinner = createSpinner(t("loading_plugin_data"));
     spinner.start();
     const repoPath = await repoManager.ensureRepo();
-    spinner.succeed(t("install_repo_ready"));
-    logger.info(`${t("skill_install_progress")} ${chalk8.bold(skills.length)} \u4E2A Skills...`);
+    spinner.succeed(t("loading_plugin_data_complete"));
+    logger.info(`${t("skill_install_progress")} ${t("skill_count_format").replace("{count}", chalk10.bold(String(skills.length)))}...`);
     const results = await installSkills(skills, tool, level, repoPath);
     let successCount = 0;
     let failCount = 0;
-    for (const result of results) {
+    const total = results.length;
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const progress = `[${i + 1}/${total}]`;
       if (result.success) {
-        logger.success(`${result.skillId}`);
+        logger.success(`${progress} ${result.skillId}`);
         successCount++;
       } else {
-        logger.error(`${result.skillId}: ${result.error}`);
+        logger.error(`${progress} ${result.skillId}: ${result.error}`);
         failCount++;
       }
     }
     logger.blank();
-    logger.success(`${t("skill_install_done")}: ${chalk8.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk8.red(failCount + " \u5931\u8D25") : chalk8.dim(failCount + " \u5931\u8D25")}`);
+    logger.success(`${t("skill_install_done")}: ${chalk10.green(t("result_success_format").replace("{count}", String(successCount)))}, ${failCount > 0 ? chalk10.red(t("result_failed_format").replace("{count}", String(failCount))) : chalk10.dim(t("result_failed_format").replace("{count}", String(failCount)))}`);
     logger.blank();
-    logger.info(`\u5B89\u88C5\u5230: ${chalk8.cyan(getConfigRoot(tool, level) + "/skills/")}`);
-    logger.info(`\u542F\u52A8 ${chalk8.green(tool)} \u5373\u53EF\u4F7F\u7528`);
+    logger.info(`${t("install_to")}: ${chalk10.cyan(getConfigRoot(tool, level) + "/skills/")}`);
+    logger.info(`${t("start_to_use").replace("{tool}", chalk10.green(tool))}`);
     logger.blank();
   }
 }
-async function installPlugins(pluginIds, tool, level, repoPath) {
+async function installPlugins(pluginIds, tool, level, repoPath, installPath, yes) {
   const results = [];
   const total = pluginIds.length;
   for (let i = 0; i < pluginIds.length; i++) {
@@ -2667,7 +2913,9 @@ async function installPlugins(pluginIds, tool, level, repoPath) {
       pluginId,
       tool,
       level,
-      repoPath
+      repoPath,
+      installPath,
+      yes
     });
     if (result.success) {
       spinner.succeed(
@@ -2683,11 +2931,11 @@ async function installPlugins(pluginIds, tool, level, repoPath) {
 }
 
 // src/commands/uninstall.ts
-import { existsSync as existsSync12, unlinkSync as unlinkSync4, rmdirSync as rmdirSync2, readdirSync as readdirSync5, lstatSync as lstatSync4 } from "fs";
-import chalk9 from "chalk";
+import { existsSync as existsSync13, unlinkSync as unlinkSync5, rmdirSync as rmdirSync2, readdirSync as readdirSync6, lstatSync as lstatSync4 } from "fs";
+import chalk11 from "chalk";
 async function uninstallCommand(names, options) {
-  const tool = options.tool || "opencode";
-  const level = options.level || "project";
+  const tool = options.tool ? validateTool(options.tool) : "opencode";
+  const level = options.level ? validateLevel(options.level) : "project";
   const plugins = [];
   const skills = [];
   for (const name of names) {
@@ -2701,40 +2949,44 @@ async function uninstallCommand(names, options) {
       skills.push(skill.id);
       continue;
     }
-    logger.error(`\u672A\u627E\u5230: ${name}`);
+    logger.error(`${t("uninstall_not_found")}: ${name}`);
   }
   for (const pluginId of plugins) {
     const plugin = findPlugin(pluginId);
     if (!plugin) continue;
     const record = readRecord(plugin.id);
     if (!record) {
-      logger.warn(`${plugin.displayName} \u672A\u627E\u5230\u5B89\u88C5\u8BB0\u5F55\uFF0C\u53EF\u80FD\u672A\u5B89\u88C5\u6216\u5B89\u88C5\u8BB0\u5F55\u5DF2\u635F\u574F`);
-      logger.info(`\u5982\u9700\u5F3A\u5236\u6E05\u7406\uFF0C\u8BF7\u624B\u52A8\u5220\u9664 .opencode/ \u6216 .claude/ \u76EE\u5F55\u4E2D\u7684\u76F8\u5173\u6587\u4EF6`);
+      logger.warn(`${plugin.displayName} ${t("uninstall_no_record")}`);
+      logger.info(`${t("uninstall_no_record_hint")}`);
       continue;
     }
-    logger.info(`\u6B63\u5728\u5378\u8F7D ${plugin.displayName}...`);
+    logger.info(`${t("uninstall_in_progress")} ${plugin.displayName}...`);
     let removedFiles = 0;
     let removedDirs = 0;
     for (const filePath of record.files) {
       try {
-        if (existsSync12(filePath) || isSymlink3(filePath)) {
-          unlinkSync4(filePath);
+        if (existsSync13(filePath) || isSymlink3(filePath)) {
+          unlinkSync5(filePath);
           const name = filePath.split("/").pop() || filePath;
-          logger.step(`  \u79FB\u9664: ${name}`);
+          logger.step(`  ${t("uninstall_remove_label")}: ${name}`);
           removedFiles++;
         }
       } catch {
       }
     }
+    const configRoot = getConfigRoot(record.tool, record.level);
     const sortedDirs = [...record.directories].sort((a, b) => b.length - a.length);
     for (const dirPath of sortedDirs) {
       try {
-        if (existsSync12(dirPath)) {
-          const entries = readdirSync5(dirPath);
+        if (dirPath === configRoot) {
+          continue;
+        }
+        if (existsSync13(dirPath)) {
+          const entries = readdirSync6(dirPath);
           if (entries.length === 0) {
             rmdirSync2(dirPath);
             const name = dirPath.split("/").pop() || dirPath;
-            logger.step(`  \u6E05\u7406\u7A7A\u76EE\u5F55: ${name}/`);
+            logger.step(`  ${t("uninstall_clean_empty_dir")}: ${name}/`);
             removedDirs++;
           }
         }
@@ -2743,15 +2995,32 @@ async function uninstallCommand(names, options) {
     }
     deleteRecord(plugin.id);
     removeInstalledPlugin(plugin.id);
+    const backups = findBackups(configRoot);
+    const otherBackups = backups.filter((b) => b.pluginId !== pluginId);
+    if (otherBackups.length > 0) {
+      const choice = await showRestorePrompt(otherBackups);
+      if (choice !== "none") {
+        const restored = restoreBackup(choice, configRoot, record.tool);
+        if (restored) {
+          const backupInfo = otherBackups.find((b) => b.filePath === choice);
+          logger.success(`${t("backup_restore_success")}: ${backupInfo?.pluginName || ""}`);
+          deleteBackup(choice);
+        }
+      }
+    }
+    const currentBackups = backups.filter((b) => b.pluginId === pluginId);
+    for (const backup of currentBackups) {
+      deleteBackup(backup.filePath);
+    }
     const totalRemoved = removedFiles + removedDirs;
     if (totalRemoved > 0) {
-      logger.success(`\u5DF2\u5378\u8F7D ${plugin.displayName}\uFF08\u79FB\u9664 ${removedFiles} \u4E2A\u6587\u4EF6\uFF0C${removedDirs} \u4E2A\u76EE\u5F55\uFF09`);
+      logger.success(`${t("uninstall_removed")} ${plugin.displayName}\uFF08${t("uninstall_remove_file_format").replace("{count}", String(removedFiles))}\uFF0C${t("uninstall_remove_dir_format").replace("{count}", String(removedDirs))}\uFF09`);
     } else {
-      logger.warn(`${plugin.displayName} \u7684\u6587\u4EF6\u5DF2\u4E0D\u5B58\u5728\uFF0C\u5DF2\u6E05\u7406\u5B89\u88C5\u8BB0\u5F55`);
+      logger.warn(`${plugin.displayName}${t("uninstall_files_gone")}`);
     }
   }
   if (skills.length > 0) {
-    logger.info(`\u6B63\u5728\u5378\u8F7D ${skills.length} \u4E2A Skills...`);
+    logger.info(`${t("uninstall_skills_in_progress")} ${t("skill_count_format").replace("{count}", String(skills.length))}...`);
     const results = await uninstallSkills(skills, tool, level);
     let successCount = 0;
     let failCount = 0;
@@ -2763,7 +3032,7 @@ async function uninstallCommand(names, options) {
       }
     }
     logger.blank();
-    logger.success(`${t("skill_uninstall_done")}: ${chalk9.green(successCount + " \u6210\u529F")}, ${failCount > 0 ? chalk9.red(failCount + " \u5931\u8D25") : chalk9.dim(failCount + " \u5931\u8D25")}`);
+    logger.success(`${t("skill_uninstall_done")}: ${chalk11.green(t("result_success_format").replace("{count}", String(successCount)))}, ${failCount > 0 ? chalk11.red(t("result_failed_format").replace("{count}", String(failCount))) : chalk11.dim(t("result_failed_format").replace("{count}", String(failCount)))}`);
     logger.blank();
   }
 }
@@ -2776,17 +3045,17 @@ function isSymlink3(path) {
 }
 
 // src/commands/update.ts
-import chalk10 from "chalk";
+import chalk12 from "chalk";
 async function updateCommand(pluginNames, options) {
   let tool;
   if (options.tool) {
-    tool = options.tool;
+    tool = validateTool(options.tool);
   } else {
     const detected = await selectToolWithDetection();
-    if (detected === "back") return;
+    if (detected === "back" || detected === "cancel") return;
     tool = detected;
   }
-  const level = options.level || "project";
+  const level = options.level ? validateLevel(options.level) : "project";
   let pluginsToUpdate = [];
   if (pluginNames.length === 0) {
     const configRoot = getConfigRoot(tool, level);
@@ -2794,7 +3063,7 @@ async function updateCommand(pluginNames, options) {
     pluginsToUpdate = manifests.map((m) => m.team);
     if (pluginsToUpdate.length === 0) {
       logger.info(t("update_no_plugins"));
-      logger.info(`\u4F7F\u7528 ${chalk10.cyan("install-helper install <plugin>")} \u5B89\u88C5\u63D2\u4EF6`);
+      logger.info(t("update_install_hint").replace("{cmd}", chalk12.cyan("install-helper install <plugin>")));
       return;
     }
   } else {
@@ -2856,42 +3125,42 @@ async function updateCommand(pluginNames, options) {
 }
 
 // src/commands/info.ts
-import chalk11 from "chalk";
-import { existsSync as existsSync13, readdirSync as readdirSync6 } from "fs";
-import { join as join12 } from "path";
+import chalk13 from "chalk";
+import { existsSync as existsSync14, readdirSync as readdirSync7 } from "fs";
+import { join as join15 } from "path";
 async function infoCommand(pluginName) {
   const plugin = findPlugin(pluginName);
   if (!plugin) {
-    console.log(chalk11.red(`  ${t("info_not_found")}: ${pluginName}`));
+    console.log(chalk13.red(`  ${t("info_not_found")}: ${pluginName}`));
     return;
   }
   const installed = scanInstalled();
   const isInstalled = installed.some((p) => p.id === plugin.id);
-  const statusText = isInstalled ? chalk11.green(`\u2713 ${t("status_installed")}`) : chalk11.dim(`\u2014 ${t("status_not_installed")}`);
+  const statusText = isInstalled ? chalk13.green(`\u2713 ${t("status_installed")}`) : chalk13.dim(`\u2014 ${t("status_not_installed")}`);
   console.log();
-  console.log(chalk11.bold(`  ${plugin.displayName}`));
-  console.log(chalk11.dim("  " + "\u2500".repeat(40)));
+  console.log(chalk13.bold(`  ${plugin.displayName}`));
+  console.log(chalk13.dim("  " + "\u2500".repeat(40)));
   console.log();
-  console.log(`  ${chalk11.dim(t("info_description") + ":")} ${plugin.description}`);
-  console.log(`  ${chalk11.dim("ID:")} ${plugin.id}`);
-  console.log(`  ${chalk11.dim(t("info_status") + ":")} ${statusText}`);
-  console.log(`  ${chalk11.dim(t("info_skills") + ":")} ${plugin.skills}`);
-  console.log(`  ${chalk11.dim(t("info_agents") + ":")} ${plugin.agents}`);
-  console.log(`  ${chalk11.dim("\u522B\u540D:")} ${plugin.aliases.join(", ")}`);
+  console.log(`  ${chalk13.dim(t("info_description") + ":")} ${plugin.description}`);
+  console.log(`  ${chalk13.dim("ID:")} ${plugin.id}`);
+  console.log(`  ${chalk13.dim(t("info_status") + ":")} ${statusText}`);
+  console.log(`  ${chalk13.dim(t("info_skills") + ":")} ${plugin.skills}`);
+  console.log(`  ${chalk13.dim(t("info_agents") + ":")} ${plugin.agents}`);
+  console.log(`  ${chalk13.dim(t("info_aliases") + ":")} ${plugin.aliases.join(", ")}`);
   console.log();
   try {
     const repoManager = createRepositoryManager();
     const repoPath = await repoManager.ensureRepo();
-    const quickstartPath = join12(repoPath, plugin.dir, "quickstart.md");
-    if (existsSync13(quickstartPath)) {
-      console.log(`  ${chalk11.dim(t("info_quickstart") + ":")} ${quickstartPath}`);
+    const quickstartPath = join15(repoPath, plugin.dir, "quickstart.md");
+    if (existsSync14(quickstartPath)) {
+      console.log(`  ${chalk13.dim(t("info_quickstart") + ":")} ${quickstartPath}`);
     }
-    const agentsDir = join12(repoPath, plugin.dir, "agents");
-    if (existsSync13(agentsDir)) {
-      const agentFiles = readdirSync6(agentsDir).filter((f) => f.endsWith(".md"));
+    const agentsDir = join15(repoPath, plugin.dir, "agents");
+    if (existsSync14(agentsDir)) {
+      const agentFiles = readdirSync7(agentsDir).filter((f) => f.endsWith(".md"));
       if (agentFiles.length > 0) {
         console.log();
-        console.log(`  ${chalk11.bold("Agents:")}`);
+        console.log(`  ${chalk13.bold("Agents:")}`);
         for (const agent of agentFiles) {
           console.log(`    \u2022 ${agent.replace(".md", "")}`);
         }
@@ -2903,39 +3172,39 @@ async function infoCommand(pluginName) {
 }
 
 // src/commands/lang.ts
-import chalk12 from "chalk";
+import chalk14 from "chalk";
 async function langCommand(action, value) {
   const config = readConfig();
   if (!action || action === "show") {
     console.log();
-    console.log(chalk12.bold(`  ${t("lang_title")}`));
-    console.log(chalk12.dim("  " + "\u2500".repeat(40)));
+    console.log(chalk14.bold(`  ${t("lang_title")}`));
+    console.log(chalk14.dim("  " + "\u2500".repeat(40)));
     console.log();
-    console.log(`  ${chalk12.dim(t("lang_current") + ":")} ${config.language}`);
+    console.log(`  ${chalk14.dim(t("lang_current") + ":")} ${config.language}`);
     console.log();
-    console.log(chalk12.dim("  \u652F\u6301\u7684\u8BED\u8A00: zh_CN, en_US"));
-    console.log(chalk12.dim("  \u7528\u6CD5: install-helper lang set <language>"));
+    console.log(chalk14.dim(`  ${t("lang_supported")}`));
+    console.log(chalk14.dim(`  ${t("lang_usage")}`));
     console.log();
     return;
   }
   if (action === "set") {
     if (!value) {
-      console.log(chalk12.red("  \u8BF7\u6307\u5B9A\u8BED\u8A00: install-helper lang set zh_CN"));
+      console.log(chalk14.red(`  ${t("lang_specify")}`));
       return;
     }
     if (value !== "zh_CN" && value !== "en_US") {
-      console.log(chalk12.red(`  ${t("lang_invalid")}`));
+      console.log(chalk14.red(`  ${t("lang_invalid")}`));
       return;
     }
     updateConfig({ language: value });
     setLanguage(value);
     console.log();
-    console.log(chalk12.green(`  \u2713 ${t("lang_set")} ${value}`));
+    console.log(chalk14.green(`  \u2713 ${t("lang_set")} ${value}`));
     console.log();
     return;
   }
-  console.log(chalk12.red(`  \u672A\u77E5\u64CD\u4F5C: ${action}`));
-  console.log(chalk12.dim("  \u652F\u6301\u7684\u64CD\u4F5C: show, set"));
+  console.log(chalk14.red(`  ${t("lang_unknown_action")}: ${action}`));
+  console.log(chalk14.dim(`  ${t("lang_supported_actions")}`));
 }
 
 // src/cli.ts
@@ -2945,7 +3214,7 @@ function createCLI() {
     setLanguage(config.language);
   }
   const program2 = new Command();
-  program2.name("install-helper").description("Install Helper - Interactive installer for CANN operator development skills").version("0.0.2-beta.3");
+  program2.name("install-helper").description("CANNBot Install Helper - Interactive installer for CANN operator development skills").version("0.0.2-beta.30");
   program2.command("init", { isDefault: false }).description("Run interactive installation wizard").action(async () => {
     await initCommand();
   });
@@ -2958,7 +3227,7 @@ function createCLI() {
   program2.command("status").description("Show installed plugins").action(async () => {
     await statusCommand();
   });
-  program2.command("install [names...]").description("Install plugins or skills (auto-detects type)").option("-t, --tool <tool>", "AI tool (opencode, claude, trae, cursor, copilot)").option("-l, --level <level>", "Install level (project, global)", "project").option("-y, --yes", "Skip confirmation prompts").option("--list", "List all available skills by category").action(async (names, options) => {
+  program2.command("install [names...]").description("Install plugins or skills (auto-detects type)").option("-t, --tool <tool>", "AI tool (opencode, claude, trae, cursor, copilot)").option("-l, --level <level>", "Install level (project, global)", "project").option("-y, --yes", "Skip confirmation prompts").option("-a, --all", "Install ALL available skills").option("--list", "List all available skills by category").action(async (names, options) => {
     await installCommand(names, options);
   });
   program2.command("uninstall <names...>").description("Uninstall plugins or skills (auto-detects type)").option("-t, --tool <tool>", "AI tool (opencode, claude, trae, cursor, copilot)").option("-l, --level <level>", "Install level (project, global)", "project").action(async (names, options) => {
@@ -2982,7 +3251,7 @@ function createCLI() {
 // src/index.ts
 process.on("uncaughtException", (error) => {
   if (error.name === "ExitPromptError") {
-    console.log("\n\u5DF2\u53D6\u6D88\u5B89\u88C5");
+    console.log("\n" + t("init_cancelled"));
     process.exit(0);
   }
   throw error;