create-yss-spec 3.0.1 → 3.1.3

package/template/scripts/verify-scaffold-generator-scenarios

@@ -9,6 +9,7 @@ import sys
 import tempfile
 import json
 import os
+import hashlib
 from pathlib import Path
 
 
@@ -63,8 +64,58 @@ def write_contract(
     compiler_draft_ref: str,
     persisted_ref: str,
 ) -> None:
+    decision_path = path.with_suffix(".architecture-decisions.yaml")
+    decision_id = f"scaffold-decision.{project_name}"
+    decision_text = json.dumps(
+        {
+            "schema_version": 1,
+            "kind": "scaffold-architecture-decisions",
+            "template": False,
+            "status": "current",
+            "decisions": [
+                {
+                    "decision_id": decision_id,
+                    "project_id": project_name,
+                    "parent_project_id": None,
+                    "status": "lifecycle-approved",
+                    "recommended_architecture": "domain-driven",
+                    "recommendation_reasons": ["场景验证固定使用 DDD"],
+                    "confirmed_architecture": "domain-driven",
+                    "override_reason": None,
+                    "inheritance_mode": "root-default",
+                    "inherited_from": None,
+                    "platform_profile": "spring-boot-2.7-jdk8",
+                    "architecture_profile": "target-domain-model",
+                    "verification_database": "h2",
+                    "production_database": "not-bound",
+                    "requested_capabilities": [],
+                    "resolved_modules": [
+                        "domain",
+                        "application",
+                        "infrastructure",
+                        "adapter",
+                        "bootstrap",
+                    ],
+                    "resolution_version": 1,
+                    "user_confirmation": {
+                        "confirmed_by": "scenario-runner",
+                        "channel": "test",
+                        "confirmation_ref": "test://scaffold-decision",
+                        "confirmed_at": "2026-09-05T00:00:00Z",
+                        "normalized_text": "确认使用 DDD",
+                    },
+                    "decision_inputs_digest": f"sha256:{'1' * 64}",
+                }
+            ],
+        },
+        ensure_ascii=False,
+        indent=2,
+    ) + "\n"
+    decision_path.write_text(decision_text, encoding="utf-8")
+    subprocess.run(["node", str(REPOSITORY_ROOT / "scripts/fixtures/user-decision/build-fixture.mjs"), "--scaffold", str(decision_path)], check=True, cwd=REPOSITORY_ROOT)
+    decision_text = decision_path.read_text(encoding="utf-8")
     contract = {
-        "schema_version": 2,
+        "schema_version": 3,
         "contract_id": contract_id,
         "contract_version": 1,
         "scaffold_request_id": f"{project_name}-request",
@@ -79,6 +130,12 @@ def write_contract(
         "project_name": project_name,
         "target_output_dir": str(output_root),
         "base_package": f"com.yss.{project_name.removesuffix('-service')}",
+        "architecture_family": "domain-driven",
+        "architecture_profile": "target-domain-model",
+        "generator_skill": "yss-ddd-scaffold-generator",
+        "decision_ref": str(decision_path),
+        "decision_id": decision_id,
+        "decision_digest": f"sha256:{hashlib.sha256(decision_text.encode('utf-8')).hexdigest()}",
         "maven_coordinates": {
             "group_id": "com.yss.datamiddle",
             "project_version": "1.0.0-SNAPSHOT",
@@ -92,12 +149,24 @@ def write_contract(
         "profiles": {
             "architecture": "target-domain-model",
             "persistence": "mybatis-plus",
-            "database": "mysql",
+            "verification_database": "h2",
+            "production_database": "not-bound",
             "platform": "spring-boot-2.7-jdk8",
             "validation_namespace": "javax",
             "dto_placement": "web",
             "repository": "yss-internal",
         },
+        "module_profile": {
+            "resolution_version": 1,
+            "requested_capabilities": [],
+            "resolved_modules": [
+                "domain",
+                "application",
+                "infrastructure",
+                "adapter",
+                "bootstrap",
+            ],
+        },
         "allowed_write_paths": ["."],
         "expected_evidence_files": [
             f"{project_name}/.yss/scaffold-generation.json",
@@ -157,7 +226,9 @@ def assert_pure_scaffold(project_root: Path, contract_id: str) -> None:
     require(manifest["compiler_draft_ref"], "生成清单必须记录 实现合同编译器 draft 引用")
     require(manifest["persisted_ref"], "生成清单必须记录合同持久化引用")
     require(manifest["generation_mode"] == "controlled-generation", "生成清单必须记录受控生成模式")
-    require(manifest["schema_version"] == 2, "生成清单必须使用 schema v2")
+    require(manifest["schema_version"] == 3, "新生成清单必须使用 schema v3")
+    require(manifest["architecture_family"] == "domain-driven", "生成清单必须记录已确认的 DDD 架构族")
+    require(manifest["generator_skill"] == "yss-ddd-scaffold-generator", "生成清单必须记录实际生成器")
     require(manifest["scaffold_request_id"], "生成清单必须记录服务级 scaffold_request_id")
     require("slice_id" not in manifest, "脚手架清单不得伪造 slice_id")
     require(manifest["maven_coordinates_source"] == "approved-contract", "Maven 坐标必须来自批准合同")

package/template/scripts/verify-strategic-context-import

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { parseArgs } from "node:util";
+import { fileURLToPath } from "node:url";
+import { parseDocument } from "./vendor/yaml.mjs";
+import { parseContextContract } from "./lib/context-contract.mjs";
+import { validateVisualBaseline } from "../.agents/skills/yss-prototype-stage/scripts/visual-baseline-contract.mjs";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const schemaPath = path.join(repoRoot, "docs/process/schemas/strategic-design-handoff.schema.json");
+const pythonValidator = String.raw`
+import json, sys
+from jsonschema import Draft202012Validator
+schema = json.load(open(sys.argv[1], encoding="utf-8"))
+value = json.load(sys.stdin)
+errors = sorted(Draft202012Validator(schema).iter_errors(value), key=lambda error: list(error.absolute_path))
+for error in errors:
+    where = ".".join(str(part) for part in error.absolute_path) or "<root>"
+    print(f"{where}: {error.message}", file=sys.stderr)
+sys.exit(1 if errors else 0)
+`;
+
+function parseFile(file) {
+  const document = parseDocument(readFileSync(file, "utf8"), { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) throw new TypeError(document.errors[0].message);
+  return document.toJS({ maxAliasCount: 0 });
+}
+
+try {
+  const { values, positionals } = parseArgs({ options: { root: { type: "string", default: process.cwd() }, reconciliation: { type: "string" } }, allowPositionals: true, strict: true });
+  if (positionals.length !== 1 || !values.reconciliation) throw new TypeError("用法: scripts/verify-strategic-context-import --root <target-repo> --reconciliation <record> <handoff.yaml|json>");
+  const root = path.resolve(values.root);
+  const handoff = parseFile(path.resolve(positionals[0]));
+  if ([1, 2].includes(handoff.schema_version)) throw new TypeError(`migration-required: Strategic Design Handoff v${handoff.schema_version} 是只读历史资产；在途 UI 交接必须升级 v3 并携带 Visual Baseline`);
+  const schemaResult = spawnSync("python3", ["-c", pythonValidator, schemaPath], { encoding: "utf8", input: JSON.stringify(handoff) });
+  if (schemaResult.status !== 0) throw new TypeError(`${schemaResult.stdout}${schemaResult.stderr}`.trim());
+  const baselineRef = handoff.source.visual_baseline_ref;
+  const bundleRoot = path.resolve(root, baselineRef.persisted_ref);
+  const manifestPath = path.resolve(bundleRoot, baselineRef.manifest_ref);
+  if (!manifestPath.startsWith(`${bundleRoot}${path.sep}`) || !existsSync(manifestPath)) throw new TypeError("Strategic Design Handoff 的 Visual Baseline manifest 不可读或越界");
+  const baseline = parseFile(manifestPath);
+  const baselineResult = await validateVisualBaseline(baseline, { bundleRoot });
+  if (baselineResult.errors.length) throw new TypeError(`Visual Baseline 无效: ${baselineResult.errors.join("; ")}`);
+  if (baseline.baseline_id !== baselineRef.baseline_id || baseline.version !== baselineRef.version || baseline.bundle.digest !== baselineRef.digest) throw new TypeError("Strategic Design Handoff 的 Visual Baseline 身份、版本或 digest 不一致");
+  const actualCaseIds = baseline.cases.map((item) => item.case_id).sort();
+  if (JSON.stringify(actualCaseIds) !== JSON.stringify([...baselineRef.case_ids].sort())) throw new TypeError("Strategic Design Handoff 的 Visual Baseline case_ids 不一致");
+  const reconciliationResult = spawnSync(process.execPath, [path.join(repoRoot, "scripts/verify-context-reconciliation"), "--root", root, path.resolve(values.reconciliation)], { cwd: repoRoot, encoding: "utf8" });
+  if (reconciliationResult.status !== 0) throw new TypeError(reconciliationResult.stderr.trim());
+  const target = parseContextContract({ root });
+  for (const operation of ["added", "updated"]) {
+    for (const expected of handoff.context_delta[operation]) {
+      const actual = target.terms_by_ref.get(expected.term_ref);
+      if (!actual) throw new TypeError(`目标 CONTEXT.md 尚未导入 ${operation} 术语: ${expected.term_ref}`);
+      for (const field of ["term", "meaning", "english_identifier", "context_id"]) if (actual[field] !== expected[field]) throw new TypeError(`目标 CONTEXT.md 的 ${expected.term_ref}.${field} 与交接增量不一致`);
+      if (JSON.stringify([...actual.forbidden_aliases].sort()) !== JSON.stringify([...expected.forbidden_aliases].sort())) throw new TypeError(`目标 CONTEXT.md 的 ${expected.term_ref}.forbidden_aliases 与交接增量不一致`);
+    }
+  }
+  for (const deprecated of handoff.context_delta.deprecated) if (target.terms_by_ref.has(deprecated.term_ref)) throw new TypeError(`目标 CONTEXT.md 尚未处理 deprecated 术语: ${deprecated.term_ref}`);
+  process.stdout.write("Strategic context import 与目标 reconciliation 验证通过\n");
+} catch (error) {
+  process.stderr.write(`Strategic context import 验证失败: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/verify-strategic-context-import-scenarios

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { sealVisualBaseline } from "../.agents/skills/yss-prototype-stage/scripts/visual-baseline-contract.mjs";
+
+const repoRoot = path.resolve(import.meta.dirname, "..");
+const root = mkdtempSync(path.join(tmpdir(), "yss-strategic-import-"));
+mkdirSync(path.join(root, "docs", "evidence"), { recursive: true });
+writeFileSync(path.join(root, "yss-project.yaml"), "schema_version: 1\nrepository_mode: project-instance\n");
+const context = (meaning = "提供产品或服务的主体") => `---
+context_schema_version: 1
+---
+# CONTEXT
+## 流程术语
+| 术语 | 含义 | 英文标识 | 避免 / 备注 |
+|---|---|---|---|
+| 阶段 | 生命周期阶段 | — | |
+## 业务术语
+| 术语 | 含义 | 英文标识 | 适用限界上下文 | 避免 / 备注 |
+|---|---|---|---|---|
+| 供应商 | ${meaning} | Supplier | Global | |
+`;
+writeFileSync(path.join(root, "CONTEXT.md"), context());
+const run = (command, args) => spawnSync(command, args, { cwd: repoRoot, encoding: "utf8" });
+const snapshot = JSON.parse(run("scripts/verify-context-contract", ["--root", root, "--term-ref", "Global/Supplier", "--json"]).stdout).context_snapshot;
+const reconciliation = { schema_version: 1, repository_mode: "project-instance", stage: "stage.system-data-engineering", work_unit: "work-unit.technical-analysis", status: "reconciled", context_snapshot: snapshot, changes: { added: ["Global/Supplier"], updated: [], deprecated: [] }, unresolved_terms: [], evidence_refs: ["CONTEXT.md"] };
+const reconciliationFile = path.join(root, "docs/evidence/context-reconciliation.json"); writeFileSync(reconciliationFile, JSON.stringify(reconciliation));
+const supplier = { term_ref: "Global/Supplier", term: "供应商", meaning: "提供产品或服务的主体", english_identifier: "Supplier", context_id: "Global", forbidden_aliases: [] };
+const ref = (id) => ({ id, version: "v2", digest: `sha256:${id}`, status: "approved", persisted_ref: `source/${id}` });
+function pngHeader(width, height) { const value = Buffer.alloc(24); Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]).copy(value, 0); value.writeUInt32BE(13, 8); value.write("IHDR", 12, "ascii"); value.writeUInt32BE(width, 16); value.writeUInt32BE(height, 20); return value; }
+const bundleRoot = path.join(root, "source/visual-baseline-v1"); mkdirSync(path.join(bundleRoot, "images"), { recursive: true }); mkdirSync(path.join(bundleRoot, "sources"), { recursive: true }); mkdirSync(path.join(bundleRoot, "capture"), { recursive: true });
+writeFileSync(path.join(bundleRoot, "images/primary-desktop.png"), pngHeader(1440, 900)); writeFileSync(path.join(bundleRoot, "images/primary-narrow.png"), pngHeader(390, 844));
+writeFileSync(path.join(bundleRoot, "sources/prototype.html"), "<main>supplier</main>\n"); writeFileSync(path.join(bundleRoot, "sources/interaction.md"), "# Interaction\n"); writeFileSync(path.join(bundleRoot, "sources/states.md"), "# States\n"); writeFileSync(path.join(bundleRoot, "capture/capture.mjs"), "// capture\n"); writeFileSync(path.join(bundleRoot, "capture/result.json"), "{\"result\":\"passed\"}\n");
+const baselineFile = path.join(bundleRoot, "visual-baseline.yaml");
+const baseline = { schema_version: 1, baseline_id: "visual-baseline.supplier", feature: "supplier", version: "v1", status: "approved", bundle: { format: "portable-directory", root_ref: "source/visual-baseline-v1", digest: `sha256:${"0".repeat(64)}`, size_bytes: 0, max_image_bytes: 5242880, max_bundle_bytes: 104857600 }, source: { prototype_ref: "sources/prototype.html", prototype_digest: `sha256:${"1".repeat(64)}`, interaction_spec_ref: "sources/interaction.md", interaction_spec_digest: `sha256:${"2".repeat(64)}`, state_matrix_ref: "sources/states.md", state_matrix_digest: `sha256:${"3".repeat(64)}` }, capture_environment: { browser: "chromium", browser_version: "140.0.0", operating_system: "linux", fonts_digest: `sha256:${"4".repeat(64)}`, device_scale_factor: 1, color_space: "srgb", locale: "zh-CN", timezone: "Asia/Shanghai", animations_disabled: true, cursor_hidden: true, capture_script_ref: "capture/capture.mjs", capture_script_digest: `sha256:${"5".repeat(64)}`, capture_result_ref: "capture/result.json", capture_result_digest: `sha256:${"6".repeat(64)}` }, cases: [{ case_id: "primary-desktop", route: "/supplier", page: "SupplierPage", state: "normal", viewport: { name: "desktop", width: 1440, height: 900, scroll_mode: "viewport", scroll_position: 0 }, theme: "compact-light", locale: "zh-CN", data_scenario: "primary", image_ref: "images/primary-desktop.png", image_digest: `sha256:${"0".repeat(64)}`, image_size_bytes: 1, mask_ref: "not-applicable", mask_digest: "not-applicable", mask_size_bytes: 0, semantic_refs: ["sources/prototype.html", "sources/interaction.md"], allowed_differences: [], result: "passed" }, { case_id: "primary-narrow", route: "/supplier", page: "SupplierPage", state: "normal", viewport: { name: "narrow", width: 390, height: 844, scroll_mode: "viewport", scroll_position: 0 }, theme: "compact-light", locale: "zh-CN", data_scenario: "primary", image_ref: "images/primary-narrow.png", image_digest: `sha256:${"0".repeat(64)}`, image_size_bytes: 1, mask_ref: "not-applicable", mask_digest: "not-applicable", mask_size_bytes: 0, semantic_refs: ["sources/states.md"], allowed_differences: [], result: "passed" }] };
+writeFileSync(baselineFile, JSON.stringify(baseline)); const sealedBaseline = await sealVisualBaseline(baselineFile, bundleRoot);
+const visualBaselineRef = { baseline_id: sealedBaseline.baseline_id, version: sealedBaseline.version, digest: sealedBaseline.bundle.digest, status: "approved", persisted_ref: "source/visual-baseline-v1", manifest_ref: "visual-baseline.yaml", case_ids: sealedBaseline.cases.map((item) => item.case_id) };
+const handoff = { schema_version: 3, handoff_id: "strategic-design-handoff.supplier", handoff_version: "v3", status: "approved", source: { domain_strategy_ref: ref("domain"), stage_decision_package_ref: ref("stage"), spec_ref: ref("spec"), prototype_ref: ref("prototype"), visual_baseline_ref: visualBaselineRef, business_ticket_set_ref: ref("tickets") }, source_context_snapshot: snapshot, context_delta: { added: [supplier], updated: [], deprecated: [] }, target_context_reconciliation: { target_context_ref: "CONTEXT.md", reconciliation_schema_ref: "docs/process/schemas/context-reconciliation.schema.json", required_before_skill: "yss-tactical-design", status: "pending" }, target: { team: "downstream-rd-team", skill: "yss-tactical-design", output: "tactical-design-contract" }, problem_and_business_outcomes: ["准入"], bounded_context_and_subdomain_map: ["Global"], context_map_and_translation_responsibility: ["共享"], ubiquitous_language_and_concept_candidates: ["Global/Supplier"], scenarios_and_business_invariants: ["稳定"], tactical_design_questions: ["聚合边界"], deferred_decisions_and_ownership: [], evidence_and_version_digests: ["source/evidence"], acceptance: ["target-context-reconciliation-is-required-before-tactical-design"] };
+const handoffFile = path.join(root, "handoff.json"); writeFileSync(handoffFile, JSON.stringify(handoff));
+function verify(expected, pattern) { const result = run("scripts/verify-strategic-context-import", ["--root", root, "--reconciliation", reconciliationFile, handoffFile]); if (result.status !== expected || (pattern && !pattern.test(`${result.stdout}${result.stderr}`))) throw new Error(`${result.stdout}${result.stderr}`); }
+verify(0);
+writeFileSync(path.join(root, "CONTEXT.md"), context("错误含义"));
+const staleSnapshot = JSON.parse(run("scripts/verify-context-contract", ["--root", root, "--term-ref", "Global/Supplier", "--json"]).stdout).context_snapshot;
+writeFileSync(reconciliationFile, JSON.stringify({ ...reconciliation, context_snapshot: staleSnapshot }));
+verify(1, /不一致/);
+writeFileSync(handoffFile, JSON.stringify({ ...handoff, schema_version: 2 }));
+verify(1, /migration-required/);
+process.stdout.write("Strategic context import scenarios passed\n");

package/template/scripts/verify-strategic-handoff-consumption

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { read } from './lib/strategic-handoff-io.mjs';
+import { verifyConsumption } from './lib/strategic-handoff-consumption.mjs';
+try {
+ const {values,positionals}=parseArgs({allowPositionals:true,options:{root:{type:'string',default:process.cwd()},slice:{type:'string'}}});
+ if(positionals.length!==1)throw new TypeError('用法: verify-strategic-handoff-consumption --root <target> [--slice <slice-id>] <tactical.yaml>');
+ const result=await verifyConsumption(read(positionals[0]),{root:values.root,sliceRef:values.slice});
+ process.stdout.write(`${JSON.stringify(result,null,2)}\n`);if(result.result==='blocked')process.exitCode=1;
+}catch(error){process.stderr.write(`${JSON.stringify({result:'blocked',error:error.message})}\n`);process.exitCode=1;}

package/template/scripts/verify-strategic-handoff-package-scenarios

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, cpSync, rmSync } from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { fixture, context } from './fixtures/strategic-handoff/fixture.mjs';
+import { exportBundle, openBundle, importBundle } from './lib/strategic-handoff.mjs';
+import { read, json, hash, digest } from './lib/strategic-handoff-io.mjs';
+import { parseContextContract } from './lib/context-contract.mjs';
+const setup=async t=>{const base=mkdtempSync(path.join(tmpdir(),'handoff-test-'));t.after(()=>rmSync(base,{recursive:true,force:true}));const source=path.join(base,'source');mkdirSync(source);return{base,source,...await fixture(source)};};
+function advanceStrategy(f,version='v2') {
+ f.handoff.handoff_version=version;
+ f.strategy.domain_version=version;
+ f.strategy.approval.current_version=version;
+ f.stage.package_version=version;
+ f.stage.approval.current_version=version;
+ f.stage.domain_strategy_ref.domain_version=version;
+ f.handoff.source.domain_strategy_ref.version=version;
+ f.handoff.source.stage_decision_package_ref.version=version;
+ f.strategy.rule_catalog[0].statement='材料完整且有效';
+ f.strategy.scenarios[0].rules=['材料完整且有效'];
+ f.strategy.invariants[0].statement='材料完整且有效';
+ f.put('source/strategy.yaml',f.strategy);
+ f.handoff.source.domain_strategy_ref.digest=digest(f.strategy);
+ f.stage.domain_strategy_ref.digest=digest(f.strategy);
+ f.put('source/stage.yaml',f.stage);
+ f.handoff.source.stage_decision_package_ref.digest=digest(f.stage);
+ f.sign();
+}
+test('目录和 ZIP 可脱离源仓验包；导入幂等且不修改词汇表',async t=>{
+ const f=await setup(t);const output=path.join(f.base,'package');
+ const result=await exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output,zip:true});
+ rmSync(f.source,{recursive:true});
+ for(const bundle of [output,`${output}.zip`])assert.equal(await openBundle(bundle,b=>b.manifest.bundle_digest),result.bundle_digest);
+ const target=path.join(f.base,'target');mkdirSync(target);writeFileSync(path.join(target,'yss-project.yaml'),'schema_version: 1\nrepository_mode: project-instance\n');writeFileSync(path.join(target,'CONTEXT.md'),context);
+ const imported=await importBundle({bundle:`${output}.zip`,targetRoot:target});assert.equal(imported.result,'imported-pending-reconciliation');
+ assert.equal(readFileSync(path.join(target,'CONTEXT.md'),'utf8'),context);parseContextContract({root:target});
+ assert.equal((await importBundle({bundle:output,targetRoot:target})).result,'already-imported');
+});
+test('规则遗漏、摘要漂移、批准不匹配和离线资源丢失阻断导出',async t=>{
+ const f=await setup(t);const run=()=>exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output:path.join(f.base,'out')});
+ const text=readFileSync(path.join(f.source,'source/strategy.yaml'));f.put('source/strategy.yaml',{...f.strategy,traceability_version:undefined});
+ await assert.rejects(run,/不一致|过期|migration/);writeFileSync(path.join(f.source,'source/strategy.yaml'),text);
+ const approved=read(path.join(f.source,'approvals/spec_ref.yaml'));f.put('approvals/spec_ref.yaml',{...approved,artifact_bindings:[]});await assert.rejects(run,/批准记录未绑定/);f.put('approvals/spec_ref.yaml',approved);
+ const roles=read(path.join(f.source,'docs/agents/digital-human-roles.yaml'));f.put('docs/agents/digital-human-roles.yaml',{...roles,user_decision_policy:{...roles.user_decision_policy,gates:['gate.domain-strategy-approved']}});await assert.rejects(run,/user-decision|升级/);f.put('docs/agents/digital-human-roles.yaml',roles);
+ const sourceBytes=readFileSync(path.join(f.source,'prototype-src/main.js'));f.put('prototype-src/main.js','changed');await assert.rejects(run,/源码\/锁文件批准摘要/);writeFileSync(path.join(f.source,'prototype-src/main.js'),sourceBytes);
+ const verification=read(path.join(f.source,'evidence/offline.json'));f.put('evidence/offline.json',{...verification,command:'changed'});await assert.rejects(run,/验证记录批准摘要/);f.put('evidence/offline.json',verification);
+ f.put('preview/index.html','<img src="missing.png">');await assert.rejects(run,/过期/);
+});
+test('篡改 payload、重新封摘要后的虚构规则索引、额外文件均拒绝',async t=>{
+ const f=await setup(t),output=path.join(f.base,'package');await exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output});
+ const spec=path.join(output,'payload/files/source/spec.md'),bytes=readFileSync(spec);writeFileSync(spec,'tampered');await assert.rejects(()=>openBundle(output,()=>null),/摘要/);writeFileSync(spec,bytes);
+ writeFileSync(path.join(output,'extra.txt'),'extra');await assert.rejects(()=>openBundle(output,()=>null),/未登记/);rmSync(path.join(output,'extra.txt'));
+ const manifest=read(path.join(output,'manifest.json'));const idx=Buffer.from(json([]));writeFileSync(path.join(output,'indexes/rules.json'),idx);const row=manifest.files.find(x=>x.path==='indexes/rules.json');row.sha256=hash(idx);row.size_bytes=idx.length;delete manifest.bundle_digest;manifest.bundle_digest=digest(manifest);writeFileSync(path.join(output,'manifest.json'),json(manifest));await assert.rejects(()=>openBundle(output,()=>null),/索引与源/);
+});
+test('ZIP 路径穿越和重复条目拒绝',async t=>{
+ const f=await setup(t);
+ for(const names of [['../escape'],['manifest.json','manifest.json']]){
+  const zip=path.join(f.base,'bad.zip');rmSync(zip,{force:true});const py='import zipfile,json,sys; z=zipfile.ZipFile(sys.argv[1],"w"); [z.writestr(n,"x") for n in json.loads(sys.argv[2])]; z.close()';assert.equal(spawnSync('python3',['-c',py,zip,JSON.stringify(names)]).status,0);await assert.rejects(()=>openBundle(zip,()=>null),/ZIP/);
+ }
+});
+test('版本差异绑定前版，重复版本不允许；修改规则产生更新集合',async t=>{
+ const f=await setup(t),first=path.join(f.base,'v1');await exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output:first});
+ await assert.rejects(()=>exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output:path.join(f.base,'bad'),previous:first}),/提升/);
+ advanceStrategy(f);
+ const second=path.join(f.base,'v2');await exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output:second,previous:first});assert.deepEqual(await openBundle(second,b=>b.changes.updated),['rule.complete','scenario.submit']);
+});
+
+test('受控延期只阻断依赖切片；未知依赖扩大阻断；目标未对账禁止消费',async t=>{
+ const {verifyConsumption}=await import('./lib/strategic-handoff-consumption.mjs');
+ const f=await setup(t),output=path.join(f.base,'package');await exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output});
+ const target=path.join(f.base,'target');mkdirSync(target);writeFileSync(path.join(target,'yss-project.yaml'),'schema_version: 1\nrepository_mode: project-instance\n');writeFileSync(path.join(target,'CONTEXT.md'),context);
+ const result=await importBundle({bundle:output,targetRoot:target});
+ const draft=read(path.join(target,result.traceability_ref));
+ const tactical={status:'approved',strategic_handoff:{...draft,context_reconciliation_ref:'reconciliation.yaml'},behavior_catalog:[{behavior_id:'behavior.submit'}],test_seams:[{seam_id:'test-seam.submit',subject_ref:'behavior.submit'}]};
+ const record={schema_version:1,repository_mode:'project-instance',stage:'stage.system-data-engineering',work_unit:'work-unit.technical-analysis',status:'reconciled',context_snapshot:f.snapshot,changes:{added:['Global/Supplier'],updated:[],deprecated:[]},unresolved_terms:[],evidence_refs:['CONTEXT.md']};
+ writeFileSync(path.join(target,'reconciliation.yaml'),json(record));
+ for(const row of tactical.strategic_handoff.rows)Object.assign(row,{disposition:'implemented',tactical_refs:['behavior.submit'],test_seam_refs:['test-seam.submit'],scenario_tests:[{outcome:'success',seam_ref:'test-seam.submit'},{outcome:'failure',seam_ref:'test-seam.submit'}],evidence_refs:['CONTEXT.md'],dependency_status:'known',dependent_slice_refs:['slice.submit']});
+ assert.equal((await verifyConsumption(tactical,{root:target})).result,'verified');
+ const row=tactical.strategic_handoff.rows[0];Object.assign(row,{disposition:'deferred',reason:'分批实现',risk:'不能提交',owner:'需求负责人',followup_ticket_ref:'ticket.followup',verification_plan:'提交测试',target_version:'v2'});
+ assert.equal((await verifyConsumption(tactical,{root:target,sliceRef:'slice.submit'})).result,'blocked');
+ assert.equal((await verifyConsumption(tactical,{root:target,sliceRef:'slice.other'})).result,'verified');
+ row.dependency_status='unknown';assert.equal((await verifyConsumption(tactical,{root:target,sliceRef:'slice.other'})).result,'blocked');
+ row.dependency_status='known';row.disposition='implemented';advanceStrategy(f);const second=path.join(f.base,'v2');await exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output:second,previous:output});await importBundle({bundle:second,targetRoot:target});
+ const stale=await verifyConsumption(tactical,{root:target,sliceRef:'slice.submit'});assert.equal(stale.result,'blocked');assert(stale.issues.some(x=>x.reason==='stale-source'));assert.equal((await verifyConsumption(tactical,{root:target,sliceRef:'slice.other'})).result,'verified');
+ f.strategy.contexts[0].responsibilities.push('新增责任边界');advanceStrategy(f,'v3');const third=path.join(f.base,'v3');await exportBundle({sourceRoot:f.source,handoffRef:'handoff.yaml',output:third,previous:second});await importBundle({bundle:third,targetRoot:target});const changedBoundary=await verifyConsumption(tactical,{root:target,sliceRef:'slice.other'});assert.equal(changedBoundary.block_all,true);assert(changedBoundary.issues.some(x=>x.reason==='upstream-design-stale'));
+ writeFileSync(path.join(target,'reconciliation.yaml'),json({...record,status:'blocked',unresolved_terms:[{term:'Supplier',reason:'冲突',owner:'需求负责人',next_action:'回交战略方'}]}));
+ await assert.rejects(()=>verifyConsumption(tactical,{root:target}),/对账未通过/);
+});
+
+test('源规则必须稳定可追溯，关键场景不能遗漏结果',async t=>{
+ const {extractTraceability}=await import('./lib/strategic-handoff-rules.mjs');const f=await setup(t);
+ for(const mutate of [s=>delete s.traceability_version,s=>s.scenarios[0].rule_refs=['rule.missing'],s=>delete s.scenarios[0].success_results,s=>s.invariants[0].rule_ref='rule.missing',s=>s.rule_catalog.push({...s.rule_catalog[0]})]){const s=structuredClone(f.strategy);mutate(s);assert.throws(()=>extractTraceability(s));}
+});
+test('统一 CLI 在源目录消失后通过 ZIP 验包',async t=>{
+ const f=await setup(t),output=path.join(f.base,'cli');
+ const cli=path.join(import.meta.dirname,'strategic-handoff');
+ const exported=spawnSync(process.execPath,[cli,'export','--source-root',f.source,'--handoff','handoff.yaml','--output',output,'--zip'],{encoding:'utf8'});assert.equal(exported.status,0,exported.stderr);
+ rmSync(f.source,{recursive:true});const checked=spawnSync(process.execPath,[cli,'verify','--bundle',`${output}.zip`],{encoding:'utf8'});assert.equal(checked.status,0,checked.stderr);assert.equal(JSON.parse(checked.stdout).result,'verified');
+});

package/template/scripts/verify-subagent-task-package-scenarios

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, rmSync, writeFileSync, mkdtempSync, readFileSync } from "node:fs";
 import path from "node:path";
+import os from "node:os";
+import { buildDecisionFixture } from "./fixtures/user-decision/build-fixture.mjs";
+import { decisionDigest } from "./lib/user-decision.mjs";
+const decisionTemp = mkdtempSync(path.join(os.tmpdir(), "task-decision-test-"));
+process.on("exit", () => rmSync(decisionTemp, { recursive: true, force: true }));
+let decisionRequirement;
 import { spawnSync } from "node:child_process";
 import { ROOT } from "./lib/lifecycle-registry.mjs";
 import { generateTaskPackageDefaults, validateTaskPackage, validateTaskPackageSet } from "./lib/task-package.mjs";
@@ -19,7 +25,8 @@ const contract = {
   contract_version: 2,
   slice_id: "todo",
   status: "approved",
-  lifecycle_refs: {},
+  lifecycle_refs: { ticket: "docs/.scratch/todo/issues/01-todo.md", engineering_baseline: evidenceRef },
+  common: { project_roots: ["apps/frontend/todo", "apps/backend/todo"], allowed_write_paths: ["apps/frontend/todo/", "apps/backend/todo/"] },
   readiness: {},
   work_units: [
     { id: "work-unit.slice-frontend", role_id: "role.frontend-engineer", runtime_id: "runtime.skill-projection", task_package_ref: "work-unit.slice-frontend", contract_id: "slice-todo", contract_version: 2, allowed_write_paths: ["apps/frontend/todo/"] },
@@ -45,6 +52,10 @@ function writeFixtures() {
   writeFileSync(contractFile, JSON.stringify(contract));
   writeFileSync(evidenceFile, JSON.stringify({ ok: true }));
   writeFileSync(path.join(ROOT, maintenanceRef), JSON.stringify(maintenance));
+  const scopeRef = path.join(decisionTemp, "scope.json");
+  const asset = (ref) => ({ ref, version: "v1", digest: decisionDigest(readFileSync(path.join(ROOT, ref))) });
+  writeFileSync(scopeRef, JSON.stringify({ kind: "implementation-scope", slices: [{ ticket_ref: contract.lifecycle_refs.ticket, contract: asset(contractRef), repositories: contract.common.project_roots, allowed_write_paths: contract.common.allowed_write_paths, baselines: [asset(evidenceRef)] }] }));
+  decisionRequirement = buildDecisionFixture(decisionTemp, { boundary: "implementation-scope", scope: [contract.lifecycle_refs.ticket], subjectRef: scopeRef }).requirement;
 }
 
 function packageBase(roleId, taskId, workUnitId, kind, contractFields, stageId) {
@@ -95,6 +106,7 @@ function slicePackage(roleId, taskId, workUnitId, writePath) {
     workflow_status: "not-started",
     contract: { kind: "slice-implementation", contract_id: contract.contract_id, contract_version: contract.contract_version, status: "issued", contract_ref: contractRef, slice_contract_ref: contractRef },
     inputs: ["CONTEXT.md"],
+    user_decisions: [decisionRequirement],
     objective: "实现 Todo 垂直切片",
     allowed_write_paths: [writePath],
     forbidden_actions: ["不得修改合同"],
@@ -115,6 +127,7 @@ function completedResult(pkg, overrides = {}) {
     result: "completed",
     skill: "yss-product-lifecycle",
     changed_files: [],
+    context_reconciliation: { status: "reconciled", ref: evidenceRef },
     evidence_refs: [evidenceRef],
     deferred_seams: [],
     drift: [],
@@ -150,6 +163,7 @@ try {
   [discovery, spec, prototype, technical, tickets, review].forEach((pkg) => validateTaskPackage(pkg));
   validateTaskPackage(maintenance);
   validateTaskPackage(frontend);
+  assert.throws(() => validateTaskPackage({ ...frontend, user_decisions: [] }), /user-decision-scope-mismatch/, "Worker 派发前必须有当前实施范围批准");
   validateTaskPackage(backend);
   validateTaskPackageSet([frontend, backend]);
 
@@ -183,7 +197,7 @@ try {
   mustFail((value) => { value.execution_state = "Reviewer"; value.review_context = { implementation_actor_id: value.actor_id }; }, /不同 actor_id/, "reviewer-implementer-conflict");
   mustFail((value) => { value.workflow_status = "resolved"; value.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }]; value.result = completedResult(value, { new_impacts: ["api-change"] }); }, /new_impacts 必须为空/, "completed-new-impact");
   mustFail((value) => { value.workflow_status = "resolved"; value.verification_commands = ["scripts/verify-template", "pnpm test"]; value.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }]; value.result = completedResult(value); }, /覆盖全部 verification_commands/, "verification-command-gap");
-  mustFail((value) => { value.workflow_status = "resolved"; value.result = completedResult(value, { evidence_refs: [".template-source/evidence/.missing.json"] }); value.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }]; }, /不可读/, "unreadable-evidence");
+  mustFail((value) => { value.workflow_status = "resolved"; value.result = completedResult(value, { context_reconciliation: { status: "reconciled", ref: ".template-source/evidence/.missing.json" }, evidence_refs: [".template-source/evidence/.missing.json"] }); value.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }]; }, /不可读/, "unreadable-evidence");
   mustFail((value) => { value.workflow_status = "resolved"; value.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }]; }, /Workflow Execution Result/, "resolved-without-result");
   mustFail((value) => { value.workflow_status = "resolved"; value.result = { result: "blocked" }; value.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }]; }, /Workflow Execution Result/, "resolved-blocked-result");
   mustFail((value) => { value.workflow_status = "resolved"; value.verification_results = [{ command: "scripts/verify-template", exit_code: 0, executed_at: "now", evidence_ref: evidenceRef }]; value.result = completedResult(value); value.expected_evidence_files = [".template-source/evidence/.missing.json"]; }, /expected_evidence_files.*不可读/, "missing-expected-evidence");

package/template/scripts/verify-template-verification-scenarios

@@ -17,8 +17,13 @@ const releaseBaseline = [
   "scripts/verify-yss-dto-openapi-scenarios",
   "scripts/verify-digital-human-roles",
   "scripts/verify-digital-human-roles-scenarios",
-  "scripts/verify-approval-record docs/templates/approval-record-template.yaml",
+  "scripts/verify-approval-record --history docs/templates/approval-record-template.yaml",
   "scripts/verify-lifecycle-registry",
+  "scripts/verify-context-contract --root . --json",
+  "scripts/verify-context-contract-scenarios",
+  "scripts/verify-context-reconciliation-scenarios",
+  "scripts/verify-grill-with-docs-context-scenarios",
+  "scripts/verify-strategic-context-import-scenarios",
   "scripts/verify-lifecycle-checkpoint docs/process/templates/lifecycle-checkpoint-template.yaml",
   "scripts/verify-frontend-implementation-evidence --allow-template docs/process/templates/frontend-implementation-plan-template.yaml",
   "scripts/verify-frontend-implementation-evidence --allow-template docs/process/templates/frontend-implementation-verification-template.yaml",

package/template/scripts/verify-user-decision

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { decisionIO, verifyUserDecisionFile } from "./lib/user-decision.mjs";
+try {
+  const { positionals, values } = parseArgs({ allowPositionals: true, options: { root: { type: "string" }, requirements: { type: "string" } } });
+  if (positionals.length !== 1) throw new TypeError("用法: scripts/verify-user-decision [--root <repo>] [--requirements <当前事项.json>] <record.yaml>");
+  const options = values.root ? { root: values.root } : {};
+  const io = decisionIO(options);
+  const record = io.document(positionals[0]);
+  // No requirements means verify every requested item for approval; partial approvals need explicit current requirements.
+  options.expected = values.requirements ? io.document(values.requirements) : record.request.items.map((item) => ({ boundary: item.boundary, subject_ref: item.subject.ref, scope: item.scope }));
+  verifyUserDecisionFile(positionals[0], options);
+  process.stdout.write("用户决定及当前批准范围校验通过\n");
+} catch (error) {
+  process.stderr.write(`用户决定校验失败: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/verify-user-decision-scenarios

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { buildDecisionFixture, buildImplementationFixture } from "./fixtures/user-decision/build-fixture.mjs";
+import { validateUserDecision, assertUserDecisionRequirement, assertImplementationDecision, decisionDigest } from "./lib/user-decision.mjs";
+import { validateApprovalRecord, assertCheckpointApprovals, assertCheckpointUserDecisions } from "./lib/approval-record.mjs";
+import { validateNextRoute } from "./lib/lifecycle-transition.mjs";
+import { loadDigitalHumanRoles, countersignRuleForGate, collectCountersignGateIds } from "./lib/digital-human-roles.mjs";
+
+const root = mkdtempSync(path.join(os.tmpdir(), "yss-user-decision-"));
+process.on("exit", () => rmSync(root, { recursive: true, force: true }));
+let count = 0;
+const check = (name, fn) => { fn(); count++; process.stdout.write(`PASS ${name}\n`); };
+const fixture = (name, opts) => buildDecisionFixture(path.join(root, name), opts);
+const verify = (f) => validateUserDecision(f.record, { expected: [f.requirement] });
+const deny = (f, code) => assert.throws(() => verify(f), (error) => error.code === code, code);
+check("真实单项回复通过，CLI 校验通过", () => {
+  const f = fixture("single"); verify(f);
+  assert.equal(spawnSync("scripts/verify-user-decision", [f.ref], { encoding: "utf8" }).status, 0);
+});
+check("无回复保持等待", () => { const f = fixture("pending"); f.record.responses = []; deny(f, "user-decision-response-required"); });
+for (const decision of ["rejected", "changes-requested", "unclear", "revoked"]) check(`${decision} 不放行`, () => { const f = fixture(decision); f.record.responses = []; f.respond({ decision, text: decision, approvedScope: [] }); deny(f, "user-decision-not-approved"); });
+check("数字人代答无效", () => { const f = fixture("bot"); f.record.responses = []; f.respond({ actor: "digital-human" }); deny(f, "user-decision-responder-mismatch"); });
+check("默认选项和无反对意见不能代替原始消息", () => { const f = fixture("default"); f.record.responses[0].source.kind = "default-option"; assert.throws(() => verify(f)); });
+check("记录原文与来源不一致无效", () => { const f = fixture("text"); f.record.responses[0].text = "我批准全部"; deny(f, "user-decision-responder-mismatch"); });
+check("缺失来源和仅 Agent 摘要无效", () => { const f = fixture("missing"); f.record.responses[0].source.ref += ".missing"; deny(f, "user-decision-source-unreadable"); const g = fixture("summary"); g.record.responses[0].source.kind = "agent-summary"; assert.throws(() => verify(g)); });
+check("来源篡改被拒绝", () => { const f = fixture("source-changed"); writeFileSync(f.record.responses[0].source.ref, "变更"); deny(f, "user-decision-source-changed"); });
+check("未展示当前请求不能批准", () => { const f = fixture("presentation"); f.record.request.items[0].recommendation = "不同方案"; deny(f, "user-decision-presentation-mismatch"); });
+check("展示前回复无效", () => { const f = fixture("time"); f.record.responses = []; f.respond({ time: "2026-09-05T01:01:00Z" }); deny(f, "user-decision-source-invalid"); });
+check("错误版本及批准依据变化重新确认", () => { const f = fixture("version"); f.record.request.items[0].subject.version = "v2"; f.present(); deny(f, "user-decision-stale"); const g = fixture("asset"); writeFileSync(g.requirement.subject_ref, "新范围"); deny(g, "user-decision-stale"); });
+check("额外依据变化重新确认，无关文件不影响", () => {
+  const f = fixture("basis"); const ref = f.write("basis.md", "v1"); f.record.request.items[0].basis = [{ ref, version: "v1", digest: decisionDigest(readFileSync(ref)) }]; f.present(); f.record.responses = []; f.respond(); verify(f); f.write("unrelated.md", "change"); verify(f); f.write("basis.md", "v2"); deny(f, "user-decision-stale");
+});
+check("同版本范围可重复使用且不按时间过期", () => { const f = fixture("reuse"); verify(f); verify(f); });
+check("范围扩大和错误事项无效", () => { const f = fixture("scope"); f.requirement.scope.push("new-feature"); deny(f, "user-decision-subject-mismatch"); const g = fixture("wrong-item"); g.record.responses[0].item_ids = ["other"]; deny(g, "user-decision-subject-mismatch"); });
+check("提问者指定负责人有效，未指定代答无效", () => {
+  const f = fixture("delegate"); const item = f.record.request.items[0]; item.responder_ref = "person.owner"; item.delegation_source = f.capture("delegate", "person.requester", "biological-human", "2026-09-05T01:01:00Z", "指定 person.owner 决定 decision.demo"); f.present(); f.record.responses = []; f.respond({ principal: "person.owner" }); verify(f); delete item.delegation_source; f.present(); deny(f, "user-decision-source-invalid");
+});
+check("多项继续无效，明确全部或部分批准有效", () => {
+  const f = fixture("multi"); const second = structuredClone(f.record.request.items[0]); second.id = "decision.second"; second.boundary = "gate.openapi-frozen"; second.scope = ["api.demo"]; f.record.request.items.push(second); f.present(); f.record.responses = []; f.respond({ text: "继续" }); deny(f, "user-decision-ambiguous");
+  f.record.responses = []; f.respond({ text: "同意以上全部事项" }); verify(f);
+  f.record.responses = []; f.respond({ text: "同意 decision.demo", selection: "explicit-items", itemIds: ["decision.demo"], approvedScope: ["feature.demo"] }); verify(f);
+  assert.throws(() => validateUserDecision(f.record, { expected: [{ ...f.requirement, boundary: second.boundary, scope: second.scope }] }), /user-decision-response-required/);
+});
+check("不能把其他对话的同意嫁接为当前批准", () => {
+  const f = fixture("unrelated-response"); const source = f.record.responses[0].source;
+  const raw = JSON.parse(readFileSync(source.ref)); raw.messages[0].reply_to = "different-request"; writeFileSync(source.ref, JSON.stringify(raw)); source.digest = decisionDigest(readFileSync(source.ref)); deny(f, "user-decision-subject-mismatch");
+});
+check("无 reply-to 的完整相邻会话导出可复用", () => {
+  const f = fixture("adjacent-export"); const source = f.record.responses[0].source;
+  const reply = JSON.parse(readFileSync(source.ref)).messages[0]; delete reply.reply_to;
+  const shown = JSON.parse(readFileSync(f.record.request.presented_source.ref)).messages[0];
+  const ref = f.write("original-session.json", { source_kind: "session-export", messages: [shown, reply] });
+  source.ref = ref; source.digest = decisionDigest(readFileSync(ref)); verify(f);
+});
+check("生物人会签者必须与原始回复者一致", () => {
+  const f = fixture("human-approval", { boundary: "gate.release-ready" });
+  const record = { schema_version: 1, gate_id: "gate.release-ready", decision: "approved", actor_kind: "biological-human", role_id: "role.biological-human", runtime_id: "runtime.generic", principal_ref: "person.requester", subject_ref: f.requirement.subject_ref, approval_scope: f.requirement.scope, user_decision_ref: f.ref };
+  validateApprovalRecord(record, { requireApproved: true });
+  assert.throws(() => validateApprovalRecord({ ...record, principal_ref: "person.someone-else" }, { requireApproved: true }), /user-decision-responder-mismatch/);
+});
+check("相反原文不能被 Agent 归一化成批准", () => { const f = fixture("false-approval"); f.record.responses = []; f.respond({ text: "不同意，需要修改", decision: "approved" }); deny(f, "user-decision-ambiguous"); });
+check("完整历史展示无需重发模板消息", () => {
+  const f = fixture("historical"); const item = f.record.request.items[0];
+  const text = [item.title, item.subject.ref, item.subject.version, item.changes, item.recommendation, ...item.scope, ...item.next_actions].join("\n");
+  f.record.request.presented_source = f.capture("old-presentation", "agent.orchestrator", "digital-human", "2026-09-05T01:02:00Z", text); f.record.responses = []; f.respond(); verify(f);
+});
+check("同一事项分批批准保留已批准范围", () => {
+  const f = fixture("incremental-scope", { scope: ["scope.a", "scope.b"] }); f.record.responses = [];
+  f.respond({ text: "同意 scope.a", approvedScope: ["scope.a"] });
+  f.respond({ text: "同意 scope.b", approvedScope: ["scope.b"], time: "2026-09-05T01:04:00Z" }); verify(f);
+});
+check("撤回后不能复用旧批准", () => { const f = fixture("revoke"); f.respond({ decision: "revoked", text: "撤回同意", time: "2026-09-05T01:04:00Z" }); deny(f, "user-decision-not-approved"); });
+check("默认生物人门禁纳入解析和 checkpoint", () => {
+  const roles = loadDigitalHumanRoles();
+  for (const gate of ["gate.design-reviewed", "gate.architecture-reviewed", "gate.user-confirmation"]) {
+    assert.equal(countersignRuleForGate(roles.gate_policy, gate).bucket, "biological_human");
+    assert.ok(collectCountersignGateIds(roles.gate_policy).includes(gate));
+    assert.throws(() => assertCheckpointApprovals({ gates: { [gate]: { status: "approved" } } }), /approval_ref/);
+  }
+});
+check("历史数字人记录可读但不能关闭关键门禁", () => {
+  const record = { schema_version: 1, gate_id: "gate.spec-baseline-approved", decision: "approved", actor_kind: "digital-human", role_id: "role.product-manager", runtime_id: "runtime.generic", principal_ref: "instance:product" };
+  validateApprovalRecord(record); assert.throws(() => validateApprovalRecord(record, { requireApproved: true }), /user-decision/);
+  const f = fixture("approval"); Object.assign(record, { subject_ref: f.requirement.subject_ref, approval_scope: f.requirement.scope, user_decision_ref: f.ref }); validateApprovalRecord(record, { requireApproved: true });
+});
+check("等待期间可保存状态但不能流转依赖工作", () => {
+  const f = fixture("workflow", { boundary: "discovery-conclusion" }); const state = { user_decisions: [f.requirement] };
+  assert.equal(validateNextRoute("work-unit.discovery-requirements", "work-unit.spec-synthesis", state).result, "allowed");
+  f.record.responses = []; f.save(); assert.equal(validateNextRoute("work-unit.discovery-requirements", "work-unit.spec-synthesis", state).result, "blocked");
+  assert.equal(validateNextRoute("work-unit.discovery-opportunity", "work-unit.discovery-requirements", state).result, "allowed");
+  assertCheckpointUserDecisions({ repository_mode: "project-instance", status: "paused-human-gate", human_review: { required_decisions: [f.requirement] } });
+  assert.throws(() => assertCheckpointUserDecisions({ repository_mode: "project-instance", status: "running", human_review: { required_decisions: [f.requirement] } }), /user-decision-response-required/);
+});
+check("实施批准绑定切片、合同、仓库、路径和基线", () => {
+  const f = buildImplementationFixture(path.join(root, "implementation"), "docs/.scratch/demo/issues/one.md"); assertImplementationDecision(f.state);
+  assert.throws(() => assertImplementationDecision({ ...f.state, vertical_slice_ticket_ref: "another.md" }), /user-decision-scope-mismatch/);
+  writeFileSync(f.state.slice_contract_ref, "changed"); assert.throws(() => assertImplementationDecision(f.state), /user-decision-stale/);
+});
+process.stdout.write(`用户决定场景验证通过：${count} 组\n`);