@cannbot-ai/install-helper 1.1.16 → 1.2.0-beta.0

package/dist/index.js

@@ -268,7 +268,32 @@ var init_zh_CN = __esm({
       uninstall_uncheck_all_category: "\u5378\u8F7D\u672C\u7C7B\u522B\u5168\u90E8",
       uninstall_continue_or_confirm: "\u5DF2\u6807\u8BB0 {count} \u4E2A\u5F85\u5378\u8F7D\uFF0C\u8BF7\u9009\u62E9\u64CD\u4F5C",
       uninstall_marked_count: "\u5DF2\u6807\u8BB0 {count} \u4E2A\u5F85\u5378\u8F7D",
-      uninstall_uncategorized: "\u672A\u5206\u7C7B"
+      uninstall_uncategorized: "\u672A\u5206\u7C7B",
+      error_invalid_source: "\u65E0\u6548\u7684\u63D2\u4EF6\u6765\u6E90: {source}\n\u652F\u6301\u7684\u6765\u6E90: {sources}",
+      info_source: "\u5B89\u88C5\u6CE8\u518C\u8868",
+      cannbot_tool_unsupported: "cannbot \u578B\u63D2\u4EF6\u6682\u4E0D\u652F\u6301\u5DE5\u5177 {tool}\uFF08\u4E0A\u6E38\u5B89\u88C5\u5668\u652F\u6301: {tools}\uFF09",
+      cannbot_level_unsupported: "cannbot \u578B\u63D2\u4EF6\u4EC5\u652F\u6301 project \u7EA7\u5B89\u88C5",
+      cannbot_node_required: "\u5B89\u88C5 cannbot \u578B\u63D2\u4EF6\u9700\u8981\u53EF\u7528\u7684 Node.js \u8FD0\u884C\u73AF\u5883\uFF0C\u5F53\u524D\u672A\u68C0\u6D4B\u5230 node\u3002\u8BF7\u5B89\u88C5 Node.js\uFF08\u226520\uFF09\u540E\u91CD\u8BD5",
+      cannbot_installer_failed: "\u83B7\u53D6 @cannbot-plugin/cannbot \u5B89\u88C5\u5668\u5931\u8D25: {error}",
+      cannbot_installer_refresh_failed: "\u5237\u65B0 cannbot \u5B89\u88C5\u5668\u5931\u8D25\uFF0C\u4F7F\u7528\u672C\u5730\u7F13\u5B58\u7EE7\u7EED",
+      cannbot_installer_path_invalid: "CANNBOT_INSTALLER_PATH \u6307\u5B9A\u7684\u5B89\u88C5\u5668\u8DEF\u5F84\u65E0\u6548: {path}",
+      cannbot_plugin_not_found: "cannbot \u5B89\u88C5\u5668\u5305\u4E2D\u672A\u627E\u5230\u63D2\u4EF6 {plugin}",
+      cannbot_registry_missing: "\u5B89\u88C5\u540E\u672A\u5728 cannbot-plugin.json \u4E2D\u627E\u5230\u6CE8\u518C\u8BB0\u5F55",
+      cannbot_delegate_failed: "cannbot \u5B89\u88C5\u5668\u6267\u884C\u5931\u8D25\uFF08\u9000\u51FA\u7801 {code}\uFF09\uFF0C\u8F93\u51FA\u89C1\u4E0A\u65B9\u65E5\u5FD7",
+      cannbot_migrated_symlink: "\u68C0\u6D4B\u5230 {file} \u4E3A\u65E7\u7248\u63D2\u4EF6\u8F6F\u94FE\uFF0C\u5DF2\u8F6C\u4E3A\u771F\u5B9E\u6587\u4EF6\uFF08\u5185\u5BB9\u4FDD\u7559\u5E76\u5DF2\u5907\u4EFD\uFF09",
+      cannbot_migrate_symlink_failed: "\u65E7\u7248\u8F6F\u94FE {file} \u8F6C\u771F\u5B9E\u6587\u4EF6\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u5904\u7406\u540E\u91CD\u8BD5",
+      cannbot_dual_skill_copy: "\u4EE5\u4E0B Skills \u540C\u65F6\u5B58\u5728\u4E8E\u65B0\u65E7\u4E24\u5957\u5E03\u5C40\u4E2D\uFF0CAI \u5DE5\u5177\u4F1A\u770B\u5230\u4E24\u4EFD\u526F\u672C: {skills}",
+      cannbot_registry_corrupted: "\u65E0\u6CD5\u89E3\u6790 cannbot-plugin.json: {file}",
+      cannbot_registry_schema_unsupported: "cannbot-plugin.json schemaVersion\uFF08{version}\uFF09\u4E0D\u53D7\u652F\u6301\uFF0C\u8BF7\u5347\u7EA7 install-helper \u540E\u518D\u6267\u884C\u5378\u8F7D",
+      cannbot_uninstall_no_record: "\u672A\u627E\u5230\u8BE5\u63D2\u4EF6\u7684 cannbot \u5B89\u88C5\u8BB0\u5F55",
+      cannbot_uninstall_native_hint: "\u8BE5\u63D2\u4EF6\u5728\u5DE5\u5177\u4FA7\u6CE8\u518C\u4E86\u539F\u751F\u63D2\u4EF6\uFF0C\u5982\u9700\u53D6\u6D88\u6CE8\u518C\u53EF\u6267\u884C: opencode plugin remove {spec}",
+      doctor_cannbot: "cannbot \u96C6\u6210",
+      doctor_cannbot_node_ok: "Node.js \u8FD0\u884C\u65F6\u53EF\u7528\uFF08\u652F\u6301 cannbot \u63D2\u4EF6\u59D4\u6258\u5B89\u88C5\uFF09",
+      doctor_cannbot_node_missing: "\u672A\u68C0\u6D4B\u5230 Node.js \u8FD0\u884C\u65F6\uFF0Ccannbot \u578B\u63D2\u4EF6\u4E0D\u53EF\u5B89\u88C5",
+      doctor_cannbot_missing_skills: "\u6CE8\u518C\u8868\u8BB0\u5F55\u7684 Skills \u4E2D\u6709 {count} \u4E2A\u5728\u78C1\u76D8\u4E0A\u4E0D\u5B58\u5728",
+      doctor_cannbot_marker_duplicate: "\u63D2\u4EF6 {plugin} \u5B58\u5728\u91CD\u590D\u7684\u6807\u8BB0\u5757",
+      doctor_cannbot_marker_unpaired: "\u6807\u8BB0\u5757\u4E0D\u914D\u5BF9\uFF08start={start}, end={end}\uFF09",
+      doctor_cannbot_orphan_record: "\u63D2\u4EF6 {plugin} \u7684\u59D4\u6258\u5B89\u88C5\u8BB0\u5F55\u5DF2\u60AC\u7A7A\uFF08cannbot-plugin.json \u4E2D\u65E0\u5BF9\u5E94\u8BB0\u5F55\uFF09"
     };
   }
 });
@@ -493,7 +518,32 @@ var init_en_US = __esm({
       uninstall_uncheck_all_category: "Uninstall all in this category",
       uninstall_continue_or_confirm: "{count} marked for uninstall, choose an action",
       uninstall_marked_count: "{count} marked for uninstall",
-      uninstall_uncategorized: "Uncategorized"
+      uninstall_uncategorized: "Uncategorized",
+      error_invalid_source: "Invalid plugin source: {source}\nSupported sources: {sources}",
+      info_source: "Install registry",
+      cannbot_tool_unsupported: "Tool {tool} is not supported for cannbot plugins yet (upstream supports: {tools})",
+      cannbot_level_unsupported: "cannbot plugins support project-level installation only",
+      cannbot_node_required: "A working Node.js runtime is required to install cannbot plugins but node was not found. Please install Node.js (>=20) and retry",
+      cannbot_installer_failed: "Failed to fetch the @cannbot-plugin/cannbot installer: {error}",
+      cannbot_installer_refresh_failed: "Failed to refresh the cannbot installer; continuing with the local cache",
+      cannbot_installer_path_invalid: "The installer path set by CANNBOT_INSTALLER_PATH is invalid: {path}",
+      cannbot_plugin_not_found: "Plugin {plugin} was not found in the cannbot installer package",
+      cannbot_registry_missing: "No cannbot-plugin.json record found after installation",
+      cannbot_delegate_failed: "The cannbot installer exited with code {code}; see the output above",
+      cannbot_migrated_symlink: "{file} was a legacy plugin symlink; converted to a real file (content kept, backup saved)",
+      cannbot_migrate_symlink_failed: "Failed to convert the legacy symlink {file} to a real file; resolve it manually and retry",
+      cannbot_dual_skill_copy: "These Skills exist in both the legacy and cannbot layouts, the AI tool will see two copies: {skills}",
+      cannbot_registry_corrupted: "Cannot parse cannbot-plugin.json: {file}",
+      cannbot_registry_schema_unsupported: "cannbot-plugin.json schemaVersion ({version}) is not supported; upgrade install-helper before uninstalling",
+      cannbot_uninstall_no_record: "No cannbot install record found for this plugin",
+      cannbot_uninstall_native_hint: "This plugin registered a native plugin with the tool; unregister it via: opencode plugin remove {spec}",
+      doctor_cannbot: "cannbot integration",
+      doctor_cannbot_node_ok: "Node.js runtime available (cannbot delegation supported)",
+      doctor_cannbot_node_missing: "No Node.js runtime detected; cannbot plugins cannot be installed",
+      doctor_cannbot_missing_skills: "{count} skills recorded in the registry are missing on disk",
+      doctor_cannbot_marker_duplicate: "Plugin {plugin} has duplicate marker blocks",
+      doctor_cannbot_marker_unpaired: "Marker blocks are unpaired (start={start}, end={end})",
+      doctor_cannbot_orphan_record: "Delegated install record for {plugin} is orphaned (no matching cannbot-plugin.json entry)"
     };
   }
 });
@@ -717,7 +767,12 @@ var init_embedded_config = __esm({
       pluginDirs: [
         "plugins-official"
       ],
-      cacheTtlHours: 24
+      cacheTtlHours: 24,
+      cannbotInstaller: {
+        package: "@cannbot-plugin/cannbot",
+        channel: "latest",
+        ttlHours: 24
+      }
     };
   }
 });
@@ -1436,6 +1491,16 @@ var init_embedded_plugins = __esm({
 });
 
 // src/core/registry.ts
+var registry_exports = {};
+__export(registry_exports, {
+  PLUGIN_REGISTRY: () => PLUGIN_REGISTRY,
+  findPlugin: () => findPlugin,
+  getAllPlugins: () => getAllPlugins,
+  getCannbotPlugins: () => getCannbotPlugins,
+  getPluginById: () => getPluginById,
+  mergeDynamicPlugins: () => mergeDynamicPlugins,
+  setCannbotPlugins: () => setCannbotPlugins
+});
 import { readdirSync as readdirSync2, existsSync as existsSync5 } from "fs";
 import { join as join4 } from "path";
 function loadPlugins() {
@@ -1445,6 +1510,12 @@ function loadPlugins() {
   );
   return plugins;
 }
+function setCannbotPlugins(entries) {
+  CANNBOT_PLUGINS = entries.map((entry) => ({ ...entry, source: "cannbot" }));
+}
+function getCannbotPlugins() {
+  return [...CANNBOT_PLUGINS];
+}
 function mergeDynamicPlugins(repoPath) {
   if (!existsSync5(repoPath)) return;
   const existingIds = new Set(PLUGIN_REGISTRY.map((p) => p.id));
@@ -1485,8 +1556,19 @@ function mergeDynamicPlugins(repoPath) {
     );
   }
 }
