@yottameta/yotta-skills 0.2.1 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # 更新日志
 
+## v0.4.0 (2026-08-31)
+
+阶段 C（O1 静态编排 playbook + 路由指引）：从「知道装了什么」升级为「给出该用哪几个、什么顺序」。
+
+- 新增静态编排 playbook（7 个场景组合）：输出呈现、长生命周期、交付质量门、装前安全门、造技能发版、安全事件响应、入口安装。
+- 新增 CLI `--route "<需求摘要>"`：先更新本地注册表，再输出候选组合、调用顺序、技能角色、置信度、命中依据、已装/缺失状态、安装命令与应用模式提醒；支持 `--json`。
+- 新增 MCP `route_request` 工具，与 CLI 复用同一套路由核心；MCP 工具扩展为四个。
+- 缺失技能只建议安装，不自动安装；安装命令需用户确认并先执行装前安全扫描。应用模式默认显式调用，切换为按场景自动调用需用户确认。
+- 文档：SKILL.md / README 中英 / orchestration.md / tutorial.md 同步「编排路由」层与边界；banner 同步升级为编排层定位。
+- 测试：新增路由核心（playbook 完整性 / 命中顺序 / 缺失建议 / 无匹配兜底 / 应用模式）、CLI JSON 与文本输出、MCP e2e 用例。
+- 版本升至 0.4.0。
+
+## v0.3.0 (2026-08-31)
+
+阶段 B（D2 re-index 自动钩子）：新装技能自动被发现。
+
+- 新增 CLI `--reindex`：重扫所有技能目录并增量合并注册表，变化聚焦输出（文本 / `--json` 机器可读），供会话开工与钩子调用；`--rescan` 为同义别名。
+- 装技能后自动 re-index：`install` / `update` 完成后自动重扫注册表，把本次落位结果反映进 `~/.yottaskills/registry.json`（新增 / 更新 / 消失随输出列出）；`--no-reindex` 可关闭。
+- 会话开工 re-scan：SKILL.md「使用须知」护栏补「会话开工先跑一次 `yotta-skills --reindex`」；注册表 `note` 口径同步 `--inventory / --reindex`。
+- MCP `reindex` 工具改走 `--reindex --json`（同一套扫描核心）；CLI 等价命令注明。
+- 文档：SKILL.md / README 中英 / references/install-flow.md / tutorial.md 同步 re-index 用法。
+- 测试：新增 `--reindex`（含幂等）与装后自动 re-index（含 `--no-reindex` 关闭）用例；全量用例全绿。
+- 版本升至 0.3.0。
+
 ## v0.2.1 (2026-08-31)
 
 MCP 配置说明补全（按需加载口径）。

package/README.md

@@ -6,8 +6,8 @@
 
 <h1 align="center">yotta-skills · 元阁 (YuanGe)</h1>
 
-<p align="center">YottaMeta's skill-family <b>orchestration planner + one-command installer</b>: plan which skills to combine for a task, then one <code>npx</code> line installs the published <code>yotta-*</code> skills (currently <b>22</b>) into any agent or directory.</p>
-<p align="center">List the family, install everything, incrementally update, preview with <code>--dry-run</code>, pin exact versions — idempotent and zero-dependency (Node.js 18+), pure npm ecosystem.</p>
+<p align="center">YottaMeta's skill-family <b>orchestration router, inventory, and one-command installer</b>: route which skills to combine for a task, then one <code>npx</code> line installs the published <code>yotta-*</code> skills (currently <b>22</b>) into any agent or directory.</p>
+<p align="center">List the family, route a task, install everything, incrementally update, preview with <code>--dry-run</code>, pin exact versions - idempotent and zero-dependency (Node.js 18+), pure npm ecosystem.</p>
 <p align="center">This package contains <b>no skill bodies</b> — only a manifest, a downloader, a placer and a summary. Each skill still comes from its own npm package.</p>
 
 <p align="center">
@@ -25,12 +25,13 @@ Installing the whole YottaMeta family used to mean running <code>npx</code> for
 
 元阁 is also the **family orchestration planner**: given a task, check the orchestration table first — which skills to combine, in what order, and why — then install exactly those. The decision table ships in the package as <code>references/orchestration.md</code> and is summarized in <code>SKILL.md</code>.
 
-- **List** — see the whole family: slug, Chinese name, package, version and a one-line description.
+- **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.
 - **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.
 - **Idempotent** — a skill already at the manifest version is skipped; re-running is safe.
 - **Pre-install summary** — if yotta-verify (元信) is available, each skill is scanned first; the verdict is informational only.
-- **Inventory** — scan the skill directories on this machine and keep a local registry (<code>~/.yottaskills/registry.json</code>); self-contained, no other skills required. An optional <code>yotta-skills</code> MCP (on-demand, not resident) exposes <code>list_installed_skills</code> / <code>describe_skill</code> / <code>reindex</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>); 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 (e.g. at session start). 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.
 
 Boundaries: it only downloads, places and summarizes — it does **not** develop skill content, does **not** bundle any skill body, and does **not** use <code>-g</code> global installs. It never writes outside the target you specify.
 
@@ -55,8 +56,14 @@ npx -y @yottameta/yotta-skills update --agent codex
 # Preview what would be installed (no network, no changes)
 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"
+
 # Inventory installed skills on this machine (self-contained scan, no other skills needed)
 npx -y @yottameta/yotta-skills --inventory
+
+# Re-index the registry (session start / after installing skills; incremental)
+npx -y @yottameta/yotta-skills --reindex
 ```
 
 Requirements: Node.js 18+, npm, and system <code>tar</code> (built into Windows 10+ / macOS / most Linux distributions).
@@ -71,6 +78,9 @@ Requirements: Node.js 18+, npm, and system <code>tar</code> (built into Windows
 | `install <skill>... [--agent <name> \| --dir <path>]` | Install only the given skills |
 | `update [--agent <name> \| --dir <path>]` | Incremental update: add missing, upgrade version-skewed |
 | `--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 (session start / after installing skills; `--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; `--json` for JSON, `--project` adds project-level dirs |
+| `--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: range, latest patch of the same major) |
 | `--force` | Reinstall even when already at the latest version |
