create-yss-spec 2.2.10 → 3.0.1

package/template/docs/templates/implementation-routing-template.md

@@ -9,7 +9,7 @@ owner: ai
 
 > 适用场景：Spec、OpenAPI Freeze / 无 API 影响记录、Design Review 和垂直切片 Ticket 已就绪后，进入实现前。
 > 本文记录契约状态、Ticket 状态、YSS skill 最小集合、测试策略和回滚点，不替代垂直切片 Ticket 或实施计划。
-> Router 只能生成 `draft`、`blocked` 或 `ready-for-lifecycle-review`；不得自行写入 `approved`、`ready-for-agent` 或 `completed`。合同批准、持久化和 Ticket 状态推进由生命周期编排器负责。
+> 实现合同编译器 只能生成 `draft`、`blocked` 或 `ready-for-lifecycle-review`；不得自行写入 `approved`、`ready-for-agent` 或 `completed`。合同批准、持久化和 Ticket 状态推进由生命周期编排器负责。
 
 ## 1. 输入材料
 
@@ -40,7 +40,7 @@ owner: ai
 | Harness 内项目根路径符合 `apps/<backend|frontend>/<project>/` | 是 / 否 / 不适用 | `apps/backend/`、`apps/frontend/` 仅为容器 |
 | 未使用 `app/backend/`、`app/frontend/` 及其子路径 | 是 / 否 / 不适用 | 命中即阻断生成和实现 |
 | 原型确认后先完成后端脚手架，再进入业务代码路由 | 是 / 否 / 不适用 | `backend_scaffold_policy_satisfied` |
-| 后端脚手架合同字段完整且版本当前 | 是 / 否 / 不适用 | schema v2：`scaffold_request_id`、项目/输出目录、Router draft、生命周期批准、base package、Maven 坐标、target DDD/Profile、initialize-only、允许写路径、预期证据、验证命令 |
+| 后端脚手架合同字段完整且版本当前 | 是 / 否 / 不适用 | schema v2：`scaffold_request_id`、项目/输出目录、实现合同编译器 draft、生命周期批准、base package、Maven 坐标、target DDD/Profile、initialize-only、允许写路径、预期证据、验证命令 |
 | 后端构建 / 测试 / OpenAPI / CI 命令均使用项目根目录 `./mvnw ...`，或已记录受控例外 | 是 / 否 / 不适用 | 裸 `mvn ...` 默认为规范偏离 |
 | 持久化文档正文和章节标题已转换为中文，仅保留必要英文技术标识 / metadata | 是 / 否 | 英文 skill / 模板不得原样落地为交付文档 |
 | YSS skill 路由已完成 | 是 / 否 |  |
@@ -55,7 +55,7 @@ owner: ai
 | contract_version |  |
 | slice_id |  |
 | status | `draft` / `blocked` / `ready-for-lifecycle-review` |
-| compiled_by | `yss-router` |
+| compiled_by | `yss-implementation-contract-compiler` |
 | 生命周期批准状态 | pending / approved / rejected；由生命周期编排器填写 |
 | 合同持久化路径 |  |
 
@@ -238,11 +238,11 @@ owner: ai
 
 ### 4.3 后端脚手架工作单元
 
-当 backend `scaffold_status=required` 时，先登记一个 `controlled-generation` 工作单元：`primary_skill=yss-ddd-scaffold-generator`，并在后续追加 `yss-backend-scaffold-parent` 基线校验和 `yss-router` 合同重编译。`existing` / `initialized` 不重复全量生成，但必须提供等价基线和 Wrapper 证据。
+当 backend `scaffold_status=required` 时，先登记一个 `controlled-generation` 工作单元：`primary_skill=yss-ddd-scaffold-generator`，并在后续追加 `yss-backend-scaffold-parent` 基线校验和 `yss-implementation-contract-compiler` 合同重编译。`existing` / `initialized` 不重复全量生成，但必须提供等价基线和 Wrapper 证据。
 
 | 项 | 内容 |
 |---|---|
-| 前置 | `prototype_confirmation`、工程基线、实现仓库和脚手架目标已确认；Router 脚手架合同 draft 已经生命周期批准并持久化为结构化 JSON，生成器通过 `--contract-file` 消费 |
+| 前置 | `prototype_confirmation`、工程基线、实现仓库和脚手架目标已确认；实现合同编译器 脚手架合同 draft 已经生命周期批准并持久化为结构化 JSON，生成器通过 `--contract-file` 消费 |
 | 生成器 | `yss-ddd-scaffold-generator` |
 | 模式 | `controlled-generation` |
 | Java / Maven 身份 | `base_package` 与 Maven `group_id` 分开登记；项目版本、父 POM GAV、`yss-components.version` 进入批准合同并原样传给 CLI |
@@ -251,7 +251,7 @@ owner: ai
 | 生成选项 | 关闭 `--with-example`；生成器严格 initialize-only，非空目录、`--force`、旧项目迁移和当前模板升级均为 `unsupported` |
 | Profile | `target-domain-model` / `mybatis-plus` / `mysql` / `spring-boot-2.7-jdk8` / `javax` / `web` / `yss-internal`；其他组合须先通过独立 fixture |
 | 验证 | 使用一键生成验证入口，实际执行项目根目录 `./mvnw validate`、`./mvnw test`、`./mvnw package`；通过后仅为 `empty-scaffold-verified`，golden first slice 通过后才是 `first-slice-verified` |
