@yottameta/yotta-skills 0.20.0 → 0.20.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v0.20.2 (2026-09-29)
+- 家族安装的 npm 拉包新增镜像回退：默认源返回 404（国内镜像未同步该版本 tarball）时自动改用官方源 `https://registry.npmjs.org/` 重试一次；安装输出显示回退行，安装证据新增 `npm_registry_fallback` 字段。
+- 两次都失败时给出可直接复制的修复提示（`npm_config_registry` / `YOTTA_SKILLS_NPM_FLAGS`）；已显式指定 registry 或设置 `YOTTA_SKILLS_NO_FALLBACK=1` 时不回退。
+- 非 404 错误（网络超时等）不触发回退，保持原失败信息。
+- 静态 playbook / 路由 / hook / scanPolicy 契约零变更。
+
+## v0.20.1 (2026-09-29)
+- 家族安装接入 scanPolicy 例外复核：元信判 `DO NOT INSTALL` 时，按包内 `scan-policy.json` 的已审查例外（逐条绑定技能 + 版本 + treeHash + 规则 + 路径）复核，豁免检测规则表 / 攻防样例 / 文档说明类命中；复核后无阻断级发现则继续安装。
+- 修复元忆 / 元察 / 元鉴从元阁安装时被元信自指误报阻断的问题（检测类技能自带规则表字面量）；例外表与 handoff / OpenCode 的 scanPolicy 同源，由 `tools/build_scan_policy.py` 生成。
+- 技能升版或内容变化后旧例外自动失效（treeHash 绑定，fail-closed），安装回到元信原始判定。
+- 安装日志新增 `scan_policy` 字段（是否应用 / 豁免条数 / version / treeHash）。
+- 元信扫描输出解析失败（空输出 / 截断 / 子进程抖动）自动重试一次；仍失败时报错带退出码与 stderr 摘要。
+- 静态 playbook / 路由 / hook 契约零变更。
+
 ## v0.20.0 (2026-09-28)
 - 新增 `o1.route` 动态扩展口：`--route` / MCP `route_request` 可选调用用户配置的本地扩展提供方（provider），在已装注册表白名单内增补 / 重排路由结果。
 - 静态 playbook 结果先算必算；未配置或未授权 / 超时 / 非法输出时一律回落静态结果，文本输出与历史一致，`--json` 增加 `dynamic` 状态块。

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: yotta-skills
-version: 0.20.0
+version: 0.20.2
 description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点 + 运行时 hook 适配。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么组合使用（安装与调用均由用户确认后执行）」；安装层：一条命令把 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，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / 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）：只做「组合策划 + 静态路由建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index + hook 适配」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能、不静默写宿主配置或全局记忆；家族安装先自举或调用元信装前门禁，DO NOT INSTALL 阻断，非元阁家族包不自动安装。
 license: MIT
 metadata:
@@ -348,6 +348,12 @@ npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄" --json
 - `INSTALL WITH CAUTION` / `REVIEW REQUIRED`：继续安装，但显示风险并写入证据；
 - `DO NOT INSTALL` 或扫描失败：阻断，不替换旧版本。
 
+扫描后元阁会用包内 `scan-policy.json`（已审查例外表）复核：每条例外绑定「技能 + 版本 +
+内容 treeHash + 规则 + 路径」，只豁免检测规则表、攻防样例与文档说明这类已审查命中。
+技能升版或内容有任何变化，旧例外自动失效（fail-closed），安装回到元信原始判定。
+命中例外的安装会显示 `↳ scanPolicy 复核：豁免 N 条已审查发现` 并写入安装证据；
+未命中例外的 `DO NOT INSTALL` 照常阻断。
+
 引擎查找顺序（v0.19.13 收紧）：`--verify` 指定路径 → 环境变量 `YOTTA_SKILLS_VERIFY` →
 **受信安装记录**（`~/.yottaskills/trusted-verifier.json`，由安装管线在元信安装 / 更新成功后写入，
 记录包身份 + 引擎路径 + SHA-256）。候选引擎必须同时满足：路径不经符号链接跳转、
@@ -369,14 +375,16 @@ npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄" --json
 |---|---|
 | `YOTTA_SKILLS_NPM` | 指定 npm 可执行文件（同 `--npm`） |
 | `YOTTA_SKILLS_NPM_FLAGS` | 追加传给 `npm pack` 的参数（按空白拆分，如 `--registry=...`） |
+| `YOTTA_SKILLS_NO_FALLBACK` | 设为 `1` 时禁用「默认源 404 → 官方源重试」的自动回退 |
 | `YOTTA_SKILLS_PYTHON` | 指定 python 可执行文件（元信 scan 用，同 `--python`） |
 | `YOTTA_SKILLS_VERIFY` | 指定 yotta_verify.py 路径（同 `--verify`） |
 | `YOTTA_SKILLS_MANIFEST` | 指定技能清单 JSON 路径（默认随包 skills.json） |
 
 ## 常见问题
 
