@yottameta/yotta-skills-plugin 0.19.28 → 0.20.0

package/.agents/plugins/marketplace.json

@@ -12,7 +12,7 @@
         "authentication": "ON_INSTALL"
       },
       "category": "Developer Tools",
-      "version": "0.19.28",
+      "version": "0.20.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.19.28",
+      "version": "0.20.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.19.28",
+  "version": "0.20.0",
   "description": "YuanGe (元阁) — orchestration and routing for the YottaMeta skill family, packaged as a YottaMeta Agent Plugin.",
   "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.19.28",
+  "version": "0.20.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,6 +1,6 @@
 ---
 name: yotta-skills
-version: 0.19.28
+version: 0.20.0
 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:
@@ -43,6 +43,7 @@ metadata:
 **元阁全家的总编排策划 + 编排路由 + 一键安装 + 技能盘点**，一句话四层：
 
 - **路由层（该用哪几个）**：`--route "<需求摘要>"` / MCP `route_request` 查本地注册表与静态编排 playbook，输出候选组合、调用顺序、每个技能角色、置信度、依据、已装/缺失状态与安装命令；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；只建议安装，不自动安装。
+- **动态扩展口（v0.20.0，capability `o1.route`）**：可选调用用户显式配置的本地扩展提供方（provider），在已装注册表白名单内对路由结果增补 / 重排；静态 playbook 结果先算必算、永不缺席，未配置或调用失败时文本输出与历史一致，`--json` 仅多一个 `dynamic` 状态块。协议与配置见 `references/provider-protocol.md`。
 - **策划层（怎么用）**：接到需求，先按「编排策划」定位命中哪个组合——哪些元技能搭配起来最强、适合什么场景、AI 该给出什么安装与调用建议（**安装与调用均由用户确认后执行**）。
 - **安装层（怎么装）**：一条 `npx -y @yottameta/yotta-skills` 把组合/全家装进指定智能体或目录——`--list` 看清单、`install` 装、`update` 增量更新、`doctor` 只读自检、`rollback` 恢复快照、`--dry-run` 预览、`--pin` 锁版本。
 

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