-| 后置 | `yss-backend-scaffold-parent`、`yss-router` 业务合同重编译、YSS Skill Execution Result |
+| 后置 | `yss-backend-scaffold-parent`、`yss-implementation-contract-compiler` 业务合同重编译、YSS Skill Execution Result |
 
 所有后续生成代码必须绑定当前批准且版本一致的 Slice Implementation Contract、主 YSS skill、依赖闭包、允许写路径、预期证据和 Execution Result。业务行为必须使用 `behavior-tdd`；缺任一条件即阻断，不得以脚手架成功或时间压力豁免。
 
@@ -324,7 +324,7 @@ owner: ai
 
 - [ ] 垂直切片 Ticket 完整，且状态允许进入实现。
 - [ ] 统一合同包含 `contract_id` / `contract_version`、Common、Frontend、Backend、Contract 和 Cross-repo 子合同；不适用项均有原因。
-- [ ] 生命周期编排器已批准并持久化合同；Router 没有自行给出 `approved` 或 `ready-for-agent`。
+- [ ] 生命周期编排器已批准并持久化合同；实现合同编译器 没有自行给出 `approved` 或 `ready-for-agent`。
 - [ ] YSS skills 已最小化选择，没有绕过 Ticket、OpenAPI Freeze / 无 API 影响记录或必要的 Spec Delta。
 - [ ] 后端切片如适用，已填写 `Backend Slice Implementation Contract`，并且 required skills、禁止模式、证据文件、延期 seam 和验证命令完整。
 - [ ] 受影响外部实现仓库已登记，并绑定分支、MR / PR、CI 和验证命令。
@@ -340,7 +340,7 @@ owner: ai
 
 ## 9. 下一步门禁
 
-- Router 结论：draft / blocked / ready-for-lifecycle-review
+- 实现合同编译器 结论：draft / blocked / ready-for-lifecycle-review
 - 生命周期编排器结论：approved / rejected / pending
 - 下一步：生命周期合同审查 / TDD 实现 / 完整重路由 / Architecture Re-check / 回到 系统 / 数据架构设计 / 回到垂直切片
 - 阻断项：

package/template/docs/templates/requirement-freeze-template.md

@@ -17,7 +17,7 @@ owner: ai
 | Spec 初稿 |  |  |  |
 | 产品总体设计 / 功能架构 |  |  | 必需 |
 | 产品设计 / 交互说明 |  |  |  |
-| 高保真 HTML 原型 | `docs/.scratch/<feature>/design/prototypes/index.html` |  | 有 UI 时必需；Ant Design v6 主题/视觉标准 + schema v2 语义映射/浏览器/无障碍证据，生产 API 为 YSS UI + Ant Design Vue 4.x |
+| 原型交付物 | `docs/.scratch/<feature>/design/prototypes/index.html` 或稳定 URL |  | 有产品设计影响时必需；按 H1/H2 档位提供 schema v3 浏览器、Design QA 与条件 AntD 事实；真实组件待验事项进入前端实现计划 |
 | Prototype Review |  |  |  |
 | CONTEXT 术语 |  |  | 业务术语须含 PascalCase `英文标识` |
 
@@ -51,7 +51,7 @@ owner: ai
 
 ## 6. 完成标准
 
-- [ ] Spec 已吸收产品总体设计 / 功能架构、产品设计、低保真原型评审和高保真 HTML 原型暴露的阻断项。
+- [ ] Spec 已吸收产品总体设计 / 功能架构、产品设计、低保真原型评审和原型交付物暴露的阻断项。
 - [ ] 本轮做什么、不做什么、延后什么已经明确。
 - [ ] OpenAPI、工程基线、系统架构、数据架构、风险影响已有明确结论。
 - [ ] 可进入 API 影响分析 / 契约草案 / 工程基线，或阻断项已列出。

package/template/docs/templates/review-report-template.md

@@ -23,11 +23,11 @@ Approved / Changes requested / Blocked
 
 ## Slice Implementation Contract 审查
 
-> 按 Router 生成条件对称核验合同和执行结果。Reviewer 不得直接信任实现者自报的 `implemented`。
+> 按 实现合同编译器 生成条件对称核验合同和执行结果。Reviewer 不得直接信任实现者自报的 `implemented`。
 
 | 检查项 | 结论 | 证据 |
 |---|---|---|
-| `contract_id` / `contract_version` 与生命周期批准、持久化版本及 Ticket 引用一致；Router 未自行写入 `approved`、`ready-for-agent` 或 `completed` | pass / violation |  |
+| `contract_id` / `contract_version` 与生命周期批准、持久化版本及 Ticket 引用一致；实现合同编译器 未自行写入 `approved`、`ready-for-agent` 或 `completed` | pass / violation |  |
 | Common、Frontend、Backend、Contract、Cross-repo 子合同按实际影响填写，不适用项均有原因 | pass / violation |  |
 | `required_skills` 依赖闭包与实际影响对称；Application、MapStruct、Lombok、Alibaba 等强制依赖未遗漏 | pass / violation / not-applicable |  |
 | 每个工作单元绑定唯一 `behavior-tdd` 或 `controlled-generation`；业务行为未混入机械生成 | pass / violation |  |
@@ -125,12 +125,12 @@ rg -n "from 'ant-design-vue'|<(Table|Tree|Form)[ >]|YFormily|YssFormily|YTable|Y
 | Agent 修改合同允许路径之外的文件，或缺少预期证据文件 | 应标记为 `violation` 并阻断 build |  |
 | Agent 把状态机、权限、事务或错误映射放入 `controlled-generation` | 应拆分为 `behavior-tdd` 工作单元并触发完整重路由 |  |
 | Agent 使用 `seam-deferred` 却缺少风险、责任人、后续 Ticket、验证计划或目标版本 / 发布日期 | 应标记为 `violation` 并阻断 |  |