-- **npmmirror 全新包 404**：镜像同步有延迟，通过 `YOTTA_SKILLS_NPM_FLAGS` 追加
-  `--registry=https://registry.npmjs.org/`（国内需代理）或等待镜像缓存后重试。
+- **npmmirror 全新包 404**：默认源返回 404 时安装器会**自动**改用官方源
+  `https://registry.npmjs.org/` 重试一次（输出显示回退行，安装证据记 `npm_registry_fallback`）；
+  若已显式指定 registry 或设置 `YOTTA_SKILLS_NO_FALLBACK=1`，则保持在指定源上，失败时给出可复制的修复提示。
 - **未收录智能体**：`--agent <name>` 报未收录时，改用 `--dir` 指到它的技能目录。
 - **Windows 下 npm 报错**：CLI 已内置 npm-cli.js 解析，无需额外处理；如需覆盖用 `--npm`。
 - **某技能安装失败**：汇总报告会列出失败原因，可单装该技能排查。

package/bin/yotta-skills.js

@@ -35,10 +35,12 @@ const lifecycleLib = require('../lib/install-lifecycle');
 const snapshotLib = require('../lib/install-snapshot');
 const updateCheckLib = require('../lib/update-check');
 const hookAdapterLib = require('../lib/hook-adapter');
+const scanPolicyLib = require('../lib/scan-policy');
+const npmPackLib = require('../lib/npm-pack');
 const { createInstaller, isSafeTarEntry } = require('../lib/install-pipeline');
 
 const PKG_ROOT = path.join(__dirname, '..');