@@ -141,12 +151,12 @@ The full 22-skill manifest with Chinese names, package names, versions and descr
 
 ## How it works
 
-For each skill in the manifest: `npm pack <pkg>@<spec>` into a temp directory → `tar -xzf` → optional yotta-verify pre-install summary → replace `<dest>/<slug>` → summary report. Details: `references/install-flow.md`; beginner tutorial (Chinese): `references/tutorial.md`.
+For each skill in the manifest: `npm pack <pkg>@<spec>` into a temp directory → `tar -xzf` → optional yotta-verify pre-install summary → replace `<dest>/<slug>` → summary report. After `install` / `update` finishes, the local skill registry is re-indexed automatically so newly installed skills show up in `--inventory` / `--reindex` (disable with `--no-reindex`). Details: `references/install-flow.md`; beginner tutorial (Chinese): `references/tutorial.md`.
 
 ## Development & validation
 
 ```bash
-# Run the test suite (12 cases) from the skill directory
+# Run the test suite from the skill directory
 npm test
 ```
 

package/README.zh-CN.md

@@ -6,9 +6,9 @@
 
 <h1 align="center">yotta-skills · 元阁 (YuanGe)</h1>
 
-<p align="center">YottaMeta 的<b>技能生态编排策划 + 全家一键安装器</b>：先按场景规划该组合哪几个技能，再一条 <code>npx</code> 命令把已发布的全部
+<p align="center">YottaMeta 的<b>技能生态编排路由 + 全家一键安装器 + 技能盘点</b>：先按需求路由该组合哪几个技能，再一条 <code>npx</code> 命令把已发布的全部
 <code>yotta-*</code> 技能（当前 <b>22</b> 个）装进指定智能体或目录。</p>
-<p align="center">看清单、装全家、增量更新、<code>--dry-run</code> 预览、<code>--pin</code> 锁版本——
+<p align="center">看清单、路由组合、装全家、增量更新、<code>--dry-run</code> 预览、<code>--pin</code> 锁版本--
 幂等、零依赖（Node.js 18+）、纯 npm 生态。</p>
 <p align="center">本包<b>不含任何技能本体</b>——只做「清单 + 下载 + 落位 + 汇总」；每个技能仍走各自 npm 包。</p>
 
@@ -28,12 +28,13 @@
 
 元阁也是全家的**编排策划层**：接到需求先查「编排策划」组合表——该组合哪几个技能、按什么顺序、各自强在哪——再按需安装恰好那几个。决策表随包提供（<code>references/orchestration.md</code>），<code>SKILL.md</code> 中有摘要。
 
-- **看清单**——全家技能一览：slug / 中文名 / 包名 / 版本 / 一句话说明。
+- **看清单**--全家技能一览：slug / 中文名 / 包名 / 版本 / 一句话说明。
+- **编排路由**--`--route` 按需求摘要输出候选组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装命令；只建议安装，不自动安装。
 - **安装**——装全家（或指定技能）到智能体默认用户级目录或任意目录。
 - **更新**——增量更新：补齐缺失技能、升级版本不一致的技能。
 - **幂等**——已在清单版本的技能跳过；重复运行安全。
 - **装前摘要**——若装了元信（yotta-verify），先对每个待装技能做一次装前扫描；verdict 仅提示、不拦截。
-- **盘点**——扫描本机各智能体技能目录，维护本地注册表（<code>~/.yottaskills/registry.json</code>）；自包含，不需要任何其他技能。可选 <code>yotta-skills</code> MCP（按需加载、不常驻）提供 <code>list_installed_skills</code> / <code>describe_skill</code> / <code>reindex</code> 三工具，配置见 <code>SKILL.md</code>。
+- **盘点 / re-index**--扫描本机各智能体技能目录，维护本地注册表（<code>~/.yottaskills/registry.json</code>）；自包含，不需要任何其他技能。新装技能自动被发现：<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>。
 
 边界：只做「下载 + 落位 + 汇总」——**不**开发技能内容、**不**内置任何技能本体、**不**用 <code>-g</code>
 全局安装；只在你指定的目标内写文件。
@@ -59,8 +60,14 @@ npx -y @yottameta/yotta-skills update --agent codex
 # 预览将安装清单（不联网、不改动）
 npx -y @yottameta/yotta-skills --dry-run
 
+# 按需求摘要给出组合、顺序与缺失技能安装建议
+npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄"
+
 # 盘点本机已装技能（自包含扫描，不依赖任何元技能）
 npx -y @yottameta/yotta-skills --inventory
+
+# 重扫注册表（会话开工 / 新装技能后，增量合并变化）
+npx -y @yottameta/yotta-skills --reindex
 ```
 
 前置：Node.js 18+、npm、系统 tar（Windows 10+ / macOS / 多数 Linux 自带）。
@@ -75,6 +82,9 @@ npx -y @yottameta/yotta-skills --inventory
 | `install <skill>... [--agent <name> \| --dir <path>]` | 只装指定的一个或多个技能 |
 | `update [--agent <name> \| --dir <path>]` | 增量更新：补齐缺失、升级版本不一致的技能 |
 | `--inventory` | 盘点已装技能：扫描技能目录并更新本地注册表（自包含）；`--json` 输出 JSON、`--project` 附扫项目级目录 |
+| `--reindex` | 重扫注册表：扫描技能目录并增量合并变化（会话开工 / 装技能后自动调用；`--rescan` 同义）；`--json` 输出 JSON |
+| `--route <需求摘要>` | 静态编排路由：输出组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装建议；`--json` 输出 JSON、`--project` 附扫项目级目录 |
+| `--no-reindex` | 安装 / 更新后不自动重扫注册表 |
 | `--dry-run` | 预览将执行的安装 / 更新清单；不联网、不改动 |
 | `--pin` | 锁死清单精确版本（默认 range：跟随同 major 最新 patch） |
 | `--force` | 已是最新也重新安装 |
@@ -150,13 +160,14 @@ bash install.sh --list           # 列出智能体 -> 默认目录
 ## 工作原理
 
 对清单里每个技能：`npm pack <pkg>@<spec>` 到临时目录 → `tar -xzf` 解压 → 可选元信装前摘要 →
-替换 `<dest>/<slug>` → 汇总报告。细节见 `references/install-flow.md`；新手中文教程见
-`references/tutorial.md`。
+替换 `<dest>/<slug>` → 汇总报告。`install` / `update` 完成后自动重扫本地技能注册表，
+新装技能随即出现在 `--inventory` / `--reindex` 里（可用 `--no-reindex` 关闭）。
+细节见 `references/install-flow.md`；新手中文教程见 `references/tutorial.md`。
 
 ## 开发与校验
 
 ```bash