-| Agent 返回非空 `new_impacts` 后继续编码或补写旧合同 | 应暂停相关工作单元，将合同标记 `stale`，回到 Router 或更早生命周期阶段 |  |
+| Agent 返回非空 `new_impacts` 后继续编码或补写旧合同 | 应暂停相关工作单元，将合同标记 `stale`，回到 实现合同编译器 或更早生命周期阶段 |  |
 | Agent 只列验证命令但没有实际结果和执行时间 | 不构成 fresh verification，不得给出 Approved / 可合并结论 |  |
 | Agent 用第二个通用审查 skill 代替 `code-review`，或 Standards 未读取合同 `required_skills` / Alibaba / `yss-ui` | 应标记为 `violation` 并阻断完成 |  |
 | Agent 把 YSS 页面模块约定并进 UI fidelity，或适用报告行留空 | 应回到 Standards 专项检查，空白行视为 `missing_evidence` |  |
 | Agent 在审查会话中直接改实现代码以“关掉” finding | 应标记为 `violation`；finding 交实现者在原合同路径修复，再重新捕获候选并全轴复审 |  |
 | Agent 把 `violation` 记为 `not-applicable`，或为日常 Alibaba / YSS 另开生物人豁免门禁 | 应阻断；命中后只允许修复或完整 `seam-deferred`，未命中才 `not-applicable` |  |
-| Agent 发现 `drift` / `new_impacts` / `required_skills` 与真实影响不一致后仍在旧合同上编码 | 应将合同标 `stale`，回 Router 或更早生命周期阶段 |  |
+| Agent 发现 `drift` / `new_impacts` / `required_skills` 与真实影响不一致后仍在旧合同上编码 | 应将合同标 `stale`，回 实现合同编译器 或更早生命周期阶段 |  |
 
 ## 签字确认

package/template/docs/templates/spec-template.md

@@ -51,7 +51,7 @@ owner: ai
 - UI 影响：是 / 否
 - 产品总体设计：`docs/.scratch/<feature>/design/<feature>-product-overview-design.md`
 
-> 只有存在 UI 影响时，才强制低保真页面草图、状态矩阵、高保真 HTML 原型和用户确认；否则记录 `not-applicable` 及原因。
+> 只有存在产品设计影响时，才强制低保真页面草图、状态矩阵、按 H1/H2 路由的原型交付物和用户确认；否则记录 `not-applicable` 及原因。
 
 ## OpenAPI 影响
 

package/template/docs/templates/vertical-slice-ticket-template.md

@@ -51,12 +51,12 @@ Status: ready-for-human
 | contract_id |  |
 | contract_version |  |
 | contract_ref |  |
-| Router 状态 | draft / blocked / ready-for-lifecycle-review |
+| 实现合同编译器 状态 | draft / blocked / ready-for-lifecycle-review |
 | 生命周期批准状态 | pending / approved / rejected |
-| suggested_owner_role_id | `role.frontend-engineer` / `role.backend-engineer` / `role.test-engineer`（Router 建议，编排器派活） |
+| suggested_owner_role_id | `role.frontend-engineer` / `role.backend-engineer` / `role.test-engineer`（实现合同编译器 建议，编排器派活） |
 | Build Architecture Checklist |  |
 
-> Router 不得自行将合同批准或将本 Ticket 推进为 `ready-for-agent`。只有生命周期编排器核验并持久化当前版本合同、清除阻塞边后，才能推进状态。
+> 实现合同编译器 不得自行将合同批准或将本 Ticket 推进为 `ready-for-agent`。只有生命周期编排器核验并持久化当前版本合同、清除阻塞边后，才能推进状态。
 
 ### 工作单元
 
@@ -103,7 +103,7 @@ Status: ready-for-human
 | affected_work_units |  |
 | new_impacts |  |
 | stale_contract_version |  |
-| return_stage | Router / Architecture Re-check / 产品设计 / OpenAPI Draft-Review-Freeze / 系统或数据架构 / other |
+| return_stage | 实现合同编译器 / Architecture Re-check / 产品设计 / OpenAPI Draft-Review-Freeze / 系统或数据架构 / other |
 | recovery_conditions |  |
 
 出现 `drift`、`violation` 或非空 `new_impacts` 时暂停受影响工作单元，不得先完成代码再补合同；更新合同版本并通过生命周期审查后才能恢复。

package/template/docs/user-guide/yss-ui-mcp.md

@@ -5,8 +5,6 @@
 - Claude Code：`.mcp.json`
 - Antigravity：`.agents/mcp_config.json`
 - Cursor：`.cursor/mcp.json`
-- Gemini CLI：`.gemini/settings.json`
-- Kiro：`.kiro/settings/mcp.json`
 - VS Code：`.vscode/mcp.json`
 
 这些配置统一通过 `npx -y @yss-ui/mcp` 启动，不写用户主目录，也不覆盖个人全局配置。首次加载模板后，重启或刷新对应客户端即可发现 MCP。

package/template/docs/user-guide//346/210/230/346/234/257/350/256/276/350/256/241/345/255/220/351/241/271/347/233/256/347/224/250/346/210/267/346/211/213/345/206/214.md

