@yottameta/yotta-skills 0.19.12 → 0.19.14

package/CHANGELOG.md

@@ -1,3 +1,34 @@
+## v0.19.14 (2026-09-21)
+
+**清单同步：元忆 0.16.2（首启修复）**
+
+- `skills.json` / `references/skill-list.md` 的 yotta-memory 版本 0.16.1 → 0.16.2，`updated` → 2026-09-21。
+- 同步内容：元忆 0.16.2 首启修复——空加密库 `view` 恢复钥匙解锁、非 TTY `--password-stdin`、`--recovery-key-out`、缺 `agent-key` 降级未授权、空明文 `migrate`、doctor 分档与 `view` 端口健康检查。
+- 安装器 / 路由 / hook 契约零变更；本版仅为清单与版本同步。
+
+## v0.19.13 (2026-09-19)
+
+**安全修复：校验器（元信）发现改为「受信安装记录 + 身份 + 摘要」三重绑定。**
+
+- 背景（平台扫描发现，T07 工具劫持）：旧实现通过本地技能注册表里 `slug=yotta-verify` 的
+  `source_dirs` 发现扫描引擎，而注册表身份来自被扫描技能自己 `SKILL.md` frontmatter 的 `name`。
+  任意目录只要自称 `yotta-verify` 并提供 `scripts/yotta_verify.py`，就会被当作引擎执行——
+  既可直接执行任意代码，也能伪造 `SAFE TO INSTALL` 放行后续安装。
+- 修复：
+  - 新增 `lib/trusted-verifier.js`：受信记录 `~/.yottaskills/trusted-verifier.json`
+    （与注册表同目录，支持 `YOTTA_SKILLS_REGISTRY_FILE` 多 agent 隔离），只在安装管线
+    校验通过、元信安装 / 更新成功后写入。
+  - `findVerifier` 只认两类来源：用户显式指定（`--verify` / `YOTTA_SKILLS_VERIFY`）与
+    受信记录；候选须通过「路径 realpath 无符号链接跳转 + 包身份（slug / package / trust /
+    SKILL.md 与 manifest 版本一致）+ 引擎 SHA-256 与记录一致」。
+  - 任一环节不满足即 fail-closed：不再回退到注册表 / 目标目录里的同名引擎，改走自举安装
+    （从 npm 重装一份干净的元信，装完立即写记录）。
+  - 自举安装后新增身份 / 摘要复核，未通过不返回引擎。
+- 测试：新增 `test/trusted-verifier.test.js` 8 项（含 T07 回归、摘要不符、身份不符、版本不符、
+  裸引擎不被采用、记录读写往返）；测试夹具 `test/helpers/fake-npm.js` 按真实元信包形态
+  生成 manifest；`node --test "test/*.test.js"` 180/180。
+- 清单同步：`skills.json` 元信 0.3.1 → 0.3.2（`references/skill-list.md` 同步）。
+
 ## v0.19.12 (2026-09-19)
 
 同步家族维护批次清单版本：元安全 0.2.6 / 元盾 0.1.4 / 元察 0.2.9 / 元析 0.1.7 / 元安 0.2.4 / 元审 0.2.5。

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: yotta-skills
-version: 0.19.12
+version: 0.19.14
 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:
@@ -341,10 +341,14 @@ npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄" --json
 - `INSTALL WITH CAUTION` / `REVIEW REQUIRED`：继续安装，但显示风险并写入证据；
 - `DO NOT INSTALL` 或扫描失败：阻断，不替换旧版本。
 
