@yottameta/yotta-skills-plugin 0.28.2 → 0.29.0

package/skills/yotta-skills/lib/hub.js

@@ -1017,6 +1017,277 @@ function unlinkSkills(options) {
   return { hubDir, targetDir, dryRun, results };
 }
 
+/**
+ * 删除 Hub 技能：全宿主清理指向 Hub 的链接（含死链）→ Hub 目录移入回收站 →
+ * 定向清 Hub 台账与链接台账 → 写审计。
+ *
+ * 五阶段 fail-closed：
+ *   1. preflight（只读分类，dry-run 到此为止）
+ *   2. unlink（只删指向 Hub 的链接；报错即中止，不进入 3）
+ *   3. trash（目录移入回收站保留 7 天；跨卷走复制 + 校验 + 删源）
+ *   4. ledger（定向删 Hub 台账条目 + 过滤链接台账；不调 syncHubState，防记回 missing）
+ *   5. 汇总（含版本闸门报告）
+ *
+ * options:
+ * - hubDir / slug（必填）
+ * - targets: [{ dir, label, agentId }]（调用方解析范围；核心不做范围判断）
+ * - dryRun / trashRoot / trashRetentionDays / now
+ * - renameEntry / unlink（测试注入点）
+ */
+function removeSkills(options) {
+  const opts = options || {};
+  const hubDir = path.resolve(opts.hubDir);
+  const slug = String(opts.slug || '').trim().toLowerCase();
+  const dryRun = Boolean(opts.dryRun);
+  const unlinkFn = typeof opts.unlink === 'function' ? opts.unlink : unlinkSkills;
+  const targets = (Array.isArray(opts.targets) ? opts.targets : [])
+    .filter((item) => item && item.dir)
+    .map((item) => ({
+      dir: path.resolve(item.dir),
+      label: item.label || '指定目录',
+      agentId: item.agentId || null,
+    }));
+  const trashRoot = resolveTrashRoot(hubDir, opts);
+  const skillDir = path.join(hubDir, slug);
+  const compact = (plan) => ({
+    dir: plan.dir,
+    label: plan.label,
+    status: plan.status,
+    action: plan.action,
+    note: plan.note,
+    ...(plan.version ? { version: plan.version } : {}),
+    ...(plan.versionGate ? { versionGate: true } : {}),
+    ...(plan.drift ? { drift: true } : {}),
+    ...(plan.broken ? { broken: true } : {}),
+  });
+
+  let hubPathKind = 'missing';
+  let hubEntry = null;
+  try {
+    const stat = fs.lstatSync(skillDir);
+    hubPathKind = stat.isSymbolicLink() ? 'link' : stat.isDirectory() ? 'directory' : 'file';
+  } catch (_) {
+    hubPathKind = 'missing';
+  }
+  if (hubPathKind === 'file') {
+    return {
+      hubDir,
+      slug,
+      dryRun,
+      verdict: 'failed',
+      ok: false,
+      exitCode: 1,
+      hubPresent: false,
+      hubPathKind,
+      hubVersion: null,
+      targets: [],
+      unlinkable: 0,
+      kept: [],
+      failed: [{ dir: skillDir, note: 'Hub 内同名路径是普通文件；fail-closed，拒绝删除' }],
+      trashedTo: null,
+    };
+  }
+  if (hubPathKind !== 'missing') {
+    hubEntry = scanHubSkills(hubDir).find((item) => samePath(item.dir, skillDir)) || null;
+  }
+  const hubVersion = hubEntry && hubEntry.version ? hubEntry.version : '';
+
+  // ── 1. preflight（只读） ────────────────────────────────────────────────
+  const plans = targets.map((target) => {
+    const targetPath = path.join(target.dir, slug);
+    const current = classifyTarget(targetPath, hubDir);
+    if (current.kind === 'missing') {
+      return {
+        dir: target.dir,
+        label: target.label,
+        target: targetPath,
+        action: 'none',
+        status: 'missing',
+        note: '目标不存在',
+      };
+    }
+    if (current.kind === 'link') {
+      if (!current.inHub) {
+        return {
+          dir: target.dir,
+          label: target.label,
+          target: targetPath,
+          action: 'keep',
+          status: 'refused',
+          note: '链接指向 Hub 之外；fail-closed 保留',
+        };
+      }
+      const drift = !samePath(current.target, skillDir);
+      const broken = current.targetExists === false;
+      return {
+        dir: target.dir,
+        label: target.label,
+        target: targetPath,
+        action: 'unlink',
+        status: 'link',
+        drift,
+        broken,
+        note: broken
+          ? '死链（Hub 目标缺失），将清理'
+          : drift
+            ? '链接指向 Hub 内其它技能，将一并清理'
+            : '指向本技能的链接，将清理',
+      };
+    }
+    if (current.kind === 'directory') {
+      const meta = readSkillMeta(targetPath);
+      const version = meta && meta.version ? meta.version : '';
+      const higher = Boolean(version && hubVersion && compareVersions(version, hubVersion) > 0);
+      return {
+        dir: target.dir,
+        label: target.label,
+        target: targetPath,
+        action: 'keep',
+        status: 'kept-directory',
+        version: version || null,
+        versionGate: higher,
+        note: higher
+          ? '宿主真副本 v' + version + ' 高于 Hub v' + hubVersion + '；保留（先确认该副本）'
+          : '宿主真副本，保留（只删链接）',
+      };
+    }
+    return {
+      dir: target.dir,
+      label: target.label,
+      target: targetPath,
+      action: 'keep',
+      status: 'kept-file',
+      note: '普通文件，保留',
+    };
+  });
+
+  const stateSnapshot = readHubState(hubDir);
+  const hasStateEntry = Boolean(stateSnapshot.skills && stateSnapshot.skills[slug]);
+  const hubPresent = hubPathKind === 'directory' || hubPathKind === 'link';
+  const unlinkable = plans.filter((plan) => plan.action === 'unlink').length;
+  const kept = plans.filter((plan) => plan.action === 'keep');
+  const base = {
+    hubDir,
+    slug,
+    dryRun,
+    hubPresent,
+    hubPathKind,
+    hubVersion: hubVersion || null,
+    targets: plans.map(compact),
+    unlinkable,
+    kept: kept.map(compact),
+  };
+  if (dryRun) {
+    return { ...base, verdict: 'dry-run', ok: true, exitCode: 0, trashedTo: null };
+  }
+
+  // ── 2. unlink（含死链；报错即中止，不删 Hub） ───────────────────────────
+  const unlinked = [];
+  const failed = [];
+  for (const plan of plans) {
+    if (plan.action !== 'unlink') continue;
+    const result = unlinkFn({ hubDir, targetDir: plan.dir, slugs: [slug], dryRun: false });
+    const item = (result.results || [])[0] || { status: 'error', note: '未知结果' };
+    plan.status = item.status;
+    plan.note = item.note || plan.note;
+    if (item.status === 'error') failed.push({ dir: plan.dir, note: item.note });
+    else unlinked.push({ dir: plan.dir, status: item.status, note: item.note });
+  }
+  if (failed.length > 0) {
+    if (fs.existsSync(hubDir)) {
+      try {
+        appendAudit(hubDir, {
+          event: 'remove',
+          slug,
+          verdict: 'failed',
+          reason: 'unlink-error',
+          targets: plans.map(compact),
+          removedLinks: unlinked.length,
+        });
+      } catch (_) { /* audit best-effort */ }
+    }
+    return { ...base, verdict: 'failed', ok: false, exitCode: 1, unlinked, failed, trashedTo: null };
+  }
+
+  // ── 3. trash（Hub 目录入回收站；失败即中止） ────────────────────────────
+  let trashedTo = null;
+  let method = null;
+  if (hubPresent) {
+    trashedTo = path.join(trashRoot, trashRunStamp(opts.now), 'hub-remove', slug);
+    try {
+      fs.mkdirSync(path.dirname(trashedTo), { recursive: true });
+      const transfer = moveEntryAcrossDevices(skillDir, trashedTo, { renameEntry: opts.renameEntry });
+      method = transfer.method;
+    } catch (error) {
+      if (fs.existsSync(hubDir)) {
+        try {
+          appendAudit(hubDir, {
+            event: 'remove',
+            slug,
+            verdict: 'failed',
+            reason: 'trash-error',
+            targets: plans.map(compact),
+            removedLinks: unlinked.length,
+            trashedTo,
+          });
+        } catch (_) { /* audit best-effort */ }
+      }
+      return {
+        ...base,
+        verdict: 'failed',
+        ok: false,
+        exitCode: 1,
+        unlinked,
+        failed: [{ dir: skillDir, note: error.message }],
+        trashedTo,
+      };
+    }
+  }
+
+  // ── 4. ledger（定向清台账；不调 syncHubState） ──────────────────────────
+  const state = readHubState(hubDir);
+  if (state.skills && state.skills[slug]) {
+    delete state.skills[slug];
+    writeHubState(hubDir, state);
+  }
+  const linkState = readLinkState(hubDir);
+  const remainingLinks = linkState.links.filter((item) => item.slug !== slug);
+  if (remainingLinks.length !== linkState.links.length) {
+    writeLinkState(hubDir, { links: remainingLinks });
+  }
+  let prunedTrash = 0;
+  try { prunedTrash = pruneTrash(trashRoot, { days: opts.trashRetentionDays }); } catch (_) { prunedTrash = 0; }
+
+  // ── 5. 汇总 + 审计 ─────────────────────────────────────────────────────
+  const verdict = hubPresent ? 'removed' : (unlinked.length > 0 || hasStateEntry ? 'cleanup-only' : 'not-found');
+  const exitCode = verdict === 'not-found' ? 4 : 0;
+  if (fs.existsSync(hubDir)) {
+    try {
+      appendAudit(hubDir, {
+        event: 'remove',
+        slug,
+        verdict,
+        targets: plans.map(compact),
+        removedLinks: unlinked.length,
+        kept: kept.length,
+        trashedTo,
+        method,
+      });
+    } catch (_) { /* audit best-effort */ }
+  }
+  return {
+    ...base,
+    verdict,
+    ok: exitCode === 0,
+    exitCode,
+    unlinked,
+    kept: kept.map(compact),
+    trashedTo,
+    method,
+    prunedTrash,
+  };
+}
+
 function linkStatus(hubDir) {
   const state = readLinkState(hubDir);
   return state.links.map((item) => {
@@ -1190,6 +1461,22 @@ function doctor(options) {
     singleSourceChecks(opts, add);
   } catch (_) { /* 只读检查失败不影响 doctor 主流程 */ }
 
+  // F3（0.29.0）：宿主状态细分只读检查 —— 残留 / 仅标记给 info 提示，不 fail。
+  if (opts.discovery) {
+    for (const host of opts.discovery.hosts || []) {
+      if (!host || !host.dir) continue;
+      if (host.state === 'orphan') {
+        add('host_state:' + pathKey(host.dir), true, 'info',
+          '宿主目录疑似残留（实体未确认）: ' + host.label + ' — ' + host.dir,
+          '确认宿主已卸载后可清理：yotta-skills hub hosts remove "' + host.dir + '" --purge（默认预览，--yes 执行）');
+      } else if (host.state === 'marker-only') {
+        add('host_state:' + pathKey(host.dir), true, 'info',
+          '已装实体但技能目录未创建: ' + host.label,
+          '需要分发时运行 yotta-skills hub link --agent ' + (host.agentId || '<id>'));
+      }
+    }
+  }
+
   const errors = checks.filter((check) => !check.ok && check.severity === 'error');
   const warnings = checks.filter((check) => !check.ok && check.severity === 'warning');
   return {
@@ -1233,6 +1520,7 @@ module.exports = {
   classifyTarget,
   linkSkills,
   unlinkSkills,
+  removeSkills,
   linkStatus,
   status,
   doctor,

package/skills/yotta-skills/lib/install-pipeline.js

@@ -86,6 +86,25 @@ function createInstaller(deps) {
     if (!opts.force && existingVersion === skill.version) {
       return { skill, status: 'skip', version: existingVersion, note: '已是最新', exitCode: 0 };
     }
+    if (opts.dryRun) {
+      // 0.29.0 D1：只读预览 —— 不发网络请求、不写任何文件（含台账）。
+      const latestUnresolved = skill.version === 'latest';
+      const planned = existingVersion ? 'update' : 'install';
+      return {
+        skill,
+        status: 'planned',
+        planned,
+        version: latestUnresolved ? 'latest' : skill.version,
+        installedVersion: existingVersion,
+        latestUnresolved,
+        note: latestUnresolved
+          ? 'latest（预览不解析）'
+          : planned === 'update'
+            ? '将更新 v' + existingVersion + ' -> v' + skill.version
+            : '将安装 v' + skill.version,
+        exitCode: 0,
+      };
+    }
 
     let tmp = null;
     let staged = null;

package/skills/yotta-skills/lib/self-install.js

@@ -0,0 +1,224 @@
+'use strict';
+/**
+ * 元阁独立安装（install-self）与位置查看（where）—— 0.29.0 F1。
+ *
+ * 独立安装 = 把管理引擎完整运行件（bin / lib / assets / package.json / skills.json）
+ * 装到用户级独立位置（默认 ~/.yottaskills/yotta-skills；YOTTA_SKILLS_HOME 可覆盖根），
+ * 写 <root>/self.json 登记。与 Hub 真源、宿主技能池完全独立：不写宿主配置、
+ * 不写 mcp.json、不建全局 shim。
+ *
+ * fail-closed：目标与 Hub 真源重叠 / 锁与数据桥接目录 / 非空陌生目录（--force 才覆盖
+ * 同名运行件，无关文件保留）。
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const hubLib = require('./hub');
+const agentDirsLib = require('./agent-dirs');
+
+const SELF_REGISTRY_VERSION = 1;
+const RUNTIME_PAYLOAD = ['bin', 'lib', 'assets', 'package.json', 'skills.json'];
+const PACKAGE_NAME = '@yottameta/yotta-skills';
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function resolveSelfRoot(opts) {
+  const options = opts || {};
+  const env = options.env || process.env;
+  const explicit = options.selfRoot || env.YOTTA_SKILLS_HOME;
+  if (explicit) return path.resolve(explicit);
+  return path.join(options.homeDir || os.homedir(), '.yottaskills');
+}
+
+function selfRegistryPath(opts) {
+  return path.join(resolveSelfRoot(opts), 'self.json');
+}
+
+function defaultSelfDir(opts) {
+  return path.join(resolveSelfRoot(opts), 'yotta-skills');
+}
+
+function readSelfRegistry(opts) {
+  try {
+    const value = JSON.parse(fs.readFileSync(selfRegistryPath(opts), 'utf8'));
+    if (value && typeof value === 'object' && Array.isArray(value.installs)) {
+      return {
+        version: SELF_REGISTRY_VERSION,
+        installs: value.installs.filter((item) => item && typeof item.dir === 'string' && item.dir),
+      };
+    }
+  } catch (_) { /* missing or corrupt registry falls back to empty */ }
+  return { version: SELF_REGISTRY_VERSION, installs: [] };
+}
+
+function writeSelfRegistry(opts, registry) {
+  const file = selfRegistryPath(opts);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + '.tmp-' + process.pid;
+  fs.writeFileSync(tmp, JSON.stringify({
+    version: SELF_REGISTRY_VERSION,
+    installs: registry.installs,
+  }, null, 2) + '\n', 'utf8');
+  fs.renameSync(tmp, file);
+  return file;
+}
+
+function safeRealpath(target) {
+  try {
+    return fs.realpathSync.native(target);
+  } catch (_) {
+    try {
+      return fs.realpathSync(target);
+    } catch (_) {
+      return path.resolve(target);
+    }
+  }
+}
+
+function samePath(left, right) {
+  const a = safeRealpath(left);
+  const b = safeRealpath(right);
+  if (process.platform === 'win32') return a.toLowerCase() === b.toLowerCase();
+  return a === b;
+}
+
+function isInside(root, target) {
+  const relative = path.relative(path.resolve(root), path.resolve(target));
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function packageRoot() {
+  return path.join(__dirname, '..');
+}
+
+function readPackageVersion(dir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8')).version || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function hasContent(dir) {
+  try {
+    return fs.readdirSync(dir).length > 0;
+  } catch (_) {
+    return false;
+  }
+}
+
+/** 目标是否已是元阁运行件目录（允许正常覆盖升级）。 */
+function hasOwnMarker(dir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'));
+    if (pkg && pkg.name === PACKAGE_NAME) return true;
+  } catch (_) { /* no readable package.json */ }
+  return fs.existsSync(path.join(dir, 'bin', 'yotta-skills.js'));
+}
+
+function guardTarget(dir, opts) {
+  const hubDir = hubLib.resolveHubDir(opts);
+  if (samePath(dir, hubDir) || isInside(hubDir, dir) || isInside(dir, hubDir)) {
+    return '目标与 Hub 真源重叠（' + hubDir + '）：独立安装与 Hub 必须分离';
+  }
+  if (agentDirsLib.isBridgeOnlyDir(dir, opts)) {
+    return '目标是锁 / 数据桥接目录（XDG_STATE_HOME/skills 或 XDG_DATA_HOME/skills），不允许独立安装';
+  }
+  return null;
+}
+
+function copyEntry(from, to) {
+  fs.rmSync(to, { recursive: true, force: true });
+  if (fs.statSync(from).isDirectory()) {
+    fs.mkdirSync(to, { recursive: true });
+    fs.cpSync(from, to, { recursive: true });
+  } else {
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    fs.copyFileSync(from, to);
+  }
+}
+
+function installSelf(opts) {
+  const options = opts || {};
+  const src = packageRoot();
+  const dir = path.resolve(options.dir || defaultSelfDir(options));
+  const dryRun = Boolean(options.dryRun);
+  const force = Boolean(options.force);
+  const version = readPackageVersion(src);
+  const registryFile = selfRegistryPath(options);
+
+  const guard = guardTarget(dir, options);
+  if (guard) return { ok: false, error: guard, exitCode: 2 };
+
+  const exists = fs.existsSync(dir);
+  const stranger = exists && hasContent(dir) && !hasOwnMarker(dir);
+  if (stranger && !force) {
+    return {
+      ok: false,
+      error: '目标是非空陌生目录：' + dir + '（默认拒绝覆盖）',
+      hint: '确认目录用途后加 --force 覆盖同名运行件（无关文件保留）；或改用 --dir 指定空目录。',
+      exitCode: 2,
+    };
+  }
+
+  const payload = {
+    action: 'install-self',
+    dryRun,
+    dir,
+    version,
+    files: RUNTIME_PAYLOAD.slice(),
+    registry: registryFile,
+    overwrite: exists,
+    forced: Boolean(stranger && force),
+    exitCode: 0,
+  };
+  if (dryRun) return { ok: true, ...payload };
+
+  for (const name of RUNTIME_PAYLOAD) {
+    copyEntry(path.join(src, name), path.join(dir, name));
+  }
+
+  const registry = readSelfRegistry(options);
+  const entry = { dir, version, installedAt: nowIso(), source: src };
+  const index = registry.installs.findIndex((item) => samePath(item.dir, dir));
+  if (index >= 0) registry.installs[index] = entry;
+  else registry.installs.push(entry);
+  writeSelfRegistry(options, registry);
+
+  return { ok: true, ...payload, installs: registry.installs };
+}
+
+function whereInfo(opts) {
+  const options = opts || {};
+  const running = safeRealpath(process.argv[1] || '');
+  const registry = readSelfRegistry(options);
+  return {
+    action: 'where',
+    running,
+    version: readPackageVersion(packageRoot()),
+    defaultDir: defaultSelfDir(options),
+    hubDir: hubLib.resolveHubDir(options),
+    registry: selfRegistryPath(options),
+    installs: registry.installs.map((item) => ({
+      dir: item.dir,
+      version: item.version || null,
+      installedAt: item.installedAt || null,
+      source: item.source || null,
+      current: running ? isInside(item.dir, running) : false,
+    })),
+  };
+}
+
+module.exports = {
+  SELF_REGISTRY_VERSION,
+  RUNTIME_PAYLOAD,
+  resolveSelfRoot,
+  selfRegistryPath,
+  defaultSelfDir,
+  readSelfRegistry,
+  writeSelfRegistry,
+  installSelf,
+  whereInfo,
+};

package/skills/yotta-skills/references/hub.md

@@ -55,12 +55,48 @@ Hub 真源对清单声明了 `runtimePayload` 的技能（元忆 / 元阁：`bin
 `hub doctor` 的 `link_scope:*` 检查只读报告「位于默认范围之外」的已建链接，
 并给出 `hub unlink --dir <目录>` 的清理提示；`hub hosts` 输出三类的本机计数。
 
+## 宿主状态细分与自定义注册（0.29.0 起）
+
+每条宿主目录带生命周期状态（`hub hosts` / 面板宿主矩阵）：
+
+- **可用**：目录存在 + 实体证据（应用标记 / 用户注册 / 手动标记）—— 默认链接 / 分发；
+- **残留**：目录存在 + 无实体证据（卸载残留或 CLI-only 安装）—— 默认保留使用（仍可链接），
+  可显式清理；文案统一「实体未确认」，不判定「已卸载」；
+- **未创建**：目录不存在且无实体证据 —— 安装宿主后自动出现；
+- **仅标记**：已装实体、技能目录未创建 —— `hub link --agent <id>` 会创建目录并链接。
+
+`hub doctor` 的 `host_state:*` 检查对残留 / 仅标记给 info 提示，不判 fail。
+自定义宿主目录可用 `hub hosts add` 注册进发现 / 分发 / 收编范围（只注册，
+不创建目录、不改宿主配置；移除注册绝不删目录）：
+
+```bash
+# 注册 / 查看 / 移除自定义宿主（realpath 去重；Hub / 桥接目录拒绝注册）
+npx -y @yottameta/yotta-skills hub hosts add ~/my-agent/skills --label "我的宿主"
+npx -y @yottameta/yotta-skills hub hosts list
+npx -y @yottameta/yotta-skills hub hosts remove ~/my-agent/skills
+
+# 手动标记状态（实体证据不足时）：available / orphan / ignored
+npx -y @yottameta/yotta-skills hub hosts mark ~/my-agent/skills --state orphan
+
+# 清理残留目录：默认预览；--yes 执行 —— 只删指向 Hub 的链接（含死链），
+# 非 Hub 链接 / 非技能内容随目录保留在回收站（7 天，输出恢复路径）
+npx -y @yottameta/yotta-skills hub hosts remove ~/my-agent/skills --purge
+npx -y @yottameta/yotta-skills hub hosts remove ~/my-agent/skills --purge --yes
+```
+
+注册表 = `<root>/hosts.json`（root = `YOTTA_SKILLS_HOME` 或 `~/.yottaskills`，schema v1，
+可 diff）；面板「宿主矩阵 → 添加自定义目录」等价可用，写操作需页面令牌与确认串。
+
 ## 命令
 
 ```bash
 # 发现本机已装智能体与技能目录（文件系统优先；不读元忆 / 注册表）
 npx -y @yottameta/yotta-skills hub hosts
 
+# 状态过滤 / 自定义注册 / 残留清理（详见「宿主状态细分与自定义注册」节）
+npx -y @yottameta/yotta-skills hub hosts --state orphan
+npx -y @yottameta/yotta-skills hub hosts add ~/my-agent/skills --label "我的宿主"
+
 # 安装 / 更新 Hub 真源
 # 范围 = 全家清单 27 + 特殊家族 5；特殊家族跟随各自 npm latest
 # 非元技能不参与更新（来源无统一安装源，用户自行处理）
@@ -86,11 +122,35 @@ npx -y @yottameta/yotta-skills hub link --all --include-discovered
 # 只删除链接，不动 Hub 真源；清理范围外链接用 --dir <目录> 精确指定
 npx -y @yottameta/yotta-skills hub unlink --all
 
+# 指定智能体分发 / 解除（只影响该宿主；Hub 真源保留）
+npx -y @yottameta/yotta-skills hub link yotta-memory --agent codex
+npx -y @yottameta/yotta-skills hub unlink yotta-memory --agent codex
+
+# 彻底删除 Hub 技能：全宿主清链接（含死链）+ 目录入回收站 + 清台账 + 审计
+npx -y @yottameta/yotta-skills hub remove my-skill --dry-run
+
 # 查看来源、版本、链接宿主与异常
 npx -y @yottameta/yotta-skills hub status
 npx -y @yottameta/yotta-skills hub doctor
 ```
 
+## 删除技能（hub remove，0.28.3 起）
+
+`hub remove <slug>` 五阶段 fail-closed：
+
+1. **preflight（只读）**：逐目录分类健康链接 / 死链 / 漂移链接 / 指向 Hub 外链接 /
+   真副本 / 不存在；`--dry-run` 到此为止（零写入）。
+2. **unlink**：只删指向 Hub 的链接（含死链）；报错即中止，不进入下一步。
+3. **trash**：Hub 目录移入 `<hub>/../trash/<stamp>/hub-remove/<slug>`，保留 7 天；
+   跨卷自动回退「复制 → 校验 → 删源」。
+4. **ledger**：定向删 `.yotta-hub.json` 条目 + 过滤 `.yotta-links.json`
+   （不调 `syncHubState`，防止把删除记回 `missing`）。
+5. **审计 + 汇总**：写 `remove` 审计；无痕迹时退出码 4。
+
+边界：真副本 / 外部链接一律保留并报告（真副本版本高于 Hub 时逐条提示）；
+`--agent` / `--dir` 收窄仅用于「Hub 目标已缺失」的死链清理；恢复路径 =
+从回收站取回 + `hub install` 重装 + `hub link` 重建。
+
 ## 宿主发现口径
 
 1. 已收录宿主映射（81 条；兼容 Vercel Labs `skills` CLI / SkillCat 的公开宿主表，
@@ -121,9 +181,11 @@ npx -y @yottameta/yotta-skills view --port 8790
 
 面板只在 `127.0.0.1`（默认 8789）监听，零远程资源、零遥测，只读写 Hub
 目录与台账 / 证据文件，不读元忆、不改宿主全局配置。六个视图：概览、宿主矩阵、
-收编向导、链接与体检、记录与回滚、路由与编排，另附高级 CLI 页。
+收编向导、链接与体检、记录与回滚、路由与编排，另附**全量 CLI 页**（全部命令 /
+子命令 + 人话说明 + 可复制示例 + 完整选项，与 `--help` 单一真源）。
 
-动作边界：收编 / 链接 / 解除 / 回滚可执行（预览 → 确认 → 执行 → 证据）；
+动作边界：收编 / 链接 / 解除 / 回滚 / 删除技能可执行（预览 → 确认 → 执行 → 证据；
+删除技能需手输 slug 二次确认）；概览 Hub 内容行可过滤后直接删除技能；
 install / update / refresh 只在高级 CLI 页给出可复制命令，不在网页执行。
 写操作需要页面会话令牌，解除与回滚需要破坏性确认串；收编始终逐项运行元信
 扫描，high / critical 阻断。
@@ -132,6 +194,8 @@ install / update / refresh 只在高级 CLI 页给出可复制命令，不在网
 
 - `unlink` 只删除 lstat 确认为链接、且 readlink 目标位于 Hub 内的路径。
 - 真目录 / 非 Hub 链接一律拒绝删除；`--force` 对真目录先备份再替换。
+- `remove` 只删指向 Hub 的链接与 Hub 内目录；链接清理报错即中止、不删 Hub；
+  Hub 目录入回收站保留 7 天，可恢复。
 - 收敛只动元技能在宿主目录中的旧副本：移入回收站（7 天）而非直删；
   不碰插件与宿主 MCP 配置；外部技能源文件绝不修改。
 - Hub 仅本机使用，不对外分发技能内容。

package/skills/yotta-skills/references/skill-list.md

@@ -1,14 +1,14 @@
 # 全家技能清单（27 个）
 
 > 机器权威源：`skills.json`（随包分发）；本文件为人工可读副本，新技能发布后须同步更新
-> `skills.json`（登记表为内部台账，不随包分发）。清单更新日期：2026-10-02。
+> `skills.json`（登记表为内部台账，不随包分发）。清单更新日期：2026-10-03。
 
 | slug | 中文名 | npm 包 | 清单版本 | 家族 | 说明 |
 |---|---|---|---|---|
 | `yotta-anti-shallow` | 元谨 | `@yottameta/yotta-anti-shallow` | 1.4.2 | quality | 防 AI 敷衍规则引擎（深入分析/根因追溯时激活） |
 | `yotta-code-quality` | 元质 | `@yottameta/yotta-code-quality` | 0.4.3 | quality | 结对式代码质量评审（十二类腐化风险 + 0-100 健康分） |
 | `yotta-workflow` | 元序 | `@yottameta/yotta-workflow` | 0.4.3 | workflow | 跨会话/跨项目通用工作流协议（状态就近存） |
-| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.22.0 | memory | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
+| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.22.1 | memory | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
 | `yotta-learn` | 元习 | `@yottameta/yotta-learn` | 0.2.2 | memory | 学习沉淀 CLI：错误/纠正/洞见沉淀为 .learnings/ 条目 |
 | `yotta-security-audit` | 元安 | `@yottameta/yotta-security-audit` | 0.3.1 | security | 安全扫描引擎：13 类检测器 + 系统安全基线 + 学生数据隐私（教育版） |
 | `yotta-vetter` | 元审 | `@yottameta/yotta-vetter` | 0.2.7 | security | 安全审查协议：四阶段 review + SAFE TO INSTALL 判定 |