-let VERSION = '0.20.0';
+let VERSION = '0.20.2';
 try { VERSION = require(path.join(PKG_ROOT, 'package.json')).version; } catch (_) { /* keep fallback */ }
 
 function loadManifest() {
@@ -586,50 +588,44 @@ function runScan(engine, skillDir) {
   return gateLib.runVerifier(engine, skillDir, { python, spawnSync });
 }
 
-function scanTarget(engine, skillDir) {
+function scanTarget(engine, skillDir, context) {
   const scan = runScan(engine, skillDir);
-  if (scan.ok) {
-    const counts = scan.counts || {};
-    const line = 'critical ' + (counts.critical || 0) + ' / high ' + (counts.high || 0) +
-      ' / medium ' + (counts.medium || 0) + ' / low ' + (counts.low || 0) +
-      ' / info ' + (counts.info || 0);
-    out('  元信 scan: ' + scan.verdict + '（' + line + '）');
-    if (scan.verdict === gateLib.BLOCK) out('  ⚠ 元信 verdict 为 DO NOT INSTALL，已阻断安装。');
-    else if (scan.verdict === gateLib.CAUTION || scan.verdict === gateLib.REVIEW) {
-      out('  ⚠ 元信 verdict 为 ' + scan.verdict + '，继续安装并保留风险证据。');
-    }
-  } else {
+  if (!scan.ok) {
     out('  元信 scan: ' + scan.error);
-  }
-  return scan;
+    return scan;
+  }
+  const ctx = context || {};
+  const reviewed = scanPolicyLib.applyScanPolicy(scan, {
+    slug: ctx.slug,
+    version: ctx.version,
+    pkgDir: skillDir,
+    policy: scanPolicyLib.loadPolicy(path.join(PKG_ROOT, 'scan-policy.json')),
+  });
+  const counts = scan.counts || {};
+  const line = 'critical ' + (counts.critical || 0) + ' / high ' + (counts.high || 0) +
+    ' / medium ' + (counts.medium || 0) + ' / low ' + (counts.low || 0) +
+    ' / info ' + (counts.info || 0);
+  out('  元信 scan: ' + scan.verdict + '（' + line + '）');
+  if (reviewed.policy && reviewed.policy.applied && reviewed.policy.excluded > 0) {
+    out('  ↳ scanPolicy 复核：豁免 ' + reviewed.policy.excluded +
+      ' 条已审查发现（检测规则 / 文档说明，treeHash 绑定）→ ' + reviewed.verdict);
+  }
+  if (reviewed.verdict === gateLib.BLOCK) out('  ⚠ 元信 verdict 为 DO NOT INSTALL，已阻断安装。');
+  else if (reviewed.verdict === gateLib.CAUTION || reviewed.verdict === gateLib.REVIEW) {
+    out('  ⚠ 元信 verdict 为 ' + reviewed.verdict + '，继续安装并保留风险证据。');
+  }
+  return reviewed;
 }
 
 // ── 安装 ───────────────────────────────────────────────────────────────────
+const runNpmPackBase = npmPackLib.createPackRunner({ spawnSync, specOf, resolveNpm });
+
 function runNpmPack(skill, opts, packDir) {
-  const spec = specOf(skill, opts.pin);
-  const args = ['pack', spec, '--pack-destination', packDir];
-  const flags = (process.env.YOTTA_SKILLS_NPM_FLAGS || '').trim();
-  if (flags) args.push(...flags.split(/\s+/));
-  const npm = resolveNpm(opts);
-  const r = spawnSync(npm.bin, [...npm.prefix, ...args], { encoding: 'utf8', timeout: 180000, maxBuffer: 64 * 1024 * 1024, shell: npm.shell });
-  if (r.status !== 0) {
-    const raw = (r.stderr || r.stdout || 'npm pack 失败').trim();
-    const ll = raw.split(/\r?\n/).filter(Boolean);
-    const brief = ll.slice(-4).join(' | ');
-    return { error: brief || 'npm pack 失败', detail: raw };
-  }
-  const lines = (r.stdout || '').split(/\r?\n/).map(l => l.trim()).filter(Boolean);
-  let tarball = null;
-  for (const l of lines) if (/\.tgz$/.test(l)) tarball = l;
-  if (!tarball) {
-    try {
-      const found = fs.readdirSync(packDir).filter(f => f.endsWith('.tgz'));
-      if (found.length === 1) tarball = found[0];
-    } catch (_) { /* ignore */ }
+  const packed = runNpmPackBase(skill, opts, packDir);
+  if (packed.registryFallback) {
+    out('  ↳ npm 默认源 404，已用官方源重试成功（' + npmPackLib.OFFICIAL_REGISTRY + '）');
   }
-  if (!tarball) return { error: '未找到 npm pack 产物（' + spec + '）' };
-  const vm = String(tarball).match(/-([0-9]+\.[0-9]+\.[0-9]+)\.tgz$/);
-  return { tarball: path.join(packDir, tarball), resolved: vm ? vm[1] : null, spec };
+  return packed;
 }
 
 function extractTarball(tarball, extractDir) {

package/install.sh

@@ -89,7 +89,7 @@ install_to() {
       rm -rf -- "$dest/$item"
     fi
   done
-  for item in SKILL.md skill-manifest.json references scripts assets skills.json LICENSE NOTICE README.md README.zh-CN.md CHANGELOG.md USER_GUIDE.md; do
+  for item in SKILL.md skill-manifest.json references scripts assets skills.json scan-policy.json LICENSE NOTICE README.md README.zh-CN.md CHANGELOG.md USER_GUIDE.md; do
     if [ -e "$SOURCE_DIR/$item" ]; then
       cp -RP "$SOURCE_DIR/$item" "$dest/"
     fi

package/lib/install-pipeline.js

@@ -148,7 +148,10 @@ function createInstaller(deps) {
           safeRecord({ event: 'before_install', skill: skill.slug, decision: 'block', error: gate.error });
           return { skill, status: 'fail', version: packed.resolved, note: gate.error, exitCode: 5 };
         }
-        const scanResult = deps.scanTarget(gate.engine, extracted.pkgDir);
+        const scanResult = deps.scanTarget(gate.engine, extracted.pkgDir, {
+          slug: skill.slug,
+          version: packed.resolved,
+        });
         if (!scanResult.ok) {
           safeRecord({ event: 'before_install', skill: skill.slug, decision: 'block', error: scanResult.error });
           return { skill, status: 'fail', version: packed.resolved, note: scanResult.error, exitCode: 5 };
@@ -193,6 +196,7 @@ function createInstaller(deps) {
             decision: 'block',
             verdict: scanResult.verdict,
             counts: scanResult.counts,
+            scan_policy: scanResult.policy || null,
             hook_decision: hookEvaluation.decision,
           });
           return {
@@ -208,6 +212,7 @@ function createInstaller(deps) {
           verdict: scanResult.verdict,
           counts: scanResult.counts,
           warn: verdict.warn,
+          policy: scanResult.policy || null,
         };
       }
 
@@ -332,6 +337,8 @@ function createInstaller(deps) {
           bootstrap_scan: gate.mode === 'trusted-bootstrap' && skill.slug === 'yotta-verify' ? 'self' : null,
           verdict: scan.verdict,
           decision: scan.decision,
+          scan_policy: scan.policy || null,
+          npm_registry_fallback: Boolean(packed.registryFallback),
           snapshot,
         });
       } catch (error) {

package/lib/npm-pack.js

@@ -0,0 +1,104 @@
+'use strict';
+const fs = require('fs');
+const path = require('path');
+
+const OFFICIAL_REGISTRY = 'https://registry.npmjs.org/';
+const FALLBACK_HINT =
+  '提示：镜像同步延迟时可用官方源重试 —— 设置环境变量 npm_config_registry=' + OFFICIAL_REGISTRY +
+  '，或 YOTTA_SKILLS_NPM_FLAGS=--registry=' + OFFICIAL_REGISTRY;
+
+function isNotFound(raw) {
+  const text = String(raw || '');
+  return /\bE404\b/.test(text) || /\b404 Not Found\b/i.test(text) || /could not be found/i.test(text);
+}
+
+function hasRegistryFlag(args) {
+  return (args || []).some((arg) => arg === '--registry' || String(arg).startsWith('--registry='));
+}
+
+function briefOf(raw) {
+  const lines = String(raw || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return lines.slice(-4).join(' | ');
+}
+
+function findTarball(stdout, packDir, readdirSync) {
+  const lines = String(stdout || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  let tarball = null;
+  for (const line of lines) if (/\.tgz$/.test(line)) tarball = line;
+  if (tarball) return tarball;
+  try {
+    const found = readdirSync(packDir).filter((name) => name.endsWith('.tgz'));
+    if (found.length === 1) return found[0];
+  } catch (_) {
+    /* ignore */
+  }
+  return null;
+}
+
+/**
+ * 创建 npm pack 执行器。
+ *
+ * 默认源（国内镜像）拉不到 tarball 时会报 404 —— 此时自动改用官方源重试一次，
+ * 并把 registryFallback 标记回传给安装管线（写入证据）。用户已显式指定 registry、
+ * 或设置 YOTTA_SKILLS_NO_FALLBACK=1 时不重试。
+ */
+function createPackRunner(deps) {
+  const spawnSync = deps.spawnSync;
+  const specOf = deps.specOf;
+  const resolveNpm = deps.resolveNpm;
+  const readdirSync = deps.readdirSync || fs.readdirSync;
+  const fallbackDisabled = deps.fallbackDisabled || (() => process.env.YOTTA_SKILLS_NO_FALLBACK === '1');
+
+  return function runNpmPack(skill, opts, packDir) {
+    const spec = specOf(skill, opts.pin);
+    const baseArgs = ['pack', spec, '--pack-destination', packDir];
+    const flags = (process.env.YOTTA_SKILLS_NPM_FLAGS || '').trim();
+    if (flags) baseArgs.push(...flags.split(/\s+/));
+    const npm = resolveNpm(opts);
+    const attempt = (args) => spawnSync(npm.bin, [...npm.prefix, ...args], {
+      encoding: 'utf8',
+      timeout: 180000,
+      maxBuffer: 64 * 1024 * 1024,
+      shell: npm.shell,
+    });
+
+    let result = attempt(baseArgs);
+    let registryFallback = false;
+    if (result.status !== 0) {
+      const raw = (result.stderr || result.stdout || 'npm pack 失败').trim();
+      if (!fallbackDisabled() && !hasRegistryFlag(baseArgs) && isNotFound(raw)) {
+        result = attempt([...baseArgs, '--registry', OFFICIAL_REGISTRY]);
+        registryFallback = result.status === 0;
+      }
+    }
+    if (result.status !== 0) {
+      const raw = (result.stderr || result.stdout || 'npm pack 失败').trim();
+      const brief = briefOf(raw) || 'npm pack 失败';
+      const hint = isNotFound(raw) ? '\n  ' + FALLBACK_HINT : '';
+      return { error: brief + hint, detail: raw };
+    }
+    const tarball = findTarball(result.stdout, packDir, readdirSync);
+    if (!tarball) return { error: '未找到 npm pack 产物（' + spec + '）' };
+    const versionMatch = String(tarball).match(/-([0-9]+\.[0-9]+\.[0-9]+)\.tgz$/);
+    return {
+      tarball: path.join(packDir, tarball),
+      resolved: versionMatch ? versionMatch[1] : null,
+      spec,
+      registryFallback,
+    };
+  };
+}
+
+module.exports = {
+  OFFICIAL_REGISTRY,
+  FALLBACK_HINT,
+  isNotFound,
+  hasRegistryFlag,
+  createPackRunner,
+};

package/lib/scan-policy.js

@@ -0,0 +1,209 @@
+'use strict';
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const VERDICT_SAFE = 'SAFE TO INSTALL';
+const VERDICT_CAUTION = 'INSTALL WITH CAUTION';
+const VERDICT_REVIEW = 'REVIEW REQUIRED';
+const VERDICT_BLOCK = 'DO NOT INSTALL';
+
+const VERDICT_BY_SEVERITY = {
+  critical: VERDICT_BLOCK,
+  high: VERDICT_CAUTION,
+  medium: VERDICT_REVIEW,
+  low: VERDICT_SAFE,
+  info: VERDICT_SAFE,
+};
+const SEVERITY_ORDER = ['critical', 'high', 'medium', 'low', 'info'];
+const VERIFY_SCANNER = 'yotta-verify';
+
+// 与 tools/build_opencode_bundle.py（handoff 构建器）逐字节同口径：
+// 例外表绑定 prune 后的技能树 treeHash，技能升版或内容变化后旧例外自动失效（fail-closed）。
+const REMOVE_NAMES = new Set([
+  '.git', '.github', '.gitignore', '.npmignore', 'test', 'bin',
+  'package.json', 'package-lock.json', 'install.sh', 'server.json',
+  '__pycache__', '.pytest_cache', '.mypy_cache',
+]);
+const KEEP_EXTRA = {
+  'yotta-memory': ['bin'],
+  'yotta-skills': ['bin', 'lib', 'skills.json', 'scan-policy.json'],
+};
+const PRUNE_DIRS = new Set(['__pycache__', '.pytest_cache', '.mypy_cache']);
+const HASH_SKIP_FILES = new Set(['.yotta-managed.json']);
+
+function normalizeRel(value) {
+  return String(value == null ? '' : value).replace(/\\/g, '/').replace(/^\.\//, '');
+}
+
+function loadPolicy(policyPath) {
+  try {
+    const raw = fs.readFileSync(policyPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || !parsed.skills) return null;
+    return parsed;
+  } catch (_) {
+    return null;
+  }
+}
+
+function keepExtraFor(slug) {
+  return new Set(KEEP_EXTRA[slug] || []);
+}
+
+function collectRows(dir, relBase, keepExtra, depth, rows) {
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_) {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const rel = relBase ? relBase + '/' + entry.name : entry.name;
+    if (entry.isDirectory()) {
+      if (PRUNE_DIRS.has(entry.name)) continue;
+      if (depth === 0 && REMOVE_NAMES.has(entry.name) && !keepExtra.has(entry.name)) continue;
+      collectRows(path.join(dir, entry.name), rel, keepExtra, depth + 1, rows);
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    if (depth === 0 && REMOVE_NAMES.has(entry.name) && !keepExtra.has(entry.name)) continue;
+    if (entry.name.endsWith('.pyc') || entry.name.endsWith('.pyo')) continue;
+    if (HASH_SKIP_FILES.has(rel)) continue;
+    let data;
+    try {
+      data = fs.readFileSync(path.join(dir, entry.name));
+    } catch (_) {
+      continue;
+    }
+    rows.push({ rel, hash: crypto.createHash('sha256').update(data).digest('hex') });
+  }
+}
+
+function computeTreeHash(pkgDir, slug) {
+  const rows = [];
+  collectRows(pkgDir, '', keepExtraFor(slug), 0, rows);
+  rows.sort((a, b) => Buffer.compare(Buffer.from(a.rel, 'utf8'), Buffer.from(b.rel, 'utf8')));
+  const manifest = rows.map((row) => Buffer.concat([
+    Buffer.from(row.rel, 'utf8'),
+    Buffer.from('\0', 'ascii'),
+    Buffer.from(row.hash, 'ascii'),
+    Buffer.from('\n', 'ascii'),
+  ]));
+  const digest = crypto.createHash('sha256').update(Buffer.concat(manifest)).digest('hex');
+  return 'sha256:' + digest;
+}
+
+function summarize(findings) {
+  const counts = { critical: 0, high: 0, medium: 0, low: 0, info: 0 };
+  for (const finding of findings) {
+    const severity = finding && finding.severity;
+    if (Object.prototype.hasOwnProperty.call(counts, severity)) counts[severity] += 1;
+  }
+  let verdict = VERDICT_SAFE;
+  for (const severity of SEVERITY_ORDER) {
+    if (counts[severity]) {
+      verdict = VERDICT_BY_SEVERITY[severity];
+      break;
+    }
+  }
+  return { counts, verdict };
+}
+
+function exceptionMatches(exception, finding) {
+  if (!exception || exception.action !== 'allow') return false;
+  const scanners = Array.isArray(exception.scanners) ? exception.scanners : [];
+  if (scanners.length > 0 && !scanners.includes(VERIFY_SCANNER)) return false;
+  if (String(exception.rule || '') !== String(finding.rule_id || '')) return false;
+  return normalizeRel(exception.path) === normalizeRel(finding.file);
+}
+
+/**
+ * 用随包分发的 scanPolicy 例外表复核元信扫描结果。
+ *
+ * 绑定校验（缺一即不生效，fail-closed）：skill 条目存在 + version 一致 + treeHash 一致。
+ * 只有 action=allow 且 scanners 含 yotta-verify 的例外才会豁免对应 (rule, path) 发现。
+ */
+function applyScanPolicy(scan, context) {
+  const ctx = context || {};
+  const base = {
+    applied: false,
+    reason: null,
+    excluded: 0,
+    excludedFindings: [],
+    version: null,
+    treeHash: null,
+  };
+  const result = { ...scan, policy: base };
+  if (!scan || !scan.ok) {
+    result.policy.reason = 'scan-failed';
+    return result;
+  }
+  const policy = ctx.policy;
+  const slug = ctx.slug;
+  const version = ctx.version;
+  const pkgDir = ctx.pkgDir;
+  if (!policy || !slug || !pkgDir) {
+    result.policy.reason = 'policy-unavailable';
+    return result;
+  }
+  const entry = policy.skills[slug];
+  if (!entry) {
+    result.policy.reason = 'no-entry';
+    return result;
+  }
+  if (!Array.isArray(scan.findings)) {
+    result.policy.reason = 'findings-unavailable';
+    return result;
+  }
+  if (entry.version !== version) {
+    result.policy.reason = 'version-mismatch';
+    return result;
+  }
+  const treeHash = computeTreeHash(pkgDir, slug);
+  result.policy.version = entry.version;
+  result.policy.treeHash = treeHash;
+  if (entry.treeHash !== treeHash) {
+    result.policy.reason = 'treehash-mismatch';
+    return result;
+  }
+  const exceptions = Array.isArray(entry.exceptions) ? entry.exceptions : [];
+  const kept = [];
+  for (const finding of scan.findings) {
+    const hit = exceptions.find((exception) => exceptionMatches(exception, finding));
+    if (hit) {
+      result.policy.excludedFindings.push({
+        rule: finding.rule_id,
+        path: normalizeRel(finding.file),
+        severity: finding.severity,
+        reason: hit.reason || null,
+      });
+      continue;
+    }
+    kept.push(finding);
+  }
+  const summary = summarize(kept);
+  result.policy.applied = true;
+  result.policy.reason = 'applied';
+  result.policy.excluded = result.policy.excludedFindings.length;
+  result.verdict = summary.verdict;
+  result.counts = summary.counts;
+  result.findings = kept;
+  return result;
+}
+
+module.exports = {
+  VERDICT_SAFE,
+  VERDICT_CAUTION,
+  VERDICT_REVIEW,
+  VERDICT_BLOCK,
+  REMOVE_NAMES,
+  KEEP_EXTRA,
+  normalizeRel,
+  loadPolicy,
+  computeTreeHash,
+  summarize,
+  exceptionMatches,
+  applyScanPolicy,
+};

package/lib/verify-gate.js

@@ -48,11 +48,17 @@ function parseScanOutput(stdout) {
   try {
     const value = JSON.parse(String(stdout || ''));
     if (!value || typeof value.verdict !== 'string') {
-      return { ok: false, verdict: null, counts: null, error: '扫描输出缺少 verdict' };
+      return { ok: false, verdict: null, counts: null, findings: null, error: '扫描输出缺少 verdict' };
     }
-    return { ok: true, verdict: value.verdict, counts: value.counts || {}, error: null };
+    return {
+      ok: true,
+      verdict: value.verdict,
+      counts: value.counts || {},
+      findings: Array.isArray(value.findings) ? value.findings : null,
+      error: null,
+    };
   } catch (error) {
-    return { ok: false, verdict: null, counts: null, error: error.message };
+    return { ok: false, verdict: null, counts: null, findings: null, error: error.message };
   }
 }
 
@@ -62,22 +68,70 @@ function evaluateVerdict(verdict) {
   return { decision: 'block', block: true, warn: true };
 }
 
-function runVerifier(engine, target, options) {
-  const result = options.spawnSync(options.python, ['-B', engine, 'scan', target, '--json'], {
+function runScanOnce(engine, target, options) {
+  return options.spawnSync(options.python, ['-B', engine, 'scan', target, '--json'], {
     encoding: 'utf8',
     timeout: 60000,
+    maxBuffer: 32 * 1024 * 1024,
   });
+}
+
+function stderrBrief(result) {
+  const text = String((result && result.stderr) || '').trim();
+  if (!text) return '';
+  return text.split(/\r?\n/).filter(Boolean).slice(-2).join(' | ').slice(0, 300);
+}
+
+/**
+ * 元信扫描是只读幂等操作：解析失败（空输出 / 截断 / 进程异常）时重试一次，
+ * 避免偶发的子进程抖动把安装判死；两次都失败才按阻断处理。
+ */
+function runVerifier(engine, target, options) {
+  const opts = options || {};
+  const retries = opts.retries === undefined ? 1 : Math.max(0, Number(opts.retries) || 0);
+  let result = null;
+  let parsed = null;
+  for (let attempt = 0; attempt <= retries; attempt += 1) {
+    result = runScanOnce(engine, target, opts);
+    if (!result || result.error || result.status === null) {
+      parsed = null;
+      continue;
+    }
+    parsed = parseScanOutput(result.stdout);
+    if (parsed.ok) break;
+  }
   if (result && result.error) {
-    return { ok: false, verdict: null, counts: null, error: result.error.message, exitCode: null };
+    return { ok: false, verdict: null, counts: null, findings: null, error: result.error.message, exitCode: null };
   }
   if (!result || result.status === null) {
-    return { ok: false, verdict: null, counts: null, error: '元信 scan 执行失败', exitCode: null };
+    return {
+      ok: false,
+      verdict: null,
+      counts: null,
+      findings: null,
+      error: '元信 scan 执行失败（超时或无法启动）',
+      exitCode: null,
+    };
   }
-  const parsed = parseScanOutput(result.stdout);
-  if (!parsed.ok) {
-    return { ok: false, verdict: null, counts: null, error: parsed.error, exitCode: result.status };
+  if (!parsed || !parsed.ok) {
+    const brief = stderrBrief(result);
+    return {
+      ok: false,
+      verdict: null,
+      counts: null,
+      findings: null,
+      error: '元信 scan 输出无法解析（exit ' + result.status + '）' + (brief ? ': ' + brief : ''),
+      exitCode: result.status,
+    };
   }
-  return { ok: true, verdict: parsed.verdict, counts: parsed.counts, error: null, exitCode: result.status };
+  return {
+    ok: true,
+    verdict: parsed.verdict,
+    counts: parsed.counts,
+    findings: parsed.findings,
+    error: null,
+    exitCode: result.status,
+  };
 }
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-skills",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
   "license": "MIT",
   "keywords": [
@@ -26,6 +26,7 @@
     "lib",
     "scripts",
     "skills.json",
+    "scan-policy.json",
     "!**/__pycache__",
     "!**/*.pyc"
   ],

package/references/install-flow.md

@@ -8,7 +8,8 @@
 对每个待装技能：
 
 1. 读清单（`skills.json`，默认随包；`YOTTA_SKILLS_MANIFEST` 可覆盖）；
-2. `npm pack <pkg>@<spec> --pack-destination <临时目录>`；
+2. `npm pack <pkg>@<spec> --pack-destination <临时目录>`（默认源返回 404 时自动改用官方源重试一次，
+   证据记 `npm_registry_fallback`）；
 3. 系统 `tar -xzf` 解压到临时目录（产物应有 `SKILL.md`）；
 4. 读取包内 `skill-manifest.json`；没有 manifest 时使用 `skills.json` 的家族默认契约；
 5. 校验 slug / package / version / 权限 / 生命周期脚本路径；
@@ -85,6 +86,9 @@
   与 `bootstrap_scan=self`，随后用元信扫描其余家族包；
 - verdict 处置：`SAFE TO INSTALL` 继续；`INSTALL WITH CAUTION` / `REVIEW REQUIRED`
   继续但显示风险并留证；`DO NOT INSTALL` 和扫描失败阻断，不替换目标；
+- scanPolicy 复核：`DO NOT INSTALL` 时用包内 `scan-policy.json` 的已审查例外复核（逐条绑定
+  skill + version + treeHash + 规则 + 路径；缺失 / 不匹配一律 fail-closed）；豁免后无阻断级
+  发现则继续，显示 `↳ scanPolicy 复核：豁免 N 条已审查发现` 并把 `scan_policy` 写进安装证据；
 - `--skip-scan` 只保留为人工应急路径，使用时输出 `explicit-unverified` 并写入证据；
 - `update --auto` 始终执行装前门禁，不接受 `--skip-scan`。
 

package/references/tutorial.md

@@ -108,8 +108,8 @@ npx -y @yottameta/yotta-skills rollback --slug yotta-memory --agent codex
 
 ## 10. 常见问题
 
-- **npmmirror 全新包 404**：镜像同步有延迟。设置环境变量 `YOTTA_SKILLS_NPM_FLAGS` 为
-  `--registry=https://registry.npmjs.org/`（国内需代理）再执行，或等待镜像缓存后重试。
+- **npmmirror 全新包 404**：镜像同步有延迟时安装器会自动改用官方源重试一次（默认行为）；
+  如需固定在指定源，设置 `YOTTA_SKILLS_NPM_FLAGS=--registry=...` 或 `YOTTA_SKILLS_NO_FALLBACK=1`。
 - **`--agent` 报未收录**：改用 `--dir` 指到该智能体的技能目录（`.agents/skills` 不是
   通用目录）。
 - **某技能安装失败**：汇总报告给出失败原因；可单装该技能排查：

package/scan-policy.json

@@ -0,0 +1,525 @@
+{
+  "schemaVersion": 1,
+  "generatedFrom": "tools/build_opencode_bundle.py SCAN_SPECS",
+  "note": "元信装前扫描例外表；绑定 skill+version+treeHash(fail-closed)，仅供已审查的检测规则/文档说明类命中豁免。",
+  "skippedSkills": [
+    "yotta-dev-mcp"
+  ],
+  "skills": {
+    "yotta-anti-shallow": {
+      "version": "1.4.1",
+      "treeHash": "sha256:81fbbb00cb39ff09f8c6a35e6099228bfadcd71394cace26e5ca61d87cba5e56",
+      "files": 7,
+      "bytes": 220568,
+      "mode": "strict",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-001",
+          "path": "README.md",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": false,
+          "reason": "user-control-documentation"
+        }
+      ]
+    },
+    "yotta-chain": {
+      "version": "0.1.4",
+      "treeHash": "sha256:ba455f7460fc0b0b6469d57cbd13b60c7a103fb85c0619bb5f61efcd4085f5a2",
+      "files": 9,
+      "bytes": 274372,
+      "mode": "strict",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "HIS-001E",
+          "path": "scripts/yotta_chain.py",
+          "action": "allow",
+          "category": "sensitive-read",
+          "detection": false,
+          "reason": "dependency-manifest-analysis"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "HIS-002",
+          "path": "scripts/yotta_chain.py",
+          "action": "allow",
+          "category": "data-exfiltration",
+          "detection": false,
+          "reason": "dependency-manifest-analysis"
+        }
+      ]
+    },
+    "yotta-guardian": {
+      "version": "0.1.7",
+      "treeHash": "sha256:7bc0b09d06b6b6dbbb8cb29601ccdb2a41b1b9bdfd96d78af2c10ede035dce16",
+      "files": 13,
+      "bytes": 267260,
+      "mode": "detection",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-020",
+          "path": "README.zh-CN.md",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-020",
+          "path": "SKILL.md",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "NET-008",
+          "path": "SKILL.md",
+          "action": "allow",
+          "category": "network-call",
+          "detection": true,
+          "reason": "detection-rule"
+        }
+      ]
+    },
+    "yotta-logwatch": {
+      "version": "0.3.0",
+      "treeHash": "sha256:fbe53b95f9fb738555f2936c8285fa6857613328d0c667f73a259fb3bccfbef5",
+      "files": 13,
+      "bytes": 267453,
+      "mode": "detection",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "SKILL.md",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "README.zh-CN.md",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "references/powershell-log-rules.md",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "OBF-001",
+          "path": "references/web-log-rules.md",
+          "action": "allow",
+          "category": "obfuscation",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "scripts/yotta_logwatch.py",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-020",
+          "path": "references/powershell-log-rules.md",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-028",
+          "path": "scripts/yotta_logwatch.py",
+          "action": "allow",
+          "category": "credential-harvest",
+          "detection": true,
+          "reason": "detection-rule"
+        }
+      ]
+    },
+    "yotta-memory": {
+      "version": "0.19.0",
+      "treeHash": "sha256:05b7befbd1dcc565bb231fa70971c3947ea24dcb2eca7cf353f3667fd02a68e3",
+      "files": 18,
+      "bytes": 1160686,
+      "mode": "strict",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-002",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-007",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-009",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-012",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-020",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-022",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-026",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "memory-store-scanner-rule-table"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "HIS-002",
+          "path": "bin/yotta-memory.js",
+          "action": "allow",
+          "category": "data-exfiltration",
+          "detection": false,
+          "reason": "config-dir-read-and-local-http-server-are-separated"
+        }
+      ]
+    },
+    "yotta-recon": {
+      "version": "0.1.7",
+      "treeHash": "sha256:d3d04d34fe4416017b8b4304b0ce78bc1447b908f7d01747826924cde2adead2",
+      "files": 11,
+      "bytes": 275665,
+      "mode": "detection",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "NET-004",
+          "path": "references/protocol-probes.md",
+          "action": "allow",
+          "category": "network-call",
+          "detection": false,
+          "reason": "authorized-scan-capability"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "NET-004",
+          "path": "scripts/yotta_recon.py",
+          "action": "allow",
+          "category": "network-call",
+          "detection": false,
+          "reason": "authorized-scan-capability"
+        }
+      ]
+    },
+    "yotta-security-audit": {
+      "version": "0.3.0",
+      "treeHash": "sha256:bffcb3573f64b11d2b78e6aa5793e6db35f1f429f9a7dc7ad2b49cd8ab25ea8c",
+      "files": 15,
+      "bytes": 355942,
+      "mode": "detection",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-020",
+          "path": "README.zh-CN.md",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-020",
+          "path": "SKILL.md",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-020",
+          "path": "references/threat-patterns.md",
+          "action": "allow",
+          "category": "prompt-injection",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "PIJ-028",
+          "path": "README.zh-CN.md",
+          "action": "allow",
+          "category": "credential-harvest",
+          "detection": true,
+          "reason": "detection-rule"
+        }
+      ]
+    },
+    "yotta-triage": {
+      "version": "0.1.3",
+      "treeHash": "sha256:f1dabde26bf05cf9b36cc28ebe5522ba3af558a6824306bd4a85ad583684df5c",
+      "files": 10,
+      "bytes": 233925,
+      "mode": "detection",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "references/risk-model.md",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "references/triage-spec.md",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "DEX-007",
+          "path": "scripts/yotta_triage.py",
+          "action": "allow",
+          "category": "remote-download",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "OBF-003",
+          "path": "scripts/yotta_triage.py",
+          "action": "allow",
+          "category": "obfuscation",
+          "detection": true,
+          "reason": "detection-rule"
+        },
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "NET-008",
+          "path": "references/triage-spec.md",
+          "action": "allow",
+          "category": "network-call",
+          "detection": true,
+          "reason": "detection-rule"
+        }
+      ]
+    },
+    "yotta-vetter": {
+      "version": "0.2.6",
+      "treeHash": "sha256:691ff78f9a7e1a46d1595d97b6a97d84e94bdcb5c159f9d743f7f0e875063382",
+      "files": 11,
+      "bytes": 222254,
+      "mode": "strict",
+      "exceptions": [
+        {
+          "scanners": [
+            "yotta-verify",
+            "yotta-agent-hardening"
+          ],
+          "rule": "NET-006",
+          "path": "scripts/yotta_vetter.py",
+          "action": "allow",
+          "category": "network-call",
+          "detection": false,
+          "reason": "documented-source-check"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "CRE-002",
+          "path": "CHANGELOG.md",
+          "action": "allow",
+          "category": "credential-access",
+          "detection": false,
+          "reason": "detection-changelog"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "CRE-003",
+          "path": "CHANGELOG.md",
+          "action": "allow",
+          "category": "credential-access",
+          "detection": false,
+          "reason": "detection-changelog"
+        },
+        {
+          "scanners": [
+            "yotta-agent-hardening"
+          ],
+          "rule": "CRE-005",
+          "path": "CHANGELOG.md",
+          "action": "allow",
+          "category": "credential-access",
+          "detection": false,
+          "reason": "detection-changelog"
+        }
+      ]
+    }
+  }
+}

package/scripts/yotta-skills-mcp.py

@@ -26,7 +26,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-VERSION = "0.20.0"
+VERSION = "0.20.2"
 TOOL_NAME = "yotta-skills"
 CN_NAME = "元阁"
 MCP_PROTOCOL_MODERN = "2026-07-28"

package/skill-manifest.json

@@ -3,7 +3,7 @@
   "slug": "yotta-skills",
   "name": "元阁",
   "package": "@yottameta/yotta-skills",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "trust": "yottameta",
   "install": {
     "idempotent": true