create-yss-spec 3.4.1 → 3.4.4

package/template/scripts/lib/slice-contract.mjs

@@ -0,0 +1,211 @@
+import {validateExistingUiBaseline} from './existing-ui-baseline.mjs';
+import {sliceRepositories} from './slice-repositories.mjs';
+import { sliceCheckApplicability } from './slice-applicability.mjs';
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseDocument } from '../vendor/yaml.mjs';
+import { safe, hash, digest, schema } from './strategic-handoff-io.mjs';
+
+const originals = new WeakMap();
+const sourceSnapshots = new WeakMap();
+const nonempty = value => typeof value === 'string' && value.trim();
+const unique = values => [...new Set(values)];
+const fail = message => { throw new TypeError(`slice-contract-invalid: ${message}`); };
+const requireThat = (ok, message) => { if (!ok) fail(message); };
+export const sourceSliceContract = value => originals.get(value) || value?.slice_contract || value;
+export function parseSliceYaml(bytes) {
+  const doc = parseDocument(String(bytes), { uniqueKeys: true, intAsBigInt: true });
+  requireThat(!doc.errors.length, `YAML 无效: ${doc.errors[0]?.message}`);
+  const value = doc.toJS({ maxAliasCount: 0 });
+  const convert = item => {
+    if (typeof item === 'bigint') {
+      requireThat(item <= BigInt(Number.MAX_SAFE_INTEGER) && item >= BigInt(Number.MIN_SAFE_INTEGER), 'YAML 整数超出精确范围，请使用字符串');
+      return Number(item);
+    }
+    if (Array.isArray(item)) return item.map(convert);
+    if (item && typeof item === 'object') return Object.fromEntries(Object.entries(item).map(([k,v]) => [k,convert(v)]));
+    requireThat(typeof item !== 'number' || Number.isFinite(item), 'YAML 非有限数值');
+    return item;
+  };
+  return convert(value);
+}
+export function withinSlicePath(candidate, parent) {
+  if (!nonempty(candidate) || !nonempty(parent)) return false;
+  const rel = path.relative(path.resolve(parent), path.resolve(candidate));
+  return rel === '' || (!path.isAbsolute(rel) && rel !== '..' && !rel.startsWith(`..${path.sep}`));
+}
+function safeWritePath(value) {
+  requireThat(nonempty(value) && !path.isAbsolute(value) && !value.split(/[\\/]/).includes('..') && !/[\x00-\x1f*?{}\[\]]/.test(value), `写范围必须为明确的仓库相对路径: ${value}`);
+}
+export function resolveSliceBasis(contract, key, stack = []) {
+  requireThat(!stack.includes(key), `依据别名循环: ${[...stack,key].join(' -> ')}`);
+  const binding = contract.basis?.[key];
+  requireThat(binding !== undefined, `缺少上游依据 ${key}`);
+  return typeof binding === 'string' ? resolveSliceBasis(contract,binding,[...stack,key]) : binding;
+}
+export function readSliceSources(contract, { root = process.cwd() } = {}) {
+  const result = {}, bytesByPath=new Map();
+  for (const key of Object.keys(contract.basis)) {
+    const binding = resolveSliceBasis(contract,key);
+    const file=safe(root,binding.ref);
+    if(!bytesByPath.has(file))bytesByPath.set(file,fs.readFileSync(file));
+    const bytes=bytesByPath.get(file);
+    requireThat(hash(bytes) === binding.digest, `stale: 上游依据 ${key} 原始字节变化`);
+    result[key] = { ...binding, text: bytes.toString('utf8') };
+  }
+  return result;
+}
+export function sliceArchitectureEvidence(contract,sources) {
+  const identity=contract.resolution.architecture_identity;
+  if(!identity)return undefined;
+  const keys=['engineering_baseline','repository_registration','manifest'];
+  if(identity.schema_version!==2)return Object.fromEntries(keys.map(key=>[key,parseSliceYaml(sources[key].text)]));
+  const registration=parseSliceYaml(sources.repository_registration.text);
+  const evidence={repository_registration:resolveSliceBasis(contract,'repository_registration')};
+  for(const key of ['engineering_baseline','manifest']) {
+    const original=registration.architecture_evidence?.[key],bound=resolveSliceBasis(contract,key);
+    requireThat(original?.ref===bound.ref&&original?.digest===bound.digest,`登记与 ${key} 绑定冲突`);
+    evidence[key]=original;
+  }
+  return evidence;
+}
+function requireKeys(value, names, label) {
+  for (const name of names) requireThat(value[name] !== undefined, `${label} 缺少 ${name}`);
+}
+function locate(text, locator) {
+  if(locator.startsWith('pointer:')) {
+    const value=locator.slice(8).split('/').slice(1).reduce((current,key)=>current?.[key.replaceAll('~1','/').replaceAll('~0','~')],parseSliceYaml(text));
+    requireThat(value!==undefined,`定位缺失: ${locator}`);return JSON.stringify(value);
+  }
+  const lines = text.split('\n');
+  const range = /^lines:(\d+)-(\d+)$/.exec(locator);
+  if (range) {
+    const start=Number(range[1]),end=Number(range[2]);
+    requireThat(start>=1&&end>=start&&end<=lines.length,`定位范围无效: ${locator}`);
+    return lines.slice(start-1,end).join('\n');
+  }
+  const body=text.replace(/^---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/,'');
+  const matches=body.split('\n').filter(line=>line.includes(locator));
+  requireThat(matches.length===1, `定位缺失或不唯一: ${locator}`);
+  return matches[0];
+}
+export function sliceAcceptanceText(contract, sources) {
+  return Object.fromEntries(Object.entries(contract.acceptance).map(([id,item])=>{
+    requireThat(sources[item.source],`验收 ${id} 来源缺失`);
+    return [id,locate(sources[item.source].text,item.locator)];
+  }));
+}
+/** Validate the authoritative v3 document, then expand inherited facts ONLY in memory. */
+export function normalizeSliceContract(document, options = {}) {
+  const raw = sourceSliceContract(document);
+  requireThat(raw && [2,3].includes(raw.schema_version), 'Slice Implementation Contract schema v1 已停止支持；需要 schema v2 或 v3');
+  if (raw.schema_version === 2) return structuredClone(raw);
+  schema(raw,'docs/process/schemas/slice-implementation-contract-v3.schema.json');
+  const sources=readSliceSources(raw,options), refs=Object.fromEntries(Object.entries(sources).map(([key,item])=>[key,item.ref]));
+  requireKeys(refs,['spec','ticket','engineering_baseline','implementation_repository','build_architecture_checklist'],'依据');
+  if(!raw.applicability.checks)requireKeys(refs,['architecture_review'],'依据');
+  else {
+    requireKeys(refs,['lifecycle_registry','process_tailoring'],'适用性依据');
+    const registry=parseSliceYaml(sources.lifecycle_registry.text),expected=sliceCheckApplicability(raw.scope,registry);
+    requireThat(digest(raw.applicability.checks)===digest(expected),'材料适用性与生命周期规则冲突');
+    if(expected['check.architecture-reviewed'].status==='required')requireKeys(refs,['architecture_review'],'命中检查');
+  }
+  if(raw.ticket_policy)requireThat(nonempty(sources.ticket.version),'冻结 Ticket 缺少需求版本');
+  const extension=raw.extensions || {}, scope=raw.scope, resolution=structuredClone(raw.resolution);
+  if(raw.ticket_policy&&scope.project_roots.length>1)requireThat(extension.cross_repo?.repository_bindings,'新跨仓草案缺少逐仓登记绑定');
+  const repositories=sliceRepositories(raw,sources,options);
+  for (const key of ['frontend','backend','api','cross_repo']) {
+    const item=raw.applicability[key];
+    if (item.status === 'required') requireThat(extension[key],`命中 ${key} 影响但缺少子合同`);
+    else {
+      requireThat(nonempty(item.reason),`${key} 不适用缺少理由`);
+      requireThat(!extension[key],`${key} 不适用时不得保存空子合同`);
+    }
+  }
+  for(const [impact,section]of [['frontend','frontend'],['ui','frontend'],['backend','backend'],['api','api'],['cross-repo','cross_repo']])if(scope.impacted_areas.includes(impact))requireThat(raw.applicability[section].status==='required',`影响面 ${impact} 与适用性冲突`);
+  if(scope.impacted_areas.some(x=>['data','persistence'].includes(x)))requireKeys(refs,['data_architecture'],'数据依据');
+  if (extension.frontend && raw.applicability.frontend.baseline_kind==='existing-ui-baseline') {
+    requireThat(raw.applicability.frontend.ui_change==='none'&&!scope.impacted_areas.includes('ui'),'既有 UI 基线不能承接 UI 变化');
+    requireKeys(refs,['existing_ui_baseline','frontend_delivery'],'既有 UI 依据');
+    const observed=parseSliceYaml(sources.existing_ui_baseline.text);
+    const validation=validateExistingUiBaseline(observed,{bundleRoot:path.dirname(safe(options.root||process.cwd(),sources.existing_ui_baseline.ref))});
+    requireThat(validation.errors.length===0,`既有 UI 基线不可消费: ${validation.errors.join('; ')}`);
+    requireThat(extension.frontend.visual_baseline_case_ids.every(id=>observed.cases.some(c=>c.case_id===id)),'既有 UI 用例未被基线覆盖');
+  } else if (extension.frontend) requireKeys(refs,['requirement_freeze','low_fidelity_review','prototype_review','prototype_profile_decision','prototype_deliverable','prototype_deliverable_verification','prototype_confirmation','visual_baseline','state_matrix'],'前端依据');
+  if (extension.backend) {
+    requireKeys(refs,['technical_design','repository_registration','manifest','backend_repository','maven_wrapper'],'后端依据');
+    requireThat(resolution.architecture_identity||repositories&&Object.values(repositories).some(r=>r.resolution.architecture_identity),'后端缺少架构身份');
+    requireThat(nonempty(sources.technical_design.version),'技术设计缺少版本');
+    for (const selector of extension.backend.design_refs) locate(sources.technical_design.text,selector);
+  }
+  requireKeys(refs,[extension.api?'openapi_freeze':'no_api_impact_record'],'API 依据');
+  requireThat(!refs[extension.api?'no_api_impact_record':'openapi_freeze'],'API 影响结论冲突');
+  for (const p of scope.allowed_write_paths) safeWritePath(p);
+  requireThat(!scope.project_roots.some(p=>/^app\/(backend|frontend)(\/|$)/.test(p)), '禁止 app/backend 或 app/frontend');
+  if (scope.implementation_path_policy !== 'external-repository-native') for(const p of scope.project_roots) requireThat(/^apps\/(backend|frontend)\/[^/]+/.test(p),'Harness 工程必须落入具体 project 目录');
+  sliceAcceptanceText(raw,sources);
+  const unitIds=new Set(), usedChecks=new Set(), covered=new Set();
+  const expected=Object.keys(raw.acceptance);
+  for(const [id,check] of Object.entries(raw.verification)) {
+    requireThat(scope.project_roots.some(p=>withinSlicePath(check.cwd,p)),`验证 ${id} 的 cwd 未登记`);
+    if(check.dependency_roots)requireThat(repositories&&check.dependency_roots.every(p=>repositories[p]),`验证 ${id} 依赖仓库未登记`);
+    requireThat(check.acceptance_refs.length && check.acceptance_refs.every(ref=>expected.includes(ref)),`验证 ${id} 验收引用无效`);
+  }
+  const work_units=raw.work_units.map(unit=>{
+    requireThat(!unitIds.has(unit.id),`工作单元重复: ${unit.id}`);unitIds.add(unit.id);
+    const allowed=unit.allowed_write_paths || scope.allowed_write_paths;
+    for(const p of allowed) { safeWritePath(p);requireThat(scope.allowed_write_paths.some(parent=>withinSlicePath(p,parent)),`任务 ${unit.id} 写范围越界: ${p}`); }
+    const root=unit.project_root || (scope.project_roots.length===1?scope.project_roots[0]:null);
+    requireThat(scope.project_roots.includes(root),`任务 ${unit.id} 必须选择登记的 project_root`);
+    const checks=unique([...Object.keys(raw.verification).filter(id=>raw.verification[id].required_for_all),...unit.verification_refs]);
+    requireThat(checks.every(id=>raw.verification[id]),`任务 ${unit.id} 引用未知验证`);
+    requireThat(checks.every(id=>withinSlicePath(raw.verification[id].cwd,root)),`任务 ${unit.id} 验证执行仓库冲突`);
+    const skills=[unit.primary_skill,...(unit.supporting_skills || [])];
+    requireThat(skills.every(id=>resolution.required_skills.includes(id)),`任务 ${unit.id} Skill 不在冻结闭包内`);
+    requireThat(unit.acceptance_refs.every(id=>expected.includes(id)&&checks.some(k=>raw.verification[k].acceptance_refs.includes(id))),`任务 ${unit.id} 验收没有验证覆盖`);
+    for(const id of unit.acceptance_refs)covered.add(id);
+    for(const id of checks)usedChecks.add(id);
+    if(unit.tdd_mode==='controlled-generation') {
+      requireThat(unit.controlled_generation,'controlled-generation 缺少受控例外');
+      requireKeys(unit.controlled_generation,['exception_reason','generator','generator_inputs','expected_files','verification_commands','behavior_tests_after_generation'],'受控生成');
+    } else requireThat(!unit.controlled_generation,'行为测试不得携带受控生成例外');
+    const work_unit={...unit,allowed_write_paths:allowed,project_root:root,supporting_skills:unit.supporting_skills||[],verification:checks.map(id=>({id,...raw.verification[id]})),verification_commands:checks.map(id=>raw.verification[id].command),expected_evidence:unique(checks.flatMap(id=>raw.verification[id].expected_evidence)),forbidden_patterns:unique([...(scope.forbidden_patterns||[]),...(unit.forbidden_patterns||[])])};
+    return {...work_unit,contract_id:raw.contract_id,contract_version:raw.contract_version,work_unit};
+  });
+  requireThat(expected.every(id=>covered.has(id)), '存在未被工作单元覆盖的验收');
+  requireThat(Object.keys(raw.verification).every(id=>usedChecks.has(id)),'存在未分配的验证要求');
+  if(repositories)for(const id of extension.cross_repo.integration_verification)requireThat(raw.verification[id]?.dependency_roots?.length,'联合验证必须引用有依赖仓库和明确 cwd 的 verification');
+  const allChecks=Object.values(raw.verification);
+  resolution.freshness='current'; // Only after every bound source was read and verified above.
+  if(resolution.architecture_identity) {
+    resolution.architecture_identity_digest=digest(resolution.architecture_identity).slice(7);
+    resolution.architecture_evidence=sliceArchitectureEvidence(raw,sources);
+  }
+  if(refs.technical_design)resolution.technical_design=resolveSliceBasis(raw,'technical_design');
+  if(refs.frontend_delivery)resolution.frontend_delivery={acceptance_ref:refs.frontend_delivery,digest:sources.frontend_delivery.digest};
+  const common={...scope,required_capabilities:resolution.required_capabilities,required_skills:resolution.required_skills,verification_commands:allChecks.map(c=>c.command),expected_evidence_files:unique(allChecks.flatMap(c=>c.expected_evidence)),quality_baseline_ref:refs.engineering_baseline,forbidden_patterns:scope.forbidden_patterns||[],full_reroute_triggers:scope.full_reroute_triggers||[]};
+  const normalized={...structuredClone(raw),...(repositories?{repositories}:{}),common,resolution,lifecycle_refs:{...refs,openapi_freeze_or_no_impact:refs.openapi_freeze||refs.no_api_impact_record},readiness:{blockers:[],stale_inputs:[],not_applicable:Object.entries(raw.applicability).filter(([,a])=>a.status==='not-applicable').map(([item,a])=>({item,reason:a.reason}))},work_units,
+    frontend:extension.frontend?{status:'required',...extension.frontend,approved_prototype_ref:refs.prototype_confirmation,state_matrix_ref:refs.state_matrix,visual_baseline_ref:refs.visual_baseline,...(resolution.frontend_delivery?{delivery:resolution.frontend_delivery}:{})}:{status:'not-applicable'},
+    backend:extension.backend?{status:'required',...extension.backend}:{status:'not-applicable'},
+    contract:{api_impact:!!extension.api,...(extension.api?{freeze_ref:refs.openapi_freeze,...extension.api}:{no_api_impact_ref:refs.no_api_impact_record})},
+    cross_repo:extension.cross_repo?{repositories:scope.project_roots,...extension.cross_repo}:{}
+  };
+  originals.set(normalized,raw);
+  sourceSnapshots.set(normalized,sources);
+  return normalized;
+}
+export function readSliceContract(ref,{root=process.cwd(),diagnostic=false}={}) {
+  const bytes=fs.readFileSync(safe(root,ref)),raw=sourceSliceContract(parseSliceYaml(bytes));
+  const contract=diagnostic&&raw.status==='blocked'?null:normalizeSliceContract(raw,{root});
+  return {contract,raw,sources:structuredClone(sourceSnapshots.get(contract)||{}),binding:{ref,id:raw.contract_id,version:raw.contract_version,digest:hash(bytes)}};
+}
+
+/** Select only after full normalization; original raw identity is retained for approval comparison. */
+export function selectSliceWorkUnit(contract,workUnitId) {
+ if(!contract.repositories)return contract;
+ const unit=contract.work_units.find(u=>u.id===workUnitId);
+ requireThat(unit,'跨仓执行必须选择唯一 work_unit_id');
+ const repo=contract.repositories[unit.project_root];
+ const selected={...contract,backend:repo.project.delivery_role==='backend'?contract.backend:{status:'not-applicable'},frontend:repo.project.delivery_role==='frontend'?{...contract.frontend,...(repo.resolution.frontend_delivery?{delivery:repo.resolution.frontend_delivery}:{})}:{status:'not-applicable'},resolution:{...repo.resolution,freshness:contract.resolution.freshness},common:{...contract.common,project_roots:[unit.project_root],allowed_write_paths:unit.allowed_write_paths},lifecycle_refs:{...contract.lifecycle_refs,...Object.fromEntries(Object.entries(repo.basis).map(([k,v])=>[k,v.ref]))}};
+ originals.set(selected,sourceSliceContract(contract));return selected;
+}