-function findPlugin(query) {
+function findPlugin(query, options) {
   const normalized = query.toLowerCase().trim();
+  const wantCannbot = options?.source !== "skills";
+  if (wantCannbot) {
+    const cannbotExact = CANNBOT_PLUGINS.find(
+      (p) => p.id === normalized || p.id === query.trim()
+    );
+    if (cannbotExact) return cannbotExact;
+    const cannbotAlias = CANNBOT_PLUGINS.find(
+      (p) => p.aliases.some((a) => a === normalized)
+    );
+    if (cannbotAlias) return cannbotAlias;
+  }
   const exactMatch = PLUGIN_REGISTRY.find(
     (p) => p.id === normalized || p.id === query.trim()
   );
@@ -1495,17 +1577,25 @@ function findPlugin(query) {
     (p) => p.aliases.some((a) => a === normalized)
   );
   if (aliasMatch) return aliasMatch;
+  if (wantCannbot) {
+    const cannbotPrefixes = CANNBOT_PLUGINS.filter((p) => p.id.startsWith(normalized));
+    if (cannbotPrefixes.length === 1) return cannbotPrefixes[0];
+  }
   const prefixMatches = PLUGIN_REGISTRY.filter((p) => p.id.startsWith(normalized));
   if (prefixMatches.length === 1) return prefixMatches[0];
   return void 0;
 }
 function getAllPlugins() {
-  return PLUGIN_REGISTRY;
+  return [...CANNBOT_PLUGINS, ...PLUGIN_REGISTRY].sort(
+    (a, b) => a.displayName < b.displayName ? -1 : a.displayName > b.displayName ? 1 : 0
+  );
 }
 function getPluginById(id) {
+  const cannbot = CANNBOT_PLUGINS.find((p) => p.id === id);
+  if (cannbot) return cannbot;
   return PLUGIN_REGISTRY.find((p) => p.id === id);
 }
-var PLUGIN_REGISTRY;
+var PLUGIN_REGISTRY, CANNBOT_PLUGINS;
 var init_registry = __esm({
   "src/core/registry.ts"() {
     "use strict";
@@ -1513,6 +1603,7 @@ var init_registry = __esm({
     init_scanner();
     init_embedded_plugins();
     PLUGIN_REGISTRY = loadPlugins();
+    CANNBOT_PLUGINS = [];
   }
 });
 
@@ -2177,8 +2268,9 @@ async function stepPlugins(tool, level) {
   const choices = plugins.map((p) => {
     const isInstalled = installedSet.has(p.id);
     const suffix = isInstalled ? ` [${t("wizard_already_installed")}]` : "";
+    const badge = p.source === "cannbot" ? chalk3.magenta(" [cannbot]") : "";
     return {
-      name: `> ${chalk3.cyan(p.displayName)}${suffix}`,
+      name: `> ${chalk3.cyan(p.displayName)}${badge}${suffix}`,
       value: p.id,
       description: p.description
     };
@@ -2403,7 +2495,7 @@ var STATIC_SKILL_CATEGORIES = [
   },
   {
     id: "model",
-    name: "\u6A21\u578B\u63A8\u7406\u4F18\u5316",
+    name: "\u6A21\u578B\u63A8\u7406\u4E0E\u8BAD\u7EC3",
     skills: [
       { id: "model-infer-migrator", description: "\u6846\u67B6\u9002\u914D\u4E0E\u90E8\u7F72\u57FA\u7EBF", source: "model" },
       { id: "model-infer-parallel-analysis", description: "\u5E76\u884C\u7B56\u7565\u5206\u6790\uFF08TP/EP/DP\uFF09", source: "model" },
@@ -2417,7 +2509,9 @@ var STATIC_SKILL_CATEGORIES = [
       { id: "model-infer-precision-debug", description: "NPU \u63A8\u7406\u7CBE\u5EA6\u8BCA\u65AD", source: "model" },
       { id: "model-infer-runtime-debug", description: "NPU \u63A8\u7406\u8FD0\u884C\u65F6\u9519\u8BEF\u8BCA\u65AD", source: "model" },
       { id: "model-infer-harmony", description: "\u7AEF\u4FA7\u9E3F\u8499 ASR \u91CF\u5316\u8F6C\u6362\u4E0E\u6253\u5305", source: "model" },
-      { id: "model-train-accuracy-debug", description: "PyTorch on NPU \u5927\u6A21\u578B\u8BAD\u7EC3\u7CBE\u5EA6\u5F02\u5E38\u5B9A\u4F4D", source: "model" },
+      { id: "model-train-precision-numerical-mismatch", description: "PyTorch on NPU \u8BAD\u7EC3\u6B63\u5411/\u53CD\u5411\u6709\u9650\u503C\u504F\u5DEE\u8BCA\u65AD", source: "model" },
+      { id: "model-train-precision-nonfinite", description: "PyTorch on NPU \u8BAD\u7EC3 NaN/Inf/Overflow \u8BCA\u65AD", source: "model" },
+      { id: "model-train-precision-determinism", description: "PyTorch on NPU \u8BAD\u7EC3\u975E\u786E\u5B9A\u6027\u8BCA\u65AD", source: "model" },
       { id: "model-train-log-visualization", description: "NPU \u5927\u6A21\u578B\u8BAD\u7EC3\u65E5\u5FD7\u53EF\u89C6\u5316\u4E0E\u5BF9\u6BD4", source: "model" },
       { id: "model-train-oom-analysis", description: "PyTorch on NPU \u8BAD\u7EC3 OOM \u5185\u5B58\u8BCA\u65AD\u4E0E\u4F18\u5316", source: "model" },
       { id: "science-model-npu-migration", description: "NPU \u4EE3\u7801\u7EA7\u8FC1\u79FB\uFF08\u73AF\u5883\u95E8\u7981/\u811A\u672C\u9002\u914D/\u7CBE\u5EA6\u6027\u80FD\u5BF9\u6BD4\uFF09", source: "plugins-community/science-model-npu-migration", filePath: "plugins-community/science-model-npu-migration/SKILL.md" }
@@ -2800,13 +2894,245 @@ function createRepositoryManager(customPath) {
   return new RepositoryManager(customPath);
 }
 
-// src/core/installer.ts
-init_registry();
-init_manifest();
+// src/core/cannbot-delegate.ts
+import { existsSync as existsSync17, readFileSync as readFileSync12, writeFileSync as writeFileSync5, copyFileSync as copyFileSync3, unlinkSync as unlinkSync6, readdirSync as readdirSync8 } from "fs";
+import { join as join16, resolve as resolve2 } from "path";
+import { execa as execa6 } from "execa";
+
+// src/core/cannbot-installer.ts
 init_paths();
-import { existsSync as existsSync14, readFileSync as readFileSync9 } from "fs";
-import { join as join13, basename as basename2 } from "path";
-import { execa as execa4, execaSync } from "execa";
+init_logger();
+init_i18n();
+init_embedded_config();
+import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync7, readdirSync as readdirSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join10, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { execa as execa3, execaSync } from "execa";
+import { parse as parseYaml3 } from "yaml";
+var __filename4 = fileURLToPath4(import.meta.url);
+var __dirname4 = dirname5(__filename4);
+var DEFAULT_CONFIG = {
+  package: "@cannbot-plugin/cannbot",
+  channel: "latest",
+  ttlHours: 24
+};
+var NPM_MIRRORS = [
+  void 0,
+  // user's npm config (registry.npmjs.org by default)
+  "https://registry.npmmirror.com"
+];
+function loadCannbotInstallerConfig() {
+  let config = DEFAULT_CONFIG;
+  const configCandidates = [
+    join10(__dirname4, "config", "repository.yaml"),
+    join10(__dirname4, "..", "config", "repository.yaml")
+  ];
+  for (const configPath of configCandidates) {
+    try {
+      const parsed = parseYaml3(readFileSync7(configPath, "utf-8"));
+      if (!parsed?.cannbotInstaller) continue;
+      config = {
+        package: parsed.cannbotInstaller.package || DEFAULT_CONFIG.package,
+        channel: parsed.cannbotInstaller.channel || DEFAULT_CONFIG.channel,
+        ttlHours: parsed.cannbotInstaller.ttlHours || DEFAULT_CONFIG.ttlHours
+      };
+      break;
+    } catch {
+    }
+  }
+  if (config === DEFAULT_CONFIG) {
+    const embedded = embedded_config_default;
+    if (embedded.cannbotInstaller) {
+      config = {
+        package: embedded.cannbotInstaller.package || DEFAULT_CONFIG.package,
+        channel: embedded.cannbotInstaller.channel || DEFAULT_CONFIG.channel,
+        ttlHours: embedded.cannbotInstaller.ttlHours || DEFAULT_CONFIG.ttlHours
+      };
+    }
+  }
+  return {
+    ...config,
+    channel: process.env.CANNBOT_INSTALLER_CHANNEL || config.channel
+  };
+}
+function getCannbotInstallerPrefix() {
+  return join10(getCannbotConfigDir(), "installers", "cannbot");
+}
+function getCannbotPackageRoot() {
+  const override = process.env.CANNBOT_INSTALLER_PATH;
+  if (override) return override;
+  const { package: packageName } = loadCannbotInstallerConfig();
+  return join10(getCannbotInstallerPrefix(), "node_modules", ...packageName.split("/"));
+}
+function getCannbotBinPath() {
+  return join10(getCannbotPackageRoot(), "bin", "cannbot.js");
+}
+function getStatePath() {
+  return join10(getCannbotInstallerPrefix(), "state.json");
+}
+function readState() {
+  try {
+    return JSON.parse(readFileSync7(getStatePath(), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function writeState(state) {
+  const prefix = getCannbotInstallerPrefix();
+  if (!existsSync11(prefix)) {
+    mkdirSync4(prefix, { recursive: true });
+  }
+  writeFileSync2(getStatePath(), JSON.stringify(state, null, 2));
+}
+function isCannbotInstallerReady() {
+  return existsSync11(getCannbotBinPath());
+}
+function getCannbotInstallerVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync7(join10(getCannbotPackageRoot(), "package.json"), "utf-8"));
+    return pkg.version || null;
+  } catch {
+    return null;
+  }
+}
+function hasNodeRuntime() {
+  try {
+    const result = execaSync("node", ["--version"], { timeout: 1e4 });
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+async function npmInstallInstaller(config, force) {
+  const prefix = getCannbotInstallerPrefix();
+  if (!existsSync11(prefix)) {
+    mkdirSync4(prefix, { recursive: true });
+  }
+  const spec = `${config.package}@${config.channel}`;
+  let lastError = null;
+  for (const registry of NPM_MIRRORS) {
+    const args = ["install", "--prefix", prefix, "--no-audit", "--no-fund", "--ignore-scripts", spec];
+    if (registry) args.push("--registry", registry);
+    try {
+      await execa3("npm", args, { timeout: 3e5 });
+      return;
+    } catch (error) {
+      lastError = error;
+      if (force || !isCannbotInstallerReady()) {
+        continue;
+      }
+      break;
+    }
+  }
+  if (isCannbotInstallerReady() && !force) {
+    logger.warn(t("cannbot_installer_refresh_failed"));
+    return;
+  }
+  throw lastError instanceof Error ? lastError : new Error(t("error_unknown"));
+}
+async function ensureCannbotInstaller(options) {
+  const config = loadCannbotInstallerConfig();
+  const packageRoot = getCannbotPackageRoot();
+  if (process.env.CANNBOT_INSTALLER_PATH) {
+    if (!isCannbotInstallerReady()) {
+      throw new Error(
+        t("cannbot_installer_path_invalid").replace("{path}", process.env.CANNBOT_INSTALLER_PATH)
+      );
+    }
+    return packageRoot;
+  }
+  const ready = isCannbotInstallerReady();
+  if (!ready || options?.force) {
+    await npmInstallInstaller(config, options?.force || !ready);
+    writeState({
+      version: getCannbotInstallerVersion() || "unknown",
+      channel: config.channel,
+      installedAt: Date.now()
+    });
+    return packageRoot;
+  }
+  const state = readState();
+  const ttlMs = config.ttlHours * 60 * 60 * 1e3;
+  if (!state || Date.now() - state.installedAt > ttlMs) {
+    try {
+      await npmInstallInstaller(config, false);
+      writeState({
+        version: getCannbotInstallerVersion() || "unknown",
+        channel: config.channel,
+        installedAt: Date.now()
+      });
+    } catch {
+    }
+  }
+  return packageRoot;
+}
+function readManifest2(pluginDir) {
+  try {
+    return JSON.parse(readFileSync7(join10(pluginDir, ".claude-plugin", "plugin.json"), "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function discoverCannbotPlugins() {
+  if (!isCannbotInstallerReady()) {
+    return [];
+  }
+  const packageRoot = getCannbotPackageRoot();
+  const entries = [];
+  const parents = [join10(packageRoot, "dist", "plugins"), join10(packageRoot, "plugins")];
+  for (const parent of parents) {
+    if (!existsSync11(parent)) continue;
+    let names = [];
+    try {
+      names = readdirSync4(parent);
+    } catch {
+      continue;
+    }
+    for (const name of names) {
+      const pluginDir = join10(parent, name);
+      const manifest = readManifest2(pluginDir);
+      if (!manifest || typeof manifest.name !== "string") continue;
+      if (entries.some((e) => e.id === manifest.name)) continue;
+      entries.push({
+        id: manifest.name,
+        version: manifest.version || "",
+        description: manifest.description || "",
+        skillsCount: Array.isArray(manifest.skills) ? manifest.skills.length : 0,
+        agentsCount: Array.isArray(manifest.agents) ? manifest.agents.length : 0,
+        dir: join10(parent, name)
+      });
+    }
+  }
+  return entries;
+}
+async function ensureCannbotDiscovery() {
+  try {
+    await ensureCannbotInstaller();
+  } catch {
+    return false;
+  }
+  const entries = discoverCannbotPlugins();
+  const { setCannbotPlugins: setCannbotPlugins2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  setCannbotPlugins2(
+    entries.map((entry) => ({
+      id: entry.id,
+      dir: entry.dir,
+      displayName: entry.id,
+      script: "cannbot",
+      aliases: [],
+      skills: entry.skillsCount,
+      agents: entry.agentsCount,
+      description: entry.description,
+      version: entry.version,
+      source: "cannbot"
+    }))
+  );
+  return true;
+}
+
+// src/core/cannbot-registry.ts
+import { existsSync as existsSync13, readFileSync as readFileSync9, readdirSync as readdirSync6, rmSync as rmSync3, rmdirSync, unlinkSync as unlinkSync4, lstatSync as lstatSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join12, resolve, sep as sep2, dirname as dirname6 } from "path";
 
 // src/core/record.ts
 init_paths();
@@ -2814,21 +3140,21 @@ init_fs();
 init_fs_helpers();
 init_logger();
 init_i18n();
-import { existsSync as existsSync11, mkdirSync as mkdirSync4, readFileSync as readFileSync7, unlinkSync as unlinkSync3, readdirSync as readdirSync4 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync8, unlinkSync as unlinkSync3, readdirSync as readdirSync5 } from "fs";
+import { join as join11 } from "path";
 function getInstallsDir() {
-  return join10(getCannbotConfigDir(), "installs");
+  return join11(getCannbotConfigDir(), "installs");
 }
 function getRecordPath(pluginId) {
-  return join10(getInstallsDir(), `${pluginId}.json`);
+  return join11(getInstallsDir(), `${pluginId}.json`);
 }
 function readRecord(pluginId) {
   const recordPath = getRecordPath(pluginId);
-  if (!existsSync11(recordPath)) {
+  if (!existsSync12(recordPath)) {
     return null;
   }
   try {
-    const content = readFileSync7(recordPath, "utf-8");
+    const content = readFileSync8(recordPath, "utf-8");
     return JSON.parse(content);
   } catch {
     logger.warn(t("record_corrupted").replace("{file}", recordPath));
@@ -2837,15 +3163,15 @@ function readRecord(pluginId) {
 }
 function writeRecord(record) {
   const installsDir = getInstallsDir();
-  if (!existsSync11(installsDir)) {
-    mkdirSync4(installsDir, { recursive: true });
+  if (!existsSync12(installsDir)) {
+    mkdirSync5(installsDir, { recursive: true });
   }
   const recordPath = getRecordPath(record.pluginId);
   atomicWriteFileSync(recordPath, JSON.stringify(record, null, 2));
 }
 function deleteRecord(pluginId) {
   const recordPath = getRecordPath(pluginId);
-  if (existsSync11(recordPath)) {
+  if (existsSync12(recordPath)) {
     unlinkSync3(recordPath);
   }
 }
@@ -2854,59 +3180,59 @@ function scanInstalledFiles(pluginId, displayName, tool, level, installPath, con
   const directories = [];
   if (manifest) {
     const skillsDir = getSkillsRoot(tool, level, installPath);
-    if (existsSync11(skillsDir)) {
+    if (existsSync12(skillsDir)) {
       directories.push(skillsDir);
       for (const skillName of manifest.installed_skills || []) {
-        const skillPath = join10(skillsDir, skillName);
-        if (existsSync11(skillPath) || isSymlink(skillPath)) {
+        const skillPath = join11(skillsDir, skillName);
+        if (existsSync12(skillPath) || isSymlink(skillPath)) {
           files.push(skillPath);
         }
       }
     }
-    const agentsDir = join10(configRoot, "agents");
-    if (existsSync11(agentsDir)) {
+    const agentsDir = join11(configRoot, "agents");
+    if (existsSync12(agentsDir)) {
       directories.push(agentsDir);
       for (const agentName of manifest.installed_agents || []) {
-        const agentPath = join10(agentsDir, agentName);
-        const agentPathMd = join10(agentsDir, agentName + ".md");
-        if (existsSync11(agentPath) || isSymlink(agentPath)) {
+        const agentPath = join11(agentsDir, agentName);
+        const agentPathMd = join11(agentsDir, agentName + ".md");
+        if (existsSync12(agentPath) || isSymlink(agentPath)) {
           files.push(agentPath);
-        } else if (existsSync11(agentPathMd) || isSymlink(agentPathMd)) {
+        } else if (existsSync12(agentPathMd) || isSymlink(agentPathMd)) {
           files.push(agentPathMd);
         }
       }
     }
   }
-  const workflowsLink = join10(configRoot, "workflows");
+  const workflowsLink = join11(configRoot, "workflows");
   if (isSymlink(workflowsLink)) {
     files.push(workflowsLink);
   }
-  const manifestPath = join10(configRoot, "cannbot-manifest.json");
-  if (existsSync11(manifestPath)) {
+  const manifestPath = join11(configRoot, "cannbot-manifest.json");
+  if (existsSync12(manifestPath)) {
     files.push(manifestPath);
   }
-  const pluginManifestPath = join10(configRoot, `${pluginId}-manifest.json`);
-  if (existsSync11(pluginManifestPath)) {
+  const pluginManifestPath = join11(configRoot, `${pluginId}-manifest.json`);
+  if (existsSync12(pluginManifestPath)) {
     files.push(pluginManifestPath);
   }
   const configFileName = tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
-  const configFilePath = level === "project" ? join10(installPath, configFileName) : join10(configRoot, configFileName);
-  if (existsSync11(configFilePath) || isSymlink(configFilePath)) {
+  const configFilePath = level === "project" ? join11(installPath, configFileName) : join11(configRoot, configFileName);
+  if (existsSync12(configFilePath) || isSymlink(configFilePath)) {
     files.push(configFilePath);
   }
   if (level === "project" && configRootConfigLink !== false) {
-    const configRootConfigPath = join10(configRoot, configFileName);
-    if (configRootConfigPath !== configFilePath && (existsSync11(configRootConfigPath) || isSymlink(configRootConfigPath))) {
+    const configRootConfigPath = join11(configRoot, configFileName);
+    if (configRootConfigPath !== configFilePath && (existsSync12(configRootConfigPath) || isSymlink(configRootConfigPath))) {
       files.push(configRootConfigPath);
     }
   }
   const repoLinks = externalRepoNames && externalRepoNames.length > 0 ? externalRepoNames : ["asc-devkit", "pypto", "tilelang-ascend", "cann-recipes-infer", "cann-samples", "ops-tensor"];
   for (const repoName of repoLinks) {
-    const repoLinkPath = join10(installPath, repoName);
+    const repoLinkPath = join11(installPath, repoName);
     if (isSymlink(repoLinkPath)) {
       files.push(repoLinkPath);
     }
-    const repoLinkInConfig = join10(configRoot, repoName);
+    const repoLinkInConfig = join11(configRoot, repoName);
     if (isSymlink(repoLinkInConfig)) {
       files.push(repoLinkInConfig);
     }
@@ -2924,15 +3250,15 @@ function scanInstalledFiles(pluginId, displayName, tool, level, installPath, con
   };
 }
 function getSkillRecordPath() {
-  return join10(getInstallsDir(), "skills.json");
+  return join11(getInstallsDir(), "skills.json");
 }
 function readSkillRecord() {
   const recordPath = getSkillRecordPath();
-  if (!existsSync11(recordPath)) {
+  if (!existsSync12(recordPath)) {
     return {};
   }
   try {
-    const content = readFileSync7(recordPath, "utf-8");
+    const content = readFileSync8(recordPath, "utf-8");
     return JSON.parse(content);
   } catch {
     logger.warn(t("skill_record_corrupted"));
@@ -2941,8 +3267,8 @@ function readSkillRecord() {
 }
 function writeSkillRecord(record) {
   const installsDir = getInstallsDir();
-  if (!existsSync11(installsDir)) {
-    mkdirSync4(installsDir, { recursive: true });
+  if (!existsSync12(installsDir)) {
+    mkdirSync5(installsDir, { recursive: true });
   }
   const recordPath = getSkillRecordPath();
   atomicWriteFileSync(recordPath, JSON.stringify(record, null, 2));
@@ -3004,19 +3330,19 @@ function getInstalledSkills(tool, level, installPath, allowFsScan = true) {
   const recordedSkills = record[tool]?.[level]?.[installPath]?.skills || [];
   const skillsDir = getSkillsRoot(tool, level);
   const fromRecord = recordedSkills.filter((skillId) => {
-    const skillPath = join10(skillsDir, skillId);
-    return existsSync11(skillPath) || isSymlink(skillPath);
+    const skillPath = join11(skillsDir, skillId);
+    return existsSync12(skillPath) || isSymlink(skillPath);
   });
   if (!allowFsScan) {
     return fromRecord;
   }
   const fromFs = [];
-  if (existsSync11(skillsDir)) {
+  if (existsSync12(skillsDir)) {
     try {
-      const entries = readdirSync4(skillsDir);
+      const entries = readdirSync5(skillsDir);
       for (const entry of entries) {
         if (entry === "." || entry === "..") continue;
-        const entryPath = join10(skillsDir, entry);
+        const entryPath = join11(skillsDir, entry);
         if (isSymlink(entryPath) && !fromRecord.includes(entry)) {
           fromFs.push(entry);
         }
@@ -3035,15 +3361,347 @@ function getLastBatchSkills(tool, level, installPath) {
   const lastBatch = entry.batches[entry.batches.length - 1];
   const skillsDir = getSkillsRoot(tool, level, installPath);
   return lastBatch.skills.filter((skillId) => {
-    const skillPath = join10(skillsDir, skillId);
-    return existsSync11(skillPath) || isSymlink(skillPath);
+    const skillPath = join11(skillsDir, skillId);
+    return existsSync12(skillPath) || isSymlink(skillPath);
   });
 }
 
+// src/core/cannbot-registry.ts
+init_config();
+init_paths();
+init_logger();
+init_i18n();
+var CANNBOT_TOOL_LAYOUTS = {
+  opencode: { configDirs: [".opencode"], defaultConfigDir: ".opencode" },
+  codex: { configDirs: [".codex"], defaultConfigDir: ".codex" },
+  claude: { configDirs: [".claude"], defaultConfigDir: ".claude" },
+  trae: { configDirs: [".traecli", ".marscode", ".trae", ".trae-cn"], defaultConfigDir: ".trae" }
+};
+var CANNBOT_SUPPORTED_TOOLS = Object.keys(CANNBOT_TOOL_LAYOUTS);
+var CANNBOT_REGISTRY_SCHEMA_VERSION = 2;
+var REGISTRY_FILE_NAME = "cannbot-plugin.json";
+function toolConfigDir(target, tool) {
+  const layout = CANNBOT_TOOL_LAYOUTS[tool];
+  if (!layout) return join12(target, `.${tool}`);
+  return layout.configDirs.map((name) => join12(target, name)).find((path) => existsSync13(path)) ?? join12(target, layout.defaultConfigDir);
+}
+function findCannbotRegistryPath(target, tool) {
+  const configDir = toolConfigDir(target, tool);
+  const registryPath = join12(configDir, REGISTRY_FILE_NAME);
+  return existsSync13(registryPath) ? registryPath : null;
+}
+function readCannbotRegistry(target, tool) {
+  const registryPath = findCannbotRegistryPath(target, tool);
+  if (!registryPath) return null;
+  let registry;
+  try {
+    registry = JSON.parse(readFileSync9(registryPath, "utf-8"));
+  } catch {
+    logger.warn(t("cannbot_registry_corrupted").replace("{file}", registryPath));
+    return null;
+  }
+  if (typeof registry.schemaVersion !== "number" || !Array.isArray(registry.plugins)) {
+    logger.warn(t("cannbot_registry_corrupted").replace("{file}", registryPath));
+    return null;
+  }
+  return {
+    registryPath,
+    registry,
+    schemaSupported: registry.schemaVersion === CANNBOT_REGISTRY_SCHEMA_VERSION
+  };
+}
+function toInstalledEntry(target, registryPath, record) {
+  return {
+    id: record.plugin,
+    version: record.pluginVersion || "",
+    tool: record.tool,
+    target,
+    registryPath,
+    skillsCount: Array.isArray(record.skills) ? record.skills.length : 0,
+    agentsCount: Array.isArray(record.agents) ? record.agents.length : 0,
+    record
+  };
+}
+function scanCannbotInstalled(target) {
+  const root = resolve(target || process.cwd());
+  const installed = [];
+  for (const tool of CANNBOT_SUPPORTED_TOOLS) {
+    const result = readCannbotRegistry(root, tool);
+    if (!result) continue;
+    for (const record of result.registry.plugins) {
+      if (!record?.plugin) continue;
+      installed.push(toInstalledEntry(root, result.registryPath, record));
+    }
+  }
+  return installed;
+}
+function removeMarkerBlock(content, pluginName) {
+  const start = `<!-- cannbot:${pluginName}:start -->`;
+  const end = `<!-- cannbot:${pluginName}:end -->`;
+  const pattern = new RegExp(
+    `${start.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`,
+    "g"
+  );
+  return content.replace(pattern, "");
+}
+function countMarkerBlocks(content, pluginName) {
+  const start = `<!-- cannbot:${pluginName}:start -->`;
+  return content.split(start).length - 1;
+}
+function removeIfSafe(pathToRemove, allowedBase) {
+  const resolved = resolve(pathToRemove);
+  if (resolved !== allowedBase && !resolved.startsWith(allowedBase + sep2)) {
+    return "skipped";
+  }
+  try {
+    const stat = lstatSync2(resolved);
+    if (stat.isDirectory()) {
+      rmSync3(resolved, { recursive: true, force: true });
+    } else {
+      unlinkSync4(resolved);
+    }
+    return "removed";
+  } catch {
+    return "missing";
+  }
+}
+function removeEmptyDirUpward(dirPath, stopAt) {
+  let current = resolve(dirPath);
+  const stop = resolve(stopAt);
+  let removedAny = false;
+  while (current.startsWith(stop + sep2)) {
+    try {
+      const entries = readdirSync6(current);
+      if (entries.length > 0) break;
+      rmdirSync(current);
+      removedAny = true;
+    } catch {
+      break;
+    }
+    current = dirname6(current);
+  }
+  return removedAny;
+}
+function cleanHookSettings(hookSettingsPath, target, pluginId) {
+  const resolved = resolve(target, hookSettingsPath);
+  if (!existsSync13(resolved)) return;
+  let settings;
+  try {
+    settings = JSON.parse(readFileSync9(resolved, "utf-8"));
+  } catch {
+    return;
+  }
+  if (!settings || typeof settings !== "object" || !settings.hooks) return;
+  const pluginRootFragment = `.cannbot/plugins/${pluginId}`;
+  const cleanHooks = (hooks) => {
+    if (Array.isArray(hooks)) {
+      return hooks.filter((entry) => !JSON.stringify(entry).includes(pluginRootFragment));
+    }
+    if (hooks && typeof hooks === "object") {
+      const result = {};
+      for (const [key, value] of Object.entries(hooks)) {
+        const cleaned = cleanHooks(value);
+        if (Array.isArray(cleaned) ? cleaned.length > 0 : cleaned !== void 0) {
+          result[key] = cleaned;
+        }
+      }
+      return result;
+    }
+    return hooks;
+  };
+  try {
+    const cleaned = cleanHooks(settings.hooks);
+    if (Array.isArray(cleaned) ? cleaned.length === 0 : Object.keys(cleaned).length === 0) {
+      delete settings.hooks;
+    } else {
+      settings.hooks = cleaned;
+    }
+    writeFileSync3(resolved, `${JSON.stringify(settings, null, 2)}
+`);
+  } catch {
+  }
+}
+function cleanCodexNativePlugin(record, pluginId) {
+  const native = record.nativePlugin;
+  if (!native || typeof native !== "object") return;
+  if (native.pluginRoot) {
+    try {
+      rmSync3(native.pluginRoot, { recursive: true, force: true });
+      logger.step(`  ${t("uninstall_remove_label")}: ${native.pluginRoot}`);
+    } catch {
+    }
+  }
+  if (native.marketplacePath && existsSync13(native.marketplacePath)) {
+    try {
+      const marketplace = JSON.parse(readFileSync9(native.marketplacePath, "utf-8"));
+      if (Array.isArray(marketplace?.plugins)) {
+        marketplace.plugins = marketplace.plugins.filter(
+          (p) => !(p && (p.name === pluginId || p.name === native.marketplaceName))
+        );
+        if (marketplace.plugins.length === 0) {
+          unlinkSync4(native.marketplacePath);
+        } else {
+          writeFileSync3(native.marketplacePath, `${JSON.stringify(marketplace, null, 2)}
+`);
+        }
+      }
+    } catch {
+    }
+  }
+}
+function uninstallCannbotPlugin(pluginId, target) {
+  const result = {
+    success: false,
+    pluginId,
+    removedFiles: 0,
+    removedDirs: 0,
+    errors: []
+  };
+  const root = resolve(target || process.cwd());
+  let read = null;
+  let record;
+  for (const tool of CANNBOT_SUPPORTED_TOOLS) {
+    const candidate = readCannbotRegistry(root, tool);
+    if (!candidate) continue;
+    const found = candidate.registry.plugins.find((r) => r?.plugin === pluginId);
+    if (found) {
+      read = candidate;
+      record = found;
+      break;
+    }
+  }
+  if (!read || !record) {
+    result.errors.push(t("cannbot_uninstall_no_record"));
+    return result;
+  }
+  if (!read.schemaSupported) {
+    result.errors.push(
+      t("cannbot_registry_schema_unsupported").replace("{version}", String(read.registry.schemaVersion))
+    );
+    return result;
+  }
+  const registryPath = read.registryPath;
+  const allowedBase = root;
+  for (const relPath of [...record.skills || [], ...record.agents || []]) {
+    const absolute = join12(root, relPath);
+    if (removeIfSafe(absolute, allowedBase) === "removed") {
+      result.removedFiles++;
+      removeEmptyDirUpward(dirname6(absolute), allowedBase);
+    }
+  }
+  if (record.instructions) {
+    const instructionsPath = join12(root, record.instructions);
+    const resolved = resolve(instructionsPath);
+    if (resolved.startsWith(allowedBase + sep2) && existsSync13(resolved)) {
+      try {
+        const content = readFileSync9(resolved, "utf-8");
+        const cleaned = removeMarkerBlock(content, pluginId);
+        if (cleaned.trim().length === 0) {
+          unlinkSync4(resolved);
+          result.removedFiles++;
+        } else if (cleaned !== content) {
+          writeFileSync3(resolved, cleaned);
+        }
+      } catch (error) {
+        result.errors.push(error instanceof Error ? error.message : t("error_unknown"));
+      }
+    }
+  }
+  if (record.assets) {
+    if (removeIfSafe(join12(root, record.assets), allowedBase) === "removed") {
+      result.removedDirs++;
+      removeEmptyDirUpward(join12(root, ".cannbot", "plugins"), allowedBase);
+    }
+  }
+  const siblings = scanCannbotInstalled(root).map((e) => e.record).filter((r) => r.plugin !== pluginId);
+  const siblingUses = (rel) => siblings.some((r) => [r.permissions, r.settings, r.hookSettings].filter(Boolean).includes(rel));
+  if (record.permissions && !siblingUses(record.permissions)) {
+    if (removeIfSafe(join12(root, record.permissions), allowedBase) === "removed") {
+      result.removedDirs++;
+    }
+  }
+  if (record.settings && !siblingUses(record.settings)) {
+    if (removeIfSafe(join12(root, record.settings), allowedBase) === "removed") {
+      result.removedFiles++;
+    }
+  }
+  if (record.hookSettings) {
+    cleanHookSettings(record.hookSettings, root, pluginId);
+  }
+  for (const relDep of record.dependencies || []) {
+    if (removeIfSafe(join12(root, relDep), allowedBase) === "removed") {
+      result.removedDirs++;
+    }
+  }
+  if ((record.dependencies || []).length > 0) {
+    removeEmptyDirUpward(join12(root, ".cannbot", "dependencies", pluginId), allowedBase);
+  }
+  cleanCodexNativePlugin(record, pluginId);
+  if (record.nativePlugin && typeof record.nativePlugin === "object" && record.nativePlugin.package) {
+    logger.warn(t("cannbot_uninstall_native_hint").replace("{spec}", String(record.nativePlugin.package)));
+  }
+  try {
+    const registry = JSON.parse(readFileSync9(registryPath, "utf-8"));
+    registry.plugins = registry.plugins.filter((r) => r?.plugin !== pluginId);
+    if (registry.plugins.length === 0) {
+      unlinkSync4(registryPath);
+      removeEmptyDirUpward(dirname6(registryPath), allowedBase);
+    } else {
+      writeFileSync3(registryPath, `${JSON.stringify(registry, null, 2)}
+`);
+    }
+  } catch (error) {
+    result.errors.push(error instanceof Error ? error.message : t("error_unknown"));
+  }
+  if (CANNBOT_TOOL_LAYOUTS[record.tool]) {
+    const configDir = dirname6(registryPath);
+    const layoutRoots = [join12(configDir, "agents"), join12(configDir, "skills")];
+    if (record.tool === "opencode" || record.tool === "codex") {
+      layoutRoots.push(join12(root, ".agents", "skills"), join12(root, ".agents"));
+    }
+    for (const dirPath of layoutRoots) {
+      if (removeEmptyDirUpward(dirPath, allowedBase)) {
+        result.removedDirs++;
+      }
+    }
+  }
+  deleteRecord(pluginId);
+  removeInstalledPlugin(pluginId);
+  result.success = result.errors.length === 0;
+  return result;
+}
+function findOrphanedDelegatedRecords(target) {
+  const orphans = [];
+  const installed = new Set(scanCannbotInstalled(target).map((e) => e.id));
+  const installsDir = join12(getCannbotConfigDir(), "installs");
+  if (!existsSync13(installsDir)) return orphans;
+  for (const file of readdirSync6(installsDir)) {
+    if (!file.endsWith(".json") || file === "skills.json") continue;
+    const pluginId = file.replace(/\.json$/, "");
+    try {
+      const rec = JSON.parse(readFileSync9(join12(installsDir, file), "utf-8"));
+      if (rec?.kind !== "delegated") continue;
+      if (!installed.has(pluginId)) {
+        orphans.push(pluginId);
+      }
+    } catch {
+    }
+  }
+  return orphans;
+}
+
+// src/core/installer.ts
+init_registry();
+init_manifest();
+init_paths();
+import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
+import { join as join15, basename as basename2 } from "path";
+import { execa as execa5, execaSync as execaSync2 } from "execa";
+
 // src/core/backup.ts
 init_manifest();
-import { existsSync as existsSync12, copyFileSync, readdirSync as readdirSync5, unlinkSync as unlinkSync4 } from "fs";
-import { join as join11 } from "path";
+import { existsSync as existsSync14, copyFileSync, readdirSync as readdirSync7, unlinkSync as unlinkSync5 } from "fs";
+import { join as join13 } from "path";
 init_registry();
 init_paths();
 function detectCurrentPlugin(configRoot, tool, installPath) {
@@ -3064,9 +3722,9 @@ function detectCurrentPlugin(configRoot, tool, installPath) {
     }
   }
   const agentsFileName = getAgentsFileName(tool);
-  const configRootAgentsFile = join11(configRoot, agentsFileName);
-  const installPathAgentsFile = installPath ? join11(installPath, agentsFileName) : null;
-  if (!existsSync12(configRootAgentsFile) && !(installPathAgentsFile && existsSync12(installPathAgentsFile))) {
+  const configRootAgentsFile = join13(configRoot, agentsFileName);
+  const installPathAgentsFile = installPath ? join13(installPath, agentsFileName) : null;
+  if (!existsSync14(configRootAgentsFile) && !(installPathAgentsFile && existsSync14(installPathAgentsFile))) {
     return null;
   }
   const allRecords = readAllRecords();
@@ -3084,13 +3742,13 @@ function detectCurrentPlugin(configRoot, tool, installPath) {
   return null;
 }
 function createBackup(configRoot, tool, fromPluginId, fromPluginName) {
-  const agentsFile = join11(configRoot, getAgentsFileName(tool));
-  if (!existsSync12(agentsFile)) {
+  const agentsFile = join13(configRoot, getAgentsFileName(tool));
+  if (!existsSync14(agentsFile)) {
     return null;
   }
   const timestamp = formatTimestamp(/* @__PURE__ */ new Date());
   const backupFileName = `${getAgentsFileName(tool)}.cannbot-backup.${fromPluginId}.${timestamp}`;
-  const backupPath = join11(configRoot, backupFileName);
+  const backupPath = join13(configRoot, backupFileName);
   try {
     copyFileSync(agentsFile, backupPath);
     return {
@@ -3104,10 +3762,10 @@ function createBackup(configRoot, tool, fromPluginId, fromPluginName) {
   }
 }
 function findBackups(configRoot) {
-  if (!existsSync12(configRoot)) {
+  if (!existsSync14(configRoot)) {
     return [];
   }
-  const files = readdirSync5(configRoot);
+  const files = readdirSync7(configRoot);
   const backups = [];
   for (const file of files) {
     if (file.includes(".cannbot-backup.")) {
@@ -3120,7 +3778,7 @@ function findBackups(configRoot) {
           const timestamp = pluginIdAndTime.substring(lastDotIndex + 1);
           const plugin = findPlugin(pluginId);
           backups.push({
-            filePath: join11(configRoot, file),
+            filePath: join13(configRoot, file),
             pluginId,
             pluginName: plugin?.displayName || pluginId,
             backupTime: timestamp
@@ -3133,7 +3791,7 @@ function findBackups(configRoot) {
 }
 function restoreBackup(backupPath, configRoot, tool) {
   try {
-    const agentsFile = join11(configRoot, getAgentsFileName(tool));
+    const agentsFile = join13(configRoot, getAgentsFileName(tool));
     copyFileSync(backupPath, agentsFile);
     return true;
   } catch {
@@ -3142,8 +3800,8 @@ function restoreBackup(backupPath, configRoot, tool) {
 }
 function deleteBackup(backupPath) {
   try {
-    if (existsSync12(backupPath)) {
-      unlinkSync4(backupPath);
+    if (existsSync14(backupPath)) {
+      unlinkSync5(backupPath);
       return true;
     }
     return false;
@@ -3216,9 +3874,42 @@ init_paths();
 init_fs_helpers();
 init_logger();
 init_i18n();
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, symlinkSync, realpathSync, readlinkSync, copyFileSync as copyFileSync2, cpSync, writeFileSync as writeFileSync2, rmSync as rmSync3, readFileSync as readFileSync8 } from "fs";
-import { join as join12, basename } from "path";
-import { execa as execa3 } from "execa";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, symlinkSync, realpathSync, readlinkSync, copyFileSync as copyFileSync2, cpSync, writeFileSync as writeFileSync4, rmSync as rmSync4, readFileSync as readFileSync10, constants as fsConstants } from "fs";
+import { join as join14, basename } from "path";
+import { execa as execa4 } from "execa";
+var ISSUE_HANDLER_ID = "gitcode-issue-handler";
+var ISSUE_HANDLER_CONFIG_FILES = ["classify_config.yaml", "operator_owners.yaml"];
+function shouldInitializeIssueHandlerConfig(level, installedSkills) {
+  return level === "project" && installedSkills.includes(ISSUE_HANDLER_ID);
+}
+function instantiateIssueHandlerConfig(repoPath, targetRepoPath) {
+  const configDir = join14(targetRepoPath, ".cannbot", ISSUE_HANDLER_ID, "config");
+  const legacyConfigDir = targetRepoPath;
+  try {
+    mkdirSync6(configDir, { recursive: true });
+  } catch (error) {
+    logger.warn(`issue-handler config directory creation failed: ${error instanceof Error ? error.message : String(error)}`);
+    return;
+  }
+  for (const fileName of ISSUE_HANDLER_CONFIG_FILES) {
+    const targetPath = join14(configDir, fileName);
+    if (existsSync15(targetPath) || isSymlink(targetPath)) continue;
+    const legacyPath = join14(legacyConfigDir, fileName);
+    const templatePath = join14(repoPath, "infra", ISSUE_HANDLER_ID, "assets", `${fileName}.template`);
+    const sourcePath = existsSync15(legacyPath) ? legacyPath : templatePath;
+    if (!existsSync15(sourcePath)) {
+      logger.warn(`issue-handler config source not found: ${sourcePath}`);
+      continue;
+    }
+    try {
+      copyFileSync2(sourcePath, targetPath, fsConstants.COPYFILE_EXCL);
+    } catch (error) {
+      if (error?.code !== "EEXIST") {
+        logger.warn(`issue-handler config install failed for ${fileName}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+  }
+}
 function installLink(source, target) {
   try {
     const resolved = realpathSync(source);
@@ -3234,7 +3925,7 @@ function installLink(source, target) {
         return "skipped";
       }
     }
-    if (existsSync13(target) || isSymlink(target)) {
+    if (existsSync15(target) || isSymlink(target)) {
       removePath(target);
     }
     try {
@@ -3252,19 +3943,19 @@ function installLink(source, target) {
   }
 }
 function installConfigFile(pluginDir, configFile, tool, level, configRoot, installPath, configRootConfigLink) {
-  const sourcePath = join12(pluginDir, configFile);
-  if (!existsSync13(sourcePath)) return;
+  const sourcePath = join14(pluginDir, configFile);
+  if (!existsSync15(sourcePath)) return;
   const agentsFileName = getAgentsFileName(tool);
   const isProjectLevel = level === "project";
   let primaryTarget;
   if (isProjectLevel) {
-    primaryTarget = join12(installPath, agentsFileName);
+    primaryTarget = join14(installPath, agentsFileName);
   } else {
-    primaryTarget = join12(configRoot, agentsFileName);
+    primaryTarget = join14(configRoot, agentsFileName);
   }
   try {
     const resolvedSource = realpathSync(sourcePath);
-    if (existsSync13(primaryTarget) || isSymlink(primaryTarget)) {
+    if (existsSync15(primaryTarget) || isSymlink(primaryTarget)) {
       removePath(primaryTarget);
     }
     try {
@@ -3279,10 +3970,10 @@ function installConfigFile(pluginDir, configFile, tool, level, configRoot, insta
   } catch (e) {
     logger.warn(t("install_config_failed").replace("{error}", e.message));
   }
-  if (isProjectLevel && primaryTarget !== join12(configRoot, agentsFileName)) {
+  if (isProjectLevel && primaryTarget !== join14(configRoot, agentsFileName)) {
     if (configRootConfigLink === false) return;
-    const configRootTarget = join12(configRoot, agentsFileName);
-    if (existsSync13(configRootTarget) || isSymlink(configRootTarget)) {
+    const configRootTarget = join14(configRoot, agentsFileName);
+    if (existsSync15(configRootTarget) || isSymlink(configRootTarget)) {
       removePath(configRootTarget);
     }
     try {
@@ -3297,15 +3988,15 @@ function installConfigFile(pluginDir, configFile, tool, level, configRoot, insta
 async function installExternalRepos(repos, repoPath, configRoot, installPath, level) {
   if (!repos || repos.length === 0) return;
   for (const repo of repos) {
-    const targetDir = join12(repoPath, repo.dir);
-    const gitDir = join12(targetDir, ".git");
-    if (existsSync13(gitDir)) {
+    const targetDir = join14(repoPath, repo.dir);
+    const gitDir = join14(targetDir, ".git");
+    if (existsSync15(gitDir)) {
       try {
-        await execa3("git", ["pull", "--quiet"], { cwd: targetDir, timeout: 12e4 });
+        await execa4("git", ["pull", "--quiet"], { cwd: targetDir, timeout: 12e4 });
       } catch {
         logger.warn(t("external_repo_update_failed").replace("{dir}", repo.dir));
       }
-    } else if (!existsSync13(targetDir)) {
+    } else if (!existsSync15(targetDir)) {
       const args = ["clone"];
       if (repo.depth) {
         args.push("--depth", String(repo.depth));
@@ -3315,11 +4006,11 @@ async function installExternalRepos(repos, repoPath, configRoot, installPath, le
       }
       args.push(repo.url, targetDir);
       try {
-        await execa3("git", args, { timeout: 12e4 });
+        await execa4("git", args, { timeout: 12e4 });
       } catch {
         logger.warn(t("install_clone_failed").replace("{url}", repo.url).replace("{dir}", repo.dir));
         try {
-          rmSync3(targetDir, { recursive: true, force: true });
+          rmSync4(targetDir, { recursive: true, force: true });
         } catch {
         }
         continue;
@@ -3329,9 +4020,9 @@ async function installExternalRepos(repos, repoPath, configRoot, installPath, le
     const resolved = realpathSync(targetDir);
     const shouldConfigRootLink = repo.configRootLink !== false && (level === "global" || repo.configRootLink === true);
     if (shouldConfigRootLink) {
-      const configRootLink = join12(configRoot, linkName);
+      const configRootLink = join14(configRoot, linkName);
       try {
-        if (existsSync13(configRootLink) || isSymlink(configRootLink)) {
+        if (existsSync15(configRootLink) || isSymlink(configRootLink)) {
           removePath(configRootLink);
         }
         try {
@@ -3346,9 +4037,9 @@ async function installExternalRepos(repos, repoPath, configRoot, installPath, le
       }
     }
     if (level === "project") {
-      const projectLink = join12(installPath, linkName);
+      const projectLink = join14(installPath, linkName);
       try {
-        if (existsSync13(projectLink) || isSymlink(projectLink)) {
+        if (existsSync15(projectLink) || isSymlink(projectLink)) {
           removePath(projectLink);
         }
         try {
@@ -3365,12 +4056,12 @@ async function installExternalRepos(repos, repoPath, configRoot, installPath, le
   }
 }
 function installWorkflows(pluginDir, configRoot) {
-  const workflowsDir = join12(pluginDir, "workflows");
-  if (!existsSync13(workflowsDir)) return;
-  const targetPath = join12(configRoot, "workflows");
+  const workflowsDir = join14(pluginDir, "workflows");
+  if (!existsSync15(workflowsDir)) return;
+  const targetPath = join14(configRoot, "workflows");
   try {
     const resolved = realpathSync(workflowsDir);
-    if (existsSync13(targetPath) || isSymlink(targetPath)) {
+    if (existsSync15(targetPath) || isSymlink(targetPath)) {
       removePath(targetPath);
     }
     try {
@@ -3396,36 +4087,36 @@ function writeCannbotManifest(configRoot, pluginId, version, level, tool, skills
     brand_dir: configRoot,
     install_time: (/* @__PURE__ */ new Date()).toISOString()
   };
-  const manifestPath = join12(configRoot, `${pluginId}-manifest.json`);
-  writeFileSync2(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+  const manifestPath = join14(configRoot, `${pluginId}-manifest.json`);
+  writeFileSync4(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   return manifest;
 }
 async function installViaManifest(plugin, repoPath, tool, level, installPath) {
   const cwd = installPath || process.cwd();
   const configRoot = getConfigRoot(tool, level, installPath);
-  const pluginDir = join12(repoPath, plugin.dir);
+  const pluginDir = join14(repoPath, plugin.dir);
   try {
     const skillsDir = getSkillsRoot(tool, level, cwd);
-    const agentsDir = join12(configRoot, "agents");
-    mkdirSync5(skillsDir, { recursive: true });
-    mkdirSync5(agentsDir, { recursive: true });
+    const agentsDir = join14(configRoot, "agents");
+    mkdirSync6(skillsDir, { recursive: true });
+    mkdirSync6(agentsDir, { recursive: true });
     const installedSkills = [];
     const installedAgents = [];
     for (const source of plugin.installSkills || []) {
-      const sourceDir = join12(repoPath, source.dir);
-      if (!existsSync13(sourceDir)) {
+      const sourceDir = join14(repoPath, source.dir);
+      if (!existsSync15(sourceDir)) {
         logger.warn(t("install_skill_source_not_found").replace("{dir}", source.dir));
         continue;
       }
       for (const skillEntry of source.skills) {
         const skillName = typeof skillEntry === "string" ? skillEntry : skillEntry.name;
         const skillAlias = typeof skillEntry === "string" ? skillName : skillEntry.as || skillName;
-        const skillPath = join12(sourceDir, skillName);
-        if (!existsSync13(skillPath)) {
+        const skillPath = join14(sourceDir, skillName);
+        if (!existsSync15(skillPath)) {
           logger.warn(t("install_skill_not_found").replace("{name}", skillName).replace("{dir}", source.dir));
           continue;
         }
-        const targetPath = join12(skillsDir, skillAlias);
+        const targetPath = join14(skillsDir, skillAlias);
         const result = installLink(skillPath, targetPath);
         if (result !== "failed") {
           installedSkills.push(skillAlias);
@@ -3437,20 +4128,20 @@ async function installViaManifest(plugin, repoPath, tool, level, installPath) {
     for (const agentName of plugin.installAgents || []) {
       if (tool === "codex") {
         const baseName = agentName.replace(/\.md$/, "");
-        const tomlSource = join12(pluginDir, "agents", "codex", `${baseName}.toml`);
-        if (!existsSync13(tomlSource)) {
+        const tomlSource = join14(pluginDir, "agents", "codex", `${baseName}.toml`);
+        if (!existsSync15(tomlSource)) {
           logger.warn(t("install_agent_codex_toml_missing").replace("{name}", baseName).replace("{path}", tomlSource));
           continue;
         }
-        const canonicalMd = join12(pluginDir, "agents", `${baseName}.md`);
-        const canonicalPath = existsSync13(canonicalMd) ? realpathSync(canonicalMd) : canonicalMd;
-        const targetPath2 = join12(agentsDir, `${baseName}.toml`);
+        const canonicalMd = join14(pluginDir, "agents", `${baseName}.md`);
+        const canonicalPath = existsSync15(canonicalMd) ? realpathSync(canonicalMd) : canonicalMd;
+        const targetPath2 = join14(agentsDir, `${baseName}.toml`);
         try {
-          const content = readFileSync8(tomlSource, "utf-8").split("__CANNBOT_AGENT_SOURCE__").join(canonicalPath);
-          if (existsSync13(targetPath2) || isSymlink(targetPath2)) {
+          const content = readFileSync10(tomlSource, "utf-8").split("__CANNBOT_AGENT_SOURCE__").join(canonicalPath);
+          if (existsSync15(targetPath2) || isSymlink(targetPath2)) {
             removePath(targetPath2);
           }
-          writeFileSync2(targetPath2, content, "utf-8");
+          writeFileSync4(targetPath2, content, "utf-8");
           installedAgents.push(`${baseName}.toml`);
         } catch {
           logger.warn(t("install_agent_failed").replace("{name}", `${baseName}.toml`));
@@ -3458,12 +4149,12 @@ async function installViaManifest(plugin, repoPath, tool, level, installPath) {
         continue;
       }
       const agentFile = agentName.endsWith(".md") ? agentName : `${agentName}.md`;
-      const agentPath = join12(pluginDir, "agents", agentFile);
-      if (!existsSync13(agentPath)) {
+      const agentPath = join14(pluginDir, "agents", agentFile);
+      if (!existsSync15(agentPath)) {
         logger.warn(t("install_agent_not_found").replace("{name}", agentFile));
         continue;
       }
-      const targetPath = join12(agentsDir, agentFile);
+      const targetPath = join14(agentsDir, agentFile);
       const result = installLink(agentPath, targetPath);
       if (result !== "failed") {
         installedAgents.push(agentFile);
@@ -3483,6 +4174,9 @@ async function installViaManifest(plugin, repoPath, tool, level, installPath) {
       installedSkills,
       installedAgents
     );
+    if (shouldInitializeIssueHandlerConfig(level, installedSkills)) {
+      instantiateIssueHandlerConfig(repoPath, cwd);
+    }
     return {
       success: true,
       skillsCount: installedSkills.length,
@@ -3509,7 +4203,7 @@ function findShell() {
   for (const cmd of candidates) {
     try {
       const detectCmd = process.platform === "win32" ? "where" : "which";
-      execaSync(detectCmd, [cmd], { timeout: 3e3 });
+      execaSync2(detectCmd, [cmd], { timeout: 3e3 });
       return cmd;
     } catch {
     }
@@ -3518,7 +4212,7 @@ function findShell() {
 }
 function scriptSupportsTool(scriptPath, tool) {
   try {
-    const scriptContent = readFileSync9(scriptPath, "utf-8");
+    const scriptContent = readFileSync11(scriptPath, "utf-8");
     return new RegExp(`\\b${tool}\\b`).test(scriptContent);
   } catch {
     return true;
@@ -3536,12 +4230,12 @@ async function installPlugin(opts) {
       warnings: []
     };
   }
-  const pluginDir = join13(opts.repoPath, plugin.dir);
+  const pluginDir = join15(opts.repoPath, plugin.dir);
   const cwd = opts.installPath || process.cwd();
   const configRoot = getConfigRoot(opts.tool, opts.level, opts.installPath);
-  const agentsFile = join13(configRoot, getAgentsFileName(opts.tool));
+  const agentsFile = join15(configRoot, getAgentsFileName(opts.tool));
   let backupInfo = null;
-  if (existsSync14(agentsFile)) {
+  if (existsSync16(agentsFile)) {
     const currentPlugin = detectCurrentPlugin(configRoot, opts.tool, opts.installPath);
     if (currentPlugin && currentPlugin.pluginId !== opts.pluginId) {
       let choice = "overwrite";
@@ -3636,8 +4330,8 @@ async function installPlugin(opts) {
       };
     }
   }
-  const scriptPath = join13(pluginDir, plugin.script);
-  if (!existsSync14(scriptPath)) {
+  const scriptPath = join15(pluginDir, plugin.script);
+  if (!existsSync16(scriptPath)) {
     return {
       success: false,
       pluginId: opts.pluginId,
@@ -3679,7 +4373,7 @@ async function installPlugin(opts) {
       stdio: "pipe",
       input: opts.yes ? "y\n" : void 0
     };
-    await execa4(shell, [scriptPath, ...args], execOptions);
+    await execa5(shell, [scriptPath, ...args], execOptions);
     const manifest = readManifest(configRoot);
     let skillsCount = 0;
     let agentsCount = 0;
@@ -3735,6 +4429,188 @@ async function installPlugin(opts) {
   }
 }
 
+// src/core/cannbot-delegate.ts
+init_config();
+init_paths();
+init_fs_helpers();
+init_i18n();
+var DELEGATE_TOOLS = ["opencode", "claude", "trae", "codex"];
+function boundaryErrors(tool, level) {
+  const errors = [];
+  if (!DELEGATE_TOOLS.includes(tool)) {
+    errors.push(
+      t("cannbot_tool_unsupported").replace("{tool}", tool).replace("{tools}", DELEGATE_TOOLS.join(", "))
+    );
+  }
+  if (level !== "project") {
+    errors.push(t("cannbot_level_unsupported"));
+  }
+  return errors;
+}
+function migrateSymlinkedInstructions(target, tool) {
+  const warnings = [];
+  const fileName = getConfigFileName(tool);
+  const candidates = [join16(target, fileName), join16(target, "AGENTS.md"), join16(target, "CLAUDE.md")];
+  for (const configPath of candidates) {
+    if (!isSymlink(configPath)) continue;
+    try {
+      const content = readFileSync12(configPath, "utf-8");
+      const backupPath = `${configPath}.cannbot-migration.${Date.now()}`;
+      copyFileSync3(configPath, backupPath);
+      unlinkSync6(configPath);
+      writeFileSync5(configPath, content);
+      warnings.push(t("cannbot_migrated_symlink").replace("{file}", fileName));
+    } catch {
+      warnings.push(t("cannbot_migrate_symlink_failed").replace("{file}", fileName));
+    }
+    break;
+  }
+  return warnings;
+}
+function detectDualSkillCopies(tool, target, skillNames) {
+  const duplicates = [];
+  if (tool !== "opencode") return duplicates;
+  const legacyRoot = getSkillsRoot("opencode", "project", target);
+  if (!existsSync17(legacyRoot)) return duplicates;
+  let legacyEntries = [];
+  try {
+    legacyEntries = readdirSync8(legacyRoot);
+  } catch {
+    return duplicates;
+  }
+  for (const name of skillNames) {
+    if (legacyEntries.includes(name)) {
+      duplicates.push(name);
+    }
+  }
+  return duplicates;
+}
+function skillNameFromPath(rel) {
+  const parts = rel.split("/");
+  return parts[parts.length - 1] || rel;
+}
+async function delegateInstall(options) {
+  const { pluginId, tool, level } = options;
+  const target = resolve2(options.target || process.cwd());
+  const displayName = options.displayName || pluginId;
+  const result = {
+    success: false,
+    pluginId,
+    skillsCount: 0,
+    agentsCount: 0,
+    errors: [],
+    warnings: []
+  };
+  result.errors.push(...boundaryErrors(tool, level));
+  if (result.errors.length > 0) {
+    return result;
+  }
+  if (!hasNodeRuntime()) {
+    result.errors.push(t("cannbot_node_required"));
+    return result;
+  }
+  try {
+    await ensureCannbotInstaller();
+  } catch (error) {
+    result.errors.push(
+      t("cannbot_installer_failed").replace(
+        "{error}",
+        error instanceof Error ? error.message : t("error_unknown")
+      )
+    );
+    return result;
+  }
+  if (!discoverCannbotPlugins().some((p) => p.id === pluginId)) {
+    try {
+      await ensureCannbotInstaller({ force: true });
+    } catch {
+    }
+    if (!discoverCannbotPlugins().some((p) => p.id === pluginId)) {
+      result.errors.push(t("cannbot_plugin_not_found").replace("{plugin}", pluginId));
+      return result;
+    }
+  }
+  result.warnings.push(...migrateSymlinkedInstructions(target, tool));
+  try {
+    await execa6(
+      "node",
+      [getCannbotBinPath(), "install", pluginId, "--tool", tool, "--target", target],
+      {
+        cwd: target,
+        stdout: "inherit",
+        stderr: "inherit",
+        timeout: 6e5
+      }
+    );
+  } catch (error) {
+    const exitCode = error.exitCode;
+    result.errors.push(
+      t("cannbot_delegate_failed").replace(
+        "{code}",
+        exitCode !== void 0 ? String(exitCode) : "?"
+      )
+    );
+    return result;
+  }
+  const registryRead = readCannbotRegistry(target, tool);
+  const record = registryRead?.registry.plugins.find((r) => r?.plugin === pluginId);
+  if (!record) {
+    result.errors.push(t("cannbot_registry_missing"));
+    return result;
+  }
+  result.skillsCount = Array.isArray(record.skills) ? record.skills.length : 0;
+  result.agentsCount = Array.isArray(record.agents) ? record.agents.length : 0;
+  const files = [];
+  const directories = [];
+  for (const rel of [...record.skills || [], ...record.agents || []]) {
+    files.push(join16(target, rel));
+  }
+  if (record.assets) {
+    directories.push(join16(target, record.assets));
+  }
+  if (record.permissions) {
+    directories.push(join16(target, record.permissions));
+  }
+  const registryPath = findCannbotRegistryPath(target, tool);
+  writeRecord({
+    pluginId,
+    displayName,
+    tool,
+    level: "project",
+    installPath: target,
+    configRoot: registryPath ? join16(registryPath, "..") : target,
+    installTime: (/* @__PURE__ */ new Date()).toISOString(),
+    files,
+    directories,
+    kind: "delegated"
+  });
+  addInstalledPlugin(pluginId);
+  const duplicates = detectDualSkillCopies(
+    tool,
+    target,
+    (record.skills || []).map(skillNameFromPath)
+  );
+  if (duplicates.length > 0) {
+    result.warnings.push(t("cannbot_dual_skill_copy").replace("{skills}", duplicates.join(", ")));
+  }
+  result.success = true;
+  return result;
+}
+async function installPluginRouted(options) {
+  const isCannbot = options.source === "cannbot" || options.plugin?.source === "cannbot";
+  if (isCannbot) {
+    return delegateInstall({
+      pluginId: options.pluginId,
+      displayName: options.plugin?.displayName,
+      tool: options.tool,
+      level: options.level,
+      target: options.installPath || process.cwd(),
+      yes: options.yes
+    });
+  }
+  return installPlugin(options);
+}
+
 // src/commands/init.ts
 init_registry();
 
@@ -3744,8 +4620,8 @@ init_fs_helpers();
 init_constants();
 init_logger();
 init_i18n();
-import { existsSync as existsSync15, mkdirSync as mkdirSync6, symlinkSync as symlinkSync2, readdirSync as readdirSync6, rmSync as rmSync4, realpathSync as realpathSync2, readlinkSync as readlinkSync2, cpSync as cpSync2 } from "fs";
-import { join as join14, dirname as dirname5, basename as basename3, isAbsolute } from "path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, symlinkSync as symlinkSync2, readdirSync as readdirSync9, rmSync as rmSync5, realpathSync as realpathSync2, readlinkSync as readlinkSync2, cpSync as cpSync2 } from "fs";
+import { join as join17, dirname as dirname7, basename as basename3, isAbsolute } from "path";
 import { select as select3, checkbox, Separator as Separator2 } from "@inquirer/prompts";
 import chalk5 from "chalk";
 import Table from "cli-table3";
@@ -3755,8 +4631,8 @@ async function installSkills(skillIds, tool, level, repoPath) {
   const configRoot = getConfigRoot(tool, level);
   const skillsDir = getSkillsRoot(tool, level);
   const installPath = level === "project" ? process.cwd() : configRoot;
-  if (!existsSync15(skillsDir)) {
-    mkdirSync6(skillsDir, { recursive: true });
+  if (!existsSync18(skillsDir)) {
+    mkdirSync7(skillsDir, { recursive: true });
   }
   const results = [];
   const installedIds = [];
@@ -3767,8 +4643,8 @@ async function installSkills(skillIds, tool, level, repoPath) {
       continue;
     }
     const sourcePath = resolveSkillSourcePath(skill, repoPath);
-    const targetPath = join14(skillsDir, skillId);
-    if (!existsSync15(sourcePath)) {
+    const targetPath = join17(skillsDir, skillId);
+    if (!existsSync18(sourcePath)) {
       results.push({ skillId, success: false, error: t("error_source_not_found").replace("{path}", sourcePath) });
       continue;
     }
@@ -3790,7 +4666,7 @@ async function installSkills(skillIds, tool, level, repoPath) {
           continue;
         }
       }
-      if (existsSync15(targetPath) || isSymlink(targetPath)) {
+      if (existsSync18(targetPath) || isSymlink(targetPath)) {
         removePath(targetPath);
       }
       try {
@@ -3814,6 +4690,9 @@ async function installSkills(skillIds, tool, level, repoPath) {
   }
   if (installedIds.length > 0) {
     addSkillsToRecord(installedIds, tool, level, installPath);
+    if (shouldInitializeIssueHandlerConfig(level, installedIds)) {
+      instantiateIssueHandlerConfig(repoPath, installPath);
+    }
   }
   return results;
 }
@@ -3824,9 +4703,9 @@ async function uninstallSkills(skillIds, tool, level) {
   const results = [];
   const removedIds = [];
   for (const skillId of skillIds) {
-    const targetPath = join14(skillsDir, skillId);
+    const targetPath = join17(skillsDir, skillId);
     try {
-      if (existsSync15(targetPath) || isSymlink(targetPath)) {
+      if (existsSync18(targetPath) || isSymlink(targetPath)) {
         removePath(targetPath);
         results.push({ skillId, success: true });
         removedIds.push(skillId);
@@ -3842,17 +4721,17 @@ async function uninstallSkills(skillIds, tool, level) {
   if (removedIds.length > 0) {
     removeSkillsFromRecord(removedIds, tool, level, installPath);
   }
-  if (existsSync15(skillsDir)) {
+  if (existsSync18(skillsDir)) {
     try {
-      const entries = readdirSync6(skillsDir);
+      const entries = readdirSync9(skillsDir);
       if (entries.length === 0) {
-        rmSync4(skillsDir, { recursive: true });
+        rmSync5(skillsDir, { recursive: true });
         logger.step(`  ${t("uninstall_clean_empty_dir")}: skills/`);
         if (tool === "codex") {
-          const agentsRoot = dirname5(skillsDir);
+          const agentsRoot = dirname7(skillsDir);
           try {
-            if (existsSync15(agentsRoot) && readdirSync6(agentsRoot).length === 0) {
-              rmSync4(agentsRoot, { recursive: true });
+            if (existsSync18(agentsRoot) && readdirSync9(agentsRoot).length === 0) {
+              rmSync5(agentsRoot, { recursive: true });
               logger.step(`  ${t("uninstall_clean_empty_dir")}: ${basename3(agentsRoot)}/`);
             }
           } catch {
@@ -4261,12 +5140,12 @@ function listAllSkills() {
 }
 function resolveSkillSourcePath(skill, repoPath) {
   if (skill.filePath) {
-    const absPath = isAbsolute(skill.filePath) ? skill.filePath : join14(repoPath, skill.filePath);
-    if (existsSync15(absPath)) {
-      return dirname5(absPath);
+    const absPath = isAbsolute(skill.filePath) ? skill.filePath : join17(repoPath, skill.filePath);
+    if (existsSync18(absPath)) {
+      return dirname7(absPath);
     }
   }
-  return join14(repoPath, skill.source, skill.id);
+  return join17(repoPath, skill.source, skill.id);
 }
 
 // src/ui/display.ts
@@ -4290,9 +5169,10 @@ function printPluginList(plugins, installed) {
   plugins.forEach((plugin, index) => {
     const isInstalled = installed.has(plugin.id);
     const status = isInstalled ? chalk6.green(`\u2713 ${t("status_installed")}`) : chalk6.dim(`\u2014`);
+    const badge = plugin.source === "cannbot" ? chalk6.magenta(" [cannbot]") + (plugin.version ? chalk6.dim(` v${plugin.version}`) : "") : "";
     table.push([
       String(index + 1),
-      plugin.displayName,
+      plugin.displayName + badge,
       status,
       plugin.description || chalk6.dim("\u2014")
     ]);
@@ -4367,13 +5247,13 @@ init_config();
 init_paths();
 init_theme();
 init_constants();
-import { existsSync as existsSync16, readFileSync as readFileSync10 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync13 } from "fs";
+import { join as join18 } from "path";
 async function initCommand() {
   const cwd = process.cwd();
-  if (existsSync16(join15(cwd, "package.json")) && (() => {
+  if (existsSync19(join18(cwd, "package.json")) && (() => {
     try {
-      const pkg = JSON.parse(readFileSync10(join15(cwd, "package.json"), "utf-8"));
+      const pkg = JSON.parse(readFileSync13(join18(cwd, "package.json"), "utf-8"));
       return pkg.name === "@cannbot-ai/install-helper";
     } catch {
       return false;
@@ -4394,6 +5274,7 @@ async function initCommand() {
   } catch {
     spinner.warn(t("loading_skills_list_failed"));
   }
+  await ensureCannbotDiscovery();
   let step = 0;
   let mode = "plugin";
   while (true) {
@@ -4480,11 +5361,12 @@ async function pluginInstallFlow() {
     const progress = `[${i + 1}/${total}]`;
     const pluginSpinner = createSpinner(`${progress} ${t("install_progress")} ${displayName}...`);
     pluginSpinner.start();
-    const result = await installPlugin({
+    const result = await installPluginRouted({
       pluginId,
       tool: answers.tool,
       level: answers.level,
-      repoPath
+      repoPath,
+      plugin
     });
     if (result.success) {
       pluginSpinner.succeed(
@@ -4496,6 +5378,9 @@ async function pluginInstallFlow() {
         `${progress} ${displayName} \u2014 ${result.errors.join(", ")}`
       );
     }
+    for (const warning of result.warnings || []) {
+      logger.warn(warning);
+    }
     results.push(result);
   }
   const summary = results.map((result, index) => ({
@@ -4603,9 +5488,24 @@ async function listCommand() {
     await repoManager.ensureRepoAndScan();
   } catch {
   }
+  await ensureCannbotDiscovery();
   const plugins = getAllPlugins();
   const installed = scanInstalled();
   const installedMap = new Map(installed.map((p) => [p.id, p]));
+  for (const entry of scanCannbotInstalled()) {
+    if (!installedMap.has(entry.id)) {
+      installedMap.set(entry.id, {
+        id: entry.id,
+        displayName: entry.id,
+        tool: entry.tool,
+        level: "project",
+        skillsCount: entry.skillsCount,
+        agentsCount: entry.agentsCount,
+        installTime: "",
+        configRoot: entry.registryPath
+      });
+    }
+  }
   printPluginList(plugins, installedMap);
 }
 
@@ -4613,11 +5513,12 @@ async function listCommand() {
 init_detector();
 init_registry();
 init_manifest();
+import chalk8 from "chalk";
+import { existsSync as existsSync20, readdirSync as readdirSync10, lstatSync as lstatSync3, unlinkSync as unlinkSync7, mkdirSync as mkdirSync8, readFileSync as readFileSync14 } from "fs";
+import { join as join19 } from "path";
+import { homedir as homedir3 } from "os";
 init_paths();
 init_i18n();
-import chalk8 from "chalk";
-import { existsSync as existsSync17, readdirSync as readdirSync7, lstatSync as lstatSync2, unlinkSync as unlinkSync5, mkdirSync as mkdirSync7 } from "fs";
-import { join as join16 } from "path";
 async function doctorCommand(options = {}) {
   console.log();
   console.log(chalk8.bold(`  ${t("doctor_title")}`));
@@ -4672,10 +5573,10 @@ async function doctorCommand(options = {}) {
   for (const { configRoot, tool, level } of configRootsToCheck) {
     const skillsDir = getSkillsRoot(tool, level);
     const agentsDir = getAgentsDir(configRoot);
-    if (existsSync17(skillsDir)) {
+    if (existsSync20(skillsDir)) {
       const brokenLinks = checkBrokenLinks(skillsDir);
       if (brokenLinks === 0) {
-        const count = readdirSync7(skillsDir).length;
+        const count = readdirSync10(skillsDir).length;
         console.log(chalk8.green("  \u2713") + ` ${skillsDir} \u2014 ${t("doctor_links_valid").replace("{count}", String(count))}`);
       } else {
         console.log(chalk8.yellow("  \u26A0") + ` ${skillsDir} \u2014 ${t("doctor_broken_links").replace("{count}", String(brokenLinks))}`);
@@ -4689,15 +5590,15 @@ async function doctorCommand(options = {}) {
     } else {
       console.log(chalk8.dim("  \u2014") + ` ${skillsDir} \u2014 ${t("doctor_not_exist")}`);
       if (options.fix) {
-        mkdirSync7(skillsDir, { recursive: true });
+        mkdirSync8(skillsDir, { recursive: true });
         fixes++;
         console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: ${t("doctor_created").replace("{path}", skillsDir)}`);
       }
     }
-    if (existsSync17(agentsDir)) {
+    if (existsSync20(agentsDir)) {
       const brokenLinks = checkBrokenLinks(agentsDir);
       if (brokenLinks === 0) {
-        const count = readdirSync7(agentsDir).length;
+        const count = readdirSync10(agentsDir).length;
         console.log(chalk8.green("  \u2713") + ` ${agentsDir} \u2014 ${t("doctor_links_valid").replace("{count}", String(count))}`);
       } else {
         console.log(chalk8.yellow("  \u26A0") + ` ${agentsDir} \u2014 ${t("doctor_broken_links").replace("{count}", String(brokenLinks))}`);
@@ -4711,7 +5612,7 @@ async function doctorCommand(options = {}) {
     } else {
       console.log(chalk8.dim("  \u2014") + ` ${agentsDir} \u2014 ${t("doctor_not_exist")}`);
       if (options.fix) {
-        mkdirSync7(agentsDir, { recursive: true });
+        mkdirSync8(agentsDir, { recursive: true });
         fixes++;
         console.log(chalk8.green("  \u2713") + ` ${t("doctor_fix_rebuilding")}: ${t("doctor_created").replace("{path}", agentsDir)}`);
       }
@@ -4721,13 +5622,16 @@ async function doctorCommand(options = {}) {
   console.log(chalk8.bold(`  ${t("doctor_config")}`));
   for (const { configRoot, tool, level } of configRootsToCheck) {
     const configFile = getConfigFileName(tool);
-    const configPath = level === "project" ? join16(configRoot, "..", configFile) : join16(configRoot, configFile);
-    if (existsSync17(configPath)) {
+    const configPath = level === "project" ? join19(configRoot, "..", configFile) : join19(configRoot, configFile);
+    if (existsSync20(configPath)) {
       console.log(chalk8.green("  \u2713") + ` ${configPath} ${t("doctor_config_exists")}`);
     } else {
       console.log(chalk8.dim("  \u2014") + ` ${configPath} ${t("doctor_config_not_exist")}`);
     }
   }
+  const cannbotResult = doctorCannbotSection(options);
+  warnings += cannbotResult.warnings;
+  fixes += cannbotResult.fixes;
   console.log();
   console.log(chalk8.dim("  " + "\u2500".repeat(46)));
   if (options.fix && fixes > 0) {
@@ -4741,16 +5645,107 @@ async function doctorCommand(options = {}) {
   }
   console.log();
 }
+function doctorCannbotSection(options) {
+  let warnings = 0;
+  let fixes = 0;
+  console.log();
+  console.log(chalk8.bold(`  ${t("doctor_cannbot")}`));
+  if (hasNodeRuntime()) {
+    console.log(chalk8.green("  \u2713") + ` ${t("doctor_cannbot_node_ok")}`);
+  } else {
+    console.log(chalk8.yellow("  \u26A0") + ` ${t("doctor_cannbot_node_missing")}`);
+    warnings++;
+  }
+  const installerConfig = loadCannbotInstallerConfig();
+  if (isCannbotInstallerReady()) {
+    const version = getCannbotInstallerVersion() || "?";
+    console.log(
+      chalk8.green("  \u2713") + ` ${installerConfig.package} v${version} ${chalk8.dim(`(${installerConfig.channel})`)}`
+    );
+  } else {
+    console.log(
+      chalk8.dim("  \u2014") + ` ${installerConfig.package} \u2014 ${t("doctor_not_installed")}`
+    );
+  }
+  const cannbotInstalled = scanCannbotInstalled();
+  if (cannbotInstalled.length === 0) {
+    console.log(chalk8.dim("  \u2014") + ` cannbot-plugin.json \u2014 ${t("doctor_not_exist")}`);
+  } else {
+    for (const entry of cannbotInstalled) {
+      console.log(
+        chalk8.green("  \u2713") + ` ${entry.id} ${chalk8.dim(`(${entry.tool}, ${entry.skillsCount} skills, ${entry.agentsCount} agents)`)}`
+      );
+      const missing = (entry.record.skills || []).filter((rel) => {
+        const p = join19(entry.target, rel);
+        return !existsSync20(p) && !lstatTryIsSymlink(p);
+      });
+      if (missing.length > 0) {
+        console.log(
+          chalk8.yellow("  \u26A0") + ` ${entry.id}: ${t("doctor_cannbot_missing_skills").replace("{count}", String(missing.length))}`
+        );
+        warnings++;
+      }
+    }
+  }
+  for (const fileName of ["AGENTS.md", "CLAUDE.md"]) {
+    const filePath = join19(process.cwd(), fileName);
+    if (!existsSync20(filePath)) continue;
+    try {
+      const content = readFileSync14(filePath, "utf-8");
+      for (const entry of cannbotInstalled) {
+        const blocks = countMarkerBlocks(content, entry.id);
+        if (blocks > 1) {
+          console.log(
+            chalk8.yellow("  \u26A0") + ` ${fileName}: ${t("doctor_cannbot_marker_duplicate").replace("{plugin}", entry.id)}`
+          );
+          warnings++;
+        }
+      }
+      const starts = (content.match(/<!-- cannbot:[\w.-]+:start -->/g) || []).length;
+      const ends = (content.match(/<!-- cannbot:[\w.-]+:end -->/g) || []).length;
+      if (starts !== ends) {
+        console.log(
+          chalk8.yellow("  \u26A0") + ` ${fileName}: ${t("doctor_cannbot_marker_unpaired").replace("{start}", String(starts)).replace("{end}", String(ends))}`
+        );
+        warnings++;
+      }
+    } catch {
+    }
+  }
+  const orphans = findOrphanedDelegatedRecords();
+  for (const pluginId of orphans) {
+    console.log(
+      chalk8.yellow("  \u26A0") + ` ${t("doctor_cannbot_orphan_record").replace("{plugin}", pluginId)}`
+    );
+    warnings++;
+    if (options.fix) {
+      try {
+        unlinkSync7(join19(homedir3(), ".cannbot", "installs", `${pluginId}.json`));
+        fixes++;
+        console.log(chalk8.green("  \u2713") + ` ${t("doctor_fixed").replace("{count}", "1")}: ${pluginId}`);
+      } catch {
+      }
+    }
+  }
+  return { warnings, fixes };
+}
+function lstatTryIsSymlink(path) {
+  try {
+    return lstatSync3(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
 function checkBrokenLinks(dir) {
   let broken = 0;
   try {
-    const entries = readdirSync7(dir);
+    const entries = readdirSync10(dir);
     for (const entry of entries) {
-      const fullPath = join16(dir, entry);
+      const fullPath = join19(dir, entry);
       try {
-        const stats = lstatSync2(fullPath);
+        const stats = lstatSync3(fullPath);
         if (stats.isSymbolicLink()) {
-          if (!existsSync17(fullPath)) {
+          if (!existsSync20(fullPath)) {
             broken++;
           }
         }
@@ -4765,14 +5760,14 @@ function checkBrokenLinks(dir) {
 function fixBrokenLinks(dir) {
   let fixed = 0;
   try {
-    const entries = readdirSync7(dir);
+    const entries = readdirSync10(dir);
     for (const entry of entries) {
-      const fullPath = join16(dir, entry);
+      const fullPath = join19(dir, entry);
       try {
-        const stats = lstatSync2(fullPath);
+        const stats = lstatSync3(fullPath);
         if (stats.isSymbolicLink()) {
-          if (!existsSync17(fullPath)) {
-            unlinkSync5(fullPath);
+          if (!existsSync20(fullPath)) {
+            unlinkSync7(fullPath);
             fixed++;
           }
         }
@@ -4786,15 +5781,15 @@ function fixBrokenLinks(dir) {
 
 // src/commands/status.ts
 init_manifest();
-init_i18n();
 import chalk9 from "chalk";
+init_i18n();
 async function statusCommand() {
   const installed = scanInstalled();
-  const installedMap = new Map(installed.map((p) => [p.id, p]));
+  const cannbotInstalled = scanCannbotInstalled();
   console.log();
   console.log(chalk9.bold(`  ${t("status_title")}`));
   console.log();
-  if (installed.length === 0) {
+  if (installed.length === 0 && cannbotInstalled.length === 0) {
     console.log(chalk9.dim(`  ${t("status_none")}`));
     console.log(chalk9.dim(`  ${t("status_hint")}`));
     console.log();
@@ -4811,6 +5806,17 @@ async function statusCommand() {
     console.log(chalk9.dim(`    ${t("status_install_time")}: ${inst.installTime}`));
     console.log();
   }
+  for (const entry of cannbotInstalled) {
+    const versionSuffix = entry.version ? chalk9.dim(` v${entry.version}`) : "";
+    console.log(
+      chalk9.green("  \u2713") + ` ${entry.id}${versionSuffix}` + chalk9.magenta(" [cannbot]") + chalk9.dim(` (${entry.tool}, project)`)
+    );
+    console.log(
+      chalk9.dim(`    ${entry.skillsCount} skills, ${entry.agentsCount} agents`)
+    );
+    console.log(chalk9.dim(`    ${entry.target}`));
+    console.log();
+  }
 }
 
 // src/commands/install.ts
@@ -4823,7 +5829,15 @@ init_config();
 init_paths();
 import { confirm as confirm2 } from "@inquirer/prompts";
 import chalk10 from "chalk";
+function validateSource(source) {
+  if (!source) return void 0;
+  if (source !== "cannbot" && source !== "skills") {
+    throw new Error(t("error_invalid_source").replace("{source}", source).replace("{sources}", "cannbot, skills"));
+  }
+  return source;
+}
 async function installCommand(names, options) {
+  const source = validateSource(options.source);
   if (options.list) {
     try {
       const repoManager = createRepositoryManager();
@@ -4988,10 +6002,11 @@ async function installCommand(names, options) {
   } catch {
     scanSpinner.warn(t("loading_skills_list_failed"));
   }
+  await ensureCannbotDiscovery();
   const plugins = [];
   const skills = [];
   for (const name of names) {
-    const plugin = findPlugin(name);
+    const plugin = findPlugin(name, { source });
     if (plugin) {
       plugins.push(plugin.id);
       continue;
@@ -5005,7 +6020,8 @@ async function installCommand(names, options) {
     const allPlugins = getAllPlugins();
     logger.info(t("available_plugins") + ":");
     for (const p of allPlugins) {
-      logger.step(`  ${p.id} (${p.aliases.join(", ")})`);
+      const badge = p.source === "cannbot" ? chalk10.magenta(" [cannbot]") : "";
+      logger.step(`  ${p.id}${badge} (${p.aliases.join(", ")})`);
     }
     logger.info(`${t("available_skills")}: ${chalk10.cyan("install-helper install --list")}`);
     return;
@@ -5029,7 +6045,9 @@ async function installCommand(names, options) {
     const pluginsToInstall = [];
     const skippedPlugins = [];
     for (const pluginId of plugins) {
-      if (installedSet.has(pluginId) && !options.yes) {
+      const pluginEntry = findPlugin(pluginId, { source });
+      const alreadyInstalled = pluginEntry?.source === "cannbot" ? scanCannbotInstalled().some((e) => e.id === pluginId && e.tool === tool) : installedSet.has(pluginId);
+      if (alreadyInstalled && !options.yes) {
         const plugin = findPlugin(pluginId);
         const displayName = plugin?.displayName || pluginId;
         logger.warn(`${displayName} [${t("install_already_installed")}]`);
@@ -5066,7 +6084,8 @@ async function installCommand(names, options) {
         level,
         repoPath,
         void 0,
-        options.yes
+        options.yes,
+        source
       );
       const summary = results.map((result) => {
         const plugin = allPlugins.find((p) => p.id === result.pluginId);
@@ -5118,7 +6137,7 @@ async function installCommand(names, options) {
     logger.blank();
   }
 }
-async function installPlugins(pluginIds, tool, level, repoPath, installPath, yes) {
+async function installPlugins(pluginIds, tool, level, repoPath, installPath, yes, source) {
   const results = [];
   const total = pluginIds.length;
   for (let i = 0; i < pluginIds.length; i++) {
@@ -5126,13 +6145,16 @@ async function installPlugins(pluginIds, tool, level, repoPath, installPath, yes
     const progress = `[${i + 1}/${total}]`;
     const spinner = createSpinner(`${progress} ${t("install_progress")} ${pluginId}...`);
     spinner.start();
-    const result = await installPlugin({
+    const plugin = findPlugin(pluginId);
+    const result = await installPluginRouted({
       pluginId,
       tool,
       level,
       repoPath,
       installPath,
-      yes
+      yes,
+      plugin,
+      source
     });
     if (result.success) {
       spinner.succeed(
@@ -5142,6 +6164,9 @@ async function installPlugins(pluginIds, tool, level, repoPath, installPath, yes
     } else {
       spinner.fail(`${progress} ${pluginId} \u2014 ${result.errors.join(", ")}`);
     }
+    for (const warning of result.warnings || []) {
+      logger.warn(warning);
+    }
     results.push(result);
   }
   return results;
@@ -5149,8 +6174,8 @@ async function installPlugins(pluginIds, tool, level, repoPath, installPath, yes
 
 // src/commands/uninstall.ts
 init_registry();
-import { existsSync as existsSync18, unlinkSync as unlinkSync6, rmdirSync, readdirSync as readdirSync8, readFileSync as readFileSync11 } from "fs";
-import { resolve, basename as basename4, sep as sep2, join as join17 } from "path";
+import { existsSync as existsSync21, unlinkSync as unlinkSync8, rmdirSync as rmdirSync2, readdirSync as readdirSync11, readFileSync as readFileSync15 } from "fs";
+import { resolve as resolve3, basename as basename4, sep as sep3, join as join20 } from "path";
 import chalk11 from "chalk";
 import { select as select5, checkbox as checkbox2, Separator as Separator4, confirm as confirm3 } from "@inquirer/prompts";
 init_config();
@@ -5179,10 +6204,16 @@ async function uninstallCommand(names, options) {
     return;
   }
   const plugins = [];
+  const cannbotPlugins = [];
   const skills = [];
+  const cannbotInstalledIds = new Set(scanCannbotInstalled().map((e) => e.id));
   for (const name of names) {
+    if (cannbotInstalledIds.has(name)) {
+      cannbotPlugins.push(name);
+      continue;
+    }
     const plugin = findPlugin(name);
-    if (plugin) {
+    if (plugin && plugin.source !== "cannbot") {
       plugins.push(plugin.id);
       continue;
     }
@@ -5201,9 +6232,16 @@ async function uninstallCommand(names, options) {
     }
     logger.error(`${t("uninstall_not_found")}: ${name}`);
   }
+  await uninstallCannbotPlugins(cannbotPlugins);
   await uninstallPlugins(plugins, options.yes || false);
   await uninstallSkillsByName(skills, tool, level);
 }
+async function uninstallCannbotPlugins(pluginIds) {
+  for (const pluginId of pluginIds) {
+    logger.info(`${t("uninstall_in_progress")} ${pluginId}...`);
+    await uninstallCannbotPluginById(pluginId);
+  }
+}
 function isRecordedSkill(skillId) {
   const record = readSkillRecord();
   for (const toolName of Object.keys(record)) {
@@ -5221,12 +6259,13 @@ async function uninstallAll(tool, level, yes) {
   const installPath = level === "project" ? process.cwd() : getConfigRoot(tool, level);
   const installedSkills = getInstalledSkills(tool, level, installPath, !yes);
   const installedPlugins = scanInstalled().filter((p) => p.tool === tool && p.level === level);
-  const totalItems = installedSkills.length + installedPlugins.length;
+  const cannbotInstalled = level === "project" ? scanCannbotInstalled().filter((e) => e.tool === tool) : [];
+  const totalItems = installedSkills.length + installedPlugins.length + cannbotInstalled.length;
   if (totalItems === 0) {
     logger.warn(t("uninstall_no_installed"));
     return;
   }
-  logger.info(t("uninstall_all_summary").replace("{skills}", String(installedSkills.length)).replace("{plugins}", String(installedPlugins.length)));
+  logger.info(t("uninstall_all_summary").replace("{skills}", String(installedSkills.length)).replace("{plugins}", String(installedPlugins.length + cannbotInstalled.length)));
   logger.blank();
   for (const s of installedSkills) {
     logger.step(`  \u2022 ${chalk11.cyan(s)}`);
@@ -5234,6 +6273,9 @@ async function uninstallAll(tool, level, yes) {
   for (const p of installedPlugins) {
     logger.step(`  \u2022 ${chalk11.cyan(p.displayName)} ${chalk11.dim(`(${p.id})`)}`);
   }
+  for (const c of cannbotInstalled) {
+    logger.step(`  \u2022 ${chalk11.cyan(c.id)} ${chalk11.magenta("[cannbot]")}`);
+  }
   logger.blank();
   if (!yes) {
     const confirmed = await confirm3({
@@ -5249,6 +6291,9 @@ async function uninstallAll(tool, level, yes) {
     logger.info(`${t("uninstall_skills_in_progress")} ${t("skill_count_format").replace("{count}", String(installedSkills.length))}...`);
     await uninstallSkills(installedSkills, tool, level);
   }
+  for (const entry of cannbotInstalled) {
+    await uninstallCannbotPluginById(entry.id);
+  }
   if (installedPlugins.length > 0) {
     logger.info(`${t("uninstall_plugin_batch_progress").replace("{count}", String(installedPlugins.length))}...`);
     for (const inst of installedPlugins) {
@@ -5259,6 +6304,18 @@ async function uninstallAll(tool, level, yes) {
   logger.success(t("uninstall_all_done"));
   logger.blank();
 }
+async function uninstallCannbotPluginById(pluginId) {
+  const result = uninstallCannbotPlugin(pluginId);
+  if (result.success) {
+    logger.success(
+      t("uninstall_summary_format").replace("{name}", pluginId).replace("{files}", String(result.removedFiles)).replace("{dirs}", String(result.removedDirs))
+    );
+  } else {
+    for (const error of result.errors) {
+      logger.error(`${pluginId}: ${error}`);
+    }
+  }
+}
 async function uninstallRecent(tool, level, yes) {
   const installPath = level === "project" ? process.cwd() : getConfigRoot(tool, level);
   const lastBatch = getLastBatchSkills(tool, level, installPath);
@@ -5399,7 +6456,8 @@ async function interactiveSkillUninstall(tool, level) {
 }
 async function interactivePluginUninstall(tool, level) {
   const installed = scanInstalled().filter((p) => p.tool === tool && p.level === level);
-  if (installed.length === 0) {
+  const cannbotInstalled = level === "project" ? scanCannbotInstalled().filter((e) => e.tool === tool) : [];
+  if (installed.length === 0 && cannbotInstalled.length === 0) {
     logger.warn(t("uninstall_no_installed_plugins"));
     return;
   }
@@ -5409,6 +6467,12 @@ async function interactivePluginUninstall(tool, level) {
       value: inst.id,
       checked: false,
       description: `${inst.skillsCount} skills, ${inst.agentsCount} agents`
+    })),
+    ...cannbotInstalled.map((entry) => ({
+      name: `${chalk11.cyan(entry.id)} ${chalk11.magenta("[cannbot]")}`,
+      value: entry.id,
+      checked: false,
+      description: `${entry.skillsCount} skills, ${entry.agentsCount} agents`
     }))
   ];
   printBoxTitle(t("uninstall_interactive_title"));
@@ -5423,21 +6487,29 @@ async function interactivePluginUninstall(tool, level) {
     theme: checkboxTheme,
     pageSize: 15
   });
-  const toUninstall = installed.filter((inst) => selected.includes(inst.id));
-  if (toUninstall.length === 0) {
+  const toUninstallLegacy = installed.filter((inst) => selected.includes(inst.id));
+  const toUninstallCannbot = cannbotInstalled.filter((entry) => selected.includes(entry.id));
+  if (toUninstallLegacy.length === 0 && toUninstallCannbot.length === 0) {
     logger.info(t("uninstall_nothing_to_uninstall"));
     return;
   }
   const confirmed = await confirm3({
-    message: t("uninstall_confirm_prompt").replace("{count}", chalk11.bold(String(toUninstall.length))),
+    message: t("uninstall_confirm_prompt").replace(
+      "{count}",
+      chalk11.bold(String(toUninstallLegacy.length + toUninstallCannbot.length))
+    ),
     default: false
   });
   if (!confirmed) {
     logger.info(t("init_cancelled"));
     return;
   }
-  logger.info(`${t("uninstall_plugin_batch_progress").replace("{count}", String(toUninstall.length))}...`);
-  for (const inst of toUninstall) {
+  const totalCount = toUninstallLegacy.length + toUninstallCannbot.length;
+  logger.info(`${t("uninstall_plugin_batch_progress").replace("{count}", String(totalCount))}...`);
+  for (const entry of toUninstallCannbot) {
+    await uninstallCannbotPluginById(entry.id);
+  }
+  for (const inst of toUninstallLegacy) {
     await uninstallPluginById(inst.id, true);
   }
   logger.blank();
@@ -5472,11 +6544,11 @@ async function uninstallPluginById(pluginId, batchMode) {
     for (const toolName of VALID_TOOLS) {
       for (const lvl of ["project", "global"]) {
         const configRoot2 = getConfigRoot(toolName, lvl);
-        const manifestPath = join17(configRoot2, `${pluginId}-manifest.json`);
-        if (!existsSync18(manifestPath)) continue;
+        const manifestPath = join20(configRoot2, `${pluginId}-manifest.json`);
+        if (!existsSync21(manifestPath)) continue;
         let manifest = null;
         try {
-          manifest = JSON.parse(readFileSync11(manifestPath, "utf-8"));
+          manifest = JSON.parse(readFileSync15(manifestPath, "utf-8"));
         } catch {
           continue;
         }
@@ -5504,29 +6576,29 @@ async function uninstallPluginById(pluginId, batchMode) {
   }
   logger.info(`${t("uninstall_in_progress")} ${plugin.displayName}...`);
   const configRoot = getConfigRoot(record.tool, record.level);
-  const allowedBases = [resolve(configRoot), resolve(record.installPath)];
+  const allowedBases = [resolve3(configRoot), resolve3(record.installPath)];
   if (record.tool === "codex") {
-    allowedBases.push(resolve(getSkillsRoot(record.tool, record.level, record.installPath)));
+    allowedBases.push(resolve3(getSkillsRoot(record.tool, record.level, record.installPath)));
   }
   const isSafePath = (p) => {
-    const resolved = resolve(p);
-    return allowedBases.some((base) => resolved === base || resolved.startsWith(base + sep2));
+    const resolved = resolve3(p);
+    return allowedBases.some((base) => resolved === base || resolved.startsWith(base + sep3));
   };
   let removedFiles = 0;
   let removedDirs = 0;
   const configFileName = record.tool === "claude" ? "CLAUDE.md" : "AGENTS.md";
-  const configRootConfigPath = join17(configRoot, configFileName);
-  const installPathConfigPath = join17(record.installPath, configFileName);
+  const configRootConfigPath = join20(configRoot, configFileName);
+  const installPathConfigPath = join20(record.installPath, configFileName);
   const extraFiles = [];
-  if (record.level === "project" && configRootConfigPath !== installPathConfigPath && !record.files.includes(configRootConfigPath) && (existsSync18(configRootConfigPath) || isSymlink(configRootConfigPath))) {
+  if (record.level === "project" && configRootConfigPath !== installPathConfigPath && !record.files.includes(configRootConfigPath) && (existsSync21(configRootConfigPath) || isSymlink(configRootConfigPath))) {
     extraFiles.push(configRootConfigPath);
   }
   const allFiles = [...record.files, ...extraFiles];
   for (const filePath of allFiles) {
     if (!isSafePath(filePath)) continue;
     try {
-      if (existsSync18(filePath) || isSymlink(filePath)) {
-        unlinkSync6(filePath);
+      if (existsSync21(filePath) || isSymlink(filePath)) {
+        unlinkSync8(filePath);
         const name = basename4(filePath);
         logger.step(`  ${t("uninstall_remove_label")}: ${name}`);
         removedFiles++;
@@ -5537,13 +6609,13 @@ async function uninstallPluginById(pluginId, batchMode) {
   const sortedDirs = [...record.directories].filter(isSafePath).sort((a, b) => b.length - a.length);
   for (const dirPath of sortedDirs) {
     try {
-      if (resolve(dirPath) === resolve(configRoot)) {
+      if (resolve3(dirPath) === resolve3(configRoot)) {
         continue;
       }
-      if (existsSync18(dirPath)) {
-        const entries = readdirSync8(dirPath);
+      if (existsSync21(dirPath)) {
+        const entries = readdirSync11(dirPath);
         if (entries.length === 0) {
-          rmdirSync(dirPath);
+          rmdirSync2(dirPath);
           const name = basename4(dirPath);
           logger.step(`  ${t("uninstall_clean_empty_dir")}: ${name}/`);
           removedDirs++;
@@ -5554,9 +6626,9 @@ async function uninstallPluginById(pluginId, batchMode) {
   }
   if (record.tool === "codex") {
     try {
-      const agentsRoot = resolve(getSkillsRoot(record.tool, record.level, record.installPath), "..");
-      if (existsSync18(agentsRoot) && readdirSync8(agentsRoot).length === 0) {
-        rmdirSync(agentsRoot);
+      const agentsRoot = resolve3(getSkillsRoot(record.tool, record.level, record.installPath), "..");
+      if (existsSync21(agentsRoot) && readdirSync11(agentsRoot).length === 0) {
+        rmdirSync2(agentsRoot);
         logger.step(`  ${t("uninstall_clean_empty_dir")}: ${basename4(agentsRoot)}/`);
         removedDirs++;
       }
@@ -5628,15 +6700,20 @@ async function updateCommand(pluginNames, options) {
     updateSpinner.fail(t("repo_clone_failed").replace("{error}", error instanceof Error ? error.message : t("error_unknown")).replace("{url}", "").replace("{dir}", ""));
     return;
   }
+  await ensureCannbotDiscovery();
   const installed = scanInstalled();
+  const cannbotInstalled = scanCannbotInstalled();
   let targets = [];
   if (pluginNames.length === 0) {
-    if (installed.length === 0) {
+    if (installed.length === 0 && cannbotInstalled.length === 0) {
       logger.info(t("update_no_plugins"));
       logger.info(t("update_install_hint").replace("{cmd}", chalk12.cyan("install-helper install <plugin>")));
       return;
     }
-    targets = installed.map((p) => ({ pluginId: p.id, tool: p.tool, level: p.level }));
+    targets = [
+      ...installed.map((p) => ({ pluginId: p.id, tool: p.tool, level: p.level, source: "skills" })),
+      ...cannbotInstalled.map((e) => ({ pluginId: e.id, tool: e.tool, level: "project", source: "cannbot" }))
+    ];
   } else {
     let defaultTool;
     let defaultLevel;
@@ -5647,20 +6724,25 @@ async function updateCommand(pluginNames, options) {
       defaultLevel = validateLevel(options.level);
     }
     for (const name of pluginNames) {
+      const cannbotMatches = cannbotInstalled.filter((e) => e.id === name);
       const plugin = findPlugin(name);
-      if (!plugin) {
+      if (cannbotMatches.length === 0 && !plugin) {
         logger.error(`${t("error_plugin_not_found")}: ${name}`);
         continue;
       }
-      const installedForPlugin = installed.filter((p) => p.id === plugin.id);
-      if (installedForPlugin.length > 0) {
-        for (const inst of installedForPlugin) {
-          if (defaultTool && inst.tool !== defaultTool) continue;
-          if (defaultLevel && inst.level !== defaultLevel) continue;
-          targets.push({ pluginId: plugin.id, tool: inst.tool, level: inst.level });
+      const legacyMatches = cannbotMatches.length === 0 && plugin && plugin.source !== "cannbot" ? installed.filter((p) => p.id === plugin.id) : [];
+      const matches = [
+        ...cannbotMatches.map((e) => ({ pluginId: e.id, tool: e.tool, level: "project", source: "cannbot" })),
+        ...legacyMatches.map((p) => ({ pluginId: p.id, tool: p.tool, level: p.level, source: "skills" }))
+      ];
+      if (matches.length > 0) {
+        for (const match of matches) {
+          if (defaultTool && match.tool !== defaultTool) continue;
+          if (defaultLevel && match.level !== defaultLevel) continue;
+          targets.push(match);
         }
       } else {
-        logger.warn(`${plugin.displayName} ${t("error_not_installed")}, ${t("update_skipped")}`);
+        logger.warn(`${plugin?.displayName || name} ${t("error_not_installed")}, ${t("update_skipped")}`);
       }
     }
   }
@@ -5668,6 +6750,18 @@ async function updateCommand(pluginNames, options) {
     logger.info(t("update_no_plugins"));
     return;
   }
+  if (targets.some((target) => target.source === "cannbot")) {
+    try {
+      await ensureCannbotInstaller({ force: true });
+    } catch (error) {
+      logger.warn(
+        t("cannbot_installer_failed").replace(
+          "{error}",
+          error instanceof Error ? error.message : t("error_unknown")
+        )
+      );
+    }
+  }
   const allPlugins = getAllPlugins();
   const results = [];
   const total = targets.length;
@@ -5678,12 +6772,14 @@ async function updateCommand(pluginNames, options) {
     const progress = `[${i + 1}/${total}]`;
     const pluginSpinner = createSpinner(`${progress} ${t("update_updating")} ${displayName}...`);
     pluginSpinner.start();
-    const result = await installPlugin({
+    const result = await installPluginRouted({
       pluginId: target.pluginId,
       tool: target.tool,
       level: target.level,
       repoPath,
-      yes: options.yes
+      yes: options.yes,
+      plugin,
+      source: target.source
     });
     if (result.success) {
       pluginSpinner.succeed(
@@ -5694,6 +6790,9 @@ async function updateCommand(pluginNames, options) {
         `${progress} ${displayName} \u2014 ${result.errors.join(", ")}`
       );
     }
+    for (const warning of result.warnings || []) {
+      logger.warn(warning);
+    }
     results.push(result);
   }
   const summary = results.map((result) => {
@@ -5713,8 +6812,8 @@ async function updateCommand(pluginNames, options) {
 // src/commands/info.ts
 init_registry();
 import chalk13 from "chalk";
-import { existsSync as existsSync19, readdirSync as readdirSync9 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync12 } from "fs";
+import { join as join21 } from "path";
 init_manifest();
 init_i18n();
 async function infoCommand(pluginName) {
@@ -5725,29 +6824,42 @@ async function infoCommand(pluginName) {
   }
   const installed = scanInstalled();
   const inst = installed.find((p) => p.id === plugin.id);
-  const isInstalled = !!inst;
+  const cannbotEntry = plugin.source === "cannbot" ? scanCannbotInstalled().find((e) => e.id === plugin.id) : void 0;
+  const isInstalled = !!inst || !!cannbotEntry;
   const statusText = isInstalled ? chalk13.green(`\u2713 ${t("status_installed")}`) : chalk13.dim(`\u2014 ${t("status_not_installed")}`);
   console.log();
   console.log(chalk13.bold(`  ${plugin.displayName}`));
+  if (plugin.source === "cannbot") {
+    console.log(chalk13.magenta("  [cannbot]") + chalk13.dim(` v${plugin.version || "?"}`));
+  }
   console.log(chalk13.dim("  " + "\u2500".repeat(40)));
   console.log();
   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") + ":")} ${inst ? inst.skillsCount : plugin.skills}`);
-  console.log(`  ${chalk13.dim(t("info_agents") + ":")} ${inst ? inst.agentsCount : plugin.agents}`);
-  console.log(`  ${chalk13.dim(t("info_aliases") + ":")} ${plugin.aliases.join(", ")}`);
+  console.log(`  ${chalk13.dim(t("info_skills") + ":")} ${inst || cannbotEntry ? cannbotEntry?.skillsCount ?? inst?.skillsCount : plugin.skills}`);
+  console.log(`  ${chalk13.dim(t("info_agents") + ":")} ${inst || cannbotEntry ? cannbotEntry?.agentsCount ?? inst?.agentsCount : plugin.agents}`);
+  if (plugin.source !== "cannbot") {
+    console.log(`  ${chalk13.dim(t("info_aliases") + ":")} ${plugin.aliases.join(", ")}`);
+  }
   console.log();
+  if (plugin.source === "cannbot") {
+    if (cannbotEntry) {
+      console.log(`  ${chalk13.dim(t("info_source") + ":")} ${cannbotEntry.registryPath}`);
+    }
+    console.log();
+    return;
+  }
   try {
     const repoManager = createRepositoryManager();
     const repoPath = await repoManager.ensureRepo();
-    const quickstartPath = join18(repoPath, plugin.dir, "quickstart.md");
-    if (existsSync19(quickstartPath)) {
+    const quickstartPath = join21(repoPath, plugin.dir, "quickstart.md");
+    if (existsSync22(quickstartPath)) {
       console.log(`  ${chalk13.dim(t("info_quickstart") + ":")} ${quickstartPath}`);
     }
-    const agentsDir = join18(repoPath, plugin.dir, "agents");
-    if (existsSync19(agentsDir)) {
-      const agentFiles = readdirSync9(agentsDir).filter((f) => f.endsWith(".md"));
+    const agentsDir = join21(repoPath, plugin.dir, "agents");
+    if (existsSync22(agentsDir)) {
+      const agentFiles = readdirSync12(agentsDir).filter((f) => f.endsWith(".md"));
       if (agentFiles.length > 0) {
         console.log();
         console.log(`  ${chalk13.bold("Agents:")}`);
@@ -5802,9 +6914,9 @@ async function langCommand(action, value) {
 // src/cli.ts
 init_config();
 init_i18n();
-import { readFileSync as readFileSync12, existsSync as existsSync20 } from "fs";
-import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname6, join as join19 } from "path";
+import { readFileSync as readFileSync16, existsSync as existsSync23 } from "fs";
+import { fileURLToPath as fileURLToPath5 } from "url";
+import { dirname as dirname8, join as join22 } from "path";
 function readVersion() {
   try {
     if (typeof INSTALL_HELPER_VERSION !== "undefined" && INSTALL_HELPER_VERSION) {
@@ -5813,16 +6925,16 @@ function readVersion() {
   } catch {
   }
   try {
-    const __filename4 = fileURLToPath4(import.meta.url);
-    const __dirname4 = dirname6(__filename4);
+    const __filename5 = fileURLToPath5(import.meta.url);
+    const __dirname5 = dirname8(__filename5);
     const candidates = [
-      join19(__dirname4, "..", "package.json"),
-      join19(__dirname4, "package.json"),
-      join19(process.cwd(), "package.json")
+      join22(__dirname5, "..", "package.json"),
+      join22(__dirname5, "package.json"),
+      join22(process.cwd(), "package.json")
     ];
     for (const pkgPath of candidates) {
-      if (existsSync20(pkgPath)) {
-        const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
+      if (existsSync23(pkgPath)) {
+        const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
         if (pkg.version && (pkg.name === "@cannbot-ai/install-helper" || pkg.name?.startsWith("@cannbot-ai/install-helper-"))) {
           return pkg.version;
         }
@@ -5852,7 +6964,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, codex, copilot, codearts)").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) => {
+  program2.command("install [names...]").description("Install plugins or skills (auto-detects type)").option("-t, --tool <tool>", "AI tool (opencode, claude, trae, cursor, codex, copilot, codearts)").option("-l, --level <level>", "Install level (project, global)", "project").option("-s, --source <source>", "Plugin source for same-name plugins (cannbot, skills)").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, codex, copilot, codearts)").option("-l, --level <level>", "Install level (project, global)", "project").option("-y, --yes", "Skip confirmation prompts").option("-a, --all", "Uninstall ALL installed skills and plugins").option("--recent", "Uninstall the most recently installed skill batch").action(async (names, options) => {