create-yss-spec 3.3.8 → 3.4.3

package/template/docs/process/strategic-handoff-package.md

@@ -1,12 +1,12 @@
 # 战略交接快照包
 
-本合同用于批准后的战略交付和研发接收，不增加生命周期阶段或门禁。`scripts/strategic-handoff` 是统一入口；Node 22+、Python 3 和现有 `jsonschema` 环境即可运行，不下载依赖、不执行交接包中的代码。包 schema 与导出配置见同目录 `schemas/strategic-handoff-package.schema.json`、`schemas/strategic-handoff-export.schema.json`（历史 v1）与 `schemas/strategic-handoff-export-v2.schema.json`（Handoff v5）。源规则仍由战略合同持有，索引与快照不成为第二套事实源。
+本合同用于批准后的战略交付和研发接收，不增加生命周期阶段或门禁。`scripts/strategic-handoff` 是统一入口；Node 22+、Python 3 和现有 `jsonschema` 环境即可运行，不下载依赖、不执行交接包中的代码。新交付统一使用 Handoff v5，并生成 `Strategic Delivery Bundle`；交付记录、验证记录、逻辑包和可选 ZIP 的 schema 分别见 `schemas/strategic-handoff-delivery.schema.json`、`schemas/strategic-handoff-delivery-verification.schema.json`、`schemas/strategic-handoff-package.schema.json`。源规则仍由战略合同持有，README、索引与快照不成为第二套事实源。
 
 ## 源资产准备
 
 1. 源仓必须为 `project-instance`。新交付使用 Domain Strategy v3 与 Stage Decision Package v3；规则、场景、决定、假设、约束、成功标准、测试 seam 与 downstream mapping 使用稳定 ID 和证据。v2 仅用于历史 Handoff v3 的只读验证；修改或重发须显式迁移、重新批准。不得用行号、文字 hash 或导出顺序生成业务身份。
 2. 每个场景明确 `critical`、`rule_refs`、`success_results` 和既有 `failure_results`；兼容字段 `rules` 必须与引用规则正文一致。不变量使用 `rule_ref`，并通过 `scenario_refs` 指向确实覆盖该规则的场景。缺身份或关联先回战略方确认、更新并重新批准，导出器不猜测。
-3. 新的既有 UI 交接使用 Handoff v5；原型交付可继续使用 Handoff v4 或显式使用 v5 的 prototype 分支。历史 Handoff v3/v4 按各自冻结 schema 和来源语义严格验证，不原地升级。校验器先读取 `schema_version` 再选择固定 schema，未知版本输出支持列表并 fail closed。`package_export` 的 `approvals` 按 `source` 字段及 `handoff` 绑定批准记录，声明 `record_ref`、`gate_id`、`digest_kind`。沿用源角色表的现有门禁；当前综合模板的战略、阶段决策及交接资产统一绑定 `gate.plan-approved`，Spec 对应 Spec 基线批准，原型和视觉基线对应 `gate.product-design-approved`；历史包及其他源 profile 仍按包内明确登记的源批准规则验证，不自动迁移当前门禁状态。
+3. 新原型与既有 UI 交接都使用 Handoff v5，分别选择 `prototype` 或 `existing-ui-baseline`。历史 Handoff v3/v4 与既有裸 v5 包继续按冻结 schema 执行 `verify/import`，但 v3/v4 不再创建新 export；修改或重新交付必须迁移到 v5 并重新批准。校验器先读取 `schema_version` 再选择固定 schema，未知版本输出支持列表并 fail closed。`package_export` 的 `approvals` 按 `source` 字段及 `handoff` 绑定批准记录，声明 `record_ref`、`gate_id`、`digest_kind`。沿用源角色表的现有门禁；当前综合模板的战略、阶段决策及交接资产统一绑定 `gate.plan-approved`，Spec 对应 Spec 基线批准，原型和视觉基线对应 `gate.product-design-approved`；历史包及其他源 profile 仍按包内明确登记的源批准规则验证，不自动迁移当前门禁状态。
 4. 批准记录除既有会签字段，还要在 `artifact_bindings` 中逐项绑定 `{id, version, digest}`。战略/阶段建议 `canonical-json`；普通文件使用 `sha256-bytes`；视觉基线使用 `visual-baseline`。正文中的 `approved` 和可读取批准路径不能替代当前字节的批准绑定。源角色表要求用户决定记录时，接收端必须支持并核验该策略；旧工具缺少该能力时阻断并要求升级，不能按旧规则放行。
 5. `additional_files` 明确补充依赖；`reference_map` 将 `evidence.*` 稳定证据引用解析为仓内路径。源资产、批准记录、证据引用、Markdown 本地链接和显式目录共同形成依赖闭包。HTTP 引用保留为引用，不在导出时下载网页。
 6. 原型分支的 `prototype` 指定 `profile`、`preview_root`、`entry_ref`、`verification_ref`、`verification_digest`（验证记录的字节摘要）；H2 另须 `source_root`、`lock_ref` 和 `source_digest`（源码目录树摘要，算法同下述预览树）。源码交付目录不含 node_modules / .git；锁文件与源码一同保存。预览目录须资源闭合，可通过本地静态服务离线浏览。源码、锁文件或验证记录变化须更新交接摘要并重新批准。
@@ -17,12 +17,29 @@
 以下路径参数由当前资产提供，不从目录 glob 猜测业务含义。
 
 ```bash
-scripts/strategic-handoff export --source-root <战略项目根> --handoff <仓内交接文件> --output <新目录> --zip
-scripts/strategic-handoff export --source-root <战略项目根> --handoff <新版本交接文件> --output <新目录> --previous <上一目录或ZIP> --zip
-scripts/strategic-handoff verify --bundle <目录或ZIP>
-scripts/strategic-handoff import --bundle <目录或ZIP> --target-root <研发项目根>
+scripts/strategic-handoff finalize --source-root <战略项目根> --handoff <Handoff-v5相对路径> [--previous <上一交付目录或package>] [--zip]
+scripts/strategic-handoff verify --bundle <交付目录|package目录|历史ZIP>
+scripts/strategic-handoff import --bundle <交付目录|package目录|历史ZIP> --target-root <研发项目根>
 ```
 