package/template/scripts/lib/slice-repositories.mjs

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import * as lifecycle from './lifecycle-transition.mjs';
+import path from 'node:path';
+import {digest,schema} from './strategic-handoff-io.mjs';
+import {parseSliceYaml,resolveSliceBasis,withinSlicePath,sliceArchitectureEvidence} from './slice-contract.mjs';
+const check=(ok,message)=>{if(!ok)throw new TypeError(`slice-repository-invalid: ${message}`);};
+/** All file facts stay in basis. Repository entries only select those facts. */
+export function sliceRepositories(contract,sources,{root=process.cwd()}={}) {
+ const bindings=contract.extensions?.cross_repo?.repository_bindings;if(!bindings)return null;
+ check(lifecycle.SLICE_REPOSITORY_PREPARATION_PROTOCOL===1&&typeof lifecycle.validateImplementationRepositoriesReady==='function','接收端不支持当前来源的多项目准备协议，不能套用本地默认规则');
+ check(sources.repository_preparation,'缺少多项目准备结果');
+ const preparation=parseSliceYaml(sources.repository_preparation.text);
+ schema(preparation,'docs/process/schemas/implementation-repository-preparation-result.schema.json');
+ const ready=lifecycle.validateImplementationRepositoriesReady({implementation_repository_preparation:preparation,delivery_impacts:Object.fromEntries(['backend','frontend'].map(role=>[role,preparation.projects.some(p=>p.delivery_role===role&&p.status!=='not-applicable')]))},{root,exists:ref=>fs.existsSync(path.resolve(root,ref)),read:ref=>fs.readFileSync(path.resolve(root,ref),'utf8')});
+ check(ready.result!=='blocked',`多项目准备未就绪: ${ready.missing_requirements.join('; ')}`);
+ check(new Set(Object.keys(bindings).map(p=>path.resolve(p))).size===Object.keys(bindings).length,'工程根存在路径别名，不能重复登记');
+ const result={},identities=new Set();
+ for(const [projectRoot,keys]of Object.entries(bindings)) {
+  const references=Object.entries(keys).filter(([name])=>!['recipe_refs','capability_refs'].includes(name));
+  const selected=Object.fromEntries(references.map(([name,key])=>{check(sources[key],`缺少 basis.${key}`);return[name,sources[key]];}));
+  const registration=parseSliceYaml(selected.implementation_repository.text),baseline=parseSliceYaml(selected.engineering_baseline.text);
+  const actual=path.resolve(registration.local_worktree,registration.project_root||'.');
+  check(path.resolve(projectRoot)===actual,'工程根与逐仓登记冲突');
+  const project=preparation.projects.filter(p=>p.project_id===registration.project_id&&p.repository_ref===selected.implementation_repository.ref);
+  check(project.length===1&&project[0].status!=='not-applicable'&&path.resolve(project[0].project_root)===actual,'准备结果没有唯一当前工程');
+  const identityKey=JSON.stringify([registration.repository_id,registration.project_id]);check(!identities.has(identityKey),'同一仓库工程不能重复绑定');identities.add(identityKey);
+  check(registration.status==='current'&&baseline.status==='current','逐仓登记或基线非 current');
+  check(registration.repository_id===baseline.repository_id&&registration.project_id===baseline.project_id,'逐仓基线身份冲突');
+  check(Array.isArray(registration.allowed_write_paths)&&registration.allowed_write_paths.length,'登记缺少写边界');
+  if(project[0].delivery_role==='backend')check(selected.technical_design&&project[0].design_prerequisites.technical_design.digest===selected.technical_design.digest&&project[0].design_prerequisites.technical_design.ref===selected.technical_design.ref,'多项目准备与切片技术设计绑定冲突');
+  const identity=baseline.architecture_identity||registration.architecture_identity;
+  if(baseline.architecture_identity&&registration.architecture_identity)check(digest(baseline.architecture_identity)===digest(registration.architecture_identity),'逐仓架构冲突');
+  const basis=Object.fromEntries(references.map(([name,key])=>[name,resolveSliceBasis(contract,key)]));
+  basis.repository_registration??=basis.implementation_repository;
+  selected.repository_registration??=selected.implementation_repository;
+  const resolution={...contract.resolution};delete resolution.architecture_identity;
+  if(identity){resolution.architecture_identity=identity;resolution.architecture_identity_digest=digest(identity).slice(7);resolution.architecture_evidence=sliceArchitectureEvidence({basis,resolution},selected);}
+  if(basis.technical_design)resolution.technical_design=basis.technical_design;
+  if(basis.frontend_delivery)resolution.frontend_delivery={acceptance_ref:basis.frontend_delivery.ref,digest:basis.frontend_delivery.digest};
+  result[projectRoot]={registration,project:project[0],basis,resolution,recipe_refs:keys.recipe_refs,capability_refs:keys.capability_refs};
+ }
+ check(Object.keys(result).length===contract.scope.project_roots.length&&contract.scope.project_roots.every(p=>result[p]),'多仓绑定必须完整覆盖工程根');
+ for(const key of ['delivery_order','rollback_order'])check(contract.extensions.cross_repo[key].length===Object.keys(result).length&&contract.extensions.cross_repo[key].every(p=>result[p]),`${key} 必须完整且唯一列出工程根`);
+ for(const unit of contract.work_units) {
+  const repo=result[unit.project_root];check(repo,`工作单元 ${unit.id} 未选择唯一工程`);
+  check((unit.allowed_write_paths||contract.scope.allowed_write_paths).every(p=>repo.registration.allowed_write_paths.some(parent=>withinSlicePath(p,parent))),`工作单元 ${unit.id} 超出逐仓登记`);
+ }
+ return result;
+}

