@yottameta/yotta-skills-plugin 0.24.1 → 0.25.0

package/.agents/plugins/marketplace.json

@@ -12,7 +12,7 @@
         "authentication": "ON_INSTALL"
       },
       "category": "Developer Tools",
-      "version": "0.24.1",
+      "version": "0.25.0",
       "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
       "interface": {
         "displayName": "元阁 yotta-skills",

package/.claude-plugin/marketplace.json

@@ -12,7 +12,7 @@
         "authentication": "ON_INSTALL"
       },
       "category": "Developer Tools",
-      "version": "0.24.1",
+      "version": "0.25.0",
       "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
       "interface": {
         "displayName": "元阁 yotta-skills",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-skills-plugin",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "YuanGe (元阁) — orchestration and routing for the YottaMeta skill family, packaged as a YottaMeta Agent Plugin and DeepSeek Harness profile bundle.",
   "license": "MIT",
   "keywords": [

package/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
   "name": "yotta-skills",
-  "version": "0.24.1",
+  "version": "0.25.0",
   "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
   "author": {
     "name": "YottaMeta",

package/skills/yotta-skills/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: yotta-skills
-version: 0.24.1
-description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点 + 运行时 hook 适配。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；M1 记忆裁决层：usage enable/mark 本地结构化记录 + decide-memory / MCP decide_memory 输出 promote / hold / demote 只读建议（需授权 provider；只建议不删除、不自动写元忆）；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么组合使用（安装与调用均由用户确认后执行）」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录（默认 --pin 锁死清单精确版本）；盘点层：--inventory / --reindex 扫描本机已装技能生成/更新注册表，新装技能自动被发现（install/update 后自动 re-index，会话开工只建议跑本地 --reindex；更新检查走手动 --check 或后台 --check --scheduled）；运行时适配层：hook capabilities / evaluate / bind / unbind 按宿主能力矩阵执行六个统一事件并留证降级，元信 before_install 已接入安装管线；自包含零依赖，不依赖任何元技能；MCP 按需加载且需用户确认后写入配置（可选：list_installed_skills/describe_skill/reindex/route_request/decide_memory，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / usage 使用记录 / decide-memory 记忆裁决 / install / update / update --check（只读检查）/ update --check --scheduled（后台周检）/ update --auto（家族自动更新）/ hook 适配 / --inventory / --reindex / --dry-run 预览 / --pin（默认）/ --range。触发：需要批量安装或更新元阁全家技能、按场景组合多个元技能、路由或判断该用哪些技能、判断哪些技能值得长期记忆、查看或记录技能使用信号、盘点或查看本机已装技能、重扫技能注册表、给某个智能体或目录一次性铺齐 yotta-* 技能、评估宿主 hook 能力、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/检查更新/自动更新/hook 适配/该用哪个技能/路由技能/记忆裁决/技能该不该记住/盘点技能/查看已装技能 等。边界（Do NOT trigger）：只做「组合策划 + 静态路由建议 + M1 记忆裁决只读建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index + hook 适配」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能、不静默写宿主配置或全局记忆、不自动删除技能或记忆；家族安装先自举或调用元信装前门禁，DO NOT INSTALL 阻断，非元阁家族包不自动安装。
+version: 0.25.0
+description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点 + 本机技能 Hub + 运行时 hook 适配。Hub 层：hub hosts 只读发现本机已装智能体与技能目录（文件系统优先，不读元忆）；hub install / update 把技能装到 ~/.yottaskills/hub 单点真源；hub link --all 用 Windows junction / POSIX symlink 分发到全部已发现宿主；hub unlink 只删链接、fail-closed；hub status 显示来源、版本、链接与异常；兼容 agentskills.io 技能格式、Vercel Labs skills CLI 的 .agents/skills 通用目录与 .skill-lock.json v3（只读）。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；M1 记忆裁决层：usage enable/mark 本地结构化记录 + decide-memory / MCP decide_memory 输出 promote / hold / demote 只读建议（需授权 provider；只建议不删除、不自动写元忆）；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么组合使用（安装与调用均由用户确认后执行）」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录（默认 --pin 锁死清单精确版本）；盘点层：--inventory / --reindex 扫描本机已装技能生成/更新注册表，新装技能自动被发现（install/update 后自动 re-index，会话开工只建议跑本地 --reindex；更新检查走手动 --check 或后台 --check --scheduled）；运行时适配层：hook capabilities / evaluate / bind / unbind 按宿主能力矩阵执行六个统一事件并留证降级，元信 before_install 已接入安装管线；自包含零依赖，不依赖任何元技能；MCP 按需加载且需用户确认后写入配置（可选：list_installed_skills/describe_skill/reindex/route_request/decide_memory，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / usage 使用记录 / decide-memory 记忆裁决 / hub 技能 Hub / install / update / update --check（只读检查）/ update --check --scheduled（后台周检）/ update --auto（家族自动更新）/ hook 适配 / --inventory / --reindex / --dry-run 预览 / --pin（默认）/ --range。触发：需要批量安装或更新元阁全家技能、单点安装并分发到多个智能体、查看本机装了哪些智能体与技能目录、接管非元技能、按场景组合多个元技能、路由或判断该用哪些技能、判断哪些技能值得长期记忆、查看或记录技能使用信号、盘点或查看本机已装技能、重扫技能注册表、给某个智能体或目录一次性铺齐 yotta-* 技能、评估宿主 hook 能力、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/检查更新/自动更新/hook 适配/该用哪个技能/路由技能/记忆裁决/技能该不该记住/盘点技能/查看已装技能/技能 Hub/单点安装/链接分发/接管技能 等。边界（Do NOT trigger）：只做「组合策划 + 静态路由建议 + M1 记忆裁决只读建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index + Hub 本机真源与链接分发 + hook 适配」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能、不静默写宿主配置或全局记忆、不自动删除技能或记忆；家族安装先自举或调用元信装前门禁，DO NOT INSTALL 阻断，非元阁家族包不自动安装。
 license: MIT
 metadata:
   zh_name: 元阁
@@ -154,6 +154,38 @@ openclaw skills update @yottameta/yotta-skills
 > **OpenClaw / QClaw 用户**：技能安装与更新走宿主官方命令 `openclaw skills install|update @yottameta/<slug>`，
 > 以保留宿主的 ClawHub 安全审计卡与更新追踪；元阁的 `--inventory` / `--reindex` 已能识别 `~/.openclaw/skills`（含 `OPENCLAW_STATE_DIR` 覆盖）。
 
+## 技能 Hub（单点安装 + 链接分发）
+
+Hub 把「每个宿主装一份」改成「本机一份真源，按宿主链接分发」。默认真源
+`~/.yottaskills/hub`，可用 `--hub <dir>` 或 `YOTTA_SKILLS_HUB` 覆盖。
+
+```bash
+# 1) 只读发现本机已装智能体与技能目录（文件系统 + 环境变量；不读元忆 / 注册表）
+npx -y @yottameta/yotta-skills hub hosts
+
+# 2) 把元技能装进 Hub 真源（复用安装管线 + 元信装前扫描）
+npx -y @yottameta/yotta-skills hub install
+
+# 3) 接管各宿主现有技能：先只读预演，再复制收编（原目录保留）
+npx -y @yottameta/yotta-skills hub adopt --scan
+npx -y @yottameta/yotta-skills hub adopt --apply
+
+# 4) 链接分发到全部已发现宿主（Windows junction / macOS·Linux symlink）
+npx -y @yottameta/yotta-skills hub link --all
+
+# 5) 查看来源、版本、链接宿主与异常
+npx -y @yottameta/yotta-skills hub status
+npx -y @yottameta/yotta-skills hub doctor
+
+# 只删链接，不动 Hub 真源（真目录 / 外部链接一律拒绝）
+npx -y @yottameta/yotta-skills hub unlink --all
+```
+
+宿主发现兼容 `agentskills.io` 技能格式与 Vercel Labs `skills` CLI 的
+`.agents/skills` 通用目录；已收录 79 条宿主映射，并只读兼容
+`.skill-lock.json` v3（`$XDG_STATE_HOME/skills/` 或 `~/.agents/`）。
+不读元忆，不重写官方锁文件，不静默降级为复制。
+
 ## 命令与选项
 
 | 命令 / 选项 | 作用 |
@@ -174,6 +206,15 @@ openclaw skills update @yottameta/yotta-skills
 | `hook bind --host <name> --manifest <file>` | 幂等注册 hook 声明；`hook unbind <id>` 反注册 |
 | `--inventory` | 盘点本机已装技能：扫描技能目录生成/更新注册表（自包含，不依赖元技能）；`--json` 输出 JSON、`--project` 附扫项目级目录 |
 | `--reindex` | 重扫注册表：扫描技能目录并增量合并变化（install / update 完成后 CLI 自动重扫；也可在会话开工等时机手动运行）；`--json` 输出 JSON、`--project` 附扫项目级目录；`--rescan` 同义 |
+| `hub hosts` | 发现本机已装智能体与技能目录（文件系统 + 环境变量；不读元忆 / 注册表）；`--json` 输出 JSON |
+| `hub install [skill...]` | 把元技能安装到 Hub 真源（默认 `~/.yottaskills/hub`；`--hub` / `YOTTA_SKILLS_HUB` 覆盖） |
+| `hub adopt --scan` | 只读预演：扫描各宿主现有技能，输出收编候选、多副本冲突、已在 Hub 状态 |
+| `hub adopt --apply [--include <a,b>] [--force] [--in-place]` | 把选中技能收编进 Hub；默认复制保真 + 原目录保留；非元阁来源标注「无更新源」 |
+| `hub refresh <slug> --from <path>` | 手动同步非元阁技能（重新收编 + 更新哈希 + 台账） |
+| `hub link --agent <id> \| --dir <dir> \| --all` | 把 Hub 技能链接到指定宿主 / 目录 / 全部已发现宿主；`--dry-run` 只预览 |
+| `hub unlink --agent <id> \| --dir <dir> \| --all` | 只删除链接；lstat + readlink 校验目标在 Hub 内，fail-closed |
+| `hub status [--json]` | 查看 Hub 技能来源、版本、链接宿主、异常链接与宿主发现摘要 |
+| `hub doctor [--json]` | 检查断链 / Hub 目标缺失 / slug 不一致 / 目录权限；异常时退出码 1 |
 | `--route <需求摘要>` | 编排路由：输出组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装建议；可选本地 provider 增补 / 重排并返回 `confidence` / `reasons` / `summary` / `alternatives`；`--json` 输出 JSON、`--project` 附扫项目级目录 |
 | `usage status` | 查看本地使用记录开关与计数；默认关闭，不创建文件 |
 | `usage enable` / `usage disable` | 开启 / 关闭 `--route` 的结构化使用记录；不记录需求原文 |

package/skills/yotta-skills/bin/yotta-skills.js

@@ -45,11 +45,15 @@ const routeDynamicLib = require('../lib/route-dynamic');
 const depsLib = require('../lib/deps');
 const untarLib = require('../lib/untar');
 const registryFetchLib = require('../lib/registry-fetch');
+const agentDirsLib = require('../lib/agent-dirs');
+const agentDiscoveryLib = require('../lib/agent-discovery');
+const hubLib = require('../lib/hub');
+const hubAdoptLib = require('../lib/hub-adopt');
 const { createInstaller, isSafeTarEntry } = require('../lib/install-pipeline');
 const { COPY_SKIP, copyDir } = require('../lib/copy-tree');
 
 const PKG_ROOT = path.join(__dirname, '..');
-let VERSION = '0.24.1';
+let VERSION = '0.25.0';
 try { VERSION = require(path.join(PKG_ROOT, 'package.json')).version; } catch (_) { /* keep fallback */ }
 
 function loadManifest() {
@@ -72,39 +76,18 @@ function loadManifest() {
 
 const MANIFEST = loadManifest();
 
-// 智能体 -> 用户级默认技能目录（与各技能 install.js 同源；.agents/skills 并非通用目录）
-const AGENT_DIRS = {
-  claude:    { label: 'Claude Code',      dirs: ['.claude/skills'] },
-  cursor:    { label: 'Cursor',           dirs: ['.cursor/skills', '.agents/skills'] },
-  codex:     { label: 'Codex',            dirs: ['.codex/skills'] }, // 特判：$CODEX_HOME/skills
-  gemini:    { label: 'Gemini CLI',       dirs: ['.gemini/skills', '.agents/skills'] },
-  goose:     { label: 'Goose',            dirs: ['.config/goose/skills', '.agents/skills'] },
-  amp:       { label: 'Amp',              dirs: ['.config/agents/skills', '.agents/skills'] },
-  opencode:  { label: 'OpenCode',         dirs: ['.config/opencode/skills'] }, // 特判：$XDG_CONFIG_HOME
-  windsurf:  { label: 'Windsurf',         dirs: ['.codeium/windsurf/skills'] },
-  workbuddy: { label: 'WorkBuddy',        dirs: ['.workbuddy/skills'] },
-  kiro:      { label: 'Kiro',             dirs: ['.kiro/skills'] },
-  trae:      { label: 'Trae Code CLI',    dirs: ['.traecli/skills'] },
-  'trae-cn': { label: 'Trae IDE（国内）',  dirs: ['.trae-cn/skills'] },
-  qwen:      { label: 'Qwen Code',        dirs: ['.qwen/skills'] },
-  comate:    { label: 'Comate 文心快码',   dirs: ['.comate/skills'] },
-  codebuddy: { label: 'CodeBuddy Code',   dirs: ['.codebuddy/skills'] },
-  kimi:      { label: 'Kimi Code CLI',    dirs: ['.kimi/skills'] },
-  agents:    { label: '通用 AGENTS.md',    dirs: ['.agents/skills'] },
-};
+// 智能体 -> 用户级默认技能目录。单一真源在 lib/agent-dirs.js
+// （兼容 Vercel Labs `skills` CLI / agentskills.io 的宿主表，MIT）。
+const AGENT_DIRS = agentDirsLib.AGENT_DIRS;
 
 function codexUserDir() {
-  const base = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-  return path.join(base, 'skills');
+  return agentDirsLib.resolveUserDir('.codex/skills', { homeDir: os.homedir(), env: process.env });
 }
 function opencodeUserDir() {
-  const base = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-  return path.join(base, 'opencode', 'skills');
+  return agentDirsLib.resolveUserDir('.config/opencode/skills', { homeDir: os.homedir(), env: process.env });
 }
 function resolveUserDir(rel) {
-  if (rel === '.codex/skills') return codexUserDir();
-  if (rel === '.config/opencode/skills') return opencodeUserDir();
-  return path.join(os.homedir(), rel);
+  return agentDirsLib.resolveUserDir(rel, { homeDir: os.homedir(), env: process.env });
 }
 
 // ── 工具函数 ───────────────────────────────────────────────────────────────
@@ -170,6 +153,9 @@ function parseArgs(argv) {
     host: null, event: null, manifest: null, context: null,
     signal: null, yes: false, explain: false, promote: false,
     only: [], domain: null, installedOnly: false,
+    hub: null, all: false, inPlace: false, allowUnverified: false,
+    from: null, include: [], as: null, skillsCli: null,
+    scan: false, apply: false,
   };
   const positionals = [];
   for (let i = 0; i < argv.length; i++) {
@@ -219,6 +205,22 @@ function parseArgs(argv) {
     }
     else if (a === '--domain') opts.domain = take('--domain').toLowerCase();
     else if (a === '--installed-only') opts.installedOnly = true;
+    else if (a === '--hub') opts.hub = take('--hub');
+    else if (a === '--all') opts.all = true;
+    else if (a === '--in-place') opts.inPlace = true;
+    else if (a === '--scan') opts.scan = true;
+    else if (a === '--apply') opts.apply = true;
+    else if (a === '--allow-unverified') opts.allowUnverified = true;
+    else if (a === '--from') opts.from = take('--from');
+    else if (a === '--include') {
+      const value = take('--include');
+      for (const item of value.split(',')) {
+        const slug = item.trim().toLowerCase();
+        if (slug) opts.include.push(slug);
+      }
+    }
+    else if (a === '--as') opts.as = take('--as').toLowerCase();
+    else if (a === '--skills-cli') opts.skillsCli = take('--skills-cli');
     else if (a === '--host') opts.host = take('--host').toLowerCase();
     else if (a === '--event') opts.event = take('--event').toLowerCase();
     else if (a === '--manifest') opts.manifest = take('--manifest');
@@ -233,7 +235,12 @@ function parseArgs(argv) {
   }
   // 命令解析：install / update / doctor / rollback，其余位置参数 = 技能 slug（可多个）
   for (const p of positionals) {
+    if (opts.command === 'hub') {
+      opts.rest.push(p);
+      continue;
+    }
     if (p === 'install' || p === 'update' || p === 'doctor' || p === 'rollback' || p === 'hook'
+      || p === 'hub'
       || p === 'usage' || p === 'decide-memory') {
       if (opts.command && opts.command !== p) die('命令冲突：' + opts.command + ' 与 ' + p);
       opts.command = p;
@@ -244,12 +251,21 @@ function parseArgs(argv) {
   // 直接给 slug 且无命令 → 视为 install 单个/多个
   if (!opts.command && opts.rest.length > 0) opts.command = 'install';
   opts.skills = opts.rest.map(s => s.toLowerCase());
+  if (opts.command === 'hub') {
+    opts.hubAction = opts.skills[0] || 'status';
+    opts.skills = opts.skills.slice(1);
+  }
   if (opts.scheduled && (opts.command !== 'update' || !opts.check || opts.auto)) {
     die('--scheduled 只能与 update --check 一起使用', 2, '请使用 update --check --scheduled；自动更新不使用后台调度入口。');
   }
   if (opts.installedOnly && opts.command !== 'update') {
     die('--installed-only 只能与 update 一起使用', 2, '标准配方：yotta-skills update --installed-only --dir <技能目录>。');
   }
+  if ((opts.all || opts.inPlace || opts.allowUnverified || opts.from || opts.include.length || opts.as || opts.scan || opts.apply)
+    && opts.command !== 'hub') {
+    die('--all / --in-place / --allow-unverified / --from / --include / --as / --scan / --apply 只能与 hub 命令一起使用', 2,
+      'Hub 用法：yotta-skills hub link --all 或 yotta-skills hub adopt --scan。');
+  }
   if (opts.domain && !domainValues().includes(opts.domain)) {
     die('未知 domain: ' + opts.domain + '。可用: ' + domainValues().join(', '), 2, 'domain 对齐家族索引 9 类；用 yotta-skills --list 查看技能清单。');
   }
@@ -1306,6 +1322,16 @@ function printHelp() {
   out('  yotta-skills hook evaluate --event <event> --manifest <file>  评估 hook 声明并留证');
   out('  yotta-skills hook bind --manifest <file>  注册 hook 声明（幂等）');
   out('  yotta-skills hook unbind <binding-id>  反注册 hook 声明');
+  out('  yotta-skills hub hosts              发现本机已装智能体与技能目录（不读元忆）');
+  out('  yotta-skills hub install [skill...]  把元技能装进本机 Hub（单点真源）');
+  out('  yotta-skills hub adopt --scan        只读预演：扫描各宿主现有技能，输出收编候选与冲突');
+  out('  yotta-skills hub adopt --apply       把选中技能复制进 Hub（默认保留原目录；--in-place 原地登记）');
+  out('  yotta-skills hub refresh <slug> --from <path>  手动同步非元阁技能（无统一更新源）');
+  out('  yotta-skills hub link --all          把 Hub 技能链接到全部已发现宿主（junction / symlink）');
+  out('  yotta-skills hub link --agent <id>   只链接到一个宿主（未知宿主用 --dir）');
+  out('  yotta-skills hub unlink --all        只删除链接，不动 Hub 真源（fail-closed）');
+  out('  yotta-skills hub status              查看 Hub 技能 / 来源 / 链接 / 宿主');
+  out('  yotta-skills hub doctor              检查断链 / 目标缺失 / slug 不一致 / 目录权限');
   out('');
   out('选项:');
   out('  --agent <name>   智能体键名（--list 可查看；未知智能体请用 --dir）');
@@ -1336,12 +1362,18 @@ function printHelp() {
   out('  --yes             usage reset 确认清空');
   out('  --explain         decide-memory 文本报告追加信号明细');
   out('  --promote         decide-memory 只写本地建议文件（不写元忆）');
+  out('  --hub <path>      Hub 目录（默认 ~/.yottaskills/hub；YOTTA_SKILLS_HUB 覆盖）');
+  out('  --all             hub link / unlink 时作用于全部已发现宿主');
+  out('  --scan            hub adopt 只读预演（默认行为）');
+  out('  --apply           hub adopt 执行收编');
+  out('  --in-place        hub adopt 原地登记，不复制（原目录删除即断链）');
+  out('  --allow-unverified 显式允许未扫描导入（默认 high / critical 阻断）');
   out('  --project         inventory / reindex 时附加扫描当前项目 .agents/skills / .codex/skills');
   out('  --no-reindex      安装 / 更新后不自动重扫注册表');
   out('  -h, --help       帮助');
   out('  -v, --version    版本');
   out('');
-  out('支持智能体: ' + Object.keys(AGENT_DIRS).join(', '));
+  out('支持智能体: ' + Object.keys(AGENT_DIRS).length + ' 个已收录映射（本机实际发现用 yotta-skills hub hosts）');
   out('依赖: Node.js 18+（必需）；npm 与系统 tar 为回退通道（内置拉包 / 内置解包为主）；元信 scan 需要 Python 3.8+（--python / YOTTA_SKILLS_PYTHON 可指向宿主自带 Python）。');
   out('环境变量: YOTTA_SKILLS_FETCH（builtin|npm）/ YOTTA_SKILLS_EXTRACT（builtin|tar）/ YOTTA_SKILLS_NPM / YOTTA_SKILLS_PYTHON / YOTTA_SKILLS_VERIFY / YOTTA_SKILLS_NPM_FLAGS / YOTTA_SKILLS_REGISTRY / YOTTA_SKILLS_REGISTRY_FILE / YOTTA_SKILLS_MANIFEST 可覆盖。');
 }
@@ -1800,6 +1832,356 @@ function runHook(opts) {
   die('未知 hook 子命令: ' + action, 2, '支持 capabilities / evaluate / bind / unbind。');
 }
 
+// ── Hub（本机单点安装 + 链接分发） ─────────────────────────────────────────
+function universalSkillDirs() {
+  const home = os.homedir();
+  const xdg = process.env.XDG_CONFIG_HOME || path.join(home, '.config');
+  return [
+    { dir: path.join(xdg, 'agents', 'skills'), agentId: 'universal', label: 'Universal .agents' },
+    { dir: path.join(home, '.agents', 'skills'), agentId: 'agents', label: '通用 AGENTS.md' },
+  ];
+}
+
+function hubTargetDirs(opts, discovery) {
+  const targets = [];
+  const seen = new Set();
+  const add = (dir, agentId, label) => {
+    if (!dir) return;
+    const resolved = path.resolve(dir);
+    const key = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+    if (seen.has(key)) return;
+    seen.add(key);
+    targets.push({ dir: resolved, agentId: agentId || null, label: label || '指定目录' });
+  };
+
+  if (opts.dir) {
+    add(opts.dir, null, '指定目录');
+    return targets;
+  }
+  if (opts.agent) {
+    const info = AGENT_DIRS[opts.agent];
+    if (!info) {
+      die('未收录智能体: ' + opts.agent + '。可用: ' + Object.keys(AGENT_DIRS).join(', ') + '；或改用 --dir <路径>。',
+        2, '先运行 yotta-skills hub hosts 查看本机实际技能目录。');
+    }
+    add(resolveUserDir(info.dirs[0]), opts.agent, info.label);
+    return targets;
+  }
+  if (!opts.all) {
+    die('hub link / unlink 需要 --agent <id>、--dir <path> 或 --all', 2,
+      '示例：yotta-skills hub link --all；或 yotta-skills hub link --agent codex。');
+  }
+
+  for (const item of universalSkillDirs()) add(item.dir, item.agentId, item.label);
+  for (const host of discovery.hosts) {
+    if (!host.exists) continue;
+    add(host.dir, host.agentId, host.label);
+  }
+  return targets;
+}
+
+function hubHostLines(discovery) {
+  const lines = [];
+  const existing = discovery.hosts.filter((host) => host.exists);
+  const missing = discovery.hosts.filter((host) => !host.exists);
+  for (const host of existing) {
+    lines.push('  ' + (host.known ? '✔' : '?') + ' ' +
+      String(host.label).padEnd(28) + host.dir.padEnd(64) +
+      String(host.skillCount).padStart(3) + ' 个技能' +
+      (host.known ? '  [已收录]' : '  [自动发现]'));
+  }
+  const noSkillDir = discovery.installed.filter((item) => !item.hasSkillsDir);
+  for (const item of noSkillDir) {
+    lines.push('  △ ' + String(item.label).padEnd(28) + '已安装，未发现技能目录  [不适用]');
+  }
+  return { lines, existing, missing, noSkillDir };
+}
+
+function printHubHosts(discovery, json) {
+  if (json) {
+    out(JSON.stringify(discovery, null, 2));
+    return;
+  }
+  const view = hubHostLines(discovery);
+  out('yotta-skills（元阁）v' + VERSION + ' —— Hub 宿主发现（文件系统优先，不读元忆）');
+  out('本机发现技能目录 ' + view.existing.length + ' 个 / 已装应用标记 ' + discovery.installed.length +
+    ' 个 / 未发现技能目录 ' + view.noSkillDir.length + ' 个');
+  for (const line of view.lines) out(line);
+  if (view.missing.length > 0) {
+    out('');
+    out('未安装 / 未发现目录 ' + view.missing.length + ' 个（已收录映射，等安装后自动出现）。');
+  }
+}
+
+function printHubStatus(payload, discovery, json) {
+  if (json) {
+    out(JSON.stringify({ ...payload, discovery }, null, 2));
+    return;
+  }
+  out('yotta-skills（元阁）v' + VERSION + ' —— Hub 状态');
+  out('标准: ' + payload.standard);
+  out('Hub: ' + payload.hubDir);
+  out('技能: ' + payload.summary.skills + ' / 非元阁技能: ' + payload.summary.external +
+    ' / 链接: ' + payload.summary.links + ' / 异常链接: ' + payload.summary.brokenLinks);
+  out('');
+  for (const skill of payload.skills) {
+    const origin = skill.origin === 'yotta' ? '元技能' : '非元阁技能（无更新源）';
+    const links = skill.links.length > 0 ? skill.links.map((link) => link.label || link.agent || '链接').join(', ') : '-';
+    out('  ' + skill.slug.padEnd(26) + 'v' + String(skill.version || '-').padEnd(10) +
+      origin.padEnd(22) + '链接: ' + links +
+      (skill.status === 'missing' ? '  [目标缺失]' : ''));
+  }
+  if (payload.skills.length === 0) out('  （Hub 为空；先运行 yotta-skills hub install）');
+  const broken = payload.links.filter((link) => link.status !== 'ok');
+  if (broken.length > 0) {
+    out('');
+    out('异常链接:');
+    for (const link of broken) out('  ✘ ' + link.slug + '  ' + link.target + '（' + link.status + '）');
+  }
+  out('');
+  printHubHosts(discovery, false);
+}
+
+function hubScanEngine(hubDir, discovery, opts) {
+  const direct = findVerifyEngine(hubDir, opts);
+  if (direct) return direct;
+  for (const host of discovery.hosts) {
+    if (!host.exists) continue;
+    const engine = findVerifyEngine(host.dir, opts);
+    if (engine) return engine;
+  }
+  return null;
+}
+
+function hubScanSkill(hubDir, discovery, opts, skillDir) {
+  if (opts.skipScan) {
+    return { ok: true, verdict: 'explicit-unverified', counts: null, block: false };
+  }
+  const engine = hubScanEngine(hubDir, discovery, opts);
+  if (!engine) {
+    return {
+      ok: false,
+      error: '未找到元信扫描引擎（可先安装 yotta-verify，或用 --allow-unverified 显式降级）',
+    };
+  }
+  const scan = runScan(engine, skillDir, opts);
+  if (!scan.ok) return scan;
+  const verdict = gateLib.evaluateVerdict(scan.verdict);
+  return { ok: true, verdict: scan.verdict, counts: scan.counts, block: verdict.block };
+}
+
+function printAdoptScan(payload, json) {
+  if (json) {
+    out(JSON.stringify(payload, null, 2));
+    return;
+  }
+  out('yotta-skills（元阁）v' + VERSION + ' —— Hub 收编预演（只读）');
+  out('Hub: ' + payload.hubDir);
+  out('候选 ' + payload.summary.candidates + ' / 冲突 ' + payload.summary.conflicts +
+    ' / 已在 Hub ' + payload.summary.alreadyInHub);
+  out('');
+  for (const item of payload.candidates) {
+    const mark = item.conflict ? '△' : item.inHub ? '·' : '✔';
+    out('  ' + mark + ' ' + item.slug.padEnd(26) + 'v' + String(item.version || '-').padEnd(10) +
+      (item.sourceHost || '-') + '  ' + (item.source || ''));
+    if (item.conflict) {
+      out('      冲突副本: ' + item.variants.map((variant) =>
+        (variant.host || '?') + ' v' + (variant.version || '?')).join(', '));
+    }
+  }
+  if (payload.candidates.length === 0) out('  （没有发现可收编技能）');
+}
+
+function printAdoptApply(payload, json) {
+  if (json) {
+    out(JSON.stringify(payload, null, 2));
+    return;
+  }
+  out('yotta-skills（元阁）v' + VERSION + ' —— Hub 收编');
+  out('Hub: ' + payload.hubDir);
+  for (const item of payload.results) {
+    const mark = item.status === 'imported' ? '✔' : item.status === 'skip' ? '·' : item.status === 'conflict' ? '△' : '✘';
+    out('  ' + mark + ' ' + item.slug.padEnd(26) + item.note);
+  }
+  out('汇总: 收编 ' + payload.results.filter((item) => item.status === 'imported').length +
+    ' / 跳过 ' + payload.results.filter((item) => item.status === 'skip').length +
+    ' / 冲突 ' + payload.results.filter((item) => item.status === 'conflict').length +
+    ' / 失败 ' + payload.results.filter((item) => !['imported', 'skip', 'conflict'].includes(item.status)).length);
+}
+
+function printHubDoctor(payload, json) {
+  if (json) {
+    out(JSON.stringify(payload, null, 2));
+    return;
+  }
+  out('yotta-skills（元阁）v' + VERSION + ' —— Hub doctor');
+  out('Hub: ' + payload.hubDir);
+  for (const check of payload.checks) {
+    if (check.ok && check.severity !== 'info') continue;
+    const mark = check.ok ? '✔' : check.severity === 'warning' ? '△' : '✘';
+    out('  ' + mark + ' ' + check.message + (check.hint ? '（修复: ' + check.hint + '）' : ''));
+  }
+  out('汇总: 错误 ' + payload.summary.errors + ' / 警告 ' + payload.summary.warnings);
+  if (!payload.ok) out('Hub doctor 未通过：请按上面的修复建议处理后重试。');
+}
+
+function runHub(opts) {
+  const hubDir = hubLib.resolveHubDir(opts);
+  const action = opts.hubAction || 'status';
+  const discovery = agentDiscoveryLib.discoverHosts({ homeDir: os.homedir(), env: process.env });
+
+  if (action === 'hosts' || action === 'discover') {
+    printHubHosts(discovery, opts.json);
+    return;
+  }
+
+  if (action === 'install' || action === 'update') {
+    out('Hub: ' + hubDir);
+    const result = action === 'install' ? runInstall(opts, hubDir) : runUpdate(opts, hubDir);
+    const synced = hubLib.syncHubState(hubDir, { manifest: MANIFEST });
+    const count = Object.values(synced.state.skills).filter((item) => item.status === 'present').length;
+    out('');
+    out('Hub 台账已更新: ' + count + ' 个技能；标准 ' + hubLib.STANDARD_ID);
+    if (result.failed > 0) process.exitCode = result.exitCode || 1;
+    return;
+  }
+
+  if (action === 'adopt') {
+    if (opts.as) {
+      die('hub adopt --as 暂未启用', 2, '先收编原 slug；改名 / 冲突改写放到后续里程碑，避免静默改技能身份。');
+    }
+    const scan = hubAdoptLib.scanCandidates({ hubDir, discovery });
+    if (!opts.apply) {
+      printAdoptScan(scan, opts.json);
+      return;
+    }
+    const payload = hubAdoptLib.applyCandidates({
+      hubDir,
+      candidates: scan.candidates,
+      include: opts.include,
+      force: opts.force,
+      inPlace: opts.inPlace,
+      skipScan: opts.skipScan,
+      allowUnverified: opts.allowUnverified,
+      manifest: MANIFEST,
+      homeDir: os.homedir(),
+      env: process.env,
+      scan: (skillDir) => hubScanSkill(hubDir, discovery, opts, skillDir),
+    });
+    printAdoptApply(payload, opts.json);
+    if (payload.results.some((item) => !['imported', 'skip', 'conflict'].includes(item.status))) process.exitCode = 1;
+    return;
+  }
+
+  if (action === 'refresh') {
+    if (!opts.from) die('hub refresh 缺少 --from <path>', 2, '示例：yotta-skills hub refresh my-skill --from <技能目录>。');
+    if (opts.skills.length !== 1) die('hub refresh 需要一个且仅一个技能 slug', 2, '示例：yotta-skills hub refresh my-skill --from <技能目录>。');
+    const result = hubAdoptLib.refreshFrom({
+      hubDir,
+      slug: opts.skills[0],
+      from: opts.from,
+      skipScan: opts.skipScan,
+      allowUnverified: opts.allowUnverified,
+      manifest: MANIFEST,
+      homeDir: os.homedir(),
+      env: process.env,
+      scan: (skillDir) => hubScanSkill(hubDir, discovery, opts, skillDir),
+    });
+    if (opts.json) out(JSON.stringify(result, null, 2));
+    else if (result.ok) out('已刷新: ' + result.slug + '（来源 ' + result.source + '）');
+    else out('刷新失败: ' + result.error);
+    if (!result.ok) process.exitCode = 1;
+    return;
+  }
+
+  if (action === 'link') {
+    const targets = hubTargetDirs(opts, discovery);
+    let failed = 0;
+    const targetPayloads = [];
+    for (const target of targets) {
+      if (path.resolve(target.dir) === path.resolve(hubDir)) {
+        targetPayloads.push({ dir: target.dir, label: target.label, skipped: true, results: [] });
+        if (!opts.json) out('跳过 Hub 自身: ' + target.dir);
+        continue;
+      }
+      const result = hubLib.linkSkills({
+        hubDir,
+        targetDir: target.dir,
+        agentId: target.agentId,
+        label: target.label,
+        slugs: opts.skills,
+        force: opts.force,
+        dryRun: opts.dryRun,
+      });
+      targetPayloads.push({ dir: target.dir, label: target.label, results: result.results });
+      if (!opts.json) {
+        out('');
+        out('目标: ' + target.dir + '（' + target.label + '）');
+        for (const item of result.results) {
+          const mark = item.status === 'linked' ? '✔' : item.status === 'conflict' ? '△' : item.status === 'error' ? '✘' : '·';
+          out('  ' + mark + ' ' + item.slug.padEnd(26) + item.note);
+          if (item.status === 'error') failed++;
+        }
+      } else {
+        failed += result.results.filter((item) => item.status === 'error').length;
+      }
+    }
+    if (opts.json) out(JSON.stringify({ hubDir, targets: targetPayloads, failed }, null, 2));
+    if (failed > 0) process.exitCode = 1;
+    return;
+  }
+
+  if (action === 'unlink') {
+    const targets = hubTargetDirs(opts, discovery);
+    let failed = 0;
+    const targetPayloads = [];
+    for (const target of targets) {
+      const result = hubLib.unlinkSkills({
+        hubDir,
+        targetDir: target.dir,
+        slugs: opts.skills,
+        dryRun: opts.dryRun,
+      });
+      targetPayloads.push({ dir: target.dir, label: target.label, results: result.results });
+      if (!opts.json) {
+        out('');
+        out('目标: ' + target.dir + '（' + target.label + '）');
+        for (const item of result.results) {
+          const mark = item.status === 'unlinked' ? '✔' : item.status === 'refused' ? '△' : item.status === 'error' ? '✘' : '·';
+          out('  ' + mark + ' ' + item.slug.padEnd(26) + item.note);
+          if (item.status === 'error') failed++;
+        }
+      } else {
+        failed += result.results.filter((item) => item.status === 'error').length;
+      }
+    }
+    if (opts.json) out(JSON.stringify({ hubDir, targets: targetPayloads, failed }, null, 2));
+    if (failed > 0) process.exitCode = 1;
+    return;
+  }
+
+  if (action === 'status') {
+    const payload = hubLib.status({ hubDir, manifest: MANIFEST });
+    printHubStatus(payload, discovery, opts.json);
+    return;
+  }
+
+  if (action === 'doctor') {
+    const payload = hubLib.doctor({
+      hubDir,
+      manifest: MANIFEST,
+      homeDir: os.homedir(),
+      env: process.env,
+    });
+    printHubDoctor(payload, opts.json);
+    if (!payload.ok) process.exitCode = 1;
+    return;
+  }
+
+  die('未知 hub 子命令: ' + action, 2,
+    '支持 install / update / adopt / refresh / link / unlink / status / hosts / doctor。');
+}
+
 // ── main ───────────────────────────────────────────────────────────────────
 function main() {
   const node = depsLib.nodeCheck();
@@ -1828,6 +2210,10 @@ function main() {
     runHook(opts);
     return;
   }
+  if (command === 'hub') {
+    runHub(opts);
+    return;
+  }
   if (command === 'rollback' && opts.list) {
     runRollback(opts, null);
     return;