-引擎查找顺序：`--verify` 指定路径 → 环境变量 `YOTTA_SKILLS_VERIFY` → 目标目录下已装的
-`yotta-verify/scripts/yotta_verify.py`。`--skip-scan` 只保留为人工应急路径，使用时输出
-`explicit-unverified` 并写入 `~/.yottaskills/install-log.jsonl`；`update --auto` 不会使用
-该开关。
+引擎查找顺序（v0.19.13 收紧）：`--verify` 指定路径 → 环境变量 `YOTTA_SKILLS_VERIFY` →
+**受信安装记录**（`~/.yottaskills/trusted-verifier.json`，由安装管线在元信安装 / 更新成功后写入，
+记录包身份 + 引擎路径 + SHA-256）。候选引擎必须同时满足：路径不经符号链接跳转、
+包内 `SKILL.md` 与 `skill-manifest.json` 身份一致（slug / package / trust / 版本）、
+引擎摘要与记录一致；任一不满足即 fail-closed，改走自举安装。
+不再按本地注册表里 `name: yotta-verify` 的目录发现引擎。
+`--skip-scan` 只保留为人工应急路径，使用时输出 `explicit-unverified` 并写入
+`~/.yottaskills/install-log.jsonl`；`update --auto` 不会使用该开关。
 
 ## 支持智能体
 

package/bin/yotta-skills.js

@@ -29,6 +29,7 @@ const http = require('http');
 const https = require('https');
 const evidenceLib = require('../lib/install-evidence');
 const gateLib = require('../lib/verify-gate');
+const trustedVerifierLib = require('../lib/trusted-verifier');
 const healthLib = require('../lib/install-health');
 const lifecycleLib = require('../lib/install-lifecycle');
 const snapshotLib = require('../lib/install-snapshot');
@@ -37,7 +38,7 @@ const hookAdapterLib = require('../lib/hook-adapter');
 const { createInstaller, isSafeTarEntry } = require('../lib/install-pipeline');
 
 const PKG_ROOT = path.join(__dirname, '..');
