create-yss-spec 3.4.1 → 3.4.4

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

@@ -6,7 +6,7 @@
 
 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，分别选择 `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 仍按包内明确登记的源批准规则验证，不自动迁移当前门禁状态。
+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`。当前战略 profile 的领域战略、阶段决策和业务 Ticket 绑定 `gate.plan-approved`，Spec 绑定 `gate.spec-baseline-approved`，原型、视觉或既有 UI 基线绑定 `gate.product-design-approved`，交接自身绑定 `gate.strategic-design-handoff-approved`。历史包仍按包内明确登记的源批准规则验证，但旧门禁只能作为历史证据，不能作为当前输入继续流转。
 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；锁文件与源码一同保存。预览目录须资源闭合，可通过本地静态服务离线浏览。源码、锁文件或验证记录变化须更新交接摘要并重新批准。
@@ -99,16 +99,10 @@ scripts/strategic-feedback verify-adjudication --root <消费者项目根> <adju
 
 共享脚本和包 schema 以主模板为维护源，通过 `scripts/sync-strategic-handoff-tools` 同步到设计/研发模板；源战略 schema 的离线验证副本由该脚本从 canonical `yss-stage-decision/references` 派生。各仓技能仍只编辑 `.agents/skills`，再生成各 runtime 投影与锁。CLI 快照使用各自同步工具，工作树快照用于集成验证，不代表已发布 commit。共享同步仅从主技能注册表投影 `existing_project_profiles` 验证元数据，保留接收模板自己的 Recipe、capability 与创作技能；源注册表及目标有效字节写入工具锁。后端接收模板使用独立视觉 wire runtime，不安装原型创作技能。超出本 profile 职责的技术设计/编译资产在预检中明确标记不支持，战略交接路线不依赖这些后端资产。
 
-## 当前用户决定与交接复用
+## 当前用户决定与交接复核
 
-源角色策略以 `required_capabilities: [strategic-decision-reuse-v1]` 声明本节语义；不支持该能力的接收器必须拒绝。历史包仍按包内源策略校验，不升级旧批准。
+当前用户决定只覆盖 Plan、Spec 和适用的产品设计。各批准记录使用 `subject_ref`、`approval_scope`、`user_decision_ref` 绑定最终可审阅资产与原始回复；Plan 审阅包聚合领域战略和阶段决策的内部检查结论，产品设计门禁聚合原型审查与浏览器验证结论。输入摘要、范围、风险或授权条件变化时，对应决定失效并重新确认。
 
-当前会签绑定 `subject_ref`、`approval_scope`、`user_decision_ref`。只有最终战略交接允许用 `decision_reuse_ref` 引用复用证明；原回复的 boundary、资产和范围保持不变。checkpoint 的 `human_review.decision_reuse` 保存 `{target_gate, ref}`，会签必须引用同一证明。数字人审查仍独立完成。
+`gate.strategic-design-handoff-approved` 不要求新的用户回复，也不把旧决定改写为交接决定。产品经理形成完整交接包后，由需求经理独立复核来源批准新鲜度、完整包摘要、风险与范围，并以 Fresh Verification 关闭交接门禁。缺少独立复核、来源批准过期、摘要漂移或验证失败均阻断 finalize。
 
-复用证明采用 schema v1，`kind: strategic-decision-reuse-v1`，包含 `target_gate`、`scope_ref`、`scope`、`requirements`。每个 requirement 保留原 `boundary`、`subject_ref`、`scope`、`user_decision_ref`。校验当前原始回复、负责人、撤销、资产摘要和范围，不接受自填布尔值作为覆盖证据。
-
-独立交付范围清单采用 schema v1，`kind: strategic-delivery-scope`，包含 `delivery_ref`、`assets`、`risks`、`conditions`。每项资产包含 `ref`、`version`、原始字节 `digest`、`boundary` 和 `scope`；原决定的 subject 或 basis 必须覆盖该资产，专业边界须一致。风险必须已出现在原决定的 risks 中，授权条件必须已出现在 next_actions 中；无法证明的部分补充确认。
-
-`delivery_ref` 是交接正文去除 `package_export`、`status` 后的独立 JSON/YAML 快照；也必须列入 assets 并由既有真实决定明确覆盖；不强制新增交接回复。所有实际 source 资产及视觉或既有 UI 基线 manifest 均须逐项覆盖。业务 Ticket 已被 Spec 的当前行为与验收范围明确覆盖时，可引用该 Spec 决定；数字人交接会签仍使用交接门禁，不改写原回复的专业边界。先固定该快照与业务资产，再确认和会签，最后组装包，避免摘要循环。仅重新组装传输包且业务依据和范围不变时复用有效确认。
-
-导出将范围清单、复用证明、原决定及其来源依赖一起收集。离线 verify 重新检查实际交付与批准覆盖；缺文件、摘要变化、范围遗漏、未知能力均阻断，不回写旧包。
+历史包中的 `strategic-decision-reuse-v1`、`decision_reuse_ref` 和旧门禁批准保持可读，供离线 `verify/import` 复核当时证据。它们不能关闭当前聚合门禁；任何修改、重发或继续流转都必须先完成战略门禁迁移并重新批准。

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/build-architecture-checklist-template.md

