@yottameta/yotta-skills 0.20.1 → 0.21.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## v0.21.0 (2026-09-30)
+- 新增 M1 记忆裁决器开源调用口：`yotta-skills decide-memory` 与 MCP `decide_memory`，调用本地扩展提供方 `m1.adjudicate`，输出每个技能的 `promote / hold / demote` 只读建议、分数与信号明细。
+- 新增本地使用记录：`usage status|enable|disable|mark|reset`；默认关闭，`usage enable` 后 `--route` 才记录结构化 route_hits 与组合对，显式 `usage mark` 记录 used / named / accepted。记录只含 slug、时间、信号类型、playbook / confidence 与组合对，不含需求原文、记忆正文、路径或身份信息。
+- `decide-memory` 默认只读；`--dry-run` 显式只读；`--promote` 只写 `~/.yottaskills/memory-adjudication.json` 建议文件，生成私密 `PREF` 记忆候选，不自动写元忆、不删除任何内容。`--explain` 输出每个信号的得分明细。
+- provider 子进程环境透传授权库相关变量（`YOTTA_LICENSE_HOME` / `YOTTA_LICENSE_KEYS_DIR` / `YOTTA_LICENSE_BASE_URL` / `YOTTA_LICENSE_SERVER_ID`），私有 M1 provider 可用 `LicenseGate.assertCan('m1.adjudicate')` 做授权门；未授权 / 超时 / 非法输出一律 fail-open，退出码保持 0。
+- 评分算法位于本地私有目录 `license/m1/`，不进任何发布件；开源侧只做特征快照、白名单校验与展示。协议见 `references/provider-protocol.md`。
+- 元忆 0.19.0 不变；静态 playbook / 安装 / hook / scanPolicy 契约零变更。
+
+## 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` 生成。

package/README.md

@@ -27,6 +27,7 @@ Installing the whole YottaMeta family used to mean running <code>npx</code> for
 
 - **List** - see the whole family: slug, Chinese name, package, version and a one-line description.
 - **Orchestration routing** - <code>--route</code> turns a task summary into a candidate combination, call order, per-skill roles, confidence, evidence, installed/missing status, and an install command; it only suggests installation and never installs automatically. An optional local provider may add or re-order installed skills within the allow-list (no behavior change when unconfigured; see <code>references/provider-protocol.md</code>).
+- **M1 memory adjudication** - <code>decide-memory</code> returns read-only <code>promote / hold / demote</code> suggestions, scores and signal details. Scoring is performed by a user-configured local provider (capability <code>m1.adjudicate</code>). It is read-only by default; <code>--promote</code> writes only a local recommendation file and never writes memory or deletes anything. <code>usage</code> is off by default and records only structured signals after the user enables it.
 - **Install** — install everything (or a subset) into an agent's default user-level directory or any directory.
 - **Update** — incremental update: add missing skills, upgrade version-skewed ones.
 - **Update check / auto-update** — <code>update --check</code> compares installed skill versions against the npm registry and reports; <code>update --check --scheduled</code> is the weekly background entry with a local cache and jitter, so it stays offline until due; <code>update --auto</code> upgrades the installed YottaMeta family to the latest (non-family skills are never auto-updated).
@@ -34,7 +35,7 @@ Installing the whole YottaMeta family used to mean running <code>npx</code> for
 - **Runtime hook adapter** — manifests declare six lifecycle requirements; <code>hook capabilities / evaluate / bind / unbind</code> probe host support, apply deterministic decisions, record evidence, and never overstate audit-only hosts as enforced.
 - **Idempotent** — a skill already at the manifest version is skipped; re-running is safe.
 - **Pre-install gate** — family installs read the package manifest, bootstrap yotta-verify (元信) when it is missing, then scan each package. <code>DO NOT INSTALL</code> blocks; caution/review continue with visible risk. Old versions are snapshotted before replacement.
-- **Inventory / re-index** - scan the skill directories on this machine and keep a local registry (<code>~/.yottaskills/registry.json</code>); set <code>YOTTA_SKILLS_REGISTRY_FILE</code> to isolate the registry per agent; self-contained, no other skills required. Newly installed skills are discovered automatically: <code>install</code> / <code>update</code> re-index the registry afterwards, and <code>--reindex</code> re-scans on demand. An optional <code>yotta-skills</code> MCP (on-demand, not resident) exposes <code>list_installed_skills</code> / <code>describe_skill</code> / <code>reindex</code> / <code>route_request</code>; see <code>SKILL.md</code> for the config.
+- **Inventory / re-index** - scan the skill directories on this machine and keep a local registry (<code>~/.yottaskills/registry.json</code>); set <code>YOTTA_SKILLS_REGISTRY_FILE</code> to isolate the registry per agent; self-contained, no other skills required. Newly installed skills are discovered automatically: <code>install</code> / <code>update</code> re-index the registry afterwards, and <code>--reindex</code> re-scans on demand. An optional <code>yotta-skills</code> MCP (on-demand, not resident) exposes <code>list_installed_skills</code> / <code>describe_skill</code> / <code>reindex</code> / <code>route_request</code> / <code>decide_memory</code>; see <code>SKILL.md</code> for the config.
 - **No silent writes** - 元阁 only suggests. Installing skills, adding a client <code>mcpServers</code> entry, and writing an agent's global memory each require explicit user confirmation beforehand; declining never blocks the plain CLI workflow.
 
 Boundaries: it only downloads, places, gates and summarizes — it does **not** develop skill content, does **not** bundle any skill body, does **not** use <code>-g</code> global installs, and does **not** silently write host configuration or agent global memory. Besides the target directory, it keeps its registry, snapshots, install evidence and update-check cache under <code>~/.yottaskills</code>.
@@ -83,6 +84,14 @@ npx -y @yottameta/yotta-skills --dry-run
 # Route a task to a combination, call order, and missing-skill install suggestion
 npx -y @yottameta/yotta-skills --route "Review this code carefully before release"
 
+# Inspect / enable local structured usage signals (off by default)
+npx -y @yottameta/yotta-skills usage status
+npx -y @yottameta/yotta-skills usage enable
+
+# Read-only M1 memory adjudication; --promote writes only a local recommendation file
+npx -y @yottameta/yotta-skills decide-memory --explain
+npx -y @yottameta/yotta-skills decide-memory --promote --json
+
 # Inventory installed skills on this machine (self-contained scan, no other skills needed)
 npx -y @yottameta/yotta-skills --inventory
 