package/template/scripts/lib/slice-task-package.mjs

@@ -0,0 +1,66 @@
+import {enforceHarnessTaskScope} from './harness-execution-scope.mjs';
+import { readFileSync } from 'node:fs';
+import { ROOT, hash, safe, digest } from './strategic-handoff-io.mjs';
+import { normalizeSliceContract, withinSlicePath, parseSliceYaml } from './slice-contract.mjs';
+import { createApprovedExecutionContext, assertApprovedExecutionContext } from './approved-execution-context.mjs';
+import { assertImplementationDecision } from './user-decision.mjs';
+import { taskPackageDefaults, loadDigitalHumanRoles } from './digital-human-roles.mjs';
+import { validateTaskPackageSchema } from './task-package-schema.mjs';
+const fail=message=>{throw new TypeError(message);};
+const equalArrays=(a,b)=>Array.isArray(a)&&a.length===b.length&&a.every((x,i)=>x===b[i]);
+function generateTaskPackageDefaults(roleId,overrides,{rolesDoc}={}) {
+  const defaults=taskPackageDefaults(roleId,rolesDoc||loadDigitalHumanRoles());
+  return {schema_version:1,role_id:roleId,skill_source:{registry_ref:'docs/agents/digital-human-roles.yaml',defaults_ref:`taskPackageDefaults(${roleId})`,core_skills:defaults.core_skills,forbidden_skills:defaults.forbidden_skills},...overrides};
+}
+
+/** Compile dispatch from the approved YAML. Only runtime identity and task ID come from the caller. */
+export function compileSliceTaskPackage(binding,{root=ROOT,work_unit_id,task_id,actor_id,runtime_id,execution_state='Worker',rolesDoc,user_decisions}={}) {
+  const actualRoles=parseSliceYaml(readFileSync(safe(root,'docs/agents/digital-human-roles.yaml')));
+  if(rolesDoc&&digest(rolesDoc)!==digest(actualRoles))fail('调用方不能替换接收端角色能力');
+  rolesDoc=actualRoles;
+  if(!actualRoles.runtimes.some(runtime=>runtime.id===runtime_id))fail('接收端不支持该 runtime_id');
+  const execution=createApprovedExecutionContext(binding,{root,work_unit_id});
+  const {contract}=assertApprovedExecutionContext(execution,{root});
+  if(contract.schema_version!==3)fail('v3 派发编译入口只接受 v3；v2 保留原派发路径');
+  const unit=contract.work_units.find(item=>item.id===work_unit_id);
+  if(!unit)fail('未找到指定 Slice 工作单元');
+  const checkpoint=readSliceDispatchApproval(root,binding.approval_ref);
+  const decisions=user_decisions||checkpoint.human_review?.user_decisions;
+  const output=generateTaskPackageDefaults(unit.role_id,{
+    task_id,work_unit_id,actor_id,runtime_id,execution_state,workflow_status:'not-started',stage_id:'stage.vertical-slice-implementation',
+    contract:{kind:'slice-implementation',contract_id:contract.contract_id,contract_version:contract.contract_version,status:'issued',contract_ref:binding.ref,slice_contract_ref:binding.ref,gate_refs:[binding.approval_ref]},
+    inputs:[binding.ref,...new Set(Object.values(contract.lifecycle_refs))],
+    objective:`${unit.behavior}（执行目录：${unit.project_root}；完整约束读取 ${binding.ref}）`,
+    allowed_write_paths:unit.allowed_write_paths,forbidden_actions:[...unit.work_unit.forbidden_patterns,'来源过期、越界、缺证据、验证失败或新增影响时停止并回交'],
+    expected_outputs:[unit.behavior],expected_evidence_files:unit.work_unit.expected_evidence,verification_commands:unit.work_unit.verification_commands,verification_results:[],
+    downstream_consumers:unit.downstream_consumers||['role.lifecycle-orchestrator'],convergence:{parent_work_unit:'work-unit.slice-implementation',convergence_ref:unit.convergence_ref||binding.approval_ref,conflict_escalation:'返回生命周期主控'},user_decisions:decisions
+  },{rolesDoc});
+  enforceHarnessTaskScope(output,{root});
+  validateTaskPackageSchema(output);
+  assertSliceV3TaskPackage(output,contract,{root});
+  return output;
+}
+function readSliceDispatchApproval(root,ref) {return parseSliceYaml(readFileSync(safe(root,ref)));}
+export function assertSliceV3TaskPackage(value,slice,{root=ROOT}={}) {
+  enforceHarnessTaskScope(value,{root});
+  const contract=value.contract;
+  const current=normalizeSliceContract(slice,{root});
+  const roles=parseSliceYaml(readFileSync(safe(root,'docs/agents/digital-human-roles.yaml'))),defaults=taskPackageDefaults(value.role_id,roles);
+  if(!roles.runtimes.some(runtime=>runtime.id===value.runtime_id)||!defaults.stages.includes(value.stage_id))fail('接收端角色或运行时不支持当前任务');
+  if(!equalArrays(value.skill_source.core_skills,defaults.core_skills)||!equalArrays(value.skill_source.forbidden_skills,defaults.forbidden_skills))fail('任务角色能力与接收端不一致');
+  const unit=current.work_units.find(item=>item.id===value.work_unit_id);
+  if(unit&&[unit.primary_skill,...(unit.supporting_skills||[])].some(skill=>defaults.forbidden_skills.includes(skill)))fail('工作单元使用接收角色禁用 Skill');
+  if(!unit||unit.role_id!==value.role_id||current.contract_id!==contract.contract_id||current.contract_version!==contract.contract_version)fail('任务身份与 Slice v3 不一致');
+  if(!Array.isArray(contract.gate_refs)||contract.gate_refs.length!==1)fail('Slice v3 派发需要唯一批准 checkpoint 引用');
+  const bytes=readFileSync(safe(root,contract.slice_contract_ref));
+  const execution=createApprovedExecutionContext({ref:contract.slice_contract_ref,digest:hash(bytes),id:current.contract_id,version:current.contract_version,approval_ref:contract.gate_refs[0]},{root,work_unit_id:value.work_unit_id});
+  assertApprovedExecutionContext(execution,{root,contract:current});
+  for(const allowed of value.allowed_write_paths)if(!unit.allowed_write_paths.some(parent=>withinSlicePath(allowed,parent)))fail('任务写范围超出 Slice v3');
+  for(const key of ['verification_commands','expected_evidence_files']) {
+    const required=key==='verification_commands'?unit.work_unit.verification_commands:unit.work_unit.expected_evidence;
+    if(!equalArrays(value[key],required))fail(`任务包遗漏或替换 Slice v3 ${key}`);
+  }
+  for(const item of unit.work_unit.forbidden_patterns)if(!value.forbidden_actions.includes(item))fail('任务包遗漏全局约束');
+  if(value.execution_state==='Worker')assertImplementationDecision({slice_contract_ref:contract.slice_contract_ref,vertical_slice_ticket_ref:current.lifecycle_refs.ticket,user_decisions:value.user_decisions},{root});
+  return value;
+}