+生命周期在交接批准后自动调用 `finalize`，不要求业务用户提供 `--output`。固定输出为：
+
+```text
+docs/deliveries/strategic/<handoff-id>/<version>/
+  delivery-record.json
+  verification.json
+  package/
+    README.md
+    manifest.json
+    payload/
+    indexes/
+  package.zip  # 仅 --zip 时生成
+```
+
+`package/` 是权威不可变交付件。相同 ID/version 且逻辑摘要一致时重新整包验证并返回 `already-packaged`；内容不一致返回 `delivery-version-conflict`，必须提升版本。README 由工具确定性生成，只列范围、来源引用、消费者、待决项和接收命令，不复制业务正文。ZIP 只负责运输，不参与逻辑版本判定，也不要求提交 Git。
+
+战略 checkpoint 不新增产物 ID：`artifact.strategic-design-handoff.ref` 继续指向批准的 Handoff v5，其 `evidence_refs` 必须同时包含交付目录内的 `delivery-record.json` 与 `verification.json`。`verification.strategic_delivery` 记录实际命令、`exit_code: 0`、`result: verified` 和同一 `bundle_digest`。缺记录、包缺失、摘要漂移或验证失败时，`work-unit.strategic-design-handoff` 保持 `blocked`；已成包并验证通过后允许阶段完成，不等待后端或前端 Import Receipt。
+
 目录是逻辑包；ZIP 只负责运输。源资产原始字节进入 payload，清单以 `original_ref → path` 映射原路径到包内路径；v3/v4 的原 Handoff 保存在 `handoff.yaml`，源根词汇表保存为 `payload/source-context.snapshot.md`。v5 的原文件映射为 `payload/files/<original_ref>`，只有根词汇表使用固定物理别名 `payload/files/source-context.snapshot.md`；该别名不成为第二个根词汇表。包中不创建嵌套 `CONTEXT.md`。常规独立验包时工具在临时目录重建验证视图，完成后清理；不把临时源词汇表注册为目标权威。
 
 `manifest.json` 的 `files` 声明所有文件的字节摘要和大小。`bundle_digest` 是删除自身字段后 canonical JSON 的 SHA-256；不把整 ZIP 摘要当逻辑版本摘要。目录与 ZIP 的逻辑摘要相同。源合同的既有语义 digest 另行复核。目录/ZIP 已存在时拒绝覆盖，同身份版本不同内容的导入拒绝；已验过且相同的重复导入返回 `already-imported`。限制为 20,000 文件、512 MiB 展开内容；拒绝 ZIP 路径穿越、重复路径、大小写碰撞和符号链接。
@@ -35,7 +52,7 @@ Handoff v5 必须声明 `ui_baseline_kind: prototype | existing-ui-baseline`，`
 
 初始化和构建前运行 `scripts/preflight-delivery --input <输入清单> --stage prepare|build|export|accept --json`；完整阶段语义见 [交付预检](delivery-preflight.md)。`openBundle(...,{readOnly:true})` 对已展开 v5 包以固定别名映射核验，不写临时源目录、不执行来源代码；ZIP 返回 `readonly-extraction-required`，旧布局返回 `readonly-source-layout-required`，均不得视为验证通过。实际导出和接收仍在执行边界重新校验。
 
-## Handoff v4/v5 消费者路由
+## Handoff v5 消费者路由
 
 `consumer_routes` 固定表达三种能力，不绑定仓名：`backend-technical-design`、`frontend-engineering-design`、`delivery-coordination`。每条路由记录稳定 `route_id`、`required | optional | not-applicable`、影响引用、入口工作单元、预期输出、依赖和 Context Reconciliation 要求；`optional` / `not-applicable` 必须有原因与证据，不能产生 `ready-for-agent`。
 
@@ -45,7 +62,7 @@ Handoff v5 必须声明 `ui_baseline_kind: prototype | existing-ui-baseline`，`
 
 ## 下游接收与逐条追溯
 
-导入落盘到 `docs/handoffs/<handoff-id>/<version>/`。Handoff v3 继续生成 Import Receipt v1 和原固定文件名；Handoff v4/v5 生成 Import Receipt v2，按目标 profile 的消费者能力登记 route、产物引用和状态，并分别生成后端追踪、Frontend Strategic Preflight / 前端追踪、协调状态索引草案。共同生成 route-aware Context Reconciliation 和 upstream impact 草案。仅写快照与草案，不自动更新根词汇表或批准状态。目标侧确认增量后更新唯一根 `CONTEXT.md` 并完成正式 reconciliation。
+导入落盘到 `docs/handoffs/<handoff-id>/<version>/`。Handoff v3 继续生成 Import Receipt v1；历史裸 Handoff v4/v5 包继续生成 Import Receipt v2。新的 v5 交付目录生成 Import Receipt v3，保存源 `delivery-record.json` 原始字节及摘要，按目标 profile 的消费者能力登记 route、产物引用和状态，并分别生成后端追踪、Frontend Strategic Preflight / 前端追踪、协调状态索引草案。共同生成 route-aware Context Reconciliation 和 upstream impact 草案，所有入口固定 `ready_for_agent: false`。接收回执由研发仓持有，不反向修改战略仓；协调索引只保存回执引用。目标侧确认增量后更新唯一根 `CONTEXT.md` 并完成正式 reconciliation。
 
 Technical Design Contract v2（DDD / MVC 共用）的 `strategic_handoff` 绑定 `import_receipt_ref`、`bundle_digest`、`context_reconciliation_ref` 和 `rows`。逐条覆盖全部规则与 `critical: true` 的成功/失败场景；行字段如下：
 