@@ -19,7 +19,7 @@ owner: ai
 | 系统 / 数据架构设计 |  |  |
 | 风险 / 回滚约束 | `AGENTS.md` |  |
 | Slice Implementation Contract |  | 填写 contract_id / contract_version / 生命周期批准状态 |
-| 后端脚手架策略 | `orchestration-contract.yaml` / DDD 或 Layered MVC 生成器 |  | backend `scaffold_status=required` 时填写 architecture decision、schema v3 合同身份、批准/持久化引用、生成器输入、Manifest v3、实际 `./mvnw` 结果和后置实现合同编译器重编译 |
+| 后端脚手架策略 | `orchestration-contract.yaml` / DDD 或 Layered MVC 生成器 |  | backend `scaffold_status=required` 时填写架构与平台用户门禁、architecture decision、精确 Spring Boot 版本、schema v4 合同身份、批准/持久化引用、生成器输入、Manifest v4、实际 `./mvnw` 结果和后置实现合同编译器重编译；既有工程填写登记值复用证据 |
 | 工程项目路径策略 | `docs/process/implementation-repo-integration.md` / 实现合同编译器 Contract |  | Harness 内必须是 `apps/backend/<project>/` 或 `apps/frontend/<project>/`；`apps/backend/`、`apps/frontend/` 仅为容器，`app/backend/`、`app/frontend/` 及其子路径阻断 |
 | 垂直切片工作单元 |  |  |
 | YSS Skill Execution Result |  | 每个 skill / work_unit 的结果文件引用 |
@@ -32,7 +32,7 @@ owner: ai
 | 后端切片必须回勾 `Backend Slice Implementation Contract`：required skills、允许写范围、禁止模式、证据文件、延期 seam 和验证命令完整 | implementation routing / 垂直切片 Ticket / `AGENTS.md` |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 缺合同或合同不完整时暂停并记录替代方案 |
 | 统一合同版本：实现消费的 contract_id / contract_version 与生命周期批准并持久化的版本一致，实现合同编译器 未自行批准合同或推进 `ready-for-agent` | Slice Implementation Contract / 生命周期证据 |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 版本不一致时将工作单元标记 `stale` 并暂停 build |
 | 合同子项闭环：Common、Frontend、Backend、Contract、Cross-repo 子合同按影响面填写，不适用项有原因 | Slice Implementation Contract |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 缺失适用子合同时回到 实现合同编译器 |