package/template/scripts/lib/strategic-handoff-io.mjs

@@ -78,6 +78,13 @@ export function sourceApprovalPolicy(source) {
   roles.user_decision_policy ||= {gates:[]};
   ensure(!(roles.user_decision_policy.required_capabilities || []).some(id => id !== 'strategic-decision-reuse-v1'), '接收工具不支持源用户决定策略，请升级工具后验包');
   const policy=roles.gate_policy;
+  // Dedicated receivers may predate check_reviews. Mirror source check-review
+  // rules into their existing digital review lookup without changing source bytes.
+  for(const rule of policy.check_reviews || []) {
+    if(!(policy.digital_human_review||[]).some(x=>x.gate===rule.gate) && !(policy.dual_digital_human||[]).some(x=>x.gate===rule.gate)) {
+      policy.digital_human_review ||= [];policy.digital_human_review.push({gate:rule.gate,drafter:rule.drafter,countersigners:[...rule.countersigners]});
+    }
+  }
   for(const gate of policy.product_digital_human_with_biological_veto || []) {
     if(!(policy.biological_human||[]).includes(gate) && !(policy.digital_human_review||[]).some(x=>x.gate===gate) && !(policy.dual_digital_human||[]).some(x=>x.gate===gate)) {
       policy.digital_human_review ||= [];policy.digital_human_review.push({gate,countersigners:['role.product-manager']});

package/template/scripts/lib/strategic-handoff.mjs

@@ -20,6 +20,19 @@ const SOURCE_SCHEMAS = new Map([
 ]);
 const CAPABILITIES=['backend-technical-design','frontend-engineering-design','delivery-coordination'];
 
+function sourceApprovalRecord(document, gateId) {
+  if(document?.kind!=='review-bundle')return document;
+  for(const field of ['bundle_id','task_id','work_unit_id','review_session_id','role_id','runtime_id','principal_ref'])ensure(nonempty(document[field]),`组合审查缺少 ${field}`);
+  ensure(Array.isArray(document.reviews)&&document.reviews.length,'组合审查不能为空');
+  ensure(new Set(document.reviews.map(row=>row?.gate_id)).size===document.reviews.length,'组合审查 gate_id 重复');
+  const rows=document.reviews.filter(row=>row.gate_id===gateId);
+  ensure(rows.length===1,`组合审查缺少当前结论: ${gateId}`);
+  const row=rows[0];
+  ensure(row.role_id===document.role_id&&row.runtime_id===document.runtime_id&&row.principal_ref===document.principal_ref,'组合审查必须来自同一复核角色、运行时和实例');
+  ensure(!row.review_session_id||row.review_session_id===document.review_session_id,'组合审查 review_session_id 不一致');
+  return {...row,review_bundle_id:document.bundle_id,review_task_id:document.task_id,review_work_unit_id:document.work_unit_id,review_session_id:document.review_session_id};
+}
+
 function deliveryReadme(handoff) {
   const sources=Object.entries(handoff.source).sort(([a],[b])=>a.localeCompare(b)).map(([key,value])=>`- \`${key}\`: \`${value.persisted_ref}\` (${value.version}, ${value.digest})`);
   const routes=handoff.consumer_routes.map(route=>`- \`${route.capability}\`: \`${route.activation}\` (${route.route_id})`);
@@ -75,6 +88,17 @@ export async function sourceApproval(record, roles, root) {
     const { assertApprovalUserDecision } = await import('./user-decision-reuse.mjs');
     assertApprovalUserDecision(record, roles, options);
   }
+  // Older dedicated receivers retain their own lifecycle policy. Normalize only
+  // this already-verified source approval, without granting local capabilities.
+  if (record.continuation_ref) {
+    ensure(roles.user_decision_policy.gates.includes(record.gate_id), '未登记的源延续批准边界');
+    const reviewers = roles.gate_policy.continuation_reviews?.[record.gate_id];
+    ensure(reviewers?.includes(record.role_id) && record.drafter_principal_ref && record.drafter_principal_ref !== record.principal_ref, '源授权延续缺少独立审查身份');
+    options.rolesDoc = structuredClone(roles);
+    const policy = options.rolesDoc.gate_policy;
+    policy.dual_digital_human = (policy.dual_digital_human || []).filter(x => x.gate !== record.gate_id);
+    policy.digital_human_review = [...(policy.digital_human_review || []).filter(x => x.gate !== record.gate_id), { gate: record.gate_id, countersigners: reviewers }];
+  }
   validateApprovalRecord(record,options);
 }
 
@@ -160,13 +184,14 @@ export async function inspectSource(root, handoffRef) {
   const indexes=extractTraceability(strategy);
   const sourceRoles=read(safe(root,'docs/agents/digital-human-roles.yaml'));
   const roles=sourceApprovalPolicy(sourceRoles);
-  for (const [artifact, version] of [[strategy,strategy.domain_version],[stage,stage.package_version]]) {
-    if(artifact.approval) { const record=read(safe(root,artifact.approval.approval_ref));await sourceApproval(record,roles,root);ensure(artifact.approval.current_version===version,'资产内置批准版本过期'); }
+  for (const [artifact, version, gateId] of [[strategy,strategy.domain_version,'check.domain-strategy-approved'],[stage,stage.package_version,'check.stage-decision-package-approved']]) {
+    if(artifact.approval) { const record=sourceApprovalRecord(read(safe(root,artifact.approval.approval_ref)),gateId);await sourceApproval(record,roles,root);ensure(artifact.approval.current_version===version,'资产内置批准版本过期'); }
   }
   // Source packages retain their published approval vocabulary. Never promote old approvals into current checkpoint gates.
   const currentPlan = (roles.gate_policy.dual_digital_human || []).some(rule => rule.gate === 'gate.plan-approved');
-  const terminalGate=currentPlan?'gate.plan-approved':countersignRuleForGate(roles.gate_policy,'gate.strategic-design-handoff-approved')?'gate.strategic-design-handoff-approved':'gate.stage-decision-package-approved';
-  const expectedGates={domain_strategy_ref:currentPlan?'gate.plan-approved':'gate.domain-strategy-approved',stage_decision_package_ref:currentPlan?'gate.plan-approved':'gate.stage-decision-package-approved',spec_ref:'gate.spec-baseline-approved',prototype_ref:currentPlan?'gate.product-design-approved':'gate.user-confirmation',visual_baseline_ref:currentPlan?'gate.product-design-approved':'gate.user-confirmation',business_ticket_set_ref:terminalGate,handoff:terminalGate};
+  const explicitlyReviewed=(gate)=>(roles.gate_policy.digital_human_review||[]).some(rule=>rule.gate===gate)||(roles.gate_policy.dual_digital_human||[]).some(rule=>rule.gate===gate)||(roles.gate_policy.biological_human||[]).includes(gate);
+  const terminalGate=currentPlan||explicitlyReviewed('gate.strategic-design-handoff-approved')?'gate.strategic-design-handoff-approved':'gate.stage-decision-package-approved';
+  const expectedGates={domain_strategy_ref:currentPlan?'gate.plan-approved':'gate.domain-strategy-approved',stage_decision_package_ref:currentPlan?'gate.plan-approved':'gate.stage-decision-package-approved',spec_ref:'gate.spec-baseline-approved',prototype_ref:currentPlan?'gate.product-design-approved':'gate.user-confirmation',visual_baseline_ref:currentPlan?'gate.product-design-approved':'gate.user-confirmation',business_ticket_set_ref:currentPlan?'gate.plan-approved':terminalGate,handoff:terminalGate};
   expectedGates.existing_ui_baseline_ref=expectedGates.prototype_ref;
   const bindings={...handoff.source,handoff:{id:handoff.handoff_id,version:handoff.handoff_version,persisted_ref:handoffRef,status:'approved'}};
   for(const [key,ref] of Object.entries(bindings)) {
@@ -183,14 +208,14 @@ export async function inspectSource(root, handoffRef) {
       }
     } else actual=bytesDigest(readFileSync(safe(root,ref.persisted_ref)),approval.digest_kind);
     if(key!=='handoff')ensure(ref.digest===actual,`源资产摘要过期: ${key}`);
-    const record=read(safe(root,approval.record_ref));
+    const record=sourceApprovalRecord(read(safe(root,approval.record_ref)),approval.gate_id);
     if(key==='existing_ui_baseline_ref')ensure(record.subject_ref===`${ref.persisted_ref}/${ref.manifest_ref}`,'既有 UI 用户决定必须以当前 manifest 为批准主体');
     await sourceApproval(record,roles,root);
     ensure(record.gate_id===approval.gate_id,`批准门禁不匹配: ${key}`);
     ensure((record.artifact_bindings || []).some(x=>x.id===(ref.id||ref.baseline_id) && x.version===ref.version && x.digest===actual),`批准记录未绑定当前资产: ${key}`);
   }
   if (roles.user_decision_policy.required_capabilities?.includes('strategic-decision-reuse-v1')) {
-    const record=read(safe(root,config.approvals.handoff.record_ref));
+    const record=sourceApprovalRecord(read(safe(root,config.approvals.handoff.record_ref)),config.approvals.handoff.gate_id);
     const scope=read(safe(root,record.subject_ref));
     ensure(scope.kind==='strategic-delivery-scope' && scope.schema_version===1, '交接必须绑定独立的交付范围清单');
     const {package_export,status,...delivery}=handoff;
@@ -198,7 +223,7 @@ export async function inspectSource(root, handoffRef) {
     ensure(scope.assets?.some(asset=>asset.ref===scope.delivery_ref && asset.digest===hash(readFileSync(safe(root,scope.delivery_ref)))), '交接内容快照缺少批准覆盖');
     for (const [key,ref] of Object.entries(handoff.source)) {
       const file=['visual_baseline_ref','existing_ui_baseline_ref'].includes(key)?`${ref.persisted_ref}/${ref.manifest_ref}`:ref.persisted_ref;
-      const decisionBoundaries=key==='business_ticket_set_ref'?['gate.spec-baseline-approved',terminalGate]:[expectedGates[key]];
+      const decisionBoundaries=[expectedGates[key]];
       ensure(scope.assets?.some(asset=>asset.ref===file && asset.version===ref.version && decisionBoundaries.includes(asset.boundary) && asset.digest===hash(readFileSync(safe(root,file)))), `交付范围清单遗漏当前资产: ${key}`);
     }
   }
@@ -217,7 +242,7 @@ function collect(root, handoffRef, handoff, config) {
   const enqueue=ref=> { if(symbolic[ref])queue.push(symbolic[ref]); else if(/^https?:\/\//i.test(ref))return; else if(ref.startsWith('evidence.'))throw new TypeError(`未解析 evidence ID: ${ref}`); else if(ref.includes('/') || /\.(?:md|yaml|json|html|png|txt|log)$/.test(ref))queue.push(ref); };
   function refs(value,key='') {
     if(Array.isArray(value)) { if(key==='evidence_refs') value.forEach(enqueue); else value.forEach(v=>refs(v,key)); }
-    else if(value && typeof value==='object') for(const [k,v]of Object.entries(value)) { if(['approval_ref','persisted_ref','user_decision_ref','decision_reuse_ref','scope_ref','subject_ref','delivery_ref'].includes(k)&&typeof v==='string')enqueue(v); else if(k==='ref'&&typeof v==='string'&&!/^[a-z]+:\/\//i.test(v))enqueue(v); else refs(v,k); }
+    else if(value && typeof value==='object') for(const [k,v]of Object.entries(value)) { if(['approval_ref','persisted_ref','user_decision_ref','decision_reuse_ref','continuation_ref','plan_continuation_ref','scope_ref','subject_ref','delivery_ref'].includes(k)&&typeof v==='string')enqueue(v); else if(k==='ref'&&typeof v==='string'&&!/^[a-z]+:\/\//i.test(v))enqueue(v); else refs(v,k); }
   }
   let totalBytes = 0;
   while(queue.length) {

package/template/scripts/lib/task-package.mjs

@@ -1,3 +1,6 @@
+import { normalizeSliceContract } from './slice-contract.mjs';
+import { assertSliceV3TaskPackage } from './slice-task-package.mjs';
+export { compileSliceTaskPackage, assertSliceV3TaskPackage } from './slice-task-package.mjs';
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { parseDocument } from "../vendor/yaml.mjs";
@@ -178,11 +181,12 @@ function validateContract(value, registry, lifecycle) {
   const contractPath = assertSafeRelativePath(contract.slice_contract_ref, "contract.slice_contract_ref");
   if (!existsSync(contractPath)) fail(`Slice Implementation Contract 不存在: ${contract.slice_contract_ref}`);
   const document = parseYaml(readFileSync(contractPath, "utf8"), "Slice Implementation Contract");
-  const slice = document.slice_contract || document;
-  if (slice.schema_version !== 2 || typeof slice.slice_id !== "string" || !slice.lifecycle_refs || !slice.readiness || !Array.isArray(slice.work_units)) fail("Slice Implementation Contract 需要 schema v2 及 slice_id/lifecycle_refs/readiness/work_units");
+  const slice = normalizeSliceContract(document,{root:ROOT});
+  if (![2,3].includes(slice.schema_version) || typeof slice.slice_id !== "string" || !slice.lifecycle_refs || !slice.readiness || !Array.isArray(slice.work_units)) fail("Slice Implementation Contract 需要 schema v2 及 slice_id/lifecycle_refs/readiness/work_units");
   if (slice.contract_id !== contract.contract_id || slice.contract_version !== contract.contract_version || slice.status !== "approved") fail("Slice Contract 必须是当前 approved 版本");
   const sliceUnit = slice.work_units.find((item) => item && item.id === value.work_unit_id);
   if (!sliceUnit) fail(`Slice Implementation Contract 缺少 work_unit_id: ${value.work_unit_id}`);
+  if(slice.schema_version===3)return assertSliceV3TaskPackage(value,slice,{root:ROOT});
   for (const field of ["role_id", "runtime_id", "task_package_ref", "contract_id", "contract_version", "allowed_write_paths"]) if (sliceUnit[field] === undefined) fail(`Slice Contract work_unit 缺少 ${field}`);
   if (sliceUnit.role_id !== value.role_id || sliceUnit.runtime_id !== value.runtime_id || sliceUnit.contract_id !== contract.contract_id || sliceUnit.contract_version !== contract.contract_version) fail("任务包与 Slice Contract work_unit 不一致");
   for (const allowed of value.allowed_write_paths) if (!sliceUnit.allowed_write_paths.includes(allowed)) fail(`allowed_write_paths 未获 Slice Contract 授权: ${allowed}`);

package/template/scripts/lib/technical-design-boundary.mjs

@@ -24,6 +24,7 @@ export function enforceTechnicalDesign(state = {}, { root = ROOT, execution, rea
   if(execution){
     assertApprovedExecutionContext(execution,{root,technicalDesign:data,architectureIdentity:state.architecture_identity,sliceId:state.slice_id});
     const approved=approvedExecutionBinding(execution);
+    if(approved.work_unit_id)args.push('--work-unit',approved.work_unit_id);
     args.push('--approved-slice',approved.ref,'--approved-slice-digest',approved.digest,'--approved-slice-approval',approved.approval_ref);
   }
   const verified = spawnSync(process.execPath, args, { cwd: root, encoding: 'utf8', timeout: 60000, maxBuffer: 2 * 1024 * 1024 });

package/template/scripts/lib/user-decision-reuse.mjs

@@ -8,6 +8,7 @@ const sameSet = (a,b) => Array.isArray(a) && Array.isArray(b) && a.length === ne
 export function assertApprovalUserDecision(record, roles, options = {}) {
   const policy = roles.user_decision_policy;
   const io = decisionIO(options);
+  if (record.continuation_ref) return assertUserDecisionRequirement({boundary:record.gate_id,subject_ref:record.subject_ref,scope:record.approval_scope,continuation_ref:record.continuation_ref}, {...options,rolesDoc:roles});
   if (policy.required_capabilities?.some(id => id !== DECISION_REUSE_CAPABILITY)) fail('接收工具不支持源用户决定策略，请升级');
   if (!record.decision_reuse_ref) return assertUserDecisionRequirement({boundary:record.gate_id,subject_ref:record.subject_ref,scope:record.approval_scope,user_decision_ref:record.user_decision_ref}, {...options,rolesDoc:roles});
   if (record.gate_id !== 'gate.strategic-design-handoff-approved' || !policy.required_capabilities?.includes(DECISION_REUSE_CAPABILITY)) fail('未登记的复用边界或能力');

package/template/scripts/lib/user-decision.mjs

@@ -1,3 +1,4 @@
+import { normalizeSliceContract } from './slice-contract.mjs';
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import path from "node:path";
@@ -5,6 +6,8 @@ import { parseDocument } from "../vendor/yaml.mjs";
 import { ROOT } from "./lifecycle-registry.mjs";
 import { loadDigitalHumanRoles } from "./digital-human-roles.mjs";
 import { validateJsonSchema } from "./json-schema.mjs";
+import { assertDecisionContinuation } from './decision-continuation.mjs';
+import { platformProfile } from './backend-platform.mjs';
 
 export function decisionError(code, detail) {
   const error = new TypeError(`${code}: ${detail}`);
@@ -161,6 +164,7 @@ export function verifyUserDecisionFile(ref, options = {}) {
 
 export function assertUserDecisionRequirement(requirement, options = {}) {
   if (!requirement) decisionError("user-decision-response-required", "缺少当前决定及其范围");
+  if (requirement.continuation_ref) return assertDecisionContinuation(requirement, options.rolesDoc || loadDigitalHumanRoles(), options);
   return verifyUserDecisionFile(requirement.user_decision_ref, { ...options, expected: [requirement] });
 }
 
@@ -191,7 +195,7 @@ export function assertImplementationDecision(state, options = {}) {
   if (state.slice_contract_ref !== slice.contract?.ref) decisionError("user-decision-subject-mismatch", "当前合同不在批准清单中");
   checkAsset(slice.contract, io);
   const content = io.document(slice.contract.ref);
-  const contract = content.slice_contract || content;
+  const contract = content.slice_contract?.schema_version === 3 || content.schema_version === 3 ? normalizeSliceContract(content, { root: options.root || ROOT }) : content.slice_contract || content;
   if (contract.lifecycle_refs?.ticket !== ticketRef) decisionError("user-decision-subject-mismatch", "持久化合同的切片引用不匹配");
   for (const [manifestKey, contractKey] of [["repositories", "project_roots"], ["allowed_write_paths", "allowed_write_paths"]]) {
     if (!Array.isArray(slice[manifestKey]) || slice[manifestKey].length === 0 || JSON.stringify([...slice[manifestKey]].sort()) !== JSON.stringify([...(contract.common?.[contractKey] || [])].sort())) decisionError("user-decision-scope-mismatch", manifestKey);
@@ -202,11 +206,21 @@ export function assertImplementationDecision(state, options = {}) {
 
 export function scaffoldDecisionSnapshot(decision) {
   const { user_confirmation, status, decision_inputs_digest, ...inputs } = decision;
-  return inputs;
+  const profile = platformProfile(decision.platform_profile, undefined, decision.platform_configuration?.spring_boot_version);
+  return {
+    ...inputs,
+    platform_selection: {
+      profile_id: profile.id,
+      spring_boot_version: profile.spring_boot_version,
+      java_version: profile.java_version,
+    },
+  };
 }
 export function assertScaffoldUserDecision(decision, options = {}) {
   const confirmation = decision.user_confirmation || {};
-  const requirement = { boundary: "scaffold-choice", subject_ref: confirmation.decision_subject_ref, scope: [decision.project_id, decision.confirmed_architecture, decision.decision_inputs_digest], user_decision_ref: confirmation.user_decision_ref };
+  const profile = platformProfile(decision.platform_profile, undefined, decision.platform_configuration?.spring_boot_version);
+  const platformScope = `${profile.id}@${profile.spring_boot_version}/java${profile.java_version}`;
+  const requirement = { boundary: "gate.backend-architecture-platform-approved", subject_ref: confirmation.decision_subject_ref, scope: [decision.project_id, decision.confirmed_architecture, platformScope, decision.decision_inputs_digest], user_decision_ref: confirmation.user_decision_ref };
   assertUserDecisionRequirement(requirement, options);
   const io = decisionIO(options);
   if (decisionDigest(io.document(requirement.subject_ref)) !== decisionDigest(scaffoldDecisionSnapshot(decision))) decisionError("user-decision-stale", "脚手架输入与用户所见快照不一致");

package/template/scripts/preflight-delivery

@@ -6,9 +6,9 @@ import { preflightDelivery, invalidPreflightInput } from './lib/delivery-preflig
 
 let result;
 try {
-  const {values}=parseArgs({options:{input:{type:'string'},stage:{type:'string'},json:{type:'boolean'}},strict:true});
+  const {values}=parseArgs({options:{input:{type:'string'},stage:{type:'string'},'work-unit':{type:'string'},json:{type:'boolean'}},strict:true});
   if(!values.input||!values.stage) throw new TypeError('必须提供 --input <file> 和 --stage prepare|build|export|accept');
-  result=await preflightDelivery(read(path.resolve(values.input)),{stage:values.stage,root:process.cwd()});
+  result=await preflightDelivery(read(path.resolve(values.input)),{stage:values.stage,root:process.cwd(),work_unit_id:values['work-unit']});
 } catch(error) { result=invalidPreflightInput(error.message); }
 process.stdout.write(`${JSON.stringify(result,null,2)}\n`);
 process.exitCode=result.exit_code;

package/template/scripts/slice-contract

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { prepareSliceImplementationContract, migrateSliceContractV2, persistSliceDraft } from './lib/slice-contract-preparation.mjs';
+import { renderSliceContractView, diffSliceContracts } from './lib/slice-contract-views.mjs';
+import { parseSliceYaml, readSliceContract } from './lib/slice-contract.mjs';
+
+try {
+  const args=process.argv.slice(2),mode=args.shift(),options={},positional=[];
+  for(let i=0;i<args.length;i++) {
+    if(args[i]==='--json'){options.json=true;continue;}
+    if(args[i].startsWith('--')) {
+      const key=args[i].slice(2);if(!['root','input','output','unit','before-root'].includes(key)||!args[i+1])throw new Error(`未知或缺值参数 ${args[i]}`);
+      options[key]=args[++i];
+    }else positional.push(args[i]);
+  }
+  const root=path.resolve(options.root||process.cwd());
+  let result;
+  if(mode==='prepare'||mode==='migrate') {
+    const input=options.input?parseSliceYaml(fs.readFileSync(path.resolve(root,options.input))):{};
+    if(mode==='prepare')result=prepareSliceImplementationContract({...input,root,ticket_ref:positional[0]});
+    else result=migrateSliceContractV2(readSliceContract(positional[0],{root}).raw,{...input,root});
+    if(options.output)persistSliceDraft(result,options.output,{root});
+    if(result.report.blockers.length)process.exitCode=1;
+  }else if(mode==='view')result=renderSliceContractView(positional[0],{root,unit_id:options.unit});
+  else if(mode==='diff')result=diffSliceContracts(positional[0],positional[1],{root,beforeRoot:options['before-root']?path.resolve(options['before-root']):root});
+  else if(mode==='verify')result={read_only:true,approval_validity:'not-checked',...readSliceContract(positional[0],{root}).binding};
+  else throw new Error('用法: scripts/slice-contract prepare <ticket> --input <补充.yaml> --output <新合同.yaml> | migrate <v2.yaml> --input <补充.yaml> --output <新合同.yaml> | view <合同.yaml> [--unit <id>] | diff <旧合同> <新合同> | verify <合同> [--root <项目根>]');
+  process.stdout.write(options.json||!result.markdown?`${JSON.stringify(result,null,2)}\n`:`${result.markdown}\n`);
+}catch(error){process.stderr.write(`${error.message}\n`);process.exitCode=1;}