@@ -61,7 +78,7 @@ scripts/verify-strategic-handoff-consumption --root <研发项目根> --slice <
 node .agents/skills/yss-technical-design/scripts/validate-technical-design.mjs <技术设计合同> --root <研发项目根>
 ```
 
-Handoff v4/v5 后端消费必须绑定 `backend-technical-design` 的 `route_id`，先对账，再由 `yss-technical-design` 依据已批准架构调用 `yss-tactical-design` 或 `yss-mvc-design`。Handoff v3 的 `yss-technical-design` / `yss-tactical-design` 单目标组合只读兼容，不修改已冻结包。`tactical_refs` 在 v2 Technical Design 可指向 MVC 或 DDD 分支对象；无战略交接包的 MVC 项目直接消费批准需求，不补造战略 DDD。
+Handoff v4/v5 后端消费必须绑定 `backend-technical-design` 的 `route_id`，先对账，再由 `yss-technical-design` 依据已批准架构调用 `yss-tactical-design` 或 `yss-mvc-design`。Handoff v3/v4 仅作历史只读兼容，不修改已冻结包。`tactical_refs` 在 v2 Technical Design 可指向 MVC 或 DDD 分支对象；无战略交接包的 MVC 项目直接消费批准需求，不补造战略 DDD。
 
 前端先验证与交接版本匹配的 Strategic Preflight：Handoff v4 使用 v1，Handoff v5 使用 v2 的 `ui_baseline_kind/ui_baseline_ref`，只允许起草前端工程设计与实现计划，固定返回 `ready_for_agent: false`。最终 Frontend Delivery Acceptance v2（Handoff v4）或 v3（Handoff v5）在 Backend/API/Data 有影响时必须绑定真实 Backend Delivery 收据与版本探测；UI-only 时使用与战略路由一致的 `backend-not-applicable`，此时 `operation_ids` 必须为空。无论哪条路径，当前且已批准的 Slice Contract 仍是实现入口。
 

package/template/docs/templates/approval-record-template.yaml

@@ -16,6 +16,8 @@ notes: 会签必须可读取；起草者不得出现在 countersigner_role_ids
 subject_ref: null
 approval_scope: []
 user_decision_ref: null
+# 已有交付范围授权时可引用独立当前审查支持的延续证明；不能仅填写 approved。
+continuation_ref: null
 # 聚合门禁 / 内部专业审查绑定的当前主体字节 SHA-256（64 位十六进制）。
 subject_digest: null
 # 专业检查必须与起草者为不同执行实例；不仅仅比较职称。

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

@@ -1,10 +1,11 @@
 ---
 status: ready-for-human
+requirement_version: v1
 ---
 
 # 垂直切片 Ticket：<标题>
 
-填写前读取[中文写作规范](../process/document-writing.md)和 [Ticket 对照](examples/lifecycle-writing-examples.md#3-ticket把交付行为与实现就绪区分清楚)。状态只在 frontmatter 维护，正文记录依据。
+填写前读取[中文写作规范](../process/document-writing.md)和 [Ticket 对照](examples/lifecycle-writing-examples.md#3-ticket把交付行为与实现就绪区分清楚)。冻结前在 frontmatter 记录状态。新 Slice 绑定本文件的需求版本与原始字节；冻结后 frontmatter 仅代表冻结时状态，当前执行状态由项目已配置的主 tracker 维护，平台不可用时使用现有任务包和待发布记录。不得回写本文件的状态、验收勾选或执行结果。需求变化另存新版本并重新编译、审查与批准，旧文件和批准不自动迁移。
 
 ## 父级
 
@@ -33,11 +34,11 @@ status: ready-for-human
 
 ## 验收标准
 
-每项写条件、操作和可观察结果，关联上游规则；保留必要例外。测试未执行前保持未勾选。
+每项写条件、操作和可观察结果，关联上游规则；保留必要例外。需求基线不记录执行结果；实际验收结论写入 tracker / 任务包。
 
-- [ ] 标准 1
-- [ ] 标准 2
-- [ ] 标准 3
+- AC-1：标准 1
+- AC-2：标准 2
+- AC-3：标准 3
 
 ## 测试 Seam
 
@@ -55,33 +56,19 @@ status: ready-for-human
 | contract_id |  |
 | contract_version |  |
 | contract_ref |  |
-| 实现合同编译器 状态 | draft / blocked / ready-for-lifecycle-review |
-| 生命周期批准状态 | pending / approved / rejected |
+| 编译与批准记录 | 在现有 checkpoint / 任务包中维护，不回写冻结 Ticket |
 | suggested_owner_role_id | `role.frontend-engineer` / `role.backend-engineer` / `role.test-engineer`（实现合同编译器 建议，编排器派活） |
 | Build Architecture Checklist |  |
 
-> 实现合同编译器 不得自行将合同批准或将本 Ticket 推进为 `ready-for-agent`。只有生命周期编排器核验并持久化当前版本合同、清除阻塞边后，才能推进状态。
+> 实现合同编译器 不得自行将合同批准或将本 Ticket 推进为 `ready-for-agent`。只有生命周期编排器核验并持久化当前版本合同、清除阻塞边后，才能在主 tracker 推进执行状态。
 
-### 工作单元
+### 工作单元与工程约束
 
-| work_unit_id | 验收行为 / 目标 | primary_skill | supporting_skills | tdd_mode | allowed_write_paths | expected_evidence | verification_commands | Execution Result 引用 | 状态 |
-|---|---|---|---|---|---|---|---|---|---|
-|  |  |  |  | behavior-tdd / controlled-generation |  |  |  |  | pending / running / blocked / completed / stale |
+新切片使用 Slice v3。Ticket 保留行为、验收、测试 seam 与合同引用；工作单元、Skill、写范围、验证命令在权威 YAML 中保存一次，不再在此复制表格。
 
-`controlled-generation` 仅允许机械脚手架、样板、冻结客户端或配置，并记录 exception reason、生成器输入和生成后行为测试；业务规则、状态机、事务、权限、错误映射、复杂查询和用户可见交互必须使用 `behavior-tdd`。只有需求明确包含权限业务行为时才把它写入工作单元，不另设安全 / 权限姿态。
+Agent 使用 `scripts/slice-contract view <合同.yaml>` 展示审阅说明，使用 `--unit <id>` 展示任务和完整工程约束。本切片新增细化、例外或缺口由 Agent 整理，独立专业审查核验；已有用户确认覆盖且无实质变化时复用。任务进度和 Execution Result 引用进入现有 tracker / 任务包。
 
-## YSS 技能与后端实现合同
-
-> 涉及后端时必须填写；不涉及时写明 `not-applicable`。不得只写“符合 YSS”。
-
-| 影响面 | 必需 skill | 需要 / 不需要的理由 | 预期证据 |
-|---|---|---|---|
-| Domain / 领域行为 | `yss-domain` |  |  |
-| Application / 用例编排 | `yss-application` |  |  |
-| Infrastructure / Repository | `yss-repository` / `yss-mybatis` |  |  |
-| Web Adapter / DTO | `yss-web-controller` / `yss-dto` |  |  |
-| POJO / 对象转换 | `lombok` / `mapstruct` |  |  |
-| Java 规范 | `alibaba-java-code-style` |  |  |
+涉及后端时，适用设计从已批准 Technical Design 绑定取得。`controlled-generation` 只适用于机械生成，并保留例外与验证；业务行为使用 `behavior-tdd`。
 
 ### 后端阻断规则
 
@@ -98,7 +85,7 @@ status: ready-for-human
 
 列出实际依赖、未决项、责任人和解除条件；尚未核验时写“待核验”。只有确认没有阻塞时才写“无”，无依赖不等于已通过实现就绪核验。
 
-## 重路由状态
+## 重路由记录位置
 
 | 字段 | 内容 |
 |---|---|
@@ -110,19 +97,21 @@ status: ready-for-human
 | return_stage | 实现合同编译器 / Architecture Re-check / 产品设计 / OpenAPI Draft-Review-Freeze / 系统或数据架构 / other |
 | recovery_conditions |  |
 
-出现 `drift`、`violation` 或非空 `new_impacts` 时暂停受影响工作单元，不得先完成代码再补合同；更新合同版本并通过生命周期审查后才能恢复。
+本表作为 tracker / 任务包的记录字段说明，冻结后不在本文件填写。出现 `drift`、`violation` 或非空 `new_impacts` 时暂停受影响工作单元，不得先完成代码再补合同；更新合同版本并通过生命周期审查后才能恢复。
 
 ## 会签
 
+冻结后会签结果保存在现有批准记录与 checkpoint，不修改以下冻结时引用。
+
 | 门禁 | 记录路径 | 会签角色 | 状态 |
 |---|---|---|---|
 |  | `docs/.scratch/<feature>/gates/<gate-id>-approval.yaml` | 见 `docs/agents/digital-human-roles.yaml` | pending / approved / blocked / not-applicable |
 
 ## 状态
 
-状态依据：<当前版本合同、批准和就绪核验记录引用，以及尚未关闭的阻塞>。
+冻结时状态依据：<当时的合同、批准和就绪核验记录引用，以及尚未关闭的阻塞>。当前状态从主 tracker / 任务包读取。
 
-> 默认 frontmatter 为 `ready-for-human`。仅在生命周期确认合同已批准且当前、阻塞已清除、全部适用门禁及就绪条件通过后更新为 `ready-for-agent`；本节不另维护第二个状态值。
+> 默认 frontmatter 为 `ready-for-human`。仅在生命周期确认合同已批准且当前、阻塞已清除、全部适用门禁及就绪条件通过后在主 tracker 更新为 `ready-for-agent`；冻结文件不更新。
 
 ## AI / 人工审查点
 
@@ -132,12 +121,14 @@ status: ready-for-human
 
 ## 完成定义
 
+以下为完成判据；检查结果和勾选进入 tracker / 任务包，不回写本文件。
+
 - [ ] 如有需要，已基于冻结 OpenAPI Spec 拆分切片
 - [ ] 实现完成
 - [ ] 已新增测试且测试通过
 - [ ] 已移除调试 / 原型代码
-- [ ] 已回勾 `Backend Slice Implementation Contract` 和 `Build Architecture Checklist`
-- [ ] 已回勾当前 `contract_id` / `contract_version`、全部工作单元和对应 `YSS Skill Execution Result`
+- [ ] 已在任务包核验 `Backend Slice Implementation Contract` 和 `Build Architecture Checklist`
+- [ ] 已在任务包核验当前 `contract_id` / `contract_version`、全部工作单元和对应 `YSS Skill Execution Result`
 - [ ] 实际 changed files 均在合同允许路径内，预期证据齐全，验证结果包含执行时间
 - [ ] `new_impacts`、`drift`、`violation` 和重路由状态均有明确结论，合同未处于 `stale`
 - [ ] 如领域或架构决策变化，已更新 `CONTEXT.md` / ADR；新增业务术语含 PascalCase `英文标识`，代码与契约字段能追溯到该词干

package/template/docs/user-guide//350/256/276/345/244/207/345/200/237/347/224/250/350/264/257/347/251/277/346/241/210/344/276/213.md

@@ -35,7 +35,7 @@
 
 ```bash
 node scripts/preflight-delivery --input <战略预检输入.json> --stage export --json