-# 在技能目录内跑测试（12 个用例）
+# 在技能目录内跑测试
 npm test
 ```
 

package/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: yotta-skills
-version: 0.2.1
-description: 元阁 —— 元阁全家技能的总编排策划 + 一键安装器 + 技能盘点。策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么自动装+自动用」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录；盘点层：--inventory 扫描本机已装技能生成注册表（自包含零依赖，不依赖任何元技能）；MCP 按需加载（可选：list_installed_skills/describe_skill/reindex，不常驻，未加载降级 CLI）。支持 --list 清单 / install / update / --inventory / --dry-run 预览 / --pin 锁版本。触发：需要批量安装或更新元阁全家技能、按场景组合多个元技能、盘点或查看本机已装技能、给某个智能体或目录一次性铺齐 yotta-* 技能、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/盘点技能/查看已装技能 等。边界（Do NOT trigger）：只做「组合策划 + 清单 + 下载 + 落位 + 汇总 + 盘点」，不含技能本体、不做技能内容开发、不 -g 污染全局；装前摘要仅供参考，安装决策由用户确认。
+version: 0.4.0
+description: 元阁 -- 元阁全家技能的总编排策划 + 编排路由 + 一键安装器 + 技能盘点。路由层：--route / route_request 按需求摘要给出候选组合、调用顺序、角色、置信度、依据、已装/缺失状态与安装命令，只建议不自动安装；策划层：按场景给出「该组合哪几个元技能、组合强在哪、怎么自动装+自动用」；安装层：一条命令把 YottaMeta 已发布的全部 yotta-* 技能装进指定智能体或目录；盘点层：--inventory / --reindex 扫描本机已装技能生成/更新注册表，新装技能自动被发现（install/update 后自动 re-index，会话开工可先跑 --reindex；自包含零依赖，不依赖任何元技能）；MCP 按需加载（可选：list_installed_skills/describe_skill/reindex/route_request，不常驻，未加载降级 CLI）。支持 --list 清单 / --route 路由 / install / update / --inventory / --reindex / --dry-run 预览 / --pin 锁版本。触发：需要批量安装或更新元阁全家技能、按场景组合多个元技能、路由或判断该用哪些技能、盘点或查看本机已装技能、重扫技能注册表、给某个智能体或目录一次性铺齐 yotta-* 技能、预览安装清单、锁版本安装、或用户说 元阁/装全家/一次装齐/yotta-skills/install-all/更新全家/该用哪个技能/路由技能/盘点技能/查看已装技能 等。边界（Do NOT trigger）：只做「组合策划 + 静态路由建议 + 清单 + 下载 + 落位 + 汇总 + 盘点 + re-index」，不含技能本体、不做技能内容开发、不 -g 污染全局、不自动安装缺失技能；装前摘要仅供参考，安装决策由用户确认。
 license: MIT
 metadata:
   zh_name: 元阁
@@ -15,7 +15,8 @@ metadata:
 
 **写入内容（逐字）**：
 
-> **元阁编排**：单技能是零件，组合才是系统。接到需求，先查「元阁编排策划」命中哪个组合
+> **元阁编排**：单技能是零件，组合才是系统。会话开工先跑一次 `yotta-skills --reindex`
+> （重扫本机技能注册表，新装技能自动被看见）。接到需求，先查「元阁编排策划」命中哪个组合
 > （输出呈现标准 / 长生命周期 / 交付质量门 / 装前安全门 / 造技能发版 / 安全事件响应 / 入口安装），
 > 再按需自动安装并应用。完整决策表见技能 `yotta-skills/references/orchestration.md`。
 
@@ -26,11 +27,12 @@ metadata:
 
 # 元阁（yotta-skills）
 
-**元阁全家的总编排策划 + 一键安装 + 技能盘点**，一句话三层：
+**元阁全家的总编排策划 + 编排路由 + 一键安装 + 技能盘点**，一句话四层：
 
+- **路由层（该用哪几个）**：`--route "<需求摘要>"` / MCP `route_request` 查本地注册表与静态编排 playbook，输出候选组合、调用顺序、每个技能角色、置信度、依据、已装/缺失状态与安装命令；只建议安装，不自动安装。
 - **策划层（怎么用）**：接到需求，先按「编排策划」定位命中哪个组合——哪些元技能搭配起来最强、适合什么场景、AI 该怎么自动装并自动用起来。
 - **安装层（怎么装）**：一条 `npx -y @yottameta/yotta-skills` 把组合/全家装进指定智能体或目录——`--list` 看清单、`install` 装、`update` 增量更新、`--dry-run` 预览、`--pin` 锁版本。
-- **盘点层（已装了什么）**：`--inventory` 扫描本机各智能体技能目录，生成/更新本地注册表——自包含扫描，不依赖任何元技能。
+- **盘点层（已装了什么）**：`--inventory` / `--reindex` 扫描本机各智能体技能目录，生成/更新本地注册表；装技能后自动 re-index，新装技能自动被发现——自包含扫描，不依赖任何元技能。
 
 每个技能仍走各自独立的 npm 包（版本源唯一）；本包只做「清单 + 下载 + 落位 + 汇总」，**不内置任何技能本体**。
 > **本包不含技能本体**：拿到它只代表有了「编排策划 + 安装工具」；真正装齐需运行 `install`。
@@ -100,6 +102,9 @@ npx -y @yottameta/yotta-skills --dry-run
 
 # 盘点本机已装技能（自包含扫描，不依赖任何元技能）
 npx -y @yottameta/yotta-skills --inventory
+
+# 重扫注册表（会话开工 / 新装技能后，增量合并变化）
+npx -y @yottameta/yotta-skills --reindex
 ```
 
 ## 命令与选项