@@ -210,9 +210,9 @@ Strategic Design 解决“业务应该怎样分工和划边界”；Tactical Des
 ## 与其他文档怎么分工
 
 - [用户手册索引](./用户手册索引.md)：所有入门手册的入口。
-- [战略设计子项目用户手册](../../submodules/yss-strategic-design-harness/docs/user-guide/战略设计子项目用户手册.md)：上游 Discovery、DDD 战略设计、Spec、原型和 Strategic Design Handoff。
+- [战略设计子项目用户手册](../../submodules/yss-harness-design-agent/docs/user-guide/战略设计子项目用户手册.md)：上游 Discovery、DDD 战略设计、Spec、原型和 Strategic Design Handoff。
 - [系统概要设计模板](../architecture/templates/system-overview-design-template.md)：轻量 Tactical DDD Check 的记录位置。
 - [架构评审清单](../architecture/templates/architecture-review-checklist.md)：设计评审时的结构化检查项。
-- `yss-router` 与后端 / 前端专项技能：批准后的实现合同、代码和验证规则。
+- `yss-implementation-contract-compiler` 与后端 / 前端专项技能：批准后的实现合同、代码和验证规则。
 
 本手册是模板源中的通用分发资产。真实项目应使用自己的术语、规则、合同版本和批准记录；不要把“客户合同审批”示例当成真实业务结论。

package/template/docs/user-guide//347/224/250/346/210/267/346/211/213/345/206/214.md

@@ -205,13 +205,13 @@ codex plugin add yss-backend-harness@personal
 
 ### 插件不会替代什么
 
-Plugin 是运行时适配器，不是新的事实源。它不会替代 `yss-product-lifecycle`、`yss-router` 或 `tdd`，不会设置 `ready-for-agent`，不会 Freeze OpenAPI，也不能承担独立审查。
+Plugin 是运行时适配器，不是新的事实源。它不会替代 `yss-product-lifecycle`、`yss-implementation-contract-compiler` 或 `tdd`，不会设置 `ready-for-agent`，不会 Freeze OpenAPI，也不能承担独立审查。
 
 执行结果应包含 `Workflow Execution Result`（例如 `completed`、`blocked`、`needs-human` 或 `failed`）及对应证据。发现路径越界、合同过期、影响面变化或证据缺失时，应停止并回到路由流程。
 
 ### 不可用时怎么办
 
-如果插件未安装、版本不兼容或执行失败，回退到通用的 `yss-router + tdd` 流程，并记录阻塞原因和实际验证命令。不要为了绕过插件故障而跳过生命周期门禁。
+如果插件未安装、版本不兼容或执行失败，回退到通用的 `yss-implementation-contract-compiler + tdd` 流程，并记录阻塞原因和实际验证命令。不要为了绕过插件故障而跳过生命周期门禁。
 
 ### 其他应用的接入建议
 
@@ -331,7 +331,7 @@ Spec 初稿通常使用 `ready-for-human`。这表示还要确认，不表示可
 - 失败后能不能重试。
 - 窄屏下是否还能完成操作。
 
-成功时，交互说明、状态矩阵、低保真和高保真原型相互一致，并有评审、浏览器验证和用户确认记录。
+先独立评审低保真和状态矩阵，再选择满足风险的最低原型档位：H1 确认视觉和少量交互，H2 验证主流程与异常状态。原型阶段不调用生产实现技能 `yss-ui`；真实组件假设与待验行为交给前端实现计划和实现还原验证。成功时，交互说明、状态矩阵、低保真和原型交付物相互一致，并有评审、浏览器验证和用户确认记录。
 
 正式信息：
 
@@ -397,7 +397,7 @@ Draft 只是草案。评审通过后才能 Freeze。Freeze 可以理解为“接
 
 前端：
 
-- 让 `yss-router` 选择当前页面需要的专项 skill。
+- 让 `yss-implementation-contract-compiler` 选择当前页面需要的专项 skill。
 - 以 `yss-ui`、`yss-page-module-development` 和 `tdd` 为主。
 - 只修改合同允许的路径。
 - 实际运行已登记的 `pnpm` 命令。
@@ -536,7 +536,7 @@ Agent 应返回合同版本、修改文件、实际命令、退出码和证据
 | 已确认 | 已由业务方、产品或权威资料确认 | 可以进入后续文档 |
 | 待确认 | 暂时没有答案 | 写负责人和确认时间，不让 Agent 猜 |
 | 非目标 | 本次明确不做 | 用来控制范围 |
-| 外部事实 | 来自法规、第三方 API、竞品或技术资料 | 用 `research` 或 `competitive-intelligence` 核对 |
+| 外部事实 | 来自法规、第三方 API、竞品或技术资料 | 用 `yss-research` 或 `competitive-intelligence` 核对；`research` 仅为兼容旧名 |
 | 猜测 | 还没有人确认的推测 | 保持为待确认 |
 
 ### 处理稳定术语

package/template/docs/user-guide//347/224/250/346/210/267/346/211/213/345/206/214/347/264/242/345/274/225.md

@@ -5,7 +5,7 @@
 ## 推荐阅读顺序
 
 1. [YSS 用户手册](./用户手册.md)：了解仓库身份、生命周期主链和 Agent 使用模式。
-2. [战略设计子项目用户手册](../../submodules/yss-strategic-design-harness/docs/user-guide/战略设计子项目用户手册.md)：从模糊想法形成 Strategic Design Handoff。
+2. [战略设计子项目用户手册](../../submodules/yss-harness-design-agent/docs/user-guide/战略设计子项目用户手册.md)：从模糊想法形成 Strategic Design Handoff。
 3. [战术设计子项目用户手册](./战术设计子项目用户手册.md)：把交接包细化为 Tactical Design，供研发实现和评审。
 
 ## 按任务查找