-| 后端脚手架顺序：工程基线与 Agent 推荐 → 用户确认并持久化 architecture decision → schema v3 合同 draft / 生命周期批准 → DDD 或 Layered MVC 生成器 → 对应基线与 Manifest v3 校验 → 实现合同编译器重编译；生成器无交互且不得生成业务行为 | `yss-product-lifecycle` / `yss-ddd-scaffold-generator` / `yss-layered-mvc-scaffold-generator` |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 选择缺失、digest 漂移、顺序缺失、生成器混入业务行为或缺 Execution Result 时阻断 |
+| 新建后端顺序：工程基线与 Agent 推荐 → `gate.backend-architecture-platform-approved` 同时确认 DDD / MVC 与精确 Spring Boot 版本 → 持久化 architecture decision → DDD / MVC 分支设计 → schema v4 合同 draft / 生命周期批准 → 对应生成器 → 基线与 Manifest v4 校验 → 实现合同编译器重编译；既有工程核验复用登记值；生成器无交互且不得生成业务行为 | `yss-product-lifecycle` / `yss-ddd-scaffold-generator` / `yss-layered-mvc-scaffold-generator` |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 门禁或选择缺失、digest 漂移、顺序缺失、生成器混入业务行为或缺 Execution Result 时阻断 |
 | 写路径与证据：Execution Result 的 changed_files 均位于 allowed_write_paths，expected_evidence_files 已实际生成 | Slice Implementation Contract / YSS Skill Execution Result |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 路径越界或证据缺失标记 `violation` 并阻断 build |
 | TDD 模式：每个工作单元唯一选择 `behavior-tdd` 或 `controlled-generation`；生成器未承载状态、权限、业务过滤、事务、错误映射或用户可见交互 | Slice Implementation Contract / 垂直切片 Ticket / Execution Result |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 模式不匹配时拆分工作单元并完整重路由 |
 | 所有后续生成代码：必须消费当前批准合同、主 YSS skill、依赖闭包、允许写路径、预期证据和 YSS Skill Execution Result；业务行为使用 `behavior-tdd` | `post_scaffold_generated_code_policy` |  | `implemented` / `seam-deferred` / `drift` / `violation` / `not-applicable` |  | 缺任一条件或以时间压力豁免时阻断 build |

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

@@ -226,7 +226,7 @@ owner: ai
 
 | 受影响端 | 是否已有可用工程 | scaffold_status | 目标是否确认 | 处理结论 | 使用 skill | 输出位置 / 仓库 | 备注 |
 |---|---|---|---|---|---|---|---|
-| backend | 是 / 否 / 不适用 | existing / required / initialized / not-applicable | 是 / 否 / 不适用 | 复用现有 / 初始化 / 阻塞 | `yss-ddd-scaffold-generator` / `yss-layered-mvc-scaffold-generator` / none |  | 填写 architecture_family、decision_id 与 digest |
+| backend | 是 / 否 / 不适用 | existing / required / initialized / not-applicable | 是 / 否 / 不适用 | 复用现有 / 初始化 / 阻塞 | `yss-ddd-scaffold-generator` / `yss-layered-mvc-scaffold-generator` / none |  | 新建填写 gate、architecture_family、精确 Spring Boot 版本、decision_id 与 digest；既有工程填写登记值复用证据 |
 | frontend | 是 / 否 / 不适用 | existing / required / initialized / not-applicable | 是 / 否 / 不适用 | 复用现有 / 初始化 / 阻塞 | `yss-frontend-scaffold-generator` / none |  |  |
 
 脚手架输出位置必须回指具体项目根：后端为 `apps/backend/<project>/`，前端为 `apps/frontend/<project>/`；不得把 `apps/backend/`、`apps/frontend/` 容器根或任何 `app/backend/`、`app/frontend/` 路径作为生成目标。
@@ -240,18 +240,18 @@ owner: ai
 
 ### 4.3 后端脚手架工作单元
 
-当 backend `scaffold_status=required` 时，生命周期先按领域复杂度推荐 DDD/MVC，并以批量决策表反问用户确认本体默认与子项目覆盖。选择写入 `scaffold-architecture-decisions.yaml`；缺失、未确认或 stale 时阻断。随后登记一个 `controlled-generation` 工作单元：`domain-driven` 使用 `primary_skill=yss-ddd-scaffold-generator`，`layered-mvc` 使用 `primary_skill=yss-layered-mvc-scaffold-generator`。生成后执行对应基线校验和 `yss-implementation-contract-compiler` 合同重编译。`existing` / `initialized` 不重复生成，架构转换另立迁移工作单元。
+当 backend `scaffold_status=required` 时，生命周期先按领域复杂度推荐 DDD/MVC，并展示平台清单中的精确 Spring Boot / Java 版本，以批量决策表取得同一次用户确认并通过 `gate.backend-architecture-platform-approved`。选择写入 `scaffold-architecture-decisions.yaml`；缺失、未确认或 stale 时阻断。门禁通过后才进入对应的 DDD 战术设计或 MVC 技术设计，再登记 `controlled-generation` 工作单元。`domain-driven` 使用 `primary_skill=yss-ddd-scaffold-generator`，`layered-mvc` 使用 `primary_skill=yss-layered-mvc-scaffold-generator`。生成后执行对应基线校验和 `yss-implementation-contract-compiler` 合同重编译。`existing` / `initialized` 核验并复用当前登记架构与平台，不重复询问或生成；架构转换、平台升级另立迁移工作单元。
 
 | 项 | 内容 |
 |---|---|