-let VERSION = '0.19.11';
+let VERSION = '0.19.14';
 try { VERSION = require(path.join(PKG_ROOT, 'package.json')).version; } catch (_) { /* keep fallback */ }
 
 function loadManifest() {
@@ -542,8 +543,26 @@ function detectProjectDir() {
 
 // ── 元信 scan 与安装门禁 ──────────────────────────────────────────────────
 function findVerifyEngine(dest, opts) {
-  const registry = require('../lib/skills-scan').readRegistry();
-  return gateLib.findVerifier({ dest, opts, registry });
+  // v0.19.13：不再用注册表（身份来自被扫描技能自己的 frontmatter）发现校验器，
+  // 只认安装管线写入的受信记录（路径 + 摘要双绑定）。
+  return gateLib.findVerifier({ dest, opts, trustedVerifier: trustedVerifierLib.loadRecord() });
+}
+
+/** 安装 / 更新元信成功后写入受信记录（身份 + 摘要），后续门禁只认这份记录。 */
+function recordTrustedVerifier(dest) {
+  const engine = path.join(dest, 'yotta-verify', 'scripts', 'yotta_verify.py');
+  const check = trustedVerifierLib.verifyEngine(engine, { requireRecord: false });
+  if (!check.ok) return null;
+  const record = {
+    slug: check.info.slug,
+    package: check.info.package,
+    version: check.info.version,
+    path: check.path,
+    sha256: check.info.sha256,
+    recordedAt: new Date().toISOString(),
+  };
+  trustedVerifierLib.saveRecord(record);
+  return record;
 }
 
 function findPython(opts) {
@@ -678,6 +697,9 @@ function ensureGate(context) {
     if (result.status !== 'ok') return { ok: false, error: '元信自举失败: ' + result.note };
     const installedEngine = path.join(dest, 'yotta-verify', 'scripts', 'yotta_verify.py');
     if (!fs.existsSync(installedEngine)) return { ok: false, error: '元信自举后未找到安装引擎' };
+    if (!recordTrustedVerifier(dest)) {
+      return { ok: false, error: '元信自举后身份 / 摘要校验未通过（fail-closed，不执行该引擎）' };
+    }
     return { ok: true, engine: installedEngine, mode: 'trusted-bootstrap' };
   } finally {
     if (tmp) fs.rmSync(tmp, { recursive: true, force: true });
@@ -708,6 +730,7 @@ function runInstall(opts, dest) {
       if (r.gate && r.gate.mode === 'explicit-unverified') {
         out('  ⚠ ' + s.slug.padEnd(22) + '未执行装前扫描（explicit-unverified）');
       }
+      if (s.slug === 'yotta-verify') recordTrustedVerifier(dest);
       out('  ✔ ' + s.slug.padEnd(22) + s.name + '  -> ' + (r.version || '?'));
     }
     else if (r.status === 'skip') out('  - ' + s.slug.padEnd(22) + s.name + '  （' + r.note + '，v' + r.version + '）');
@@ -744,6 +767,7 @@ function runUpdate(opts, dest) {
       if (r.gate && r.gate.mode === 'explicit-unverified') {
         out('  ⚠ ' + s.slug.padEnd(22) + '未执行装前扫描（explicit-unverified）');
       }
+      if (s.slug === 'yotta-verify') recordTrustedVerifier(dest);
       out('  ✔ ' + s.slug.padEnd(22) + s.name + '  -> ' + (r.version || '?') + (existing ? '（原 v' + existing + '）' : '（新装）'));
     }
     else if (r.status === 'skip') out('  - ' + s.slug.padEnd(22) + s.name + '  （' + r.note + '）');

package/lib/trusted-verifier.js

@@ -0,0 +1,156 @@
+'use strict';
+/**
+ * yotta-skills 受信校验器（元信）记录与身份校验（v0.19.13）。
+ *
+ * 背景：旧实现用「本地技能注册表里 slug=yotta-verify 的 source_dirs」发现校验器，
+ * 而注册表身份来自被扫描技能自己 SKILL.md frontmatter 的 `name` —— 任意目录只要自称
+ * `yotta-verify` 并提供 `scripts/yotta_verify.py`，就会被当作扫描引擎执行
+ * （可执行任意代码，并可伪造 `SAFE TO INSTALL` 结论）。
+ *
+ * 新模型：
+ *   1. 只有「安装管线校验通过后写入的安装记录」才算受信来源（路径 + SHA-256 双绑定）；
+ *   2. 记录缺失 / 摘要不符 / 身份不符 / 路径经符号链接跳转 → 一律 fail-closed，
+ *      交由上层走自举安装（从 npm 重新装一份干净的元信）；
+ *   3. 用户显式指定（`--verify` / `YOTTA_SKILLS_VERIFY`）保留为人工可信路径，不参与本校验。
+ *
+ * 零依赖：只用 Node.js 标准库。
+ */
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const RECORD_FILE_NAME = 'trusted-verifier.json';
+const REGISTRY_DIR_NAME = '.yottaskills';
+const EXPECTED = {
+  slug: 'yotta-verify',
+  pkg: '@yottameta/yotta-verify',
+  trust: 'yottameta',
+};
+
+/** 安装记录路径：与注册表同目录（支持 YOTTA_SKILLS_REGISTRY_FILE 多 agent 隔离）。 */
+function recordPath(registryFile) {
+  if (registryFile) return path.join(path.dirname(path.resolve(registryFile)), RECORD_FILE_NAME);
+  const override = String(process.env.YOTTA_SKILLS_REGISTRY_FILE || '').trim();
+  if (override) return path.join(path.dirname(path.resolve(override)), RECORD_FILE_NAME);
+  return path.join(os.homedir(), REGISTRY_DIR_NAME, RECORD_FILE_NAME);
+}
+
+function sha256File(file) {
+  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+
+function loadRecord(registryFile) {
+  try {
+    const value = JSON.parse(fs.readFileSync(recordPath(registryFile), 'utf8'));
+    return (value && typeof value === 'object') ? value : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function saveRecord(record, registryFile) {
+  const file = recordPath(registryFile);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(record, null, 2) + '\n', 'utf8');
+  return file;
+}
+
+function frontmatterValue(skillFile, key) {
+  let text;
+  try {
+    text = fs.readFileSync(skillFile, 'utf8');
+  } catch (_) {
+    return null;
+  }
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!m) return null;
+  const re = new RegExp('^' + key + ':\\s*(.+?)\\s*$', 'm');
+  const hit = m[1].match(re);
+  return hit ? hit[1].replace(/^["']|["']$/g, '') : null;
+}
+
+/**
+ * 检查候选引擎是否「长得像」一份元信包（不做信任判定）：
+ * 路径不能经符号链接跳转；包内必须有 SKILL.md + skill-manifest.json，
+ * 且 slug / package / trust / 版本与 SKILL.md 一致。
+ */
+function inspectPackage(enginePath) {
+  if (!enginePath) return { ok: false, reason: '未指定引擎路径' };
+  const resolved = path.resolve(String(enginePath));
+  let real;
+  try {
+    if (!fs.statSync(resolved).isFile()) return { ok: false, reason: '引擎路径不是文件' };
+    real = fs.realpathSync(resolved);
+  } catch (_) {
+    return { ok: false, reason: '引擎文件不存在' };
+  }
+  if (real !== resolved) return { ok: false, reason: '引擎路径经符号链接跳转，拒绝' };
+
+  const skillDir = path.dirname(path.dirname(resolved));
+  const skillFile = path.join(skillDir, 'SKILL.md');
+  const manifestFile = path.join(skillDir, 'skill-manifest.json');
+  if (!fs.existsSync(skillFile)) return { ok: false, reason: '缺少 SKILL.md' };
+  if (!fs.existsSync(manifestFile)) return { ok: false, reason: '缺少 skill-manifest.json' };
+
+  const skillName = frontmatterValue(skillFile, 'name');
+  if (skillName !== EXPECTED.slug) {
+    return { ok: false, reason: 'SKILL.md name 不是 ' + EXPECTED.slug };
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+  } catch (_) {
+    return { ok: false, reason: 'skill-manifest.json 解析失败' };
+  }
+  if (manifest.slug !== EXPECTED.slug) return { ok: false, reason: 'manifest slug 不符' };
+  if (manifest.package !== EXPECTED.pkg) return { ok: false, reason: 'manifest package 不符' };
+  if (manifest.trust !== EXPECTED.trust) return { ok: false, reason: 'manifest trust 不符' };
+  const skillVersion = frontmatterValue(skillFile, 'version');
+  if (!skillVersion || manifest.version !== skillVersion) {
+    return { ok: false, reason: 'manifest 与 SKILL.md 版本不一致' };
+  }
+
+  return {
+    ok: true,
+    path: resolved,
+    reason: null,
+    info: {
+      slug: manifest.slug,
+      package: manifest.package,
+      version: manifest.version,
+      skillDir: skillDir,
+      sha256: sha256File(resolved),
+    },
+  };
+}
+
+/** 身份 + 摘要双绑定校验：options.record 为安装记录（缺失即 fail-closed）。 */
+function verifyEngine(enginePath, options) {
+  const opts = options || {};
+  const inspected = inspectPackage(enginePath);
+  if (!inspected.ok) return inspected;
+  const record = opts.record;
+  if (opts.requireRecord === false) return inspected;
+  if (!record || !record.path || !record.sha256) {
+    return { ok: false, reason: '缺少受信安装记录（fail-closed）' };
+  }
+  if (path.resolve(String(record.path)) !== inspected.path) {
+    return { ok: false, reason: '安装记录路径与候选引擎不一致' };
+  }
+  if (String(record.sha256).toLowerCase() !== inspected.info.sha256.toLowerCase()) {
+    return { ok: false, reason: '引擎摘要与安装记录不一致' };
+  }
+  return inspected;
+}
+
+module.exports = {
+  RECORD_FILE_NAME,
+  EXPECTED,
+  recordPath,
+  sha256File,
+  loadRecord,
+  saveRecord,
+  inspectPackage,
+  verifyEngine,
+};

package/lib/verify-gate.js

@@ -1,35 +1,46 @@
 'use strict';
 const fs = require('fs');
 const path = require('path');
+const trusted = require('./trusted-verifier');
 
 const SAFE = 'SAFE TO INSTALL';
 const CAUTION = 'INSTALL WITH CAUTION';
 const REVIEW = 'REVIEW REQUIRED';
 const BLOCK = 'DO NOT INSTALL';
 
-function candidateVerifierPaths(dest, opts) {
+/** 用户显式指定的引擎（人工可信，不做身份判定）。 */
+function explicitCandidates(opts) {
   const candidates = [];
   if (opts && opts.verify) candidates.push(path.resolve(opts.verify));
   if (process.env.YOTTA_SKILLS_VERIFY) candidates.push(path.resolve(process.env.YOTTA_SKILLS_VERIFY));
-  if (dest) candidates.push(path.join(dest, 'yotta-verify', 'scripts', 'yotta_verify.py'));
   return candidates;
 }
 
+/**
+ * 定位元信扫描引擎（v0.19.13 收紧）。
+ *
+ * 旧实现会读本地注册表里 slug=yotta-verify 的 source_dirs，而注册表身份来自被扫描技能
+ * 自己 SKILL.md frontmatter 的 name —— 伪造目录即可劫持校验器（执行任意代码 + 伪造
+ * SAFE 结论）。现只认两类来源：
+ *   ① 用户显式指定：--verify / YOTTA_SKILLS_VERIFY；
+ *   ② 安装管线写入的受信记录：包身份（slug / package / trust / 版本）+ 路径 realpath
+ *      + 引擎 SHA-256 与记录一致。
+ * 其余一律返回 null（fail-closed），由上层走自举安装。
+ */
 function findVerifier(context) {
-  const registry = context.registry;
-  const candidates = candidateVerifierPaths(context.dest, context.opts);
-  if (registry && registry.skills && registry.skills['yotta-verify']) {
-    for (const dir of registry.skills['yotta-verify'].source_dirs || []) {
-      candidates.push(path.join(dir, 'scripts', 'yotta_verify.py'));
-    }
-  }
-  for (const candidate of candidates) {
+  const ctx = context || {};
+  for (const candidate of explicitCandidates(ctx.opts || {})) {
     try {
       if (fs.statSync(candidate).isFile()) return candidate;
     } catch (_) {
       // Try the next candidate.
     }
   }
+  const record = ctx.trustedVerifier;
+  if (record && record.path) {
+    const check = trusted.verifyEngine(record.path, { record });
+    if (check.ok) return check.path;
+  }
   return null;
 }
 
@@ -74,6 +85,7 @@ module.exports = {
   CAUTION,
   REVIEW,
   BLOCK,
+  explicitCandidates,
   findVerifier,
   parseScanOutput,
   evaluateVerdict,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yottameta/yotta-skills",
-  "version": "0.19.12",
+  "version": "0.19.14",
   "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
   "license": "MIT",
   "keywords": [

package/references/skill-list.md

@@ -8,12 +8,12 @@
 | `yotta-anti-shallow` | 元谨 | `@yottameta/yotta-anti-shallow` | 1.4.0 | 防 AI 敷衍规则引擎（深入分析/根因追溯时激活） |
 | `yotta-code-quality` | 元质 | `@yottameta/yotta-code-quality` | 0.4.1 | 结对式代码质量评审（十二类腐化风险 + 0-100 健康分） |
 | `yotta-workflow` | 元序 | `@yottameta/yotta-workflow` | 0.4.1 | 跨会话/跨项目通用工作流协议（状态就近存） |
-| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.16.1 | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
+| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.16.2 | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
 | `yotta-learn` | 元习 | `@yottameta/yotta-learn` | 0.2.1 | 学习沉淀 CLI：错误/纠正/洞见沉淀为 .learnings/ 条目 |
 | `yotta-security-audit` | 元安 | `@yottameta/yotta-security-audit` | 0.2.4 | 安全扫描引擎：13 类检测器 + 系统安全基线 |
 | `yotta-vetter` | 元审 | `@yottameta/yotta-vetter` | 0.2.5 | 安全审查协议：四阶段 review + SAFE TO INSTALL 判定 |
 | `yotta-recon` | 元析 | `@yottameta/yotta-recon` | 0.1.7 | 跨智能体网络侦察：零依赖端口/服务/版本指纹探测 |
-| `yotta-guardian` | 元盾 | `@yottameta/yotta-guardian` | 0.1.4 | 跨智能体危险调用拦截护栏：确定性规则 + 可插拔意图验证 |
+| `yotta-guardian` | 元盾 | `@yottameta/yotta-guardian` | 0.1.5 | 跨智能体危险调用拦截护栏：确定性规则 + 可插拔意图验证 |
 | `yotta-humanize` | 元真 | `@yottameta/yotta-humanize` | 0.2.1 | 去 AI 味中文写作编辑：检测器引擎 |
 | `yotta-logs` | 元史 | `@yottameta/yotta-logs` | 0.3.1 | 跨智能体历史会话 / 记忆日志检索 |
 | `yotta-security-testing` | 元测 | `@yottameta/yotta-security-testing` | 0.3.1 | 有纪律的 AI 安全测试方法论 + Scope Guard 五道防线 |
@@ -26,7 +26,7 @@
 | `yotta-chain` | 元链 | `@yottameta/yotta-chain` | 0.1.4 | 供应链依赖校验引擎 |
 | `yotta-triage` | 元鉴 | `@yottameta/yotta-triage` | 0.1.3 | 恶意样本静态初筛引擎（哈希/熵/字符串/PE-ELF） |
 | `yotta-prompt` | 元引 | `@yottameta/yotta-prompt` | 0.2.2 | 意图澄清 + 生态入口（常驻注入，map 串联元阁全家） |
-| `yotta-verify` | 元信 | `@yottameta/yotta-verify` | 0.3.1 | 装前安全扫描器 + audited 徽章（prompt injection + 危险模式） |
+| `yotta-verify` | 元信 | `@yottameta/yotta-verify` | 0.3.2 | 装前安全扫描器 + audited 徽章（prompt injection + 危险模式） |
 
 ## 家族分布
 

package/scripts/yotta-skills-mcp.py

@@ -26,7 +26,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-VERSION = "0.19.12"
+VERSION = "0.19.14"
 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.19.12",
+  "version": "0.19.14",
   "trust": "yottameta",
   "install": {
     "idempotent": true

package/skills.json

@@ -1,6 +1,6 @@
 {
   "manifestVersion": 1,
-  "updated": "2026-09-19",
+  "updated": "2026-09-21",
   "note": "清单同步要求：每次技能发布新版本后，按 YottaSkills 技能登记表更新本文件（登记表为内部台账，不随包分发）。",
   "skills": [
     {
@@ -28,7 +28,7 @@
       "slug": "yotta-memory",
       "name": "元忆",
       "pkg": "@yottameta/yotta-memory",
-      "version": "0.16.1",
+      "version": "0.16.2",
       "desc": "有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT）"
     },
     {
@@ -63,7 +63,7 @@
       "slug": "yotta-guardian",
       "name": "元盾",
       "pkg": "@yottameta/yotta-guardian",
-      "version": "0.1.4",
+      "version": "0.1.5",
       "desc": "跨智能体危险调用拦截护栏：确定性规则 + 可插拔意图验证"
     },
     {
@@ -154,7 +154,7 @@
       "slug": "yotta-verify",
       "name": "元信",
       "pkg": "@yottameta/yotta-verify",
-      "version": "0.3.1",
+      "version": "0.3.2",
       "desc": "装前安全扫描器 + audited 徽章（prompt injection + 危险模式）"
     }
   ]