@@ -13,9 +13,9 @@
 | 你现在要做什么 | 推荐手册 |
 |---|---|
 | 创建、接管或更新 YSS 项目 | [YSS 用户手册](./用户手册.md) |
-| 澄清需求、确定用户和范围 | [战略设计子项目用户手册](../../submodules/yss-strategic-design-harness/docs/user-guide/战略设计子项目用户手册.md) |
+| 澄清需求、确定用户和范围 | [战略设计子项目用户手册](../../submodules/yss-harness-design-agent/docs/user-guide/战略设计子项目用户手册.md) |
 | 设计聚合、状态、不变量和领域事件 | [战术设计子项目用户手册](./战术设计子项目用户手册.md) |
-| 了解完整生命周期和阶段门禁 | [产品生命周期工作流](../../submodules/yss-strategic-design-harness/docs/user-guide/产品生命周期工作流.md) |
-| 查找长期协作习惯和反模式 | [生命周期最佳实践](../../submodules/yss-strategic-design-harness/docs/user-guide/生命周期最佳实践.md) |
+| 了解完整生命周期和阶段门禁 | [产品生命周期工作流](../../submodules/yss-harness-design-agent/docs/user-guide/产品生命周期工作流.md) |
+| 查找长期协作习惯和反模式 | [生命周期最佳实践](../../submodules/yss-harness-design-agent/docs/user-guide/生命周期最佳实践.md) |
 
 > 本仓库是 `template-source`。手册中的业务名称和示例只用于教学；真实产品资料应在 `project-instance` 中建立，并遵守对应的生命周期门禁。

package/template/scripts/audit-yss-backend-skills

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { loadSkillRegistry } from "./lib/skill-registry.mjs";
+import { OBSOLETE, ROOT } from "./lib/skill-supply-chain.mjs";
+
+const checkOnly = process.argv.includes("--check");
+const registry = loadSkillRegistry();
+const capabilityBySkill = new Map();
+for (const capability of registry.capabilities) {
+  if (!capabilityBySkill.has(capability.primary_skill)) capabilityBySkill.set(capability.primary_skill, []);
+  capabilityBySkill.get(capability.primary_skill).push(capability.id);
+}
+const inbound = new Map();
+for (const [owner, dependencies] of Object.entries(registry.skill_dependencies)) {
+  for (const dependency of dependencies) {
+    if (!inbound.has(dependency.skill)) inbound.set(dependency.skill, []);
+    inbound.get(dependency.skill).push({ owner, type: dependency.type, ...(dependency.when ? { when: dependency.when } : {}) });
+  }
+}
+const recipeCallers = new Map();
+for (const recipe of registry.recipes) for (const capability of recipe.capabilities) {
+  const skill = registry.capabilities.find((item) => item.id === capability)?.primary_skill;
+  if (!skill) continue;
+  if (!recipeCallers.has(skill)) recipeCallers.set(skill, []);
+  recipeCallers.get(skill).push(recipe.id);
+}
+
+const candidates = registry.skills
+  .filter((skill) => skill.impacts.includes("backend") || capabilityBySkill.has(skill.id))
+  .map((skill) => {
+    const capabilities = capabilityBySkill.get(skill.id) ?? [];
+    const callers = [...new Set(recipeCallers.get(skill.id) ?? [])].sort();
+    const dependencies = inbound.get(skill.id) ?? [];
+    const canonicalExists = existsSync(path.join(ROOT, ".agents/skills", skill.id, "SKILL.md"));
+    let classification = "keep";
+    let rationale = "unique capability or active typed caller exists";
+    if (OBSOLETE.has(skill.id)) {
+      classification = "remove";
+      rationale = "explicitly obsolete";
+    } else if (!capabilities.length && !callers.length && !dependencies.length) {
+      classification = "narrow";
+      rationale = "backend impact is declared but no capability, recipe, or typed dependency consumes it";
+    }
+    return { skill: skill.id, classification, canonical_exists: canonicalExists, capabilities, recipe_callers: callers, dependency_callers: dependencies, rationale };
+  })
+  .sort((left, right) => left.skill.localeCompare(right.skill));
+
+const blocking = candidates.filter((item) => item.classification === "remove" && item.canonical_exists);
+if (checkOnly) {
+  const counts = Object.fromEntries(["keep", "narrow", "merge", "remove"].map((classification) => [classification, candidates.filter((item) => item.classification === classification).length]));
+  process.stdout.write(`backend skill audit passed: ${candidates.length} candidates (${Object.entries(counts).map(([key, value]) => `${key}=${value}`).join(", ")})\n`);
+} else {
+  process.stdout.write(`${JSON.stringify({ schema_version: 1, generated_from: "docs/agents/yss-skill-registry.yaml", candidates }, null, 2)}\n`);
+}
+if (blocking.length) process.exitCode = 1;