-node scripts/strategic-handoff export --source-root . --handoff <交接描述相对路径> --output <新包目录> --zip
+node scripts/strategic-handoff finalize --source-root . --handoff <Handoff-v5相对路径> --zip
 node scripts/strategic-handoff verify --bundle <包目录或ZIP>
 ```
 

package/template/scripts/audit-legacy-backend-scaffold

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { auditLegacyBackendScaffold } from "./lib/legacy-backend-scaffold-audit.mjs";
+
+function parse(argv) {
+  const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--project-root") options.projectRoot = argv[++index];
+    else if (token === "--manifest-ref") options.manifestRef = argv[++index];
+    else if (token === "--help" || token === "-h") options.help = true;
+    else throw new TypeError(`不支持的参数: ${token}`);
+  }
+  if (!options.help && !options.projectRoot) throw new TypeError("缺少 --project-root");
+  return options;
+}
+
+try {
+  const options = parse(process.argv.slice(2));
+  if (options.help) process.stdout.write("用法: scripts/audit-legacy-backend-scaffold --project-root <path> [--manifest-ref .yss/scaffold-generation.json]\n");
+  else {
+    const result = await auditLegacyBackendScaffold(options.projectRoot, { manifestRef: options.manifestRef });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    if (result.status === "blocked") process.exitCode = 2;
+  }
+} catch (error) {
+  process.stderr.write(`❌ 历史后端脚手架审计失败: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/backend-platforms

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { loadBackendPlatforms, platformBinding, resolveBackendPlatform } from "./lib/backend-platform.mjs";
+try {
+  const catalog = loadBackendPlatforms();
+  const rows = catalog.profiles.map(profile => {
+    const combinations = catalog.compatibility.filter(entry => entry.profile_id === profile.id && entry.spring_boot_version === profile.spring_boot_version).map(entry => {
+      try { resolveBackendPlatform(platformBinding(profile, entry)); return { id: entry.id, status: "verified", parent: entry.parent, bom: entry.bom, architectures: entry.evidence.map(item => item.architecture_family), capabilities: entry.capabilities ?? [] }; }
+      catch (error) { return { id: entry.id, status: "blocked", reason: error.message }; }
+    });
+    return { profile_id: profile.id, spring_boot_version: profile.spring_boot_version, java_version: profile.java_version, recommended_java: profile.java_version === 8 || profile.java_version === 17, selectable: combinations.some(entry => entry.status === "verified"), combinations, blockers: combinations.some(entry => entry.status === "verified") ? [] : profile.candidate_blockers };
+  });
+  process.stdout.write(`${JSON.stringify({ schema_version: 1, profiles: rows }, null, 2)}\n`);
+  if (process.argv.includes("--require-verified") && rows.some(row => !row.selectable)) process.exitCode = 1;
+} catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }

package/template/scripts/lib/api-contract-decision.mjs

@@ -0,0 +1,49 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDocument } from "../vendor/yaml.mjs";
+import { validateJsonSchema } from "./json-schema.mjs";
+import { openApiDigest, resolveOpenApiRef, validateOpenApiDraftValidationRecord } from "./openapi-draft-validation.mjs";
+
+const TEMPLATE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const SCHEMA = path.join(TEMPLATE_ROOT, "docs/process/schemas/api-contract-decision.schema.json");
+const fail = (message) => { throw new TypeError(message); };
+const readBound = (root, ref, label) => {
+  const file = resolveOpenApiRef(root, ref);
+  const bytes = readFileSync(file);
+  return { file, bytes, digest: openApiDigest(bytes), label };
+};
+const requireDigest = (asset, expected) => { if (asset.digest !== expected) fail(`${asset.label}摘要漂移`); };
+
+export function validateApiContractDecision(binding, { root = TEMPLATE_ROOT } = {}) {
+  if (!binding || !binding.ref || !binding.version || !binding.digest || !["required", "not-applicable"].includes(binding.impact)) fail("缺少 API Contract Decision 当前版本绑定");
+  const projectRoot = path.resolve(root);
+  const decisionAsset = readBound(projectRoot, binding.ref, "API Contract Decision");
+  requireDigest(decisionAsset, binding.digest);
+  const document = parseDocument(decisionAsset.bytes.toString("utf8"), { uniqueKeys: true, maxAliasCount: 0 });
+  if (document.errors.length) fail(`API Contract Decision 无法解析: ${document.errors[0].message}`);
+  const decision = document.toJS({ maxAliasCount: 0 });
+  validateJsonSchema(decision, SCHEMA, { cwd: TEMPLATE_ROOT, label: "API Contract Decision v1" });
+  if (decision.decision_version !== binding.version || decision.impact !== binding.impact) fail("API Contract Decision 版本或影响结论与合同不一致");
+  requireDigest(readBound(projectRoot, decision.assessment_ref, "API 影响评估"), decision.assessment_digest);
+  for (const ref of decision.evidence_refs) readBound(projectRoot, ref, "API Decision 证据");
+  if (decision.impact === "not-applicable") return { decision, binding: { ref: binding.ref, version: binding.version, digest: binding.digest, impact: decision.impact } };
+
+  const draft = readBound(projectRoot, decision.openapi.ref, "OpenAPI YAML");
+  requireDigest(draft, decision.openapi.digest);
+  const validation = readBound(projectRoot, decision.validation_record.ref, "OpenAPI Validation");
+  requireDigest(validation, decision.validation_record.digest);
+  const review = readBound(projectRoot, decision.draft_review.ref, "OpenAPI Draft Review");
+  requireDigest(review, decision.draft_review.digest);
+  const reviewDocument = parseDocument(review.bytes.toString("utf8"), { uniqueKeys: true, maxAliasCount: 0 });
+  if (reviewDocument.errors.length) fail(`OpenAPI Draft Review 无法解析: ${reviewDocument.errors[0].message}`);
+  const reviewRecord = reviewDocument.toJS({ maxAliasCount: 0 });
+  if (reviewRecord?.result !== "approved" || !Array.isArray(reviewRecord.blocking_findings) || reviewRecord.blocking_findings.length > 0) fail("OpenAPI Draft Review 实际记录未批准或仍有阻断项");
+  if (reviewRecord.draft_ref !== decision.openapi.ref || reviewRecord.draft_digest !== decision.openapi.digest) fail("OpenAPI Draft Review 实际记录未绑定当前权威 YAML");
+  for (const ref of decision.draft_review.evidence_refs) readBound(projectRoot, ref, "OpenAPI Draft Review 证据");
+  const validated = validateOpenApiDraftValidationRecord(validation.file, { root: projectRoot });
+  if (validated.record.draft.ref !== decision.openapi.ref || validated.draftDigest !== decision.openapi.digest) fail("OpenAPI Validation 未绑定当前权威 YAML");
+  if (decision.draft_review.draft_ref !== decision.openapi.ref || decision.draft_review.draft_digest !== decision.openapi.digest || decision.draft_review.blocking_findings.length) fail("OpenAPI Draft Review 未批准当前权威 YAML");
+  if (decision.freeze.version !== decision.openapi.version || decision.freeze.draft_ref !== decision.openapi.ref || decision.freeze.draft_digest !== decision.openapi.digest) fail("OpenAPI Freeze 未绑定当前权威 YAML 版本和摘要");
+  return { decision, openapi: decision.openapi, binding: { ref: binding.ref, version: binding.version, digest: binding.digest, impact: decision.impact } };
+}