-| 前置 | `prototype_confirmation`、工程基线、实现仓库和脚手架目标已确认；`scaffold-architecture-decisions.yaml` 已由用户确认且 digest 当前；实现合同编译器 schema v3 脚手架合同 draft 已经生命周期批准并持久化为结构化 JSON，生成器通过 `--contract-file` 消费 |
+| 前置 | `prototype_confirmation`、工程基线、实现仓库和脚手架目标已确认；`gate.backend-architecture-platform-approved` 已同时确认 DDD / MVC 与精确 Spring Boot 版本，`scaffold-architecture-decisions.yaml` digest 当前；实现合同编译器 schema v4 脚手架合同 draft 已经生命周期批准并持久化为结构化 JSON，生成器通过 `--contract-file` 消费 |
 | 生成器 | `domain-driven` → `yss-ddd-scaffold-generator`；`layered-mvc` → `yss-layered-mvc-scaffold-generator` |
 | 模式 | `controlled-generation` |
 | Java / Maven 身份 | `base_package` 与 Maven `group_id` 分开登记；项目版本、父 POM GAV、`yss-components.version` 进入批准合同并原样传给 CLI |
 | 允许生成 | DDD 的 Domain / Application / Infrastructure / Adapter / Bootstrap，或 MVC 的 server / service / repository 与能力解析出的 adapter / client / feign-client；以及 POM、配置、Wrapper 和非业务机械模板 |
 | 禁止生成 | 业务规则、状态机、权限、事务、复杂查询、错误映射、业务字段和用户可见行为 |
 | 生成选项 | 关闭 `--with-example`；生成器严格 initialize-only，非空目录、`--force`、旧项目迁移和当前模板升级均为 `unsupported` |
-| Profile | DDD：`target-domain-model` + MySQL；MVC：`layered-mvc` + MySQL/Oracle/OceanBase Oracle；共同固定 Spring Boot 2.7 / Java 8 / `javax` / MyBatis-Plus，其他组合须先通过独立 fixture |
+| Profile | DDD：`target-domain-model`；MVC：`layered-mvc-service`；Spring Boot / Java 使用用户确认且兼容清单验证通过的精确组合，不使用版本范围或 `latest` |
 | 验证 | 使用一键生成验证入口，实际执行项目根目录 `./mvnw validate`、`./mvnw test`、`./mvnw package`；通过后仅为 `empty-scaffold-verified`，golden first slice 通过后才是 `first-slice-verified` |
 | 后置 | `yss-backend-scaffold-parent`、`yss-implementation-contract-compiler` 业务合同重编译、YSS Skill Execution Result |
 

package/template/docs/templates/review-bundle-template.yaml

@@ -0,0 +1,26 @@
+schema_version: 1
+kind: review-bundle
+bundle_id: review-bundle.plan
+task_id: replace-with-plan-review-task-id
+work_unit_id: work-unit.plan-requirements
+review_session_id: replace-with-stable-review-session-id
+role_id: role.product-manager
+runtime_id: runtime.generic
+principal_ref: replace-with-reviewer-instance
+reviews:
+- schema_version: 1
+  gate_id: check.domain-strategy-approved
+  decision: approved
+  actor_kind: digital-human
+  role_id: role.product-manager
+  runtime_id: runtime.generic
+  principal_ref: replace-with-reviewer-instance
+  drafter_role_id: role.requirements-manager
+  drafter_principal_ref: replace-with-drafter-instance
+  subject_ref: docs/.scratch/<feature>/domain/domain-strategy-v1.yaml
+  subject_digest: replace-with-64-char-sha256
+  approval_scope:
+  - replace-with-feature-id
+  evidence_refs:
+  - replace-with-current-review-evidence
+notes: 本模板只用于起草。只保留实际命中的 check；同一 bundle 的所有结论必须来自同一复核任务、会话和实例。

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/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/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,36 @@ function yamlFromFile(filePath, label) {
   return value;
 }
 