@@ -38,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.28';
+let VERSION = '0.20.0';
 try { VERSION = require(path.join(PKG_ROOT, 'package.json')).version; } catch (_) { /* keep fallback */ }
 
 function loadManifest() {
@@ -1202,12 +1202,110 @@ function runReindex(opts) {
   out('注册表: ' + scan.registryPath());
 }
 
+function dynamicBlock(status, providerId, note) {
+  return {
+    status: status || 'not_installed',
+    provider_id: providerId || '',
+    applied: false,
+    added: [],
+    dropped: [],
+    note: note || '',
+  };
+}
+
+/**
+ * o1.route 动态扩展口：静态结果先算必算；provider 只允许在已装注册表白名单内增补 / 重排，
+ * 任何失败都回静态结果（fail-open）。协议见 references/provider-protocol.md。
+ */
+function applyDynamicRoute(result, registry, opts) {
+  const provider = require('../lib/provider');
+  let run;
+  try {
+    run = provider.runCapability('o1.route', {
+      request: String(opts.route || ''),
+      static_result: {
+        playbook: result.playbook.id,
+        confidence: result.confidence,
+        skills: result.skills.map((skill) => skill.slug),
+      },
+      installed_skills: Object.values(registry.skills || {})
+        .filter((record) => record && record.status !== 'gone')
+        .map((record) => ({ slug: record.slug, version: record.version || '', sources: record.sources || [] })),
+    });
+  } catch (e) {
+    return dynamicBlock('error', '', '动态路由装载失败：' + e.message);
+  }
+  const block = dynamicBlock(run.status, run.provider_id, run.note || run.message || '');
+  if (run.status !== 'active' || !run.data || typeof run.data !== 'object') return block;
+
+  const installed = new Set(Object.values(registry.skills || {})
+    .filter((record) => record && record.status !== 'gone')
+    .map((record) => record.slug));
+  const requested = Array.isArray(run.data.skills) ? run.data.skills : [];
+  const seen = new Set();
+  const ordered = [];
+  for (const item of requested) {
+    const slug = item && typeof item === 'object' ? String(item.slug || '') : '';
+    if (!slug) continue;
+    if (seen.has(slug) || !installed.has(slug)) {
+      block.dropped.push(slug);
+      continue;
+    }
+    seen.add(slug);
+    ordered.push({ slug, role: typeof item.role === 'string' ? item.role : '' });
+  }
+  if (!ordered.length) return block;
+
+  const staticBySlug = new Map(result.skills.map((skill) => [skill.slug, skill]));
+  const next = [];
+  for (const item of ordered) {
+    const existing = staticBySlug.get(item.slug);
+    if (existing) {
+      next.push(existing);
+      continue;
+    }
+    const record = registry.skills[item.slug] || {};
+    next.push({
+      slug: item.slug,
+      order: 0,
+      role: item.role || '由扩展提供方补充',
+      installed: true,
+      version: record.version || '',
+      sources: record.sources || [],
+      variants: Array.isArray(record.variants) ? record.variants : [],
+      conflicts: Array.isArray(record.conflicts) ? record.conflicts : [],
+    });
+  }
+  for (const skill of result.skills) {
+    if (!next.some((item) => item.slug === skill.slug)) next.push(skill);
+  }
+  next.forEach((skill, index) => { skill.order = index + 1; });
+  block.added = next.filter((skill) => !staticBySlug.has(skill.slug)).map((skill) => skill.slug);
+  block.applied = true;
+  result.skills = next;
+  return block;
+}
+
+function dynamicRouteText(block) {
+  if (!block) return '';
+  if (block.status === 'active') {
+    const who = block.provider_id ? '提供方 ' + block.provider_id : '提供方';
+    return '已应用（' + who + '；新增 ' + block.added.length + ' / 丢弃 ' + block.dropped.length + '）';
+  }
+  if (block.status === 'license_required') return '需授权（该能力需要授权后使用；静态路由不受影响）';
+  if (block.status === 'timeout') return '未生效（提供方超时，已回落静态路由）';
+  if (block.status === 'invalid_output') return '未生效（提供方输出无效，已回落静态路由）';
+  if (block.status === 'error') return '未生效（提供方异常，已回落静态路由）';
+  return block.status;
+}
+
 /** --route：静态编排路由，输出组合、顺序、角色、缺失技能建议与其他已装技能候选。 */
 function runRoute(opts) {
   const { routeRequest, defaultYottaSlugs } = require('../lib/route');
   const { registry } = reindexRegistry(opts);
   const yottaSlugs = new Set([...defaultYottaSlugs(), ...MANIFEST.map((s) => s.slug)]);
   const result = routeRequest(opts.route, { registry, yottaSlugs });
+  result.dynamic = applyDynamicRoute(result, registry, opts);
   if (opts.json) {
     out(JSON.stringify(result, null, 2));
     return;
@@ -1244,6 +1342,10 @@ function runRoute(opts) {
     }
     out('安全提示: 其他已装技能只读 frontmatter description 做机械匹配，不读取全文指令、不自动调用；使用/安装前请先执行装前安全扫描，决定权在用户。');
   }
+  if (result.dynamic.status !== 'not_installed') {
+    out('');
+    out('动态路由: ' + dynamicRouteText(result.dynamic));
+  }
   out('');
   out('应用模式: 显式调用（可经用户确认后切换为按场景自动调用）');
   out('说明: ' + result.disclaimer);

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

@@ -0,0 +1,248 @@
+'use strict';
+
+// 扩展提供方（provider）装载器 v1：外部子进程 + stdin/stdout JSON。
+// 设计：docs/路线B-P1-接口预留设计-2026-09-28.md（根仓库）；对外协议：references/provider-protocol.md。
+// 零依赖；未配置 / 任何失败都 fail-open 回开源基线，不阻断调用方。
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+const SCHEMA = 1;
+const DEFAULT_TIMEOUT_MS = 600;
+const MAX_TIMEOUT_MS = 5000;
+const MIN_TIMEOUT_MS = 50;
+const MAX_STDOUT_BYTES = 256 * 1024;
+const KNOWN_CAPABILITIES = ['o1.route', 'm1.adjudicate', 'memory.hook', 'context.paging'];
+
+function providerHome() {
+  const fromEnv = process.env.YOTTA_PROVIDER_HOME;
+  if (fromEnv && String(fromEnv).trim()) return path.resolve(String(fromEnv).trim());
+  return path.join(os.homedir(), '.yottameta');
+}
+
+function configPath() {
+  return path.join(providerHome(), 'provider.json');
+}
+
+function validateProvider(item) {
+  if (!item || typeof item !== 'object' || Array.isArray(item)) return 'provider 条目必须是对象';
+  if (!item.id || typeof item.id !== 'string') return 'provider 缺 id';
+  if (!Array.isArray(item.capabilities) || !item.capabilities.length) return 'provider ' + item.id + ' 缺 capabilities';
+  for (const capability of item.capabilities) {
+    if (KNOWN_CAPABILITIES.indexOf(capability) === -1) return 'provider ' + item.id + ' 含未知 capability：' + capability;
+  }
+  if (!Array.isArray(item.command) || !item.command.length) return 'provider ' + item.id + ' 的 command 必须是数组';
+  for (const part of item.command) {
+    if (typeof part !== 'string' || !part) return 'provider ' + item.id + ' 的 command 含非法参数';
+    if (part.indexOf('\0') !== -1) return 'provider ' + item.id + ' 的 command 含非法字符';
+  }
+  if (item.timeout_ms !== undefined && (!Number.isFinite(item.timeout_ms) || item.timeout_ms <= 0)) {
+    return 'provider ' + item.id + ' 的 timeout_ms 非法';
+  }
+  return '';
+}
+
+function normalizeProvider(item) {
+  return {
+    id: item.id,
+    version: typeof item.version === 'string' ? item.version : '',
+    capabilities: item.capabilities.slice(),
+    command: item.command.slice(),
+    timeout_ms: Math.min(MAX_TIMEOUT_MS, Math.max(MIN_TIMEOUT_MS, Math.round(item.timeout_ms || DEFAULT_TIMEOUT_MS))),
+  };
+}
+
+function readConfig() {
+  const file = configPath();
+  if (!fs.existsSync(file)) return { status: 'not_installed', providers: [], error: '' };
+  let raw;
+  try {
+    raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch (e) {
+    return { status: 'error', providers: [], error: 'provider.json 解析失败：' + e.message };
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    return { status: 'error', providers: [], error: 'provider.json 必须是对象' };
+  }
+  if (raw.schema !== SCHEMA) {
+    return { status: 'error', providers: [], error: 'provider.json schema 不支持：' + String(raw.schema) };
+  }
+  if (!Array.isArray(raw.providers)) {
+    return { status: 'error', providers: [], error: 'provider.json providers 必须是数组' };
+  }
+  const providers = [];
+  for (const item of raw.providers) {
+    const invalid = validateProvider(item);
+    if (invalid) return { status: 'error', providers: [], error: invalid };
+    providers.push(normalizeProvider(item));
+  }
+  return { status: 'ok', providers, error: '' };
+}
+
+function pickProvider(config, capability) {
+  if (!config || config.status !== 'ok') return null;
+  for (const item of config.providers) {
+    if (item.capabilities.indexOf(capability) !== -1) return item;
+  }
+  return null;
+}
+
+function minimalEnv() {
+  const keep = [
+    'PATH', 'Path', 'PATHEXT', 'SystemRoot', 'windir', 'COMSPEC', 'ComSpec',
+    'TEMP', 'TMP', 'HOME', 'USERPROFILE', 'LANG', 'LC_ALL',
+  ];
+  const env = {};
+  for (const key of keep) {
+    if (process.env[key] !== undefined) env[key] = process.env[key];
+  }
+  env.YOTTA_PROVIDER_HOME = providerHome();
+  return env;
+}
+
+function requestId() {
+  try {
+    if (typeof crypto.randomUUID === 'function') return crypto.randomUUID();
+  } catch (e) {
+    // 回退到随机 hex
+  }
+  return crypto.randomBytes(16).toString('hex');
+}
+
+function invokeProvider(provider, capability, payload) {
+  const started = Date.now();
+  const request = {
+    schema: SCHEMA,
+    capability,
+    request_id: requestId(),
+    payload: payload || {},
+  };
+  let proc;
+  try {
+    proc = spawnSync(provider.command[0], provider.command.slice(1), {
+      input: JSON.stringify(request),
+      encoding: 'utf8',
+      timeout: provider.timeout_ms,
+      maxBuffer: MAX_STDOUT_BYTES,
+      shell: false,
+      cwd: providerHome(),
+      env: minimalEnv(),
+      windowsHide: true,
+    });
+  } catch (e) {
+    return {
+      status: 'error',
+      provider_id: provider.id,
+      duration_ms: Date.now() - started,
+      note: 'provider 启动失败：' + e.message,
+    };
+  }
+  const duration = Date.now() - started;
+  if (proc.error) {
+    const code = proc.error.code || '';
+    const timedOut = code === 'ETIMEDOUT';
+    const oversize = code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
+    return {
+      status: timedOut ? 'timeout' : 'error',
+      provider_id: provider.id,
+      duration_ms: duration,
+      note: timedOut
+        ? 'provider 超时'
+        : (oversize
+          ? 'provider 输出超过 ' + MAX_STDOUT_BYTES + ' 字节'
+          : 'provider 执行失败：' + (code || proc.error.message || 'unknown')),
+    };
+  }
+  if (proc.status !== 0) {
+    return {
+      status: 'error',
+      provider_id: provider.id,
+      duration_ms: duration,
+      note: 'provider 退出码非 0：' + proc.status,
+    };
+  }
+  let response;
+  try {
+    response = JSON.parse(String(proc.stdout || '').trim() || '{}');
+  } catch (e) {
+    return { status: 'invalid_output', provider_id: provider.id, duration_ms: duration, note: 'provider 输出不是 JSON' };
+  }
+  if (!response || typeof response !== 'object' || Array.isArray(response)) {
+    return { status: 'invalid_output', provider_id: provider.id, duration_ms: duration, note: 'provider 输出不是对象' };
+  }
+  if (response.ok === false) {
+    const code = typeof response.code === 'string' && response.code ? response.code : 'provider_error';
+    return {
+      status: code === 'license_required' ? 'license_required' : 'error',
+      provider_id: provider.id,
+      code,
+      message: typeof response.message === 'string' ? response.message : '',
+      duration_ms: duration,
+      note: typeof response.message === 'string' ? response.message : code,
+    };
+  }
+  if (response.ok !== true) {
+    return { status: 'invalid_output', provider_id: provider.id, duration_ms: duration, note: 'provider 响应缺 ok 字段' };
+  }
+  return {
+    status: 'active',
+    provider_id: provider.id,
+    data: response.data,
+    duration_ms: duration,
+    bytes_out: Buffer.byteLength(String(proc.stdout || ''), 'utf8'),
+    note: '',
+  };
+}
+
+function appendAudit(entry) {
+  try {
+    const home = providerHome();
+    fs.mkdirSync(home, { recursive: true });
+    fs.appendFileSync(
+      path.join(home, 'provider-audit.jsonl'),
+      JSON.stringify(Object.assign({ schema: SCHEMA, ts: new Date().toISOString() }, entry)) + '\n',
+      'utf8',
+    );
+  } catch (e) {
+    // 审计失败不影响调用
+  }
+}
+
+function runCapability(capability, payload) {
+  const config = readConfig();
+  if (config.status === 'not_installed') {
+    return { status: 'not_installed', provider_id: '', note: '未配置扩展提供方' };
+  }
+  if (config.status === 'error') {
+    return { status: 'error', provider_id: '', note: config.error };
+  }
+  const provider = pickProvider(config, capability);
+  if (!provider) {
+    return { status: 'not_installed', provider_id: '', note: '未配置声明 ' + capability + ' 的提供方' };
+  }
+  const result = invokeProvider(provider, capability, payload);
+  appendAudit({
+    capability,
+    provider_id: result.provider_id,
+    status: result.status,
+    duration_ms: result.duration_ms,
+    bytes_out: result.bytes_out || 0,
+  });
+  return result;
+}
+
+module.exports = {
+  SCHEMA,
+  DEFAULT_TIMEOUT_MS,
+  MAX_TIMEOUT_MS,
+  MAX_STDOUT_BYTES,
+  KNOWN_CAPABILITIES,
+  providerHome,
+  configPath,
+  readConfig,
+  pickProvider,
+  runCapability,
+};

package/skills/yotta-skills/references/provider-protocol.md

@@ -0,0 +1,101 @@
+# 扩展提供方协议 v1（元阁 · capability `o1.route`）
+
+元阁可以可选地调用一个由用户显式配置的**本地扩展提供方（provider）**，由它在已装技能白名单内
+对静态路由结果做增补 / 重排。未配置提供方时，`--route` 的行为与输出与之前完全一致。
+
+## 1. 配置
+
+配置文件：`<YOTTA_PROVIDER_HOME>/provider.json`，默认 `~/.yottameta/provider.json`。
+环境变量 `YOTTA_PROVIDER_HOME` 可覆盖根目录（测试与隔离环境用）。
+
+```json
+{
+  "schema": 1,
+  "providers": [
+    {
+      "id": "local-provider",
+      "version": "0.1.0",
+      "capabilities": ["o1.route"],
+      "command": ["node", "C:/path/to/provider.js"],
+      "timeout_ms": 600
+    }
+  ]
+}
+```
+
+- `command` 必须是**数组**（argv 语义），以 `shell: false` 执行；不接受字符串命令。
+- `timeout_ms` 默认 600，最小 50，最大 5000；超时即回落。
+- 配置文件缺失、解析失败、`command` 非数组、capability 未知：**只记录状态，不阻断命令**；缺失等同「未安装」。
+
+## 2. 调用
+
+- 只在用户显式执行 `--route`（CLI）或 `route_request`（MCP，内部走同一 CLI）时触发；安装 / 更新 / 盘点等路径不触发。
+- 元阁把**一个 JSON 请求**写入 provider 的 stdin（随后关闭），从 stdout 读**一个 JSON 响应**；stderr 只作诊断。
+- stdout 上限 256 KB；超过按错误处理并回落。
+
+```json
+{
+  "schema": 1,
+  "capability": "o1.route",
+  "request_id": "<uuid>",
+  "payload": {
+    "request": "帮我做发布前质量检查",
+    "static_result": {
+      "playbook": "delivery-quality-gate",
+      "confidence": "high",
+      "skills": ["yotta-anti-shallow", "yotta-code-quality", "yotta-publish-guard"]
+    },
+    "installed_skills": [
+      { "slug": "yotta-code-quality", "version": "0.3.0", "sources": ["Codex"] }
+    ]
+  }
+}
+```
+
+## 3. 响应
+
+```json
+{
+  "ok": true,
+  "capability": "o1.route",
+  "data": {
+    "skills": [
+      { "slug": "yotta-code-quality", "role": "可选：补充代码质量评审" },
+      { "slug": "yotta-anti-shallow" }
+    ]
+  }
+}
+```
+
+- `skills[].slug` 必须 ∈ `installed_skills` 白名单；未安装或未知的 slug 会被丢弃并记入 `dropped`，不会写入结果。
+- `role` 可选；缺省时增补条目使用「由扩展提供方补充」。
+- 元阁先算静态结果：provider 给出的顺序用于重排；静态结果中未被提及的技能会**追加保留**，不会丢失。
+- 返回空列表 / 全是不合法 slug：视为未应用（`applied = false`），静态结果原样返回。
+
+需要授权或不可用时：
+
+```json
+{ "ok": false, "code": "license_required", "message": "该能力需要授权后使用" }
+```
+
+## 4. 状态与回落
+
+| 状态 | 触发 | 元阁行为 |
+| --- | --- | --- |
+| `not_installed` | 无配置 / 无匹配 capability | 纯静态路由，文本输出与历史一致 |
+| `active` | 调用成功且响应合法 | 白名单内增补 / 重排，静态结果保留 |
+| `license_required` | provider 明确返回该 code | 纯静态路由 +「需授权」提示 |
+| `timeout` | 超过 `timeout_ms` | 纯静态路由 + 一行状态提示 |
+| `invalid_output` | 非 JSON / 缺 `ok` | 纯静态路由 + 一行状态提示 |
+| `error` | 启动失败 / 退出码非 0 / 输出超限 / 配置非法 | 纯静态路由 + 一行状态提示 |
+
+`--json` 输出始终包含 `dynamic` 块：`status` / `provider_id` / `applied` / `added` / `dropped` / `note`；
+CLI 文本输出只在状态非 `not_installed` 时多一行「动态路由: ...」，退出码不受影响（始终 0）。
+
+## 5. 审计与边界
+
+- 每次实际调用写一行 `<YOTTA_PROVIDER_HOME>/provider-audit.jsonl`：`ts` / `capability` / `provider_id` / `status` / `duration_ms` / `bytes_out`。
+- 审计**不记录**需求原文或任何 payload 内容。
+- 元阁不替 provider 联网；provider 自身行为由它自己的包声明。
+- 删除 `provider.json` 即回到纯静态路由，无残留依赖。
+- provider 输出只当数据使用：白名单外的 slug、非法结构一律丢弃，不作为指令执行。

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

@@ -8,7 +8,7 @@
 | `yotta-anti-shallow` | 元谨 | `@yottameta/yotta-anti-shallow` | 1.4.1 | 防 AI 敷衍规则引擎（深入分析/根因追溯时激活） |
 | `yotta-code-quality` | 元质 | `@yottameta/yotta-code-quality` | 0.4.1 | 结对式代码质量评审（十二类腐化风险 + 0-100 健康分） |
 | `yotta-workflow` | 元序 | `@yottameta/yotta-workflow` | 0.4.2 | 跨会话/跨项目通用工作流协议（状态就近存） |
-| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.18.1 | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
+| `yotta-memory` | 元忆 | `@yottameta/yotta-memory` | 0.19.0 | 有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT） |
 | `yotta-learn` | 元习 | `@yottameta/yotta-learn` | 0.2.1 | 学习沉淀 CLI：错误/纠正/洞见沉淀为 .learnings/ 条目 |
 | `yotta-security-audit` | 元安 | `@yottameta/yotta-security-audit` | 0.3.0 | 安全扫描引擎：13 类检测器 + 系统安全基线 + 学生数据隐私（教育版） |
 | `yotta-vetter` | 元审 | `@yottameta/yotta-vetter` | 0.2.6 | 安全审查协议：四阶段 review + SAFE TO INSTALL 判定 |

package/skills/yotta-skills/scripts/yotta-skills-mcp.py

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

package/skills/yotta-skills/skills.json

@@ -28,7 +28,7 @@
       "slug": "yotta-memory",
       "name": "元忆",
       "pkg": "@yottameta/yotta-memory",
-      "version": "0.18.1",
+      "version": "0.19.0",
       "desc": "有权限边界的文件式智能体记忆（FACT/PREF/BOUND/COMMIT）"
     },
     {