package/template/scripts/lib/api-contract-decision.test.mjs

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { validateApiContractDecision } from "./api-contract-decision.mjs";
+
+const digest = (bytes) => `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+
+function write(root, ref, value) {
+  const file = path.join(root, ref);
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, typeof value === "string" ? value : `${JSON.stringify(value, null, 2)}\n`);
+  return { ref, file, digest: digest(readFileSync(file)) };
+}
+
+function notApplicableFixture() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "api-contract-decision-"));
+  const assessment = write(root, "api-impact.json", { api: false, project_id: "demo" });
+  const evidence = write(root, "api-impact-evidence.md", "无 API 影响证据。\n");
+  const decision = {
+    schema_version: 1,
+    kind: "api-contract-decision",
+    decision_id: "api-contract.demo",
+    decision_version: "v1",
+    status: "approved",
+    current_version: true,
+    impact: "not-applicable",
+    assessment_ref: assessment.ref,
+    assessment_digest: assessment.digest,
+    evidence_refs: [evidence.ref],
+    reason: "不新增或修改 HTTP、消息或集成接口",
+  };
+  const asset = write(root, "api-contract-decision.json", decision);
+  return { root, assessment, evidence, decision, asset, binding: { ref: asset.ref, version: "v1", digest: asset.digest, impact: "not-applicable" } };
+}
+
+test("API not-applicable 决定必须绑定影响评估、原因和可读证据", () => {
+  const data = notApplicableFixture();
+  try {
+    assert.equal(validateApiContractDecision(data.binding, { root: data.root }).decision.impact, "not-applicable");
+    for (const mutation of [
+      (value) => { delete value.reason; },
+      (value) => { value.evidence_refs = []; },
+      (value) => { value.openapi = { id: "openapi.demo", ref: "empty.yaml", version: "v1", digest: `sha256:${"0".repeat(64)}` }; },
+    ]) {
+      const value = structuredClone(data.decision);
+      mutation(value);
+      const changed = write(data.root, "api-contract-decision.json", value);
+      assert.throws(() => validateApiContractDecision({ ...data.binding, digest: changed.digest }, { root: data.root }));
+    }
+  } finally {
+    rmSync(data.root, { recursive: true, force: true });
+  }
+});
+
+test("API Decision 或影响评估原始字节漂移即失效", () => {
+  const data = notApplicableFixture();
+  try {
+    writeFileSync(data.asset.file, "\n", { flag: "a" });
+    assert.throws(() => validateApiContractDecision(data.binding, { root: data.root }), /摘要漂移/);
+    const restored = write(data.root, data.asset.ref, data.decision);
+    writeFileSync(data.assessment.file, "\n", { flag: "a" });
+    assert.throws(() => validateApiContractDecision({ ...data.binding, digest: restored.digest }, { root: data.root }), /摘要漂移/);
+  } finally {
+    rmSync(data.root, { recursive: true, force: true });
+  }
+});

package/template/scripts/lib/approval-record.mjs

@@ -10,7 +10,7 @@ import {
 } from "./digital-human-roles.mjs";
 import { assertGateChecks } from "./lifecycle-controls.mjs";
 import { ROOT, loadRegistry } from "./lifecycle-registry.mjs";
-import { assertUserDecisionRequirement, assertWorkUnitUserDecision, assertImplementationDecision } from "./user-decision.mjs";
+import { assertUserDecisionRequirement, assertWorkUnitUserDecision, assertImplementationDecision, decisionIO, decisionDigest } from "./user-decision.mjs";
 
 const DECISIONS = new Set(["approved", "rejected", "vetoed"]);
 const ACTOR_KINDS = new Set(["digital-human", "biological-human", "orchestrator"]);
@@ -38,8 +38,16 @@ function yamlFromFile(filePath, label) {
   return value;
 }
 
-export function loadApprovalRecord(filePath) {
-  return yamlFromFile(filePath, "会签记录");
+export function loadApprovalRecord(filePath, gateId) {
+  return selectApprovalRecord(yamlFromFile(filePath, "会签记录"), gateId);
+}
+
+export function selectApprovalRecord(record, gateId) {
+  if (record.kind !== 'review-bundle') return record;
+  if (record.schema_version !== 1 || !Array.isArray(record.reviews) || !record.reviews.length || new Set(record.reviews.map(x => x.gate_id)).size !== record.reviews.length) fail('组合审查身份无效或重复');
+  const selected = record.reviews.filter(x => x.gate_id === gateId);
+  if (selected.length !== 1) fail('组合审查缺少当前检查的明确结论');
+  return selected[0];
 }
 
 export function resolveApprovalRef(approvalRef, fromFile = ROOT) {
@@ -68,7 +76,12 @@ export function validateApprovalRecord(record, { rolesDoc, requireApproved = fal
   if (record.actor_kind === "orchestrator") fail("编排器门禁不使用会签记录关闭");
 
   if (!requireApproved && loadRegistry().id_policy.deprecated_ids.includes(record.gate_id)) return { bucket: "historical", gate: record.gate_id };
-  const rule = countersignRuleForGate(registry.gate_policy, record.gate_id);
+  let rule = countersignRuleForGate(registry.gate_policy, record.gate_id);
+  const continuationReviewers = registry.gate_policy.continuation_reviews?.[record.gate_id];
+  if (record.continuation_ref && record.actor_kind === 'digital-human' && continuationReviewers) {
+    rule = { bucket: 'digital_human_review', gate: record.gate_id, countersigners: continuationReviewers };
+    if (!record.drafter_principal_ref || record.drafter_principal_ref === record.principal_ref) fail('延续批准必须由独立审查者核验');
+  }
   if (!rule) fail(`${record.gate_id} 不是会签门禁；evidence_only / orchestrator 门禁不写 approval-record`);
 
   if (requireApproved && record.decision !== "approved") {
@@ -107,7 +120,20 @@ function assertRecordUserDecision(record, registry, options) {
 }
 
 export function validateApprovalRecordFile(filePath, options = {}) {
-  return validateApprovalRecord(loadApprovalRecord(filePath), options);
+  const record = yamlFromFile(filePath, "会签记录");
+  if (record.kind === 'review-bundle') {
+    if (!Array.isArray(record.reviews) || !record.reviews.length) fail('组合审查不能为空');
+    return record.reviews.map(item => {
+      const row = loadApprovalRecord(filePath, item.gate_id);
+      if (options.requireApproved) {
+        if (!row.drafter_principal_ref || row.drafter_principal_ref === row.principal_ref) fail('组合审查必须保留独立身份');
+        const io = decisionIO(options);
+        if (!row.subject_ref || decisionDigest(io.bytes(row.subject_ref)) !== `sha256:${row.subject_digest}`) fail('组合审查主体缺失或已过期');
+      }
+      return validateApprovalRecord(row, options);
+    });
+  }
+  return validateApprovalRecord(record, options);
 }
 
 export function assertApprovedGateHasValidApproval(gateId, gateState, { checkpointPath } = {}) {
@@ -121,7 +147,7 @@ export function assertApprovedGateHasValidApproval(gateId, gateState, { checkpoi
   }
   const resolved = resolveApprovalRef(gateState.approval_ref, checkpointPath || ROOT);
   if (!existsSync(resolved)) fail(`${gateId} 的 approval_ref 不可读: ${gateState.approval_ref}`);
-  const record = loadApprovalRecord(resolved);
+  const record = loadApprovalRecord(resolved, gateId);
   if (record.gate_id !== gateId) fail(`${gateId} 的会签记录 gate_id 不匹配`);
   if (!gateState.subject_ref || gateState.subject_ref !== record.subject_ref || !gateState.approval_scope?.length || JSON.stringify([...gateState.approval_scope].sort()) !== JSON.stringify([...(record.approval_scope || [])].sort())) {
     fail(`${gateId} user-decision-subject-mismatch: 当前门禁资产与会签范围不匹配`);

package/template/scripts/lib/approved-execution-context.mjs

@@ -1,3 +1,4 @@
+import { selectSliceWorkUnit, normalizeSliceContract, sourceSliceContract, parseSliceYaml } from './slice-contract.mjs';
 import path from 'node:path';
 import { readFileSync } from 'node:fs';
 import { ROOT, read, parse, safe, hash, digest, schema } from './strategic-handoff-io.mjs';
@@ -29,11 +30,11 @@ export function verifySliceContractApproval(binding,{root=process.cwd(),contract
   check(binding?.ref&&binding?.digest&&binding?.approval_ref,'EXECUTION_APPROVAL_REQUIRED','需要当前持久化 Slice 的 ref/digest/approval_ref');
   const bytes=readFileSync(safe(root,binding.ref));
   check(hash(bytes)===binding.digest,'EXECUTION_CONTRACT_STALE','Slice 原始字节与绑定不一致');
-  const document=parse(bytes),contract=document.slice_contract||document;
-  check(contract.schema_version===2&&contract.status==='approved'&&typeof contract.contract_id==='string'&&contract.contract_id&&typeof contract.contract_version==='string'&&contract.contract_version&&typeof contract.slice_id==='string'&&contract.slice_id,'EXECUTION_CONTRACT_INVALID','需要已批准且有身份的持久化 Slice v2');
+  const document=parseSliceYaml(bytes),contract=normalizeSliceContract(document,{root});
+  check([2,3].includes(contract.schema_version)&&contract.status==='approved'&&typeof contract.contract_id==='string'&&contract.contract_id&&typeof contract.contract_version==='string'&&contract.contract_version&&typeof contract.slice_id==='string'&&contract.slice_id,'EXECUTION_CONTRACT_INVALID','需要已批准且有身份的持久化 Slice v2/v3');
   assertExistingSliceStructure(contract);
   check((!binding.id||binding.id===contract.contract_id)&&(!binding.version||binding.version===contract.contract_version),'EXECUTION_CONTRACT_CONFLICT','当前合同身份或版本不匹配');
-  if(expected)check(same(expected.slice_contract||expected,contract),'EXECUTION_CONTRACT_CONFLICT','调用方合同与持久化原字节不一致');
+  if(expected)check(same(sourceSliceContract(expected),sourceSliceContract(contract)),'EXECUTION_CONTRACT_CONFLICT','调用方合同与持久化原字节不一致');
   const roles=read(safe(root,'docs/agents/digital-human-roles.yaml'));
   const approval=read(safe(root,binding.approval_ref));
   if(!countersignRuleForGate(roles.gate_policy,gateId)&&roles.gate_policy.orchestrator?.includes(gateId)) {
@@ -51,13 +52,14 @@ export function verifySliceContractApproval(binding,{root=process.cwd(),contract
     validateApprovalRecord(approval,{...ioFor(root),rolesDoc:roles,requireApproved:true});
     check(approval.gate_id===gateId&&approval.artifact_bindings?.some(item=>item.id===contract.contract_id&&item.version===contract.contract_version&&item.digest===binding.digest),'EXECUTION_APPROVAL_SCOPE','源会签未绑定当前 Slice 的身份、版本和字节');
   }
+  if(contract.schema_version===3) verifySliceProfessionalReview(approval,{...binding,id:contract.contract_id,version:contract.contract_version},roles,root);
   return {contract,binding:structuredClone(binding),root};
 }
 
 function executionBasis(verified,{allowCompilerDrift=false}={}) {
   const {contract}=verified,resolution=contract.resolution||{};
   const compiler=read(safe(ROOT,'.agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml'));
-  if(!allowCompilerDrift)for(const [section,fields] of Object.entries(compiler.slice_contract_required))for(const field of fields)check(Object.hasOwn(section==='root'?contract:contract[section]||{},field),'EXECUTION_CONTRACT_INVALID',`合同缺少 ${section}.${field}`);
+  if(!allowCompilerDrift&&contract.schema_version===2)for(const [section,fields] of Object.entries(compiler.slice_contract_required))for(const field of fields)check(Object.hasOwn(section==='root'?contract:contract[section]||{},field),'EXECUTION_CONTRACT_INVALID',`合同缺少 ${section}.${field}`);
   check(Array.isArray(contract.common?.allowed_write_paths)&&contract.common.allowed_write_paths.length>0&&contract.common.allowed_write_paths.every(value=>typeof value==='string'&&value.trim()),'EXECUTION_SCOPE_MISSING','合同缺少已批准写范围');
   check(Array.isArray(contract.readiness?.blockers)&&!contract.readiness.blockers.length&&Array.isArray(contract.readiness?.stale_inputs)&&!contract.readiness.stale_inputs.length,'EXECUTION_CONTRACT_STALE','合同就绪条件仍有阻断或过期输入');
   if(!allowCompilerDrift)check(resolution.registry_digest===digest(loadSkillRegistry()).slice(7)&&resolution.compiler_contract_digest===digest(compiler).slice(7),'EXECUTION_CONTRACT_STALE','编译依据已改变，应重新编译批准');
@@ -68,16 +70,18 @@ function executionBasis(verified,{allowCompilerDrift=false}={}) {
 
 export function createApprovedExecutionContext(binding,options={}) {
   const verified=executionBasis(verifySliceContractApproval(binding,options));
+  selectSliceWorkUnit(verified.contract,options.work_unit_id);
   const context=Object.freeze({kind:'approved-slice-execution-context'});
-  contexts.set(context,{binding:verified.binding,root:verified.root,allowCompilerDrift:false});
+  contexts.set(context,{binding:verified.binding,root:verified.root,work_unit_id:options.work_unit_id,allowCompilerDrift:false});
   return context;
 }
 
 /** A prior approved scope may authenticate bounded output while current compiler facts are recomputed. */
 export function createApprovedRecompilationContext(binding,options={}) {
   const verified=executionBasis(verifySliceContractApproval(binding,options),{allowCompilerDrift:true});
+  selectSliceWorkUnit(verified.contract,options.work_unit_id);
   const context=Object.freeze({kind:'approved-slice-recompilation-context'});
-  contexts.set(context,{binding:verified.binding,root:verified.root,allowCompilerDrift:true});
+  contexts.set(context,{binding:verified.binding,root:verified.root,work_unit_id:options.work_unit_id,allowCompilerDrift:true});
   return context;
 }
 
@@ -86,7 +90,7 @@ export function assertApprovedExecutionContext(context,{root=process.cwd(),contr
   const saved=contexts.get(context);
   check(saved&&saved.root===path.resolve(root),'EXECUTION_CONTEXT_UNTRUSTED','只允许从当前原始 Slice 与本地批准生成的执行上下文');
   const verified=executionBasis(verifySliceContractApproval(saved.binding,{root,contract}),{allowCompilerDrift:saved.allowCompilerDrift});
-  const current=verified.contract,resolution=current.resolution;
+  const current=selectSliceWorkUnit(verified.contract,saved.work_unit_id),resolution=current.resolution;
   if(sliceId)check(current.slice_id===sliceId,'EXECUTION_SCOPE_CONFLICT','执行上下文属于另一切片');
   if(architectureIdentity)check(same(resolution.architecture_identity,architectureIdentity),'EXECUTION_INPUT_REPLACED','执行上下文不允许替换架构身份或固定源码输入');
   if(architectureEvidence)check(same(resolution.architecture_evidence,architectureEvidence),'EXECUTION_INPUT_REPLACED','执行上下文不允许替换原始架构证据');
@@ -102,5 +106,24 @@ export function assertApprovedExecutionContext(context,{root=process.cwd(),contr
 export function approvedExecutionBinding(context) {
   const saved=contexts.get(context);
   check(saved,'EXECUTION_CONTEXT_UNTRUSTED','不能序列化未验证的执行上下文');
-  return structuredClone(saved.binding);
+  return {...structuredClone(saved.binding),...(saved.work_unit_id?{work_unit_id:saved.work_unit_id}:{})};
+}
+
+function verifySliceProfessionalReview(approval,binding,roles,root) {
+  const refs=approval.gates?.[gateId]?.evidence_refs || approval.evidence_refs || [];
+  let found=false;
+  for(const ref of refs) {
+    if(!/\.(yaml|yml|json)$/.test(ref))continue;
+    const record=read(safe(root,ref));
+    const rows=record.kind==='review-bundle'?record.reviews:[record];
+    for(const row of rows || []) {
+      if(row.gate_id!=='check.design-reviewed'||row.subject_ref!==binding.ref)continue;
+      validateApprovalRecord(row,{...ioFor(root),rolesDoc:roles,requireApproved:true});
+      check(row.drafter_principal_ref&&row.principal_ref!==row.drafter_principal_ref,'EXECUTION_REVIEW_NOT_INDEPENDENT','Slice 工程审查必须独立于起草者');
+      check(row.subject_digest===binding.digest.slice(7)&&row.artifact_bindings?.some(x=>x.id===binding.id&&x.version===binding.version&&x.digest===binding.digest),'EXECUTION_REVIEW_STALE','Slice 工程审查未绑定当前合同');
+      check(Array.isArray(row.findings)&&row.findings.every(x=>x.kind==='suggestion'?!!x.follow_up:['requirement-violation','missing-evidence','important-risk'].includes(x.kind)&&x.status==='resolved'),'EXECUTION_REVIEW_BLOCKED','Slice 工程审查有未关闭问题');
+      found=true;
+    }
+  }
+  check(found,'EXECUTION_REVIEW_REQUIRED','Slice v3 缺少当前合同的独立工程审查');
 }

package/template/scripts/lib/backend-architecture.mjs

@@ -1,3 +1,4 @@
+import { platformProfile, resolveBackendPlatform } from "./backend-platform.mjs";
 import { createHash } from "node:crypto";
 import { loadSkillRegistry } from "./skill-registry.mjs";
 import { validateExistingArchitecture, verifyExistingArchitecture } from "./existing-backend-architecture.mjs";
@@ -12,6 +13,10 @@ export function validateArchitectureIdentity(identity, registry = loadSkillRegis
   if (!identity || typeof identity !== "object") throw new TypeError("缺少 architecture_identity；请从工程基线重新编译");
   if (identity.schema_version === 2) return validateExistingArchitecture(identity, registry);
   if (identity.schema_version !== undefined || identity.source_kind !== undefined) throw new TypeError("不支持的 architecture_identity 来源或版本");
+  if (identity.platform_configuration) {
+    const selected = platformProfile(identity.platform_configuration.profile_id, undefined, identity.platform_configuration.spring_boot_version);
+    if (selected.spring_boot_version !== identity.platform_configuration.spring_boot_version || selected.java_version !== identity.platform_configuration.java_version) throw new TypeError("backend-platform: invalid architecture platform binding");
+  }
   const profile = registry.architecture_profiles?.[identity.architecture_profile];
   if (!profile || identity.architecture_family !== profile.architecture_family || identity.generator_skill !== profile.generator_skill) {
     throw new TypeError("architecture_identity 的架构族、Profile 或生成器不匹配");
@@ -51,5 +56,6 @@ export function assertArchitectureAgreement(identity, evidence, registry) {
 
 export function architectureReady(identity, registry = loadSkillRegistry()) {
   const profile = validateArchitectureIdentity(identity, registry);
+  if (identity.platform_configuration) { try { resolveBackendPlatform(identity.platform_configuration); } catch { return false; } }
   return profile.maturity === "supported";
 }