@@ -112,6 +117,9 @@ npx -y @yottameta/yotta-skills --inventory
 | `install <skill>... [--agent <name> \| --dir <path>]` | 只装指定的一个或多个技能 |
 | `update [--agent <name> \| --dir <path>]` | 增量更新：补齐缺失技能、升级版本不一致的技能 |
 | `--inventory` | 盘点本机已装技能：扫描技能目录生成/更新注册表（自包含，不依赖元技能）；`--json` 输出 JSON、`--project` 附扫项目级目录 |
+| `--reindex` | 重扫注册表：扫描技能目录并增量合并变化（会话开工 / 装技能后自动调用）；`--json` 输出 JSON、`--project` 附扫项目级目录；`--rescan` 同义 |
+| `--route <需求摘要>` | 静态编排路由：输出组合、调用顺序、技能角色、置信度、依据、已装/缺失状态与安装建议；`--json` 输出 JSON、`--project` 附扫项目级目录 |
+| `--no-reindex` | 安装 / 更新后不自动重扫注册表 |
 | `--dry-run` | 预览将执行的安装 / 更新清单；不联网、不改动 |
 | `--pin` | 锁死清单精确版本（默认 range：跟随同 major 最新 patch） |
 | `--force` | 已是最新也重新安装 |
@@ -142,10 +150,36 @@ npx -y @yottameta/yotta-skills --inventory --dir ~/my-skills --project
 
 注册表增量合并：新增（added）/ 更新（updated）/ 消失（gone）随输出列出；同名技能来自多个目录时合并来源，版本不一致记录冲突。
 
+### re-index：新装技能自动被发现
+
+- **装技能后自动**：`install` / `update` 完成后自动重扫注册表，把本次落位结果反映进
+  `~/.yottaskills/registry.json`（新增 / 更新 / 消失随输出列出）；`--no-reindex` 可关闭。
+- **会话开工**：建议每会话开工先跑一次 `yotta-skills --reindex`（快速增量，只合并变化），
+  让新装 / 更新的技能自动进入注册表。
+- **手动**：`yotta-skills --reindex`（`--rescan` 同义）；`--json` 机器可读、`--project` 附扫项目级目录。
+
+## 编排路由（--route）
+
+把需求摘要交给静态编排 playbook 和本地注册表，得到一组可执行建议：
+
+```bash
+# 文本输出：组合、调用顺序、角色、置信度、依据、缺失技能安装命令
+npx -y @yottameta/yotta-skills --route "帮我润色输出，要规范可复制，别有 AI 味"
+
+# 机器可读（JSON）
+npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄" --json
+```
+
+- **输出**：候选组合、调用顺序、每个技能的角色、置信度、命中依据、已装/缺失状态、安装命令与应用模式提醒。
+- **缺失技能**：只给安装命令，不自动安装；安装前应先做装前安全扫描，决定权在用户。
+- **应用模式**：默认用户显式调用；切换为「按场景自动调用」需要用户确认。
+- **无明确匹配**：低置信度回退到「入口 + 安装」组合，先澄清需求再继续。
+- **边界**：路由是建议，不保证完全正确；关键动作由用户确认，数据不出本机。
+
 ### MCP：按需加载（可选）
 
 本技能自带一个 MCP server：`yotta-skills`（`scripts/yotta-skills-mcp.py`，零依赖、数据不出本机），
-提供 `list_installed_skills`（盘点）/ `describe_skill`（单技能详情）/ `reindex`（强制重扫）三个工具。
+提供 `list_installed_skills`（盘点）/ `describe_skill`（单技能详情）/ `reindex`（强制重扫）/ `route_request`（静态编排路由）四个工具。
 
 **按需加载，不走常驻**：本技能与 MCP 均为按需触发。默认以 CLI 为主
 （`npx -y @yottameta/yotta-skills --inventory`）；需要让 AI 通过工具直接调用时，再按下面配置启用：