package/template/scripts/generate-yss-skill-boundaries

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync } from "node:fs";
+import { loadCompilerContract } from "./lib/implementation-contract-compiler.mjs";
+import { loadSkillRegistry } from "./lib/skill-registry.mjs";
+import { ROOT } from "./lib/skill-supply-chain.mjs";
+import path from "node:path";
+
+const target = path.join(ROOT, ".agents/skills/yss-implementation-contract-compiler/references/boundaries.md");
+const registry = loadSkillRegistry();
+const compiler = loadCompilerContract();
+
+const lines = [
+  "# YSS Skill Boundaries",
+  "",
+  "> Generated by `scripts/generate-yss-skill-boundaries` from `docs/agents/yss-skill-registry.yaml` and `compiler-contract.yaml`. Do not hand-edit.",
+  "",
+  "实现入口先选择 capability 或窄 Recipe，再由实现合同编译器计算最小 skill 闭包。下面是派生阅读视图，不是第二套路由事实源。",
+  "",
+  "## Dependency Semantics",
+  "",
+  "| Type | Compiler behavior |",
+  "| --- | --- |",
+  "| `context-required` | 自动递归加入执行上下文。 |",
+  "| `context-conditional` | 仅当显式 condition 命中时递归加入。 |",
+  "| `coordination-only` | 记录协作原因，不扩张执行上下文。 |",
+  "| `review-only` | 仅作为审查输入记录，不扩张实现上下文。 |",
+  "| `component-dependency` | 记录组件关系；由 capability/Recipe 显式选择，不自动加载。 |",
+  "",
+  "## Capability Catalog",
+  "",
+  "| Capability | Primary skill | Task modes |",
+  "| --- | --- | --- |",
+  ...registry.capabilities.map((item) => `| \`${item.id}\` | \`${item.primary_skill}\` | ${item.task_modes.map((mode) => `\`${mode}\``).join(", ")} |`),
+  "",
+  "## Narrow Recipes",
+  "",
+  "一个切片可以组合多个 Recipe，但只计算一次闭包。Recipe 仅引用 capability。",
+  "",
+  "| Recipe | Capabilities |",
+  "| --- | --- |",
+  ...registry.recipes.map((item) => `| \`${item.id}\` | ${item.capabilities.map((capability) => `\`${capability}\``).join(", ")} |`),
+  "",
+  "## Impact Entry Mapping",
+  "",
+  "| Impact | Entry capabilities |",
+  "| --- | --- |",
+  ...Object.entries(compiler.impact_to_capabilities).map(([impact, capabilities]) => `| \`${impact}\` | ${capabilities.map((capability) => `\`${capability}\``).join(", ")} |`),
+  "",
+  "## Typed Skill Dependencies",
+  "",
+  "| Skill | Dependency | Type | Condition |",
+  "| --- | --- | --- | --- |",
+  ...Object.entries(registry.skill_dependencies).flatMap(([skill, dependencies]) => dependencies.map((dependency) => `| \`${skill}\` | \`${dependency.skill}\` | \`${dependency.type}\` | ${dependency.when ? `\`${dependency.when}\`` : "—"} |`)),
+  ""
+];
+
+const expected = lines.join("\n");
+if (process.argv.includes("--check")) {
+  const actual = readFileSync(target, "utf8");
+  if (actual !== expected) {
+    process.stderr.write("boundaries.md 与 Registry/Compiler 合同不一致；运行 scripts/generate-yss-skill-boundaries\n");
+    process.exitCode = 1;
+  } else process.stdout.write("YSS skill boundaries are current\n");
+} else {
+  writeFileSync(target, expected);
+  process.stdout.write("generated YSS skill boundaries\n");
+}

package/template/scripts/lib/export-skills.mjs

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const sourceRoot = path.join(root, ".agents/skills");
 const managed = ["skills", "skills.sh.json", ".yss-export-manifest.json"];
-const forbidden = ["AGENTS.md", "CONTEXT.md", "docs", "skills-lock.json", ".agents", ".claude", ".codex", ".hermes", ".pi", ".qoder", ".trae"];
+const forbidden = ["AGENTS.md", "CONTEXT.md", "docs", "skills-lock.json", ".agents", ".claude", ".codex", ".pi", ".qoder", ".trae"];
 const hash = (content) => createHash("sha256").update(content).digest("hex");
 const fail = (message) => { throw new TypeError("export-yss-skills: " + message); };
 
@@ -48,8 +48,8 @@ function sanitize(text, relative) {
   const prefix = prefixPath ? prefixPath + "/" : "";
   let value = text.replace(/(YSS_SKILLS_ROOT\s*=\s*["']?)\/path\/to\/\.agents\/skills/g, "$1__YSS_SKILLS_ROOT_PATH__");
   value = value.replace(/\/path\/to\/\.agents\/skills/g, "$YSS_SKILLS_ROOT");
-  value = value.replace(/(?:\$\{base_project\}\/)?(?:\/path\/to\/)?\.(?:agents|claude|codex|hermes|pi|qoder|trae)\/skills\//g, prefix);
-  value = value.replace(/\.(?:agents|claude|codex|hermes|pi|qoder|trae)\/skills\b/g, "the canonical public skill source");
+  value = value.replace(/(?:\$\{base_project\}\/)?(?:\/path\/to\/)?\.(?:agents|claude|codex|pi|qoder|trae)\/skills\//g, prefix);
+  value = value.replace(/\.(?:agents|claude|codex|pi|qoder|trae)\/skills\b/g, "the canonical public skill source");
   value = value.replace(/\/path\/to\/skill-creator/g, "skill-creator").replace(/(?<![\w.])\/path\//g, "./path/");
   value = value.replace(/\/(?:Users|home|private)\/[^\s"'()<>\]]+/g, "<local-path-removed>").replace(/\/tmp\//g, "./tmp/");
   value = value.replace(/yss-spec-project-template/g, "the consuming project").replace(/\$\{base_project\}/g, "the consuming project");
@@ -98,7 +98,7 @@ function validate(output, skillNames) {
     const text = bytes.toString("utf8");
     if (/-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----|(?:ghp_|github_pat_|github_token_|xox[baprs]-)[A-Za-z0-9_-]+|AKIA[0-9A-Z]{16}/.test(text)) fail("suspicious credential-like content: " + absolute);
     if (/(?:^|[^.\w])\/(?:Users|home|private|tmp)\//.test(text)) fail("absolute local path in public export: " + absolute);
-    if (/\.(?:agents|claude|codex|hermes|pi|qoder|trae)\/skills/.test(text)) fail("Agent root path in public export: " + absolute);
+    if (/\.(?:agents|claude|codex|pi|qoder|trae)\/skills/.test(text)) fail("Agent root path in public export: " + absolute);
   }
   validateLinks(path.join(output, "skills"));
 }

package/template/scripts/lib/implementation-contract-compiler.mjs

@@ -0,0 +1,194 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { parseDocument } from "../vendor/yaml.mjs";
+import { DEFAULT_REGISTRY, loadSkillRegistry } from "./skill-registry.mjs";
+import { ROOT } from "./skill-supply-chain.mjs";
+
+export const DEFAULT_COMPILER_CONTRACT = path.join(
+  ROOT,
+  ".agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml"
+);
+
+const REMOVED_SKILL_IDS = new Set(["yss-router", "yss-source-index"]);
+const EXPANDING_TYPES = new Set(["context-required", "context-conditional"]);
+const EXECUTION_STATUSES = new Set(["implemented", "seam-deferred", "drift", "violation", "not-applicable"]);
+
+function fail(message) {
+  throw new TypeError(message);
+}
+
+function stable(value) {
+  if (Array.isArray(value)) return value.map(stable);
+  if (!value || typeof value !== "object") return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, stable(value[key])]));
+}
+
+export function digestDocument(value) {
+  return createHash("sha256").update(JSON.stringify(stable(value))).digest("hex");
+}
+
+function loadYaml(filePath, label) {
+  const document = parseDocument(readFileSync(filePath, "utf8"), { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) fail(`${label} 无法解析: ${document.errors[0].message}`);
+  return document.toJS({ maxAliasCount: 0 });
+}
+
+export function loadCompilerContract(filePath = DEFAULT_COMPILER_CONTRACT) {
+  return loadYaml(filePath, "实现合同编译器合同");
+}
+
+function assertV2(registry, compilerContract) {
+  if (registry?.schema_version !== 2) fail("技能注册表 schema v1 已停止支持；请迁移到 capability/typed-dependency v2");
+  if (compilerContract?.schema_version !== 2) fail("实现合同编译器合同 schema v1 已停止支持；请迁移到 v2");
+}
+
+function assertNoRemovedId(value, field) {
+  for (const id of value) if (REMOVED_SKILL_IDS.has(id)) fail(`${field} 使用已移除 skill id ${id}；不提供兼容 alias`);
+}
+
+/**
+ * 把多个窄 Recipe 与显式 capability 合并为一个确定性的最小 skill 闭包。
+ */
+export function compileImplementationContract({
+  registry,
+  compilerContract,
+  recipeIds = [],
+  requiredCapabilities = [],
+  conditions = [],
+  compiledAt = new Date().toISOString(),
+  registryDigest,
+  compilerContractDigest
+}) {
+  assertV2(registry, compilerContract);
+  if (!Array.isArray(recipeIds) || !Array.isArray(requiredCapabilities) || !Array.isArray(conditions)) {
+    fail("recipeIds、requiredCapabilities 与 conditions 必须是数组");
+  }
+  assertNoRemovedId(recipeIds, "recipeIds");
+  assertNoRemovedId(requiredCapabilities, "requiredCapabilities");
+
+  const requestedRecipes = new Set(recipeIds);
+  const knownRecipes = new Map(registry.recipes.map((recipe) => [recipe.id, recipe]));
+  for (const recipeId of requestedRecipes) if (!knownRecipes.has(recipeId)) fail(`未知 recipe: ${recipeId}`);
+  const orderedRecipes = registry.recipes.filter((recipe) => requestedRecipes.has(recipe.id));
+
+  const capabilitySources = new Map();
+  const orderedCapabilities = [];
+  const addCapability = (capabilityId, source) => {
+    if (!capabilitySources.has(capabilityId)) {
+      capabilitySources.set(capabilityId, []);
+      orderedCapabilities.push(capabilityId);
+    }
+    capabilitySources.get(capabilityId).push(source);
+  };
+  for (const recipe of orderedRecipes) {
+    if (recipe.skills !== undefined) fail(`recipe ${recipe.id} 不得直接引用 skills`);
+    for (const capabilityId of recipe.capabilities) addCapability(capabilityId, { kind: "recipe", recipe_id: recipe.id });
+  }
+  for (const capabilityId of requiredCapabilities) addCapability(capabilityId, { kind: "explicit-capability" });
+  if (!orderedCapabilities.length) fail("至少需要一个 recipe 或 required capability");
+
+  const capabilities = new Map(registry.capabilities.map((capability) => [capability.id, capability]));
+  for (const capabilityId of orderedCapabilities) if (!capabilities.has(capabilityId)) fail(`未知 capability: ${capabilityId}`);
+  const knownSkills = new Set(registry.skills.map((skill) => skill.id));
+  const conditionSet = new Set(conditions);
+  const reasons = new Map();
+  const nonExpanding = [];
+  const excludedConditional = [];
+  const addReason = (skill, reason) => {
+    if (!reasons.has(skill)) reasons.set(skill, []);
+    const encoded = JSON.stringify(reason);
+    if (!reasons.get(skill).some((item) => JSON.stringify(item) === encoded)) reasons.get(skill).push(reason);
+  };
+
+  const roots = [];
+  for (const capabilityId of orderedCapabilities) {
+    const skill = capabilities.get(capabilityId).primary_skill;
+    if (!knownSkills.has(skill)) fail(`${capabilityId} 解析到未知 skill: ${skill}`);
+    if (!roots.includes(skill)) roots.push(skill);
+    for (const source of capabilitySources.get(capabilityId)) addReason(skill, { ...source, capability: capabilityId });
+  }
+
+  const visiting = new Set();
+  const visited = new Set();
+  const orderedSkills = [];
+  const visit = (skill, chain = []) => {
+    if (visiting.has(skill)) fail(`依赖循环: ${[...chain, skill].join(" -> ")}`);
+    if (visited.has(skill)) return;
+    visiting.add(skill);
+    const dependencies = [...(registry.skill_dependencies?.[skill] ?? [])]
+      .sort((left, right) => left.skill.localeCompare(right.skill));
+    for (const dependency of dependencies) {
+      const conditionMatches = !dependency.when || conditionSet.has(dependency.when);
+      if (dependency.type === "context-conditional" && !conditionMatches) {
+        excludedConditional.push({ from: skill, ...dependency });
+        continue;
+      }
+      const reason = { kind: "dependency", from: skill, type: dependency.type, ...(dependency.when ? { condition: dependency.when } : {}) };
+      if (!EXPANDING_TYPES.has(dependency.type)) {
+        if (conditionMatches) nonExpanding.push({ skill: dependency.skill, ...reason });
+        continue;
+      }
+      addReason(dependency.skill, reason);
+      if (knownSkills.has(dependency.skill)) visit(dependency.skill, [...chain, skill]);
+      else if (!orderedSkills.includes(dependency.skill)) orderedSkills.push(dependency.skill);
+    }
+    visiting.delete(skill);
+    visited.add(skill);
+    orderedSkills.push(skill);
+  };
+  for (const root of roots) visit(root);
+
+  return {
+    schema_version: 2,
+    status: "draft",
+    recipe_ids: orderedRecipes.map((recipe) => recipe.id),
+    conditions: [...conditionSet].sort(),
+    required_capabilities: orderedCapabilities,
+    required_skills: orderedSkills,
+    reason_chains: Object.fromEntries(orderedSkills.map((skill) => [skill, reasons.get(skill) ?? []])),
+    non_expanding_dependencies: nonExpanding,
+    excluded_conditional_dependencies: excludedConditional,
+    registry_digest: registryDigest ?? digestDocument(registry),
+    compiler_contract_digest: compilerContractDigest ?? digestDocument(compilerContract),
+    compiled_at: compiledAt,
+    freshness: "current"
+  };
+}
+
+export function compileDefaultImplementationContract(input = {}) {
+  return compileImplementationContract({
+    ...input,
+    registry: loadSkillRegistry(DEFAULT_REGISTRY),
+    compilerContract: loadCompilerContract()
+  });
+}
+
+export function evaluateContractFreshness(contract, { registry, compilerContract }) {
+  assertV2(registry, compilerContract);
+  if (contract?.schema_version !== 2) fail("Slice Implementation Contract schema v1 已停止支持；必须重新编译 v2 合同");
+  const resolution = contract.resolution ?? contract;
+  const reasons = [];
+  if (resolution.registry_digest !== digestDocument(registry)) reasons.push("registry-digest-changed");
+  if (resolution.compiler_contract_digest !== digestDocument(compilerContract)) reasons.push("compiler-contract-digest-changed");
+  return { freshness: reasons.length ? "stale" : "current", reasons };
+}
+
+export function validateExecutionResult(result, contract, current) {
+  if (result?.schema_version !== 2) fail("YSS Skill Execution Result schema v1 已停止支持；请迁移到 v2");
+  if (contract?.schema_version !== 2) fail("Slice Implementation Contract schema v1 已停止支持；必须重新编译 v2 合同");
+  if (!EXECUTION_STATUSES.has(result.status)) fail(`未知 execution result status: ${result.status}`);
+  const freshness = evaluateContractFreshness(contract, current);
+  if (freshness.freshness === "stale") return { status: "stale", blockers: freshness.reasons };
+  const consumed = result.consumed_contract ?? {};
+  const resolution = contract.resolution ?? contract;
+  const blockers = [];
+  if (consumed.contract_id !== contract.contract_id || consumed.contract_version !== contract.contract_version) blockers.push("contract-version-mismatch");
+  if (consumed.registry_digest !== resolution.registry_digest || consumed.compiler_contract_digest !== resolution.compiler_contract_digest) blockers.push("resolution-digest-mismatch");
+  if (!Array.isArray(result.verification_results) || !result.verification_results.length) blockers.push("verification-not-executed");
+  else for (const item of result.verification_results) {
+    if (!item?.command || item.exit_code === undefined || !item.executed_at) blockers.push("verification-result-incomplete");
+  }
+  if (Array.isArray(result.new_impacts) && result.new_impacts.length) blockers.push("new-impacts");
+  return { status: blockers.length ? "blocked" : "accepted", blockers: [...new Set(blockers)] };
+}