-export function loadApprovalRecord(filePath) {
-  return yamlFromFile(filePath, "会签记录");
+export function loadApprovalRecord(filePath, gateId) {
+  return selectApprovalRecord(yamlFromFile(filePath, "会签记录"), gateId);
+}
+
+function reviewBundleRows(bundle) {
+  if (bundle?.schema_version !== 1 || bundle.kind !== "review-bundle") fail("组合审查身份无效");
+  for (const field of ["bundle_id", "task_id", "work_unit_id", "review_session_id", "role_id", "runtime_id", "principal_ref"]) requireString(bundle[field], field);
+  if (!/^review-bundle\.[a-z0-9][a-z0-9-]*$/.test(bundle.bundle_id)) fail("组合审查 bundle_id 格式非法");
+  if (!/^work-unit\.[a-z0-9][a-z0-9-]*$/.test(bundle.work_unit_id)) fail("组合审查 work_unit_id 格式非法");
+  if (!Array.isArray(bundle.reviews) || !bundle.reviews.length) fail("组合审查不能为空");
+  if (new Set(bundle.reviews.map(row => row?.gate_id)).size !== bundle.reviews.length) fail("组合审查 gate_id 重复");
+  for (const row of bundle.reviews) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) fail("组合审查结论必须是对象");
+    if (row.role_id !== bundle.role_id || row.runtime_id !== bundle.runtime_id || row.principal_ref !== bundle.principal_ref) fail("组合审查必须来自同一复核角色、运行时和实例");
+    if (row.review_session_id != null && row.review_session_id !== bundle.review_session_id) fail("组合审查 review_session_id 不一致");
+  }
+  return bundle.reviews;
+}
+
+export function selectApprovalRecord(record, gateId) {
+  if (record.kind !== 'review-bundle') return record;
+  const selected = reviewBundleRows(record).filter(x => x.gate_id === gateId);
+  if (selected.length !== 1) fail('组合审查缺少当前检查的明确结论');
+  return {
+    ...selected[0],
+    review_bundle_id: record.bundle_id,
+    review_task_id: record.task_id,
+    review_work_unit_id: record.work_unit_id,
+    review_session_id: record.review_session_id
+  };
 }
 
 export function resolveApprovalRef(approvalRef, fromFile = ROOT) {
@@ -68,7 +96,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") {
@@ -101,13 +134,25 @@ export function validateApprovalRecord(record, { rolesDoc, requireApproved = fal
 }
 
 function assertRecordUserDecision(record, registry, options) {
-  if (!registry.user_decision_policy.gates.includes(record.gate_id) && countersignRuleForGate(registry.gate_policy, record.gate_id)?.bucket !== "biological_human") return;
+  if (!registry.user_decision_policy.gates.includes(record.gate_id)) return;
   const result = assertApprovalUserDecision(record, registry, options);
   if (record.actor_kind === "biological-human" && result.validated.some((item) => item.principal_ref !== record.principal_ref)) fail("user-decision-responder-mismatch: 生物人会签者与原始回复者不一致");
 }
 
 export function validateApprovalRecordFile(filePath, options = {}) {
-  return validateApprovalRecord(loadApprovalRecord(filePath), options);
+  const record = yamlFromFile(filePath, "会签记录");
+  if (record.kind === 'review-bundle') {
+    return reviewBundleRows(record).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 +166,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";
 }

package/template/scripts/lib/backend-platform-provenance.mjs

@@ -0,0 +1,67 @@
+/** Version qualification binds executable sources and generated bytes, not Skill prose. */
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync, lstatSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const digest = bytes => `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+const fail = message => { throw new TypeError(`platform-provenance: ${message}`); };
+function fileMap(root, refs) {
+  const files = {};
+  const visit = ref => {
+    const full = path.join(root, ref), info = lstatSync(full);
+    if (info.isSymbolicLink()) fail(`source symlink: ${ref}`);
+    if (info.isDirectory()) for (const name of readdirSync(full).sort()) visit(`${ref}/${name}`);
+    else files[ref] = { digest: digest(readFileSync(full)), executable: Boolean(info.mode & 0o111) };
+  };
+  refs.forEach(visit);
+  return Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b)));
+}
+export function platformSourceFingerprint(family, root = ROOT) {
+  const skill = family === 'domain-driven' ? 'yss-ddd-scaffold-generator' : family === 'layered-mvc' ? 'yss-layered-mvc-scaffold-generator' : null;
+  if (!skill) fail('unknown architecture');
+  const base = `.agents/skills/${skill}`;
+  const generator = fileMap(root, [`${base}/scripts/generate_scaffold.mjs`, ...(family === 'domain-driven' ? [`${base}/assets`] : ['.agents/skills/yss-ddd-scaffold-generator/assets/wrapper']), 'scripts/lib/backend-platform.mjs', 'scripts/lib/scaffold-local-database.mjs']);
+  const verifier = fileMap(root, ['scripts/lib/backend-platform-provenance.mjs', 'scripts/lib/backend-platform-verification.mjs', 'scripts/lib/command-runner.mjs', 'scripts/vendor/xml.mjs', '.agents/skills/yss-ddd-scaffold-generator/scripts/run_scaffold_verification.mjs']);
+  return { schema_version: 1, generator_digest: digest(JSON.stringify(generator)), verifier_digest: digest(JSON.stringify(verifier)) };
+}
+export function assertSourceFingerprint(value, family, root = ROOT) {
+  if (JSON.stringify(value) !== JSON.stringify(platformSourceFingerprint(family, root))) fail('generator/verifier source drift; requalify candidate');
+}
+export function generatedTreeDigest(projectRoot, manifest) {
+  const expected = manifest.ownership?.generated_files;
+  if (!Array.isArray(expected) || !expected.length) fail('missing generated file inventory');
+  const names = new Set();
+  const actual = {};
+  for (const file of expected) {
+    if (!file.path || path.isAbsolute(file.path) || file.path.split(/[\\/]/).some(p => p === '..' || p === '') || names.has(file.path)) fail('invalid generated file inventory');
+    names.add(file.path);
+    const full = path.join(projectRoot, file.path);
+    // Check every path component: file lstat alone does not detect a linked parent directory.
+    let current = projectRoot;
+    for (const part of file.path.split('/')) { current = path.join(current, part); if (lstatSync(current).isSymbolicLink()) fail(`generated symlink: ${file.path}`); }
+    const info = lstatSync(full);
+    if (!info.isFile()) fail(`generated file absent: ${file.path}`);
+    const hash = digest(readFileSync(full));
+    if (hash.replace('sha256:', '') !== file.sha256.replace('sha256:', '')) fail(`generated file drift: ${file.path}`);
+    actual[file.path] = { digest: hash, executable: Boolean(info.mode & 0o111) };
+  }
+  const visit = (directory, relative = '') => {
+    for (const item of readdirSync(directory, { withFileTypes: true })) {
+      const ref = relative ? `${relative}/${item.name}` : item.name;
+      if (item.isSymbolicLink()) fail(`unexpected symlink: ${ref}`);
+      if (item.isDirectory()) { if (!['target', '.git'].includes(item.name)) visit(path.join(directory, item.name), ref); }
+      else if (!names.has(ref) && ref !== '.yss/scaffold-generation.json' && ref !== '.yss/platform-dependencies.json' && !ref.endsWith('/.yss/platform-dependencies.json')) fail(`unexpected source file: ${ref}`);
+    }
+  };
+  visit(projectRoot);
+  return digest(JSON.stringify(Object.fromEntries(Object.entries(actual).sort(([a],[b]) => a.localeCompare(b)))));
+}
+
+export function assertResumableCandidate(projectRoot, contract, contractBytes) {
+  const manifest = JSON.parse(readFileSync(path.join(projectRoot, '.yss/scaffold-generation.json'), 'utf8'));
+  if (manifest.platform_verification !== 'candidate' || manifest.schema_version !== 4 || manifest.contract_id !== contract.contract_id || manifest.contract_version !== contract.contract_version || manifest.contract_digest.replace('sha256:', '') !== digest(contractBytes).replace('sha256:', '') || JSON.stringify(manifest.platform_configuration) !== JSON.stringify(contract.platform_configuration)) fail('resume requires the identical candidate contract/Manifest');
+  assertSourceFingerprint(manifest.source_fingerprint, contract.architecture_family);
+  if (generatedTreeDigest(projectRoot, manifest) !== manifest.generated_tree_digest) fail('resume generated tree drift');
+  return manifest;
+}