@@ -111,6 +120,10 @@ Requirements: Node.js 18+, npm, and system <code>tar</code> (built into Windows
 | `--inventory` | Inventory installed skills: scan skill directories and update the local registry (self-contained); `--json` for JSON, `--project` adds project-level dirs |
 | `--reindex` | Re-index the registry: re-scan skill directories and merge changes incrementally (on demand; `install` / `update` re-index automatically; `--rescan` is a synonym); `--json` for JSON |
 | `--route <task-summary>` | Static orchestration routing: return a combination, call order, per-skill roles, confidence, evidence, installed/missing status, and an install suggestion; also lists other installed (non-YottaMeta) skills as candidates matched mechanically against their frontmatter description, tagged "not scanned", read-only and never auto-invoked; an optional local provider may add or re-order installed skills within the allow-list (see <code>references/provider-protocol.md</code>); `--json` for JSON plus a `dynamic` status block, `--project` adds project-level dirs |
+| `usage status` / `usage enable` / `usage disable` | Inspect / enable / disable local structured usage signals; off by default and limited to slug, time, signal type, playbook / confidence and skill pairs |
+| `usage mark --skill <slug> --signal used\|named\|accepted` | Record one explicit usage signal; no prior enable required |
+| `usage reset --yes` | Clear the local usage record |
+| `decide-memory [--dry-run\|--promote] [--explain]` | Read-only M1 memory adjudication; `--promote` writes only a local recommendation file and never writes memory or deletes anything; `--json` for stable JSON |
 | `--no-reindex` | Do not re-index the registry automatically after `install` / `update` |
 | `--dry-run` | Preview the install / update list; no network, no changes |
 | `--pin` | Lock the exact manifest versions (default) |

package/README.zh-CN.md

@@ -30,6 +30,7 @@
 
 - **看清单**--全家技能一览：slug / 中文名 / 包名 / 版本 / 一句话说明。
 - **编排路由**--`--route` 按需求摘要输出候选组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装命令；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；只建议安装，不自动安装。可选本地扩展提供方可在已装白名单内增补 / 重排（未配置时行为不变），协议见 `references/provider-protocol.md`。
+- **M1 记忆裁决**--`decide-memory` 输出技能 `promote / hold / demote` 只读建议、分数与信号明细；评分由用户显式配置的本地 provider（capability `m1.adjudicate`）完成。默认只读，`--promote` 只写本地建议文件，不写元忆、不删除内容。`usage` 默认关闭，显式开启后才记录结构化使用信号（不含需求原文）。
 - **安装**——装全家（或指定技能）到智能体默认用户级目录或任意目录。
 - **更新**——增量更新：补齐缺失技能、升级版本不一致的技能。
 - **更新检查 / 自动更新**——<code>update --check</code> 只读比对已装技能版本与 npm 注册表并报告；<code>update --check --scheduled</code> 是后台周检入口，用本地缓存和随机抖动做到未到期不联网；<code>update --auto</code> 检查后自动把已装元阁家族升到最新（非元阁家族技能绝不自动更新）。
@@ -37,7 +38,7 @@
 - **运行时 hook 适配层**——技能 manifest 只声明六个生命周期要求；<code>hook capabilities / evaluate / bind / unbind</code> 负责宿主能力探测、确定性决策、结构化证据和降级标注，不把 audit 能力夸大为强制。
 - **幂等**——已在清单版本的技能跳过；重复运行安全。
 - **装前门禁**——家族安装先读取包内 manifest，元信（yotta-verify）缺失时自动自举，再逐个扫描。`DO NOT INSTALL` 阻断；`CAUTION` / `REVIEW` 继续但显示风险。旧版本会先做快照再替换。
-- **盘点 / re-index**--扫描本机各智能体技能目录，维护本地注册表（<code>~/.yottaskills/registry.json</code>）；可用 <code>YOTTA_SKILLS_REGISTRY_FILE</code> 为不同 agent 指定独立注册表；自包含，不需要任何其他技能。新装技能自动被发现：<code>install</code> / <code>update</code> 完成后自动重扫注册表，<code>--reindex</code> 可随时手动重扫（如会话开工）。可选 <code>yotta-skills</code> MCP（按需加载、不常驻）提供 <code>list_installed_skills</code> / <code>describe_skill</code> / <code>reindex</code> / <code>route_request</code> 四工具，配置见 <code>SKILL.md</code>。
+- **盘点 / re-index**--扫描本机各智能体技能目录，维护本地注册表（<code>~/.yottaskills/registry.json</code>）；可用 <code>YOTTA_SKILLS_REGISTRY_FILE</code> 为不同 agent 指定独立注册表；自包含，不需要任何其他技能。新装技能自动被发现：<code>install</code> / <code>update</code> 完成后自动重扫注册表，<code>--reindex</code> 可随时手动重扫（如会话开工）。可选 <code>yotta-skills</code> MCP（按需加载、不常驻）提供 <code>list_installed_skills</code> / <code>describe_skill</code> / <code>reindex</code> / <code>route_request</code> / <code>decide_memory</code> 五工具，配置见 <code>SKILL.md</code>。
 
 边界：只做「下载 + 落位 + 门禁 + 汇总」——**不**开发技能内容、**不**内置任何技能本体、**不**用 <code>-g</code>
 全局安装；除目标目录外，会在 <code>~/.yottaskills</code> 下保留注册表、快照、安装证据与更新检查缓存。
@@ -86,6 +87,14 @@ npx -y @yottameta/yotta-skills --dry-run
 # 按需求摘要给出组合、顺序与缺失技能安装建议
 npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄"
 
+# 查看 / 开启本地使用记录（默认关闭）
+npx -y @yottameta/yotta-skills usage status
+npx -y @yottameta/yotta-skills usage enable
+
+# M1 记忆裁决只读建议；--promote 只写本地建议文件
+npx -y @yottameta/yotta-skills decide-memory --explain
+npx -y @yottameta/yotta-skills decide-memory --promote --json
+
 # 盘点本机已装技能（自包含扫描，不依赖任何元技能）
 npx -y @yottameta/yotta-skills --inventory
 
@@ -114,6 +123,10 @@ npx -y @yottameta/yotta-skills --reindex
 | `--inventory` | 盘点已装技能：扫描技能目录并更新本地注册表（自包含）；`--json` 输出 JSON、`--project` 附扫项目级目录 |
 | `--reindex` | 重扫注册表：扫描技能目录并增量合并变化（install / update 完成后自动重扫，也可随时手动运行；`--rescan` 同义）；`--json` 输出 JSON |
 | `--route <需求摘要>` | 静态编排路由：输出组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装建议；可选本地扩展提供方在已装白名单内增补 / 重排（未配置时行为不变，协议见 `references/provider-protocol.md`）；`--json` 输出 JSON 与 `dynamic` 状态块、`--project` 附扫项目级目录 |
+| `usage status` / `usage enable` / `usage disable` | 查看 / 开启 / 关闭本地结构化使用记录；默认关闭，只记录 slug、时间、信号类型、playbook / confidence 与组合对 |
+| `usage mark --skill <slug> --signal used\|named\|accepted` | 记录一次显式使用信号；不要求先 enable |
+| `usage reset --yes` | 清空本地使用记录 |
+| `decide-memory [--dry-run\|--promote] [--explain]` | M1 记忆裁决只读建议；`--promote` 只写本地建议文件，不写元忆、不删除内容；`--json` 输出稳定 JSON |
 | `--no-reindex` | 安装 / 更新后不自动重扫注册表 |
 | `--dry-run` | 预览将执行的安装 / 更新清单；不联网、不改动 |
 | `--pin` | 锁死清单精确版本（默认） |

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: yotta-skills
-version: 0.20.1
-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 阻断，非元阁家族包不自动安装。
+version: 0.21.0
+description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点 + 运行时 hook 适配。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；M1 记忆裁决层：usage enable/mark 本地结构化记录 + decide-memory / MCP decide_memory 输出 promote / hold / demote 只读建议（需授权 provider；只建议不删除、不自动写元忆）；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么组合使用（安装与调用均由用户确认后执行）」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录（默认 --pin 锁死清单精确版本）；盘点层：--inventory / --reindex 扫描本机已装技能生成/更新注册表，新装技能自动被发现（install/update 后自动 re-index，会话开工只建议跑本地 --reindex；更新检查走手动 --check 或后台 --check --scheduled）；运行时适配层：hook capabilities / evaluate / bind / unbind 按宿主能力矩阵执行六个统一事件并留证降级，元信 before_install 已接入安装管线；自包含零依赖，不依赖任何元技能；MCP 按需加载且需用户确认后写入配置（可选：list_installed_skills/describe_skill/reindex/route_request/decide_memory，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / usage 使用记录 / decide-memory 记忆裁决 / install / update / update --check（只读检查）/ update --check --scheduled（后台周检）/ update --auto（家族自动更新）/ hook 适配 / --inventory / --reindex / --dry-run 预览 / --pin（默认）/ --range。触发：需要批量安装或更新元阁全家技能、按场景组合多个元技能、路由或判断该用哪些技能、判断哪些技能值得长期记忆、查看或记录技能使用信号、盘点或查看本机已装技能、重扫技能注册表、给某个智能体或目录一次性铺齐 yotta-* 技能、评估宿主 hook 能力、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/检查更新/自动更新/hook 适配/该用哪个技能/路由技能/记忆裁决/技能该不该记住/盘点技能/查看已装技能 等。边界（Do NOT trigger）：只做「组合策划 + 静态路由建议 + M1 记忆裁决只读建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index + hook 适配」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能、不静默写宿主配置或全局记忆、不自动删除技能或记忆；家族安装先自举或调用元信装前门禁，DO NOT INSTALL 阻断，非元阁家族包不自动安装。
 license: MIT
 metadata:
   zh_name: 元阁
@@ -44,6 +44,7 @@ metadata:
 
 - **路由层（该用哪几个）**：`--route "<需求摘要>"` / MCP `route_request` 查本地注册表与静态编排 playbook，输出候选组合、调用顺序、每个技能角色、置信度、依据、已装/缺失状态与安装命令；非元阁家族已装技能按 frontmatter description 机械匹配作并列候选（标注来源与未扫描状态，只读不自动调用）；只建议安装，不自动安装。
 - **动态扩展口（v0.20.0，capability `o1.route`）**：可选调用用户显式配置的本地扩展提供方（provider），在已装注册表白名单内对路由结果增补 / 重排；静态 playbook 结果先算必算、永不缺席，未配置或调用失败时文本输出与历史一致，`--json` 仅多一个 `dynamic` 状态块。协议与配置见 `references/provider-protocol.md`。
+- **M1 记忆裁决层（哪些值得长期记住）**：`decide-memory` / MCP `decide_memory` 调用可选本地 provider（capability `m1.adjudicate`），输出 `promote / hold / demote` 只读建议、分数与信号明细；默认不写元忆、不删除技能。`usage` 默认关闭，用户显式开启后才记录结构化使用信号。协议与边界见 `references/provider-protocol.md`。
 - **策划层（怎么用）**：接到需求，先按「编排策划」定位命中哪个组合——哪些元技能搭配起来最强、适合什么场景、AI 该给出什么安装与调用建议（**安装与调用均由用户确认后执行**）。
 - **安装层（怎么装）**：一条 `npx -y @yottameta/yotta-skills` 把组合/全家装进指定智能体或目录——`--list` 看清单、`install` 装、`update` 增量更新、`doctor` 只读自检、`rollback` 恢复快照、`--dry-run` 预览、`--pin` 锁版本。
 
@@ -173,6 +174,11 @@ openclaw skills update @yottameta/yotta-skills
 | `--inventory` | 盘点本机已装技能：扫描技能目录生成/更新注册表（自包含，不依赖元技能）；`--json` 输出 JSON、`--project` 附扫项目级目录 |
 | `--reindex` | 重扫注册表：扫描技能目录并增量合并变化（install / update 完成后 CLI 自动重扫；也可在会话开工等时机手动运行）；`--json` 输出 JSON、`--project` 附扫项目级目录；`--rescan` 同义 |
 | `--route <需求摘要>` | 静态编排路由：输出组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装建议；`--json` 输出 JSON、`--project` 附扫项目级目录 |
+| `usage status` | 查看本地使用记录开关与计数；默认关闭，不创建文件 |
+| `usage enable` / `usage disable` | 开启 / 关闭 `--route` 的结构化使用记录；不记录需求原文 |
+| `usage mark --skill <slug> --signal used\|named\|accepted` | 记录一次显式使用信号；不要求先 enable |
+| `usage reset --yes` | 清空本地使用记录 |
+| `decide-memory [--dry-run\|--promote] [--explain] [--json]` | M1 记忆裁决只读建议；`--promote` 只写本地建议文件，不写元忆、不删除内容 |
 | `--no-reindex` | 安装 / 更新后不自动重扫注册表 |
 | `--dry-run` | 预览将执行的安装 / 更新清单；不联网、不改动 |
 | `--pin` | 锁死清单精确版本（默认 range：跟随同 major 最新 patch） |
@@ -298,11 +304,41 @@ npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄" --json
 - **无明确匹配**：低置信度回退到「入口 + 安装」组合，先澄清需求再继续。
 - **边界**：路由是建议，不保证完全正确；关键动作由用户确认，数据不出本机。
 
+## M1 记忆裁决与使用记录
+
+`decide-memory` 判断哪些已装技能值得进入长期记忆，输出 `promote / hold / demote` 建议、分数与信号明细。
+评分由用户显式配置的本地 provider（capability `m1.adjudicate`）完成；未配置 / 未授权 / 超时 / 非法输出时
+只返回状态，不阻断其他能力，退出码保持 0。
+
+```bash
+# 默认只读：只看建议，不写任何文件
+npx -y @yottameta/yotta-skills decide-memory
+
+# 显式只读 + 信号明细
+npx -y @yottameta/yotta-skills decide-memory --dry-run --explain
+
+# 只写本地建议文件（不写元忆、不删除内容）
+npx -y @yottameta/yotta-skills decide-memory --promote --json
+```
+
+使用记录默认关闭：
+
+```bash
+npx -y @yottameta/yotta-skills usage status
+npx -y @yottameta/yotta-skills usage enable
+npx -y @yottameta/yotta-skills usage mark --skill yotta-memory --signal used
+npx -y @yottameta/yotta-skills usage disable
+npx -y @yottameta/yotta-skills usage reset --yes
+```
+
+边界：记录只含技能 slug、时间、信号类型、playbook / confidence 与组合对；不含需求原文、记忆正文、路径或身份信息。
+`--promote` 只写 `~/.yottaskills/memory-adjudication.json`，生成私密 `PREF` 记忆候选，由用户或 AI 再显式调用元忆写入。
+
 ### MCP：按需加载（可选）
 
 本技能自带一个 MCP server：`yotta-skills`（`scripts/yotta-skills-mcp.py`，零依赖、数据不出本机），
 基于 MCP 最新协议 2026-07-28（无状态时代；向后兼容 2025-11-25 及更早握手客户端）。
-提供 `list_installed_skills`（盘点）/ `describe_skill`（单技能详情）/ `reindex`（强制重扫）/ `route_request`（静态编排路由）四个工具。
+提供 `list_installed_skills`（盘点）/ `describe_skill`（单技能详情）/ `reindex`（强制重扫）/ `route_request`（静态编排路由）/ `decide_memory`（M1 记忆裁决只读建议）五个工具。
 
 **按需加载，不走常驻**：本技能与 MCP 均为按需触发。默认以 CLI 为主
 （`npx -y @yottameta/yotta-skills --inventory`）；需要让 AI 通过工具直接调用时，再按下面配置启用。
@@ -327,9 +363,9 @@ npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄" --json
    > `<技能目录>` = 本技能实际安装目录，**不要写死盘符路径**；Windows 用 `python`，Linux/macOS 用 `python3`。
    > 单 agent 环境可不设 `YOTTA_SKILLS_REGISTRY_FILE`；同一宿主内多 agent 共用 MCP 时，应分别配置独立路径，避免注册表状态互相覆盖。
 3. **提醒用户**：改 `mcpServers` 后多数客户端需**重启 / 重载一次** MCP server 才生效；加载后应看到
-   `list_installed_skills` / `describe_skill` / `reindex` / `route_request` 四个工具。
+   `list_installed_skills` / `describe_skill` / `reindex` / `route_request` / `decide_memory` 五个工具。
 4. **降级兜底（重要）**：若客户端未暴露 MCP 工具 / 用户拒绝改配置 / 无法改配置 / server 未加载，**自动降级 CLI**
-   （同一套扫描与路由核心、结果一致）：`npx -y @yottameta/yotta-skills --inventory / --reindex / --route ...`。
+   （同一套扫描、路由与 M1 核心、结果一致）：`npx -y @yottameta/yotta-skills --inventory / --reindex / --route ... / decide-memory ...`。
 
 ## 版本策略
 
@@ -375,14 +411,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

@@ -36,10 +36,13 @@ 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 usageJournalLib = require('../lib/usage-journal');
+const m1FeaturesLib = require('../lib/m1-features');
 const { createInstaller, isSafeTarEntry } = require('../lib/install-pipeline');
 
 const PKG_ROOT = path.join(__dirname, '..');
-let VERSION = '0.20.1';
+let VERSION = '0.21.0';
 try { VERSION = require(path.join(PKG_ROOT, 'package.json')).version; } catch (_) { /* keep fallback */ }
 
 function loadManifest() {
@@ -152,6 +155,7 @@ function parseArgs(argv) {
     inventory: false, reindex: false, noReindex: false, json: false, project: false, route: null,
     check: false, auto: false, scheduled: false, registry: null, slug: null,
     host: null, event: null, manifest: null, context: null,
+    signal: null, yes: false, explain: false, promote: false,
   };
   const positionals = [];
   for (let i = 0; i < argv.length; i++) {
@@ -196,12 +200,18 @@ function parseArgs(argv) {
     else if (a === '--event') opts.event = take('--event').toLowerCase();
     else if (a === '--manifest') opts.manifest = take('--manifest');
     else if (a === '--context') opts.context = take('--context');
+    else if (a === '--skill') opts.skill = take('--skill').toLowerCase();
+    else if (a === '--signal') opts.signal = take('--signal').toLowerCase();
+    else if (a === '--yes') opts.yes = true;
+    else if (a === '--explain') opts.explain = true;
+    else if (a === '--promote') opts.promote = true;
     else if (a.startsWith('-')) die('未知参数: ' + a, 2, '可用 --help 查看支持的选项。');
     else positionals.push(a);
   }
   // 命令解析：install / update / doctor / rollback，其余位置参数 = 技能 slug（可多个）
   for (const p of positionals) {
-    if (p === 'install' || p === 'update' || p === 'doctor' || p === 'rollback' || p === 'hook') {
+    if (p === 'install' || p === 'update' || p === 'doctor' || p === 'rollback' || p === 'hook'
+      || p === 'usage' || p === 'decide-memory') {
       if (opts.command && opts.command !== p) die('命令冲突：' + opts.command + ' 与 ' + p);
       opts.command = p;
     } else {
@@ -617,31 +627,14 @@ function scanTarget(engine, skillDir, context) {
 }
 
 // ── 安装 ───────────────────────────────────────────────────────────────────
+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) {
@@ -1117,6 +1110,9 @@ function printHelp() {
   out('  yotta-skills --inventory            盘点本机已装技能（自研扫描，不依赖任何元技能）');
   out('  yotta-skills --reindex              重扫注册表（手动触发；install / update 完成后 CLI 自动重扫）');
   out('  yotta-skills --route "<需求摘要>"   给出场景组合、调用顺序、缺失技能安装建议');
+  out('  yotta-skills usage status            查看本地使用记录开关与计数');
+  out('  yotta-skills usage enable|disable    开启 / 关闭 --route 的结构化使用记录');
+  out('  yotta-skills usage mark --skill <slug> --signal used|named|accepted');
   out('  yotta-skills hook capabilities       查看宿主六事件能力矩阵');
   out('  yotta-skills hook evaluate --event <event> --manifest <file>  评估 hook 声明并留证');
   out('  yotta-skills hook bind --manifest <file>  注册 hook 声明（幂等）');
@@ -1143,6 +1139,11 @@ function printHelp() {
   out('  --event <event>   hook 六事件之一（before_start / before_tool / before_install / before_publish / after_milestone / before_send）');
   out('  --manifest <file> hook evaluate / bind 使用的 skill-manifest.json 路径');
   out('  --context <json>  hook evaluate 的检查结果 JSON（checks / wrapperRegistered / evidence）');
+  out('  --skill <slug>    usage mark 的技能 slug');
+  out('  --signal <name>   usage mark 的信号：used / named / accepted');
+  out('  --yes             usage reset 确认清空');
+  out('  --explain         decide-memory 文本报告追加信号明细');
+  out('  --promote         decide-memory 只写本地建议文件（不写元忆）');
   out('  --project         inventory / reindex 时附加扫描当前项目 .agents/skills / .codex/skills');
   out('  --no-reindex      安装 / 更新后不自动重扫注册表');
   out('  -h, --help       帮助');
@@ -1318,6 +1319,15 @@ function runRoute(opts) {
   const yottaSlugs = new Set([...defaultYottaSlugs(), ...MANIFEST.map((s) => s.slug)]);
   const result = routeRequest(opts.route, { registry, yottaSlugs });
   result.dynamic = applyDynamicRoute(result, registry, opts);
+  try {
+    usageJournalLib.recordRoute({
+      playbook: result.playbook.id,
+      confidence: result.confidence,
+      skills: result.skills.map((skill) => skill.slug),
+    });
+  } catch (_) {
+    // 使用记录失败不阻断路由
+  }
   if (opts.json) {
     out(JSON.stringify(result, null, 2));
     return;
@@ -1363,6 +1373,184 @@ function runRoute(opts) {
   out('说明: ' + result.disclaimer);
 }
 
+function runUsage(opts) {
+  const action = opts.rest[0] || 'status';
+  if (action === 'status') {
+    const state = usageJournalLib.readUsage();
+    if (opts.json) {
+      out(JSON.stringify(state, null, 2));
+      return;
+    }
+    out('元阁本地使用记录：' + (state.enabled ? '已开启' : '已关闭'));
+    out('文件: ' + usageJournalLib.usageFilePath());
+    const skills = Object.keys(state.skills || {}).sort();
+    if (!skills.length) {
+      out('暂无记录。');
+      return;
+    }
+    for (const slug of skills) {
+      const item = state.skills[slug];
+      out('  ' + slug + '  used=' + item.used + ' named=' + item.named
+        + ' accepted=' + item.accepted + ' route_hits=' + item.route_hits
+        + ' pairs=' + Object.keys(item.pairs || {}).length);
+    }
+    return;
+  }
+  if (action === 'enable' || action === 'disable') {
+    const state = usageJournalLib.setEnabled(action === 'enable');
+    if (opts.json) {
+      out(JSON.stringify(state, null, 2));
+      return;
+    }
+    out('元阁本地使用记录已' + (state.enabled ? '开启' : '关闭') + '。');
+    out('文件: ' + usageJournalLib.usageFilePath());
+    return;
+  }
+  if (action === 'mark') {
+    if (!opts.skill) die('usage mark 缺少 --skill', 2, '例如 --skill yotta-memory。');
+    if (!opts.signal) die('usage mark 缺少 --signal', 2, '可用 used / named / accepted。');
+    let state;
+    try {
+      state = usageJournalLib.markUsage(opts.skill, opts.signal);
+    } catch (error) {
+      die(error.message, 2, '请检查 --skill 与 --signal。');
+    }
+    if (opts.json) {
+      out(JSON.stringify(state, null, 2));
+      return;
+    }
+    out('已记录：' + opts.skill + ' / ' + opts.signal);
+    return;
+  }
+  if (action === 'reset') {
+    if (!opts.yes) die('usage reset 需要 --yes 确认', 2, '该操作会清空本地使用记录。');
+    const file = usageJournalLib.resetUsage();
+    if (opts.json) {
+      out(JSON.stringify({ reset: true, file }, null, 2));
+      return;
+    }
+    out('已清空本地使用记录：' + file);
+    return;
+  }
+  die('未知 usage 子命令: ' + action, 2, '支持 status / enable / disable / mark / reset。');
+}
+
+function m1StatusText(block) {
+  if (!block) return '';
+  if (block.status === 'active') {
+    return '已应用（提供方 ' + (block.provider_id || '-') + '；建议 '
+      + block.decisions.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;
+}
+
+function runDecideMemory(opts) {
+  if (opts.dryRun && opts.promote) {
+    die('--dry-run 与 --promote 不能同时使用', 2, '默认就是只读；需要写建议文件时只加 --promote。');
+  }
+  const { registry } = reindexRegistry(opts);
+  const usage = usageJournalLib.readUsage();
+  const snapshot = m1FeaturesLib.buildFeatureSnapshot(registry, usage);
+  const provider = require('../lib/provider');
+  let run;
+  try {
+    run = provider.runCapability('m1.adjudicate', snapshot);
+  } catch (error) {
+    run = { status: 'error', provider_id: '', note: 'M1 装载失败：' + error.message };
+  }
+  const block = {
+    status: run.status || 'error',
+    provider_id: run.provider_id || '',
+    applied: false,
+    mode: opts.promote ? 'recommendation' : 'dry-run',
+    decisions: [],
+    summary: { promote: 0, hold: 0, demote: 0 },
+    dropped: [],
+    note: run.note || run.message || '',
+  };
+  if (run.status === 'active' && run.data && typeof run.data === 'object') {
+    const allowed = new Set(Object.keys(registry.skills || {}));
+    const verdicts = new Set(['promote', 'hold', 'demote']);
+    const requested = Array.isArray(run.data.decisions) ? run.data.decisions : [];
+    for (const raw of requested) {
+      const slug = raw && typeof raw === 'object' ? String(raw.slug || '') : '';
+      const score = raw && Number(raw.score);
+      const verdict = raw && String(raw.verdict || '');
+      if (!slug || !allowed.has(slug) || !verdicts.has(verdict) || !Number.isFinite(score) || score < 0 || score > 100) {
+        if (slug) block.dropped.push(slug);
+        continue;
+      }
+      const reasons = Array.isArray(raw.reasons)
+        ? raw.reasons.filter((item) => typeof item === 'string').slice(0, 20)
+        : [];
+      block.decisions.push({
+        slug,
+        verdict,
+        score: Math.round(score),
+        reasons,
+        signals: raw.signals && typeof raw.signals === 'object' && !Array.isArray(raw.signals)
+          ? raw.signals
+          : {},
+      });
+    }
+    block.decisions.sort((left, right) => right.score - left.score || left.slug.localeCompare(right.slug));
+    for (const decision of block.decisions) {
+      if (block.summary[decision.verdict] !== undefined) block.summary[decision.verdict] += 1;
+    }
+    block.applied = block.decisions.length > 0;
+  }
+
+  let reportFile = null;
+  if (opts.promote && block.status === 'active') {
+    const report = {
+      schema: 1,
+      generated_at: snapshot.generated_at,
+      provider_id: block.provider_id,
+      mode: 'recommendation',
+      decisions: block.decisions,
+      memory_candidates: m1FeaturesLib.buildMemoryCandidates(block.decisions, registry),
+      note: '只写本地建议文件；不写元忆、不删除任何内容。',
+    };
+    try {
+      reportFile = m1FeaturesLib.writeAdjudication(report);
+      block.report_file = reportFile;
+    } catch (error) {
+      die('M1 建议文件写入失败: ' + error.message, 1, '请检查 ~/.yottaskills 目录权限。');
+    }
+  }
+
+  if (opts.json) {
+    out(JSON.stringify({ schema: 1, generated_at: snapshot.generated_at, m1: block }, null, 2));
+    return;
+  }
+  out('元阁记忆裁决（M1）');
+  out('状态: ' + m1StatusText(block));
+  if (block.status === 'active') {
+    out('建议汇总: promote ' + block.summary.promote + ' / hold ' + block.summary.hold
+      + ' / demote ' + block.summary.demote + '；丢弃 ' + block.dropped.length);
+    for (const decision of block.decisions) {
+      out('  [' + decision.verdict + '] ' + decision.slug + '  ' + decision.score
+        + (decision.reasons.length ? '  - ' + decision.reasons.join('；') : ''));
+      if (opts.explain) {
+        const signals = decision.signals || {};
+        out('    信号: used=' + (signals.used || 0) + ' named=' + (signals.named || 0)
+          + ' accepted=' + (signals.accepted || 0) + ' route_hits=' + (signals.route_hits || 0)
+          + ' distinct_pairs=' + (signals.distinct_pairs || 0)
+          + ' description_quality=' + (signals.description_quality || 0)
+          + ' recency=' + (signals.recency || 0));
+      }
+    }
+    if (reportFile) out('建议文件: ' + reportFile);
+  } else if (block.note) {
+    out('说明: ' + block.note);
+  }
+  out('边界: 只建议不删除；不自动写元忆；数据不出本机。');
+}
+
 /** 装技能后自动 re-index（--no-reindex 关闭）：把本次落位结果反映进注册表。best-effort：失败不阻断安装。 */
 function maybeAutoReindex(opts, dest) {
   if (opts.noReindex || opts.dryRun || !dest) return;
@@ -1481,6 +1669,14 @@ function main() {
   if (opts.route && !opts.command) { runRoute(opts); return; }
 
   const command = opts.command || 'install';
+  if (command === 'usage') {
+    runUsage(opts);
+    return;
+  }
+  if (command === 'decide-memory') {
+    runDecideMemory(opts);
+    return;
+  }
   if (command === 'hook') {
     runHook(opts);
     return;

package/lib/install-pipeline.js

@@ -338,6 +338,7 @@ function createInstaller(deps) {
           verdict: scan.verdict,
           decision: scan.decision,
           scan_policy: scan.policy || null,
+          npm_registry_fallback: Boolean(packed.registryFallback),
           snapshot,
         });
       } catch (error) {

package/lib/m1-features.js

@@ -0,0 +1,112 @@
+'use strict';
+
+/**
+ * M1 记忆裁决器：开源侧只做确定性特征快照与建议文件。
+ *
+ * 评分算法不在本文件，由私有 provider（capability m1.adjudicate）返回。
+ * 快照只含技能元数据与聚合计数，不含需求原文、记忆正文、路径、用户名或主机名。
+ */
+
+const fs = require('fs');
+const path = require('path');
+const usageJournal = require('./usage-journal');
+
+const SCHEMA = 1;
+const REPORT_FILE = 'memory-adjudication.json';
+
+function nowIso(options) {
+  const value = options && options.now;
+  return typeof value === 'string' && value ? value : new Date().toISOString();
+}
+
+function skillSignal(usage, slug) {
+  const source = usage && usage.skills && usage.skills[slug] ? usage.skills[slug] : {};
+  const pairs = source.pairs && typeof source.pairs === 'object' && !Array.isArray(source.pairs)
+    ? source.pairs
+    : {};
+  return {
+    used: Number(source.used) || 0,
+    named: Number(source.named) || 0,
+    accepted: Number(source.accepted) || 0,
+    route_hits: Number(source.route_hits) || 0,
+    distinct_pairs: Object.keys(pairs).length,
+  };
+}
+
+function buildFeatureSnapshot(registry, usage, options) {
+  const skills = Object.values((registry && registry.skills) || {})
+    .filter((record) => record && record.slug)
+    .map((record) => {
+      const slug = String(record.slug);
+      return {
+        slug,
+        version: String(record.version || ''),
+        status: String(record.status || 'known'),
+        description: String(record.description || ''),
+        first_seen: String(record.first_seen || ''),
+        last_seen: String(record.last_seen || ''),
+        last_signal_at: String((usage && usage.skills && usage.skills[slug] && usage.skills[slug].last_signal_at) || ''),
+        pinned: record.pinned === true,
+        signals: skillSignal(usage, slug),
+      };
+    })
+    .sort((left, right) => left.slug.localeCompare(right.slug));
+  return {
+    schema: SCHEMA,
+    generated_at: nowIso(options),
+    skills,
+  };
+}
+
+function reportPath(options) {
+  const opts = options || {};
+  if (opts.file) return path.resolve(opts.file);
+  const fromEnv = String(process.env.YOTTA_SKILLS_M1_REPORT_FILE || '').trim();
+  if (fromEnv) return path.resolve(fromEnv);
+  return path.join(path.dirname(usageJournal.usageFilePath(opts)), REPORT_FILE);
+}
+
+function buildMemoryCandidates(decisions, registry) {
+  const records = (registry && registry.skills) || {};
+  const candidates = [];
+  for (const decision of Array.isArray(decisions) ? decisions : []) {
+    if (!decision || decision.verdict !== 'promote') continue;
+    const record = records[decision.slug] || {};
+    const description = String(record.description || '').trim();
+    const summary = description
+      ? description.slice(0, 180)
+      : '暂无描述';
+    candidates.push({
+      type: 'PREF',
+      subject: '技能索引：' + decision.slug,
+      statement: '本机长期保留技能 ' + decision.slug + '：' + summary
+        + '；M1 评分：' + decision.score + '。',
+      source: 'yotta-skills m1',
+      weight: 0.8,
+    });
+  }
+  return candidates;
+}
+
+function writeAdjudication(report, options) {
+  const file = reportPath(options);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + '.tmp-' + process.pid + '-' + Date.now();
+  fs.writeFileSync(tmp, JSON.stringify(report, null, 2) + '\n', 'utf8');
+  try {
+    fs.renameSync(tmp, file);
+  } catch (_) {
+    fs.rmSync(file, { force: true });
+    fs.renameSync(tmp, file);
+  }
+  return file;
+}
+
+module.exports = {
+  SCHEMA,
+  REPORT_FILE,
+  buildFeatureSnapshot,
+  reportPath,
+  buildMemoryCandidates,
+  writeAdjudication,
+};

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/provider.js

@@ -94,6 +94,7 @@ function minimalEnv() {
   const keep = [
     'PATH', 'Path', 'PATHEXT', 'SystemRoot', 'windir', 'COMSPEC', 'ComSpec',
     'TEMP', 'TMP', 'HOME', 'USERPROFILE', 'LANG', 'LC_ALL',
+    'YOTTA_LICENSE_HOME', 'YOTTA_LICENSE_KEYS_DIR', 'YOTTA_LICENSE_BASE_URL', 'YOTTA_LICENSE_SERVER_ID',
   ];
   const env = {};
   for (const key of keep) {

package/lib/usage-journal.js

@@ -0,0 +1,201 @@
+'use strict';
+
+/**
+ * 元阁本地使用记录（M1 特征来源之一）。
+ *
+ * 边界：
+ * - 只记录技能 slug、信号类型、路由 playbook / confidence 与组合对。
+ * - 不记录需求原文、记忆正文、文件内容、用户名、主机名或路径。
+ * - 自动路由记录默认关闭；显式 mark 不要求先 enable。
+ * - 文件默认 ~/.yottaskills/usage.json，YOTTA_SKILLS_USAGE_FILE 可覆盖。
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const SCHEMA = 1;
+const SIGNALS = ['used', 'named', 'accepted'];
+const MAX_COUNT = 999999;
+const SLUG_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+function defaultState() {
+  return {
+    schema: SCHEMA,
+    enabled: false,
+    updated_at: '',
+    skills: {},
+    last_route: null,
+  };
+}
+
+function usageFilePath(options) {
+  const opts = options || {};
+  if (opts.file) return path.resolve(opts.file);
+  const fromEnv = String(process.env.YOTTA_SKILLS_USAGE_FILE || '').trim();
+  if (fromEnv) return path.resolve(fromEnv);
+  return path.join(opts.homeDir || os.homedir(), '.yottaskills', 'usage.json');
+}
+
+function bump(value) {
+  const n = Number.isFinite(value) ? Math.floor(value) : 0;
+  return Math.min(MAX_COUNT, Math.max(0, n) + 1);
+}
+
+function normalizeSkill(raw) {
+  const skill = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+  const pairs = {};
+  if (skill.pairs && typeof skill.pairs === 'object' && !Array.isArray(skill.pairs)) {
+    for (const key of Object.keys(skill.pairs)) {
+      if (!SLUG_RE.test(key)) continue;
+      const n = Number(skill.pairs[key]);
+      if (Number.isFinite(n) && n > 0) pairs[key] = Math.min(MAX_COUNT, Math.floor(n));
+    }
+  }
+  return {
+    used: Math.min(MAX_COUNT, Math.max(0, Math.floor(Number(skill.used) || 0))),
+    named: Math.min(MAX_COUNT, Math.max(0, Math.floor(Number(skill.named) || 0))),
+    accepted: Math.min(MAX_COUNT, Math.max(0, Math.floor(Number(skill.accepted) || 0))),
+    route_hits: Math.min(MAX_COUNT, Math.max(0, Math.floor(Number(skill.route_hits) || 0))),
+    last_signal_at: typeof skill.last_signal_at === 'string' ? skill.last_signal_at : '',
+    pairs,
+  };
+}
+
+function normalizeState(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw) || raw.schema !== SCHEMA) {
+    return defaultState();
+  }
+  const state = defaultState();
+  state.enabled = raw.enabled === true;
+  state.updated_at = typeof raw.updated_at === 'string' ? raw.updated_at : '';
+  if (raw.skills && typeof raw.skills === 'object' && !Array.isArray(raw.skills)) {
+    for (const slug of Object.keys(raw.skills)) {
+      if (!SLUG_RE.test(slug)) continue;
+      state.skills[slug] = normalizeSkill(raw.skills[slug]);
+    }
+  }
+  if (raw.last_route && typeof raw.last_route === 'object' && !Array.isArray(raw.last_route)) {
+    const skills = Array.isArray(raw.last_route.skills)
+      ? raw.last_route.skills.filter((slug) => typeof slug === 'string' && SLUG_RE.test(slug))
+      : [];
+    state.last_route = {
+      at: typeof raw.last_route.at === 'string' ? raw.last_route.at : '',
+      playbook: typeof raw.last_route.playbook === 'string' ? raw.last_route.playbook : '',
+      confidence: typeof raw.last_route.confidence === 'string' ? raw.last_route.confidence : '',
+      skills,
+    };
+  }
+  return state;
+}
+
+function readUsage(options) {
+  const file = usageFilePath(options);
+  try {
+    return normalizeState(JSON.parse(fs.readFileSync(file, 'utf8')));
+  } catch (_) {
+    return defaultState();
+  }
+}
+
+function writeUsage(state, options) {
+  const file = usageFilePath(options);
+  const next = normalizeState(Object.assign(defaultState(), state));
+  next.updated_at = new Date().toISOString();
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = file + '.tmp-' + process.pid + '-' + Date.now();
+  fs.writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', 'utf8');
+  try {
+    fs.renameSync(tmp, file);
+  } catch (_) {
+    fs.rmSync(file, { force: true });
+    fs.renameSync(tmp, file);
+  }
+  return file;
+}
+
+function setEnabled(enabled, options) {
+  const state = readUsage(options);
+  state.enabled = enabled === true;
+  writeUsage(state, options);
+  return state;
+}
+
+function ensureSkill(state, slug) {
+  if (!state.skills[slug]) {
+    state.skills[slug] = normalizeSkill({});
+  }
+  return state.skills[slug];
+}
+
+function markUsage(skill, signal, options) {
+  const slug = String(skill || '').trim().toLowerCase();
+  if (!SLUG_RE.test(slug)) throw new Error('非法 skill slug：' + String(skill || ''));
+  if (SIGNALS.indexOf(signal) === -1) throw new Error('非法 signal：' + String(signal || ''));
+  const state = readUsage(options);
+  const record = ensureSkill(state, slug);
+  record[signal] = bump(record[signal]);
+  record.last_signal_at = new Date().toISOString();
+  writeUsage(state, options);
+  return state;
+}
+
+function uniqueSkills(skills) {
+  const seen = new Set();
+  const out = [];
+  for (const item of Array.isArray(skills) ? skills : []) {
+    const slug = String(item || '').trim().toLowerCase();
+    if (!SLUG_RE.test(slug) || seen.has(slug)) continue;
+    seen.add(slug);
+    out.push(slug);
+  }
+  return out;
+}
+
+function recordRoute(input, options) {
+  const state = readUsage(options);
+  if (!state.enabled) return { recorded: false, reason: 'disabled' };
+  const data = input && typeof input === 'object' ? input : {};
+  const skills = uniqueSkills(data.skills);
+  if (!skills.length) return { recorded: false, reason: 'empty' };
+  for (const slug of skills) {
+    const record = ensureSkill(state, slug);
+    record.route_hits = bump(record.route_hits);
+  }
+  for (let i = 0; i < skills.length; i++) {
+    for (let j = i + 1; j < skills.length; j++) {
+      const left = ensureSkill(state, skills[i]);
+      const right = skills[j];
+      left.pairs[right] = bump(left.pairs[right]);
+      const rightRecord = ensureSkill(state, right);
+      rightRecord.pairs[skills[i]] = bump(rightRecord.pairs[skills[i]]);
+    }
+  }
+  state.last_route = {
+    at: new Date().toISOString(),
+    playbook: typeof data.playbook === 'string' ? data.playbook : '',
+    confidence: typeof data.confidence === 'string' ? data.confidence : '',
+    skills,
+  };
+  writeUsage(state, options);
+  return { recorded: true, skills };
+}
+
+function resetUsage(options) {
+  const file = usageFilePath(options);
+  fs.rmSync(file, { force: true });
+  return file;
+}
+
+module.exports = {
+  SCHEMA,
+  SIGNALS,
+  usageFilePath,
+  defaultState,
+  readUsage,
+  writeUsage,
+  setEnabled,
+  markUsage,
+  recordRoute,
+  resetUsage,
+};

package/package.json

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

package/references/faq.md

@@ -113,3 +113,15 @@ npx -y @yottameta/yotta-skills install <slug> --dir /path/to/skills
 不会。元阁只给建议：`--route` 输出缺失技能与安装命令，安装动作由你执行或确认后才发生；
 写客户端 `mcpServers` 配置、把编排护栏写进全局记忆（如 `AGENTS.md` / `CLAUDE.md`）都需要**事先明确同意**，
 并会先展示目标文件与完整文本。你拒绝写入时，元阁不写任何文件，直接以 CLI 方式继续工作。
+
+## 15. `decide-memory` 会替我删除技能或写记忆吗？
+
+不会。`decide-memory` 默认只读，输出 `promote / hold / demote` 建议、分数与信号明细；
+`--promote` 只写本地 `~/.yottaskills/memory-adjudication.json` 建议文件，并生成私密 `PREF` 记忆候选。
+元忆写入由你或 AI 再显式调用元忆完成；技能本体与记忆都不会被自动删除。
+
+## 16. `usage` 会记录我的需求原文吗？
+
+不会。使用记录默认关闭；执行 `usage enable` 后才记录 `--route` 的结构化 route_hits 与组合对。
+记录只含技能 slug、时间、信号类型、playbook / confidence 与组合对，不含需求原文、记忆正文、路径或身份信息。
+`usage disable` 停止记录，`usage reset --yes` 清空记录。

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 / 权限 / 生命周期脚本路径；
@@ -108,6 +109,13 @@
 - 评估证据写入 `~/.yottaskills/hook-log.jsonl`，绑定记录写入 `~/.yottaskills/hook-bindings.json`。
 - `native-audit` 不等于强制；缺少能力或证据时必须显示 `explicit-unverified`。
 
+## M1 记忆裁决
+
+- `decide-memory` 默认只读，调用可选本地 provider（capability `m1.adjudicate`）输出 `promote / hold / demote` 建议。
+- `--promote` 只写 `~/.yottaskills/memory-adjudication.json` 建议文件；不写元忆、不删除技能。
+- `usage` 默认关闭；显式 `usage enable` 后才记录结构化使用信号，不记录需求原文。
+- 未配置 / 未授权 / 超时 / 非法输出时 fail-open，退出码保持 0。
+
 ## 快照与回滚
 
 - 旧版本快照：`~/.yottaskills/snapshots/<slug>/<timestamp>-<version>-<随机后缀>/`；

package/references/provider-protocol.md

@@ -1,7 +1,9 @@
-# 扩展提供方协议 v1（元阁 · capability `o1.route`）
+# 扩展提供方协议 v1（元阁 · capability `o1.route` / `m1.adjudicate`）
 
-元阁可以可选地调用一个由用户显式配置的**本地扩展提供方（provider）**，由它在已装技能白名单内
-对静态路由结果做增补 / 重排。未配置提供方时，`--route` 的行为与输出与之前完全一致。
+元阁可以可选地调用一个由用户显式配置的**本地扩展提供方（provider）**：
+
+- `o1.route`：在已装技能白名单内对静态路由结果做增补 / 重排；未配置时 `--route` 行为与输出与之前完全一致。
+- `m1.adjudicate`：对已装技能做 M1 记忆裁决，返回 `promote / hold / demote` 只读建议；未配置时 `decide-memory` 返回 `not_installed`，不写任何文件。
 
 ## 1. 配置
 
@@ -99,3 +101,105 @@ CLI 文本输出只在状态非 `not_installed` 时多一行「动态路由: ...
 - 元阁不替 provider 联网；provider 自身行为由它自己的包声明。
 - 删除 `provider.json` 即回到纯静态路由，无残留依赖。
 - provider 输出只当数据使用：白名单外的 slug、非法结构一律丢弃，不作为指令执行。
+
+## 6. capability `m1.adjudicate`
+
+### 6.1 触发
+
+只在用户显式执行 `yotta-skills decide-memory`（CLI）或 MCP `decide_memory` 时触发。
+安装 / 更新 / 盘点 / re-index / doctor 等路径不执行 M1 provider。
+
+### 6.2 请求
+
+元阁先把注册表与本地使用记录转成确定性特征快照，再发给 provider：
+
+```json
+{
+  "schema": 1,
+  "capability": "m1.adjudicate",
+  "request_id": "<uuid>",
+  "payload": {
+    "schema": 1,
+    "generated_at": "2026-09-30T00:00:00Z",
+    "skills": [
+      {
+        "slug": "yotta-memory",
+        "version": "0.19.0",
+        "status": "known",
+        "description": "文件式智能体记忆...",
+        "first_seen": "2026-08-23T00:00:00Z",
+        "last_seen": "2026-09-30T00:00:00Z",
+        "last_signal_at": "2026-09-30T00:00:00Z",
+        "pinned": false,
+        "signals": {
+          "used": 2,
+          "named": 0,
+          "accepted": 1,
+          "route_hits": 5,
+          "distinct_pairs": 3
+        }
+      }
+    ]
+  }
+}
+```
+
+payload 不含需求原文、记忆正文、凭据、主机名、用户名、来源目录或任意文件路径。
+
+### 6.3 响应
+
+```json
+{
+  "ok": true,
+  "capability": "m1.adjudicate",
+  "data": {
+    "policy": {
+      "version": "m1-mvp-1",
+      "promote_threshold": 60,
+      "hold_threshold": 30,
+      "cooling_days": 7
+    },
+    "decisions": [
+      {
+        "slug": "yotta-memory",
+        "verdict": "promote",
+        "score": 78,
+        "reasons": ["used x2：+24", "组合出现 x3：+9"],
+        "signals": {
+          "used": 2,
+          "named": 0,
+          "accepted": 1,
+          "route_hits": 5,
+          "distinct_pairs": 3,
+          "description_quality": 12,
+          "recency": 10
+        }
+      }
+    ]
+  }
+}
+```
+
+元阁只接受：slug 在本次注册表白名单内、verdict 为 `promote / hold / demote`、score 为 0-100。
+未知 slug / 非法 verdict / 非法 score 一律丢弃并记入 `dropped`。
+
+### 6.4 授权与回落
+
+| 状态 | 触发 | 元阁行为 |
+| --- | --- | --- |
+| `not_installed` | 无配置 / 无匹配 capability | `decide-memory` 返回 `not_installed`，不写文件 |
+| `active` | provider 返回合法 decisions | 展示建议；`--promote` 可写本地建议文件 |
+| `license_required` | provider 明确返回该 code | 显示需授权；不阻断其他能力 |
+| `timeout` / `invalid_output` / `error` | 超时 / 非法 JSON / 执行失败 | 显示状态；不写文件、不阻断 |
+
+provider 内部应使用路线 B 授权门（capability `m1.adjudicate`）。未授权时返回：
+
+```json
+{ "ok": false, "code": "license_required", "message": "该能力需要授权后使用" }
+```
+
+### 6.5 建议文件与元忆边界
+
+`--promote` 只写 `~/.yottaskills/memory-adjudication.json`，包含 decisions 与 `memory_candidates`。
+`memory_candidates` 默认使用私密 `PREF`，不自动写元忆；用户或 AI 需要再显式调用元忆写入。
+MCP `decide_memory` 始终只读，不写建议文件、不写元忆。

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` 不是
   通用目录）。
 - **某技能安装失败**：汇总报告给出失败原因；可单装该技能排查：
@@ -152,6 +152,27 @@ npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄"
 - `--json` 输出机器可读结果（含新增 / 更新 / 消失），适合脚本与钩子。
 - 如果本机还装了非元阁家族技能，`--route` 会额外列出「其他已装技能候选」：只按 frontmatter description 与需求文本做本地机械匹配，标注来源、得分、命中词项与扫描状态（默认未扫描），不读取全文指令、不自动调用；使用/安装前请先做装前安全扫描。
 
+## M1 记忆裁决（decide-memory）
+
+当你想判断「哪些已装技能值得长期记住」，可以运行：
+
+```bash
+npx -y @yottameta/yotta-skills decide-memory --explain
+npx -y @yottameta/yotta-skills decide-memory --promote --json
+```
+
+`decide-memory` 默认只读，输出每个技能的 `promote / hold / demote` 建议、分数与信号明细；
+`--promote` 只写 `~/.yottaskills/memory-adjudication.json` 建议文件，不写元忆、不删除内容。
+评分由用户显式配置的本地 provider（capability `m1.adjudicate`）完成；未配置 / 未授权 / 超时 / 非法输出时只返回状态，不阻断其他能力。
+
+使用记录默认关闭，只有显式开启后才记录结构化信号：
+
+```bash
+npx -y @yottameta/yotta-skills usage status
+npx -y @yottameta/yotta-skills usage enable
+npx -y @yottameta/yotta-skills usage mark --skill yotta-memory --signal used
+```
+
 ## 运行时 hook 适配（hook）
 
 技能 manifest 只声明六个统一事件的要求；元阁负责能力探测、确定性评估、证据留痕和降级标注：

package/scripts/yotta-skills-mcp.py

@@ -7,6 +7,7 @@ stdio MCP server（JSON-RPC 2.0，换行分隔），把元阁技能扫描核心
   describe_skill         查看单个技能详情（slug / 版本 / 功能 / 来源）
   reindex                强制重新扫描并更新注册表
   route_request          按需求摘要给出静态编排路由建议
+  decide_memory          M1 记忆裁决只读建议（不写元忆、不删除）
 
 自包含原则：扫描由元阁自带核心（bin/yotta-skills.js --inventory / --reindex）完成，
 不依赖任何元技能；数据只写本机注册表，默认 ~/.yottaskills/registry.json，
@@ -26,7 +27,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-VERSION = "0.20.1"
+VERSION = "0.21.0"
 TOOL_NAME = "yotta-skills"
 CN_NAME = "元阁"
 MCP_PROTOCOL_MODERN = "2026-07-28"
@@ -163,11 +164,24 @@ def _tool_route(arguments):
             "isError": False}
 
 
+def _tool_decide_memory(arguments):
+    if arguments.get("dry_run") is False:
+        return _tool_error("decide_memory 只读：MCP 不写建议文件，也不写元忆")
+    stdout = _run_cli(["decide-memory", "--json"])
+    try:
+        payload = json.loads(stdout)
+    except json.JSONDecodeError as e:
+        return _tool_error("decide_memory 输出解析失败：%s" % e)
+    return {"content": [{"type": "text", "text": json.dumps(payload, ensure_ascii=False, indent=2)}],
+            "isError": False}
+
+
 TOOL_HANDLERS = {
     "list_installed_skills": _tool_list,
     "describe_skill": _tool_describe,
     "reindex": _tool_reindex,
     "route_request": _tool_route,
+    "decide_memory": _tool_decide_memory,
 }
 
 
@@ -201,6 +215,16 @@ def mcp_tools():
             {"request": {"type": "string", "description": "用户需求摘要"}},
             ["request"],
         ),
+        _tool_spec(
+            "decide_memory",
+            "M1 记忆裁决只读建议：返回技能评分、promote / hold / demote 建议与信号明细。"
+            "只读，不写元忆、不删除技能、不写建议文件；需要写建议文件时使用 CLI --promote。数据不出本机。",
+            {
+                "dry_run": {"type": "boolean", "description": "固定为 true；MCP 只读"},
+                "explain": {"type": "boolean", "description": "是否要求解释信号明细（JSON 始终含 signals）"},
+            },
+            [],
+        ),
     ]
 
 
@@ -261,7 +285,7 @@ def handle_message(msg):
                 "result": _modern_ok({
                     "supportedVersions": [MCP_PROTOCOL_MODERN],
                     "capabilities": {"tools": {}},
-                    "instructions": "元阁 MCP（基于 MCP 最新协议 2026-07-28，向后兼容 2025-11-25 及更早握手）：本机技能盘点与静态编排路由 list_installed_skills/describe_skill/reindex/route_request；数据不出本机。",
+                    "instructions": "元阁 MCP（基于 MCP 最新协议 2026-07-28，向后兼容 2025-11-25 及更早握手）：本机技能盘点、静态编排路由与 M1 记忆裁决只读建议 list_installed_skills/describe_skill/reindex/route_request/decide_memory；数据不出本机。",
                 }, (3600000, "public")),
             }
         if method == "tools/list":

package/skill-manifest.json

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