@@ -164,9 +198,9 @@ npx -y @yottameta/yotta-skills --inventory --dir ~/my-skills --project
    ```
    > `<技能目录>` = 本技能实际安装目录，**不要写死盘符路径**；Windows 用 `python`，Linux/macOS 用 `python3`。
 3. **提醒用户**：改 `mcpServers` 后多数客户端需**重启 / 重载一次** MCP server 才生效；加载后应看到
-   `list_installed_skills` / `describe_skill` / `reindex` 三个工具。
+   `list_installed_skills` / `describe_skill` / `reindex` / `route_request` 四个工具。
 4. **降级兜底（重要）**：若客户端未暴露 MCP 工具 / 无法改配置 / server 未加载，**自动降级 CLI**
-   （同一套扫描核心、结果一致）：`npx -y @yottameta/yotta-skills --inventory ...`。
+   （同一套扫描与路由核心、结果一致）：`npx -y @yottameta/yotta-skills --inventory / --reindex / --route ...`。
 
 ## 版本策略
 

package/bin/yotta-skills.js

@@ -131,7 +131,7 @@ function parseArgs(argv) {
     list: false, dryRun: false, pin: false, skipScan: false, force: false,
     help: false, version: false, agent: null, dir: null, npm: null,
     python: null, verify: null, command: null, skill: null, rest: [],
-    inventory: false, rescan: false, json: false, project: false,
+    inventory: false, reindex: false, noReindex: false, json: false, project: false, route: null,
   };
   const positionals = [];
   for (let i = 0; i < argv.length; i++) {
@@ -145,7 +145,14 @@ function parseArgs(argv) {
     else if (a === '--help' || a === '-h') opts.help = true;
     else if (a === '--version' || a === '-v') opts.version = true;
     else if (a === '--inventory' || a === '--inv') opts.inventory = true;
-    else if (a === '--rescan') opts.rescan = true;
+    else if (a === '--route') {
+      const value = argv[i + 1];
+      if (value === undefined || value.startsWith('--')) die('--route 缺少需求摘要');
+      opts.route = value;
+      i++;
+    }
+    else if (a === '--reindex' || a === '--rescan') opts.reindex = true;
+    else if (a === '--no-reindex') opts.noReindex = true;
     else if (a === '--json') opts.json = true;
     else if (a === '--project') opts.project = true;
     else if (a === '--agent') opts.agent = take('--agent').toLowerCase();
@@ -437,6 +444,8 @@ function printHelp() {
   out('  yotta-skills update --agent <name>  增量更新已装技能（补齐缺失 / 版本不一致）');
   out('  yotta-skills --dry-run              预览将安装清单（不联网、不改动）');
   out('  yotta-skills --inventory            盘点本机已装技能（自研扫描，不依赖任何元技能）');
+  out('  yotta-skills --reindex              重扫注册表（会话开工 / 装技能后自动调用；增量合并）');
+  out('  yotta-skills --route "<需求摘要>"   给出场景组合、调用顺序、缺失技能安装建议');
   out('');
   out('选项:');
   out('  --agent <name>   智能体键名（--list 可查看；未知智能体请用 --dir）');
@@ -447,8 +456,10 @@ function printHelp() {
   out('  --npm <path>     指定 npm 可执行文件（默认 npm / npm.cmd）');
   out('  --python <path>  指定 python 可执行文件（元信 scan 用）');
   out('  --verify <path>  指定 yotta_verify.py 路径（默认找目标目录已装的元信）');
-  out('  --json            inventory 时输出 JSON');
-  out('  --project         inventory 时附加扫描当前项目 .agents/skills / .codex/skills');
+  out('  --json            inventory / reindex / route 时输出 JSON');
+  out('  --route <需求>    静态编排路由（输出组合 / 顺序 / 依据 / 缺失技能建议）');
+  out('  --project         inventory / reindex 时附加扫描当前项目 .agents/skills / .codex/skills');
+  out('  --no-reindex      安装 / 更新后不自动重扫注册表');
   out('  -h, --help       帮助');
   out('  -v, --version    版本');
   out('');
@@ -458,8 +469,9 @@ function printHelp() {
 
 
 
-// ── 技能盘点（--inventory，自研零依赖扫描） ────────────────────────────────
-function runInventory(opts) {
+// ── 技能盘点 / re-index（自研零依赖扫描核心） ────────────────────────────────
+/** 重扫所有技能根目录并增量合并进注册表；返回 { result, registry, changes }。 */
+function reindexRegistry(opts) {
   const scan = require('../lib/skills-scan');
   const extraDirs = opts.dir ? [opts.dir] : [];
   const roots = scan.defaultRoots({ extraDirs: extraDirs, project: opts.project });
@@ -467,6 +479,12 @@ function runInventory(opts) {
   const prev = scan.readRegistry();
   const { registry, changes } = scan.mergeRegistry(result, prev);
   scan.saveRegistry(registry);
+  return { result, registry, changes };
+}
+
+function runInventory(opts) {
+  const scan = require('../lib/skills-scan');
+  const { result, registry, changes } = reindexRegistry(opts);
   if (opts.json) {
     out(JSON.stringify({
       generated_at: registry.updated,
@@ -486,13 +504,82 @@ function runInventory(opts) {
   }
 }
 
+/** --reindex：重扫 + 增量合并，变化聚焦输出（供会话开工 / 钩子使用）。 */
+function runReindex(opts) {
+  const scan = require('../lib/skills-scan');
+  const { result, registry, changes } = reindexRegistry(opts);
+  if (opts.json) {
+    out(JSON.stringify({
+      reindexed_at: registry.updated,
+      note: registry.note,
+      count: Object.values(registry.skills).filter((s) => s.status !== 'gone').length,
+      changes: changes,
+      errors: result.errors,
+      scanned: result.scanned,
+    }, null, 2));
+    return;
+  }
+  out('re-index 完成: 新增 ' + changes.added.length + ' / 更新 ' + changes.updated.length + ' / 消失 ' + changes.gone.length);
+  for (const slug of changes.added) out('  + ' + slug);
+  for (const slug of changes.updated) out('  ~ ' + slug);
+  for (const slug of changes.gone) out('  - ' + slug);
+  if (result.errors.length) {
+    out('跳过不存在目录 ' + result.errors.length + ' 个');
+  }
+  out('注册表: ' + scan.registryPath());
+}
+
+/** --route：静态编排路由，输出组合、顺序、角色与缺失技能建议。 */
+function runRoute(opts) {
+  const { routeRequest } = require('../lib/route');
+  const { registry } = reindexRegistry(opts);
+  const result = routeRequest(opts.route, { registry });
+  if (opts.json) {
+    out(JSON.stringify(result, null, 2));
+    return;
+  }
+  out('路由结果: ' + result.playbook.name + '（置信度: ' + result.confidence + '）');
+  out('适配意图: ' + result.playbook.intent);
+  out('依据: ' + (result.matched_keywords.length ? result.matched_keywords.join('、') : '无明确匹配，回退到入口澄清'));
+  out('');
+  out('调用顺序:');
+  for (const skill of result.skills) {
+    out('  ' + skill.order + '. ' + skill.slug + ' [' + (skill.installed ? '已装' : '缺失') + '] - ' + skill.role);
+  }
+  if (result.missing_skills.length) {
+    out('');
+    out('缺失技能: ' + result.missing_skills.map((skill) => skill.slug).join(', '));
+    out('安装命令: ' + result.install_command);
+    out('安全提示: 安装前请先执行装前安全扫描；本命令不会自动安装。');
+  }
+  out('');
+  out('应用模式: 显式调用（可经用户确认后切换为按场景自动调用）');
+  out('说明: ' + result.disclaimer);
+}
+
+/** 装技能后自动 re-index（--no-reindex 关闭）：把本次落位结果反映进注册表。best-effort：失败不阻断安装。 */
+function maybeAutoReindex(opts, dest) {
+  if (opts.noReindex || opts.dryRun || !dest) return;
+  const scan = require('../lib/skills-scan');
+  try {
+    const { changes } = reindexRegistry({ ...opts, dir: dest });
+    out('');
+    out('已自动 re-index 注册表（新增 ' + changes.added.length + ' / 更新 ' + changes.updated.length + ' / 消失 ' + changes.gone.length + '；注册表: ' + scan.registryPath() + '）');
+  } catch (e) {
+    out('');
+    out('提示: 自动 re-index 跳过（' + e.message + '）；稍后可手动 --reindex 重扫');
+  }
+}
+
 // ── main ───────────────────────────────────────────────────────────────────
 function main() {
   const opts = parseArgs(process.argv.slice(2));
   if (opts.help) { printHelp(); return; }
   if (opts.version) { out('yotta-skills v' + VERSION); return; }
   if (opts.list) { printList(opts); return; }
-  if (opts.inventory) { runInventory(opts); return; }
+  if (opts.inventory && !opts.command) { runInventory(opts); return; }
+  if (opts.reindex && !opts.command) { runReindex(opts); return; }
+  if (opts.route && !opts.command) { runRoute(opts); return; }
 
   const command = opts.command || 'install';
   let dest = resolveTargetDir(opts);
@@ -518,6 +605,7 @@ function main() {
 
   if (command === 'update') runUpdate(opts, dest);
   else runInstall(opts, dest);
+  maybeAutoReindex(opts, dest);
 }
 
 main();

package/lib/route.js

@@ -0,0 +1,160 @@
+'use strict';
+
+const PLAYBOOKS = [
+  {
+    id: 'output-standard',
+    name: '输出呈现标准',
+    intent: '让输出先判型渲染为可复制格式，再去除 AI 味。',
+    keywords: ['输出', '呈现', '渲染', '排版', '可复制', 'AI味', 'AI 味', '润色', '文档', '报告'],
+    skills: [
+      { slug: 'yotta-present', order: 1, role: '判断内容形态并渲染为可复制 Markdown / 纯文本。' },
+      { slug: 'yotta-humanize', order: 2, role: '检测中文 AI 腔，并按用户原意做确定性改写。' },
+    ],
+  },
+  {
+    id: 'long-lived-agent',
+    name: '长生命周期智能体',
+    intent: '让智能体跨会话恢复状态、记忆、经验与历史。',
+    keywords: ['长期', '跨会话', '忘了我', '别忘了我', '记忆', '上下文', '状态', '历史'],
+    skills: [
+      { slug: 'yotta-workflow', order: 1, role: '开工读取项目状态，会话结束更新状态并留下次接续记录。' },
+      { slug: 'yotta-memory', order: 2, role: '按权限边界保存与恢复跨会话记忆。' },
+      { slug: 'yotta-learn', order: 3, role: '沉淀错误、纠正与洞见，供后续会话复用。' },
+      { slug: 'yotta-logs', order: 4, role: '按需检索历史会话与日志记录。' },
+    ],
+  },
+  {
+    id: 'delivery-quality-gate',
+    name: '交付质量门',
+    intent: '交付前做防敷衍、代码质量与发布守门检查。',
+    keywords: ['检查', '代码', '质量', '别糊弄', '敷衍', '评审', '发布', '守门', '交付'],
+    skills: [
+      { slug: 'yotta-anti-shallow', order: 1, role: '强制先分析、再执行、后自检，防止表面化交付。' },
+      { slug: 'yotta-code-quality', order: 2, role: '按十二类腐化风险做结对式代码质量评审。' },
+      { slug: 'yotta-publish-guard', order: 3, role: '发布前校验版本、发布件与分发通道一致性。' },
+    ],
+  },
+  {
+    id: 'preinstall-security-gate',
+    name: '装前安全门',
+    intent: '安装其他来源技能、插件或 MCP 前做安全判定。',
+    keywords: ['安装', '装前', '其他来源', '技能', '插件', 'MCP', '安全扫描'],
+    skills: [
+      { slug: 'yotta-verify', order: 1, role: '执行确定性装前扫描并给出安全判定。' },
+      { slug: 'yotta-vetter', order: 2, role: '按四阶段协议审查来源、代码、权限与风险。' },
+      { slug: 'yotta-security-audit', order: 3, role: '做深度静态检测与安全基线兜底。' },
+    ],
+  },
+  {
+    id: 'skill-build-publish',
+    name: '造技能 / 发版',
+    intent: '创建合规技能包，并在发布前完成守门检查。',
+    keywords: ['造一个', '新 skill', '新技能', '脚手架', '发版', '发布技能', '技能包'],
+    skills: [
+      { slug: 'yotta-skill-creator', order: 1, role: '生成符合规范的技能目录与发布件结构。' },
+      { slug: 'yotta-publish-guard', order: 2, role: '校验版本四件、发布件与分发通道。' },
+    ],
+  },
+  {
+    id: 'security-incident-response',
+    name: '安全事件响应',
+    intent: '从日志、情报、样本、密钥、供应链与资产侦察看清事件链路。',
+    keywords: ['日志', '攻击', '安全事件', '入侵', 'IOC', '威胁情报', '样本', '密钥泄露', '供应链', '资产', '侦察'],
+    skills: [
+      { slug: 'yotta-logwatch', order: 1, role: '分析安全日志并识别攻击链与告警聚合。' },
+      { slug: 'yotta-intel', order: 2, role: '提取、去武器化并规范化威胁情报 IOC。' },
+      { slug: 'yotta-triage', order: 3, role: '对可疑样本做静态初筛。' },
+      { slug: 'yotta-secret', order: 4, role: '扫描密钥与凭据泄露源头。' },
+      { slug: 'yotta-chain', order: 5, role: '校验依赖供应链与 lockfile 一致性。' },
+      { slug: 'yotta-recon', order: 6, role: '在授权范围内做端口、服务与版本指纹侦察。' },
+    ],
+  },
+  {
+    id: 'entry-install',
+    name: '入口 + 安装',
+    intent: '需求方向不明确时先澄清意图，再按需安装合适技能。',
+    keywords: ['不知道用哪个', '需求模糊', '该用哪个', '怎么说', '技能该用哪个'],
+    skills: [
+      { slug: 'yotta-prompt', order: 1, role: '澄清需求意图并串联到合适的技能方向。' },
+      { slug: 'yotta-skills', order: 2, role: '按场景组合安装所需技能，不默认安装全家。' },
+    ],
+  },
+];
+
+function normalizeText(text) {
+  return String(text || '').toLowerCase().replace(/\s+/g, '');
+}
+
+function scorePlaybook(request, playbook) {
+  const text = normalizeText(request);
+  const matchedKeywords = [];
+  let score = 0;
+  for (const keyword of playbook.keywords) {
+    if (text.includes(normalizeText(keyword))) {
+      matchedKeywords.push(keyword);
+      score += normalizeText(keyword).length >= 3 ? 2 : 1;
+    }
+  }
+  return { score, matchedKeywords };
+}
+
+function routeRequest(request, options) {
+  const registry = (options && options.registry) || { skills: {} };
+  const installed = registry.skills || {};
+  const ranked = PLAYBOOKS
+    .map((playbook) => ({ playbook, ...scorePlaybook(request, playbook) }))
+    .sort((a, b) => b.score - a.score || a.playbook.id.localeCompare(b.playbook.id));
+  const best = ranked[0];
+  const runnerUp = ranked[1];
+  const fallback = !best || best.score === 0;
+  const playbook = fallback
+    ? PLAYBOOKS.find((item) => item.id === 'entry-install')
+    : best.playbook;
+  const matchedKeywords = fallback ? [] : best.matchedKeywords;
+  const margin = fallback ? 0 : best.score - (runnerUp ? runnerUp.score : 0);
+  const confidence = !fallback && best.score >= 3 && margin >= 1
+    ? 'high'
+    : (!fallback && best.score >= 1 ? 'medium' : 'low');
+
+  const skills = playbook.skills.map((skill) => {
+    const record = installed[skill.slug];
+    const isInstalled = Boolean(record && record.status !== 'gone');
+    return {
+      ...skill,
+      installed: isInstalled,
+      version: isInstalled ? record.version || '' : '',
+      sources: isInstalled ? record.sources || [] : [],
+    };
+  });
+  const missingSkills = skills
+    .filter((skill) => !skill.installed)
+    .map((skill) => ({ slug: skill.slug, scan_required: true }));
+  const installCommand = missingSkills.length
+    ? 'npx -y @yottameta/yotta-skills install '
+      + missingSkills.map((skill) => skill.slug).join(' ')
+      + ' --dir <skills-dir>'
+    : null;
+
+  return {
+    request,
+    playbook: {
+      id: playbook.id,
+      name: playbook.name,
+      intent: playbook.intent,
+    },
+    confidence,
+    matched_keywords: matchedKeywords,
+    skills,
+    missing_skills: missingSkills,
+    install_command: installCommand,
+    auto_install: false,
+    application_mode: {
+      default: 'explicit',
+      options: ['explicit', 'scene-auto'],
+      note: '默认用户显式调用；切换为按场景自动调用需要用户确认。',
+    },
+    disclaimer: '路由建议不保证完全正确；关键动作应由用户确认，数据不出本机。',
+  };
+}
+
+module.exports = { PLAYBOOKS, routeRequest };

package/lib/skills-scan.js

@@ -267,7 +267,7 @@ function mergeRegistry(scanResult, previous) {
   }
   const registry = {
     updated: now,
-    note: '本地技能注册表（yotta-skills --inventory 生成）。数据不出本机。',
+    note: '本地技能注册表（yotta-skills --inventory / --reindex 生成）。数据不出本机。',
     skills: next,
   };
   return { registry, changes };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yottameta/yotta-skills",
-  "version": "0.2.1",
-  "description": "YuanGe (元阁) — one-command installer for the whole YottaMeta skill family: list, install, and update all published yotta-* skills into any agent (npx one-shot, zero dependencies, Node.js only).",
+  "version": "0.4.0",
+  "description": "YuanGe (元阁) - orchestration routing, inventory, and one-command installer for the YottaMeta skill family (zero dependencies, Node.js only).",
   "license": "MIT",
   "keywords": [
     "agent-skills",

package/references/install-flow.md

@@ -13,6 +13,8 @@
 4. 元信装前摘要（若引擎可用；`--skip-scan` 关闭）；
 5. 删除目标 `<dest>/<slug>` 后重新复制（跳过规则见下）；
 6. 汇总报告：✔ 成功 / - 跳过（已是最新）/ ✘ 失败；有失败项时退出码 1。
+7. 全部完成后自动 re-index 本地技能注册表（`~/.yottaskills/registry.json`）：重扫技能根目录并增量合并，
+   新装 / 更新的技能随即进入注册表（`--no-reindex` 可关闭；`--dry-run` 不触发）。
 
 ## 复制跳过规则
 
@@ -22,6 +24,14 @@
 因此装进技能目录的是「技能本体」（SKILL.md / references / scripts 等），不含 npm
 安装器自身、测试夹具与 Python 字节码缓存。
 
+## re-index（装技能后自动重扫注册表）
+
+- `install` / `update` 完成后，CLI 自动调用 `--reindex`（同一套 `lib/skills-scan.js` 扫描核心）：
+  重扫技能根目录 → 增量合并进 `~/.yottaskills/registry.json`（新增 / 更新 / 消失）。
+- `--no-reindex` 关闭自动重扫；`--reindex` 也可单独手动执行（会话开工 / 新装技能后）。
+- 与 `--inventory` 的区别：`--inventory` 侧重「盘点展示」（文本表格 / JSON 全量），
+  `--reindex` 侧重「变化合并」（增量、输出聚焦新增 / 更新 / 消失，适合钩子与脚本）。
+
 ## 幂等与版本判断
 
 - 读取目标 `<dest>/<slug>/SKILL.md` 的 frontmatter `version`；

package/references/orchestration.md

@@ -6,6 +6,22 @@
 
 ---
 
+## 〇、编排路由（--route / route_request）
+
+把需求摘要交给静态 playbook 与本地注册表，得到一组建议：
+
+```bash
+npx -y @yottameta/yotta-skills --route "帮我润色输出，要规范可复制，别有 AI 味"
+```
+
+- **输出**：候选组合、调用顺序、每个技能的角色、置信度、命中依据、已装/缺失状态、安装命令与应用模式提醒。
+- **缺失技能**：只给安装命令，不自动安装；安装前先做装前安全扫描，决定权在用户。
+- **应用模式**：默认用户显式调用；切换为「按场景自动调用」需要用户确认。
+- **无明确匹配**：低置信度回退到「入口 + 安装」组合，先澄清需求再继续。
+- **边界**：路由是建议，不保证完全正确；关键动作由用户确认，数据不出本机。
+
+---
+
 ## 一、技能家族全景（24 技能 / 8 家族）
 
 | 家族 | 技能（中文名 / slug） | 一句话能力 |

package/references/tutorial.md

@@ -104,3 +104,28 @@ npx -y @yottameta/yotta-skills install --agent codex --skip-scan # 跳过装前
 - **目标未指定**：当前目录没有项目级技能目录时报错（退出码 4），加 `--agent` 或
   `--dir`。
 - **已有旧版本**：默认按 range 覆盖升级到最新 patch；`--pin` 则锁定清单版本。
+
+## 11. 盘点已装技能与 re-index（新装技能自动被发现）
+
+```bash
+# 盘点本机已装技能（文本表格）
+npx -y @yottameta/yotta-skills --inventory
+
+# 重扫注册表（会话开工 / 新装技能后，增量合并变化）
+npx -y @yottameta/yotta-skills --reindex
+```
+
+- `install` / `update` 完成后会自动重扫注册表（`~/.yottaskills/registry.json`），新装 / 更新的
+  技能随即出现在 `--inventory` / `--reindex` 里；`--no-reindex` 可关闭自动重扫。
+- 建议每会话开工先跑一次 `--reindex`（快速增量，只合并变化），让后装的技能自动被看见。
+
+## 编排路由（--route）
+
+当你不知道「这个需求该用哪几个技能」，可以先把需求摘要交给元阁：
+
+```bash
+npx -y @yottameta/yotta-skills --route "检查代码质量，别糊弄"
+```
+
+输出会告诉你命中哪个组合、按什么顺序调用、每个技能负责什么、哪些已装、哪些缺失，以及缺失技能的安装命令。元阁只给建议，不会自动安装；安装前请先做装前安全扫描，并由用户确认。
+- `--json` 输出机器可读结果（含新增 / 更新 / 消失），适合脚本与钩子。

package/scripts/yotta-skills-mcp.py

@@ -6,8 +6,9 @@ stdio MCP server（JSON-RPC 2.0，换行分隔），把元阁技能扫描核心
   list_installed_skills  盘点本机已装技能（读本地注册表；未生成则先扫描一次）
   describe_skill         查看单个技能详情（slug / 版本 / 功能 / 来源）
   reindex                强制重新扫描并更新注册表
+  route_request          按需求摘要给出静态编排路由建议
 
-自包含原则：扫描由元阁自带核心（bin/yotta-skills.js --inventory）完成，
+自包含原则：扫描由元阁自带核心（bin/yotta-skills.js --inventory / --reindex）完成，
 不依赖任何元技能；数据只写本机 ~/.yottaskills/registry.json，不出本机。
 
 运行：python scripts/yotta-skills-mcp.py
@@ -23,7 +24,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-VERSION = "0.2.1"
+VERSION = "0.4.0"
 TOOL_NAME = "yotta-skills"
 CN_NAME = "元阁"
 MCP_PROTOCOL = "2025-03-26"
@@ -123,13 +124,13 @@ def _tool_describe(arguments):
 
 
 def _tool_reindex(arguments):  # noqa: ARG001
-    stdout = _run_cli(["--inventory", "--json"])
+    stdout = _run_cli(["--reindex", "--json"])
     try:
         data = json.loads(stdout)
     except json.JSONDecodeError as e:
         return _tool_error("reindex 输出解析失败：%s" % e)
     payload = {
-        "count": len(data.get("skills", [])),
+        "count": data.get("count", len(data.get("skills", []))),
         "changes": data.get("changes"),
         "errors": data.get("errors"),
         "registry": str(REGISTRY_FILE),
@@ -138,10 +139,24 @@ def _tool_reindex(arguments):  # noqa: ARG001
             "isError": False}
 
 
+def _tool_route(arguments):
+    request = str(arguments.get("request") or "").strip()
+    if not request:
+        return _tool_error("route_request 需要 request 参数")
+    stdout = _run_cli(["--route", request, "--json"])
+    try:
+        payload = json.loads(stdout)
+    except json.JSONDecodeError as e:
+        return _tool_error("route_request 输出解析失败：%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,
 }
 
 
@@ -163,10 +178,17 @@ def mcp_tools():
         ),
         _tool_spec(
             "reindex",
-            "强制重新扫描所有技能目录并更新本地注册表，返回本次变化（新增 / 更新 / 消失）。",
+            "强制重新扫描所有技能目录并更新本地注册表，返回本次变化（新增 / 更新 / 消失）；CLI 等价命令：yotta-skills --reindex。",
             {},
             [],
         ),
+        _tool_spec(
+            "route_request",
+            "按需求摘要给出静态编排路由建议：候选组合、调用顺序、每个技能角色、置信度、依据、已装/缺失状态与安装命令。"
+            "只建议安装，不自动安装；数据不出本机。",
+            {"request": {"type": "string", "description": "用户需求摘要"}},
+            ["request"],
+        ),
     ]