create-yss-spec 3.3.6 → 3.3.7

package/template/scripts/lib/frontend-delivery-boundary.mjs

@@ -7,14 +7,27 @@ import { ROOT, read, safe, ensure, digest } from './strategic-handoff-io.mjs';
 // Shared synchronous adapter for existing compiler, lifecycle and task-package seams.
 // Always re-executes the verifier; a caller-supplied "verified" flag is never evidence.
 export function enforceFrontendDelivery(state={}, {root=ROOT,phase='inputs'}={}) {
+  ensure(['preflight','design','contract','inputs','implementation','verification'].includes(phase),`未知前端交付阶段: ${phase}`);
   const profile=loadDeliveryProfile(root);
   let contract;
   const contractRef=state.slice_contract_ref||state.contract?.slice_contract_ref;
-  const selected=profile?.profile_id==='harness.frontend-delivery'||profile?.frontend_delivery?.required===true;
+  const dedicatedProfile=profile?.profile_id==='harness.frontend-delivery'||profile?.profile_id==='yss-harness-frontend';
+  const selected=dedicatedProfile||profile?.frontend_delivery?.required===true||profile?.handoff?.consumer_capabilities?.includes('frontend-engineering-design');
   const identity=selected?read(safe(root,'yss-project.yaml')):null;
   if(selected)ensure(identity.schema_version===1&&['template-source','project-instance'].includes(identity.repository_mode),'前端项目仓库身份无效');
-  const dedicated=selected&&identity.repository_mode==='project-instance';
+  const dedicated=dedicatedProfile&&identity.repository_mode==='project-instance';
   if(dedicated)ensure(state.contract?.kind!=='template-maintenance','前端产品项目不得用模板维护任务绕过输入条件');
+  if(['preflight','design'].includes(phase)) {
+    const preflight=state.frontend_preflight||state.frontend?.preflight||state.resolution?.frontend_preflight;
+    ensure(preflight?.preflight_ref,'frontend-preflight-required: 缺少 Frontend Strategic Preflight');
+    const args=[path.join(ROOT,'scripts/verify-frontend-strategic-preflight'),'--root',root];
+    if(preflight.digest)args.push('--expected-digest',preflight.digest);
+    args.push(preflight.preflight_ref);
+    const verified=spawnSync(process.execPath,args,{cwd:root,encoding:'utf8',timeout:60000,maxBuffer:2*1024*1024});
+    ensure(verified.status===0,`frontend-preflight-blocked: ${verified.error?.message||verified.stderr||verified.stdout}`);
+    const result=JSON.parse(verified.stdout);ensure(result.result==='preflight-verified'&&result.ready_for_agent===false,'前端战略预检返回非法状态');
+    return result;
+  }
   let binding=state.frontend_delivery||state.frontend?.delivery||state.resolution?.frontend_delivery;
   if(contractRef) {
     // Legacy callers may supply an absolute external contract. Discover whether
@@ -27,17 +40,20 @@ export function enforceFrontendDelivery(state={}, {root=ROOT,phase='inputs'}={})
       binding=direct||resolved||binding;
     }
   }
-  if(!dedicated&&!binding)return {result:'not-applicable'};
+  const frontendStatus=contract?.frontend?.status||state.frontend?.status;
+  const contractRequiresFrontend=typeof frontendStatus==='string'&&!['not-applicable','disabled'].includes(frontendStatus);
+  if(!dedicated&&!binding&&!contractRequiresFrontend)return {result:'not-applicable'};
   if(contractRef)safe(root,contractRef);
   ensure(binding?.acceptance_ref,'frontend-delivery-required: 缺少战略与后端联合接收记录');
   const slice=contract?.slice_id||state.slice_id;
   ensure(!contract?.slice_id||!state.slice_id||contract.slice_id===state.slice_id,'前端任务与 Slice Contract 切片不一致');
   ensure(slice,'frontend-delivery-required: 缺少明确切片');
-  if(phase==='implementation') {
+  if(['implementation','verification'].includes(phase)) {
     ensure(contract?.status==='approved','frontend-delivery-required: 必须读取已持久化的 approved Slice Contract');
     ensure(contract.frontend?.delivery||contract.resolution?.frontend_delivery,'frontend-delivery-required: Slice Contract 未绑定前端交付');
     ensure(binding.digest,'frontend-delivery-required: Slice Contract 未冻结接收记录摘要');
   }
+  if(phase==='verification')ensure(state.frontend_implementation_verification_ref||contract?.frontend?.implementation_verification_ref,'frontend-delivery-required: 验证阶段缺少 frontend_implementation_verification 引用');
   const args=[path.join(ROOT,'scripts/verify-frontend-delivery'),'--root',root,'--slice',slice];
   if(binding.digest)args.push('--expected-digest',binding.digest);
   args.push(binding.acceptance_ref);

package/template/scripts/lib/frontend-delivery.mjs

@@ -1,9 +1,49 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { openBackendDelivery } from './backend-delivery.mjs';
 import { openBundle } from './strategic-handoff.mjs';
 import { verifyConsumption } from './strategic-handoff-consumption.mjs';
-import { read, safe, ensure, hash, schema, project } from './strategic-handoff-io.mjs';
+import { read, safe, ensure, hash, schema, project, ROOT } from './strategic-handoff-io.mjs';
+
+const ACCEPTANCE_SCHEMAS=new Map([[1,'docs/process/schemas/frontend-delivery-acceptance-v1.schema.json'],[2,'docs/process/schemas/frontend-delivery-acceptance.schema.json']]);
+
+function acceptanceSchema(version) {
+  ensure(ACCEPTANCE_SCHEMAS.has(version),`Frontend Delivery Acceptance 未知 schema_version: ${String(version)}；支持版本: 1, 2；新接收请迁移到 2`);
+  return ACCEPTANCE_SCHEMAS.get(version);
+}
+
+export async function verifyFrontendStrategicPreflight({root=process.cwd(),preflightRef,expectedDigest}={}) {
+  project(root);
+  const file=safe(root,preflightRef),preflight=read(file);
+  schema(preflight,'docs/process/schemas/frontend-strategic-preflight.schema.json');
+  const preflightDigest=hash(readFileSync(file));
+  if(expectedDigest)ensure(expectedDigest===preflightDigest,'前端战略预检摘要已变化，需重编译合同');
+  ensure(preflight.status==='verified','前端战略预检尚未 verified');
+  const receipt=read(safe(root,preflight.import_receipt_ref));
+  ensure(receipt.schema_version===2,'Frontend Strategic Preflight 仅接受 Import Receipt v2');
+  const base=`docs/handoffs/${receipt.bundle_id}/${receipt.version}`;
+  ensure(preflight.import_receipt_ref===`${base}/import-receipt.json`&&receipt.package_ref===`${base}/package`,'战略预检收据路径与身份不匹配');
+  ensure(preflight.bundle_digest===receipt.bundle_digest,'战略预检与收据摘要不一致');
+  const routeReceipt=receipt.routes.find(item=>item.route_id===preflight.route_id&&item.capability==='frontend-engineering-design');
+  ensure(routeReceipt&&routeReceipt.activation!=='not-applicable','当前 Handoff 未启用前端工程设计路由');
+  const reconciliation=spawnSync(process.execPath,[path.join(ROOT,'scripts/verify-context-reconciliation'),'--root',root,safe(root,preflight.context_reconciliation_ref)],{encoding:'utf8'});
+  ensure(reconciliation.status===0,`前端战略预检 Context Reconciliation 未通过: ${reconciliation.error?.message||reconciliation.stderr}`);
+  return openBundle(safe(root,receipt.package_ref),bundle=>{
+    ensure(bundle.handoff.schema_version===4&&bundle.manifest.bundle_digest===receipt.bundle_digest,'前端战略预检必须绑定 Handoff v4 当前包');
+    const frontendRoute=bundle.handoff.consumer_routes.find(item=>item.route_id===preflight.route_id&&item.capability==='frontend-engineering-design');
+    const backendRoute=bundle.handoff.consumer_routes.find(item=>item.capability==='backend-technical-design');
+    ensure(frontendRoute&&frontendRoute.activation!=='not-applicable','前端路由未启用');
+    const known=[...bundle.indexes.rules.map(item=>item.rule_id),...bundle.indexes.scenarios.filter(item=>item.critical).map(item=>item.scenario_id)].sort();
+    ensure(JSON.stringify([...preflight.source_rule_refs].sort())===JSON.stringify(known),'前端战略预检未完整绑定源规则/关键场景');
+    const expectedVisual=`${base}/package/payload/files/${bundle.handoff.source.visual_baseline_ref.persisted_ref}/${bundle.handoff.source.visual_baseline_ref.manifest_ref}`;
+    ensure(preflight.visual_baseline_ref===expectedVisual,'前端战略预检 Visual Baseline 引用不一致');
+    const expectedMode=backendRoute.activation==='not-applicable'?'not-applicable':'required';
+    ensure(preflight.backend_dependency.mode===expectedMode&&preflight.backend_dependency.route_id===backendRoute.route_id,'前端战略预检后端依赖与消费者路由不一致');
+    if(expectedMode==='not-applicable')ensure(preflight.backend_dependency.reason===backendRoute.reason&&JSON.stringify(preflight.backend_dependency.impact_refs)===JSON.stringify(backendRoute.impact_refs)&&JSON.stringify(preflight.backend_dependency.evidence_refs)===JSON.stringify(backendRoute.evidence_refs),'backend-not-applicable 依据与战略路由不一致');
+    return {result:'preflight-verified',ready_for_agent:false,preflight_ref:preflightRef,preflight_digest:preflightDigest,strategic_bundle_digest:receipt.bundle_digest,backend_dependency:expectedMode,next_action:'prepare-frontend-engineering-design-draft'};
+  });
+}
 
 function pointer(value, ref) {
   ensure(ref.startsWith('/')&&!ref.includes('//'),'服务版本 JSON Pointer 无效');
@@ -35,10 +75,33 @@ export async function probeBackend(delivery) {
 export async function verifyFrontendDelivery({root=process.cwd(),acceptanceRef,sliceRef,expectedDigest}) {
   project(root);
   const file=safe(root,acceptanceRef), acceptance=read(file);
-  schema(acceptance,'docs/process/schemas/frontend-delivery-acceptance.schema.json');
+  schema(acceptance,acceptanceSchema(acceptance?.schema_version));
   const acceptanceDigest=hash(readFileSync(file));
   if(expectedDigest)ensure(expectedDigest===acceptanceDigest,'前端接收记录摘要已变化，需重编译合同');
   ensure(sliceRef&&acceptance.slice_id===sliceRef,'前端接收记录与执行切片不匹配');
+  if(acceptance.schema_version===2) {
+    const preflight=await verifyFrontendStrategicPreflight({root,preflightRef:acceptance.strategic_preflight.ref,expectedDigest:acceptance.strategic_preflight.digest});
+    ensure(preflight.strategic_bundle_digest===acceptance.strategic_handoff.bundle_digest,'前端接收与战略预检版本不一致');
+    if(acceptance.backend_dependency.mode==='not-applicable') {
+      ensure(!acceptance.backend_delivery,'backend-not-applicable 不得绑定后端交付收据');
+      const strategic=await verifyConsumption(acceptance,{root,sliceRef,consumer:'frontend'});
+      ensure(strategic.result==='verified',`战略承接阻断: ${JSON.stringify(strategic.issues)}`);
+      const strategicReceipt=read(safe(root,acceptance.strategic_handoff.import_receipt_ref));
+      return openBundle(safe(root,strategicReceipt.package_ref),bundle=>{
+        const visualCases=bundle.handoff.source.visual_baseline_ref.case_ids;
+        const sourceIds=new Set([...bundle.indexes.rules.map(item=>item.rule_id),...bundle.indexes.scenarios.filter(item=>item.critical).map(item=>item.scenario_id)]);
+        const ids=acceptance.frontend_cases.map(item=>item.case_id);ensure(new Set(ids).size===ids.length,'前端验收用例 ID 重复');
+        for(const item of acceptance.frontend_cases){
+          ensure(item.operation_ids.length===0,'backend-not-applicable 前端用例不得绑定 operation_ids');
+          ensure(item.source_ids.every(id=>sourceIds.has(id)),'前端用例引用未知规则/场景');
+          ensure(item.visual_case_ids.every(id=>visualCases.includes(id)),'前端用例视觉基线悬空');
+          const evidence=readFileSync(safe(root,item.evidence_ref));ensure(evidence.length>0&&hash(evidence)===item.evidence_digest,'前端承接用例说明为空或摘要漂移');
+        }
+        return {result:'inputs-verified',ready_for_agent:false,slice_id:sliceRef,acceptance_ref:acceptanceRef,acceptance_digest:acceptanceDigest,strategic_bundle_digest:strategic.consumed_bundle_digest,backend_dependency:'not-applicable',next_action:'prepare-or-revalidate-frontend-plan-and-slice-contract'};
+      });
+    }
+    ensure(acceptance.backend_dependency.mode==='required','frontend backend_dependency.mode 非法');
+  }
   const binding=acceptance.backend_delivery, receipt=read(safe(root,binding.import_receipt_ref));
   const base=`docs/backend-deliveries/${receipt.delivery_id}/${receipt.version}`;
   ensure(binding.import_receipt_ref===`${base}/import-receipt.json`&&receipt.package_ref===`${base}/package`,'后端收据路径与身份不匹配');
@@ -56,6 +119,7 @@ export async function verifyFrontendDelivery({root=process.cwd(),acceptanceRef,s
     await openBundle(safe(backend.source,delivery.strategic_bundle_ref),bundle=>{
       const visualCases=bundle.handoff.source.visual_baseline_ref.case_ids;
       for(const item of acceptance.frontend_cases) {
+        if(acceptance.schema_version===2)ensure(item.operation_ids.length>0,'有后端依赖时前端用例必须绑定已交付 operation_ids');
         ensure(item.operation_ids.every(id=>delivery.scope.operation_ids.includes(id)),'前端用例依赖未交付接口');
         ensure(item.source_ids.every(id=>delivery.scope.source_ids.includes(id)),'前端用例依赖未交付规则/场景');
         ensure(item.visual_case_ids.every(id=>visualCases.includes(id)),'前端用例视觉基线悬空');

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

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { openBundle } from './strategic-handoff.mjs';
+import { read, safe, ensure, hash, schema, project } from './strategic-handoff-io.mjs';
+
+export async function verifyConsumerFeedback({root=process.cwd(),feedbackRef}={}) {
+  project(root);const file=safe(root,feedbackRef),feedback=read(file);
+  schema(feedback,'docs/process/schemas/strategic-consumer-feedback.schema.json');
+  const receipt=read(safe(root,feedback.import_receipt_ref));
+  ensure(receipt.schema_version===2,'Consumer Feedback v1 只接受 Handoff v4 的 Import Receipt v2');
+  const base=`docs/handoffs/${receipt.bundle_id}/${receipt.version}`;
+  ensure(feedback.import_receipt_ref===`${base}/import-receipt.json`&&receipt.package_ref===`${base}/package`,'Consumer Feedback 导入收据路径无效');
+  ensure(feedback.bundle.id===receipt.bundle_id&&feedback.bundle.version===receipt.version&&feedback.bundle.digest===receipt.bundle_digest,'Consumer Feedback 绑定的 bundle 身份或摘要不一致');
+  const route=receipt.routes.find(item=>item.route_id===feedback.route_id);ensure(route&&route.activation!=='not-applicable','Consumer Feedback route_id 未被当前消费者激活');
+  for(const ref of feedback.evidence_refs)ensure(readFileSync(safe(root,ref)).length>0,`Consumer Feedback evidence 为空: ${ref}`);
+  return openBundle(safe(root,receipt.package_ref),bundle=>{
+    ensure(bundle.handoff.schema_version===4&&bundle.manifest.bundle_digest===receipt.bundle_digest,'Consumer Feedback 必须绑定当前 Handoff v4 包');
+    const source=[...bundle.indexes.rules.map(item=>({id:item.rule_id,digest:item.source_digest})),...bundle.indexes.scenarios.map(item=>({id:item.scenario_id,digest:item.source_digest}))].find(item=>item.id===feedback.source.id);
+    ensure(source&&source.digest===feedback.source.digest,'Consumer Feedback source ID 或摘要不是当前包内容');
+    return {result:'feedback-verified',feedback_ref:feedbackRef,feedback_digest:hash(readFileSync(file)),severity:feedback.severity,route_id:feedback.route_id,bundle_digest:receipt.bundle_digest};
+  });
+}
+
+export async function verifyFeedbackAdjudication({root=process.cwd(),adjudicationRef}={}) {
+  project(root);const file=safe(root,adjudicationRef),adjudication=read(file);
+  schema(adjudication,'docs/process/schemas/strategic-feedback-adjudication.schema.json');
+  const feedbackFile=safe(root,adjudication.feedback.ref);ensure(hash(readFileSync(feedbackFile))===adjudication.feedback.digest,'Feedback Adjudication 绑定的 feedback digest 已失效');
+  const verified=await verifyConsumerFeedback({root,feedbackRef:adjudication.feedback.ref});
+  for(const ref of adjudication.evidence_refs)ensure(readFileSync(safe(root,ref)).length>0,`Feedback Adjudication evidence 为空: ${ref}`);
+  if(adjudication.approval_ref)ensure(readFileSync(safe(root,adjudication.approval_ref)).length>0,'Feedback Adjudication approval_ref 为空');
+  if(adjudication.decision==='amend')return {result:'blocked',decision:'amend',requires_new_handoff:true,invalidated_bundle_digest:verified.bundle_digest,next_work_unit:adjudication.return_work_unit,target_version:adjudication.target_version};
+  if(adjudication.decision==='defer'&&verified.severity==='blocking')return {result:'blocked',decision:'defer',requires_new_handoff:false,next_work_unit:adjudication.return_work_unit,target_version:adjudication.target_version};
+  return {result:'adjudicated',decision:adjudication.decision,may_continue:true,bundle_digest:verified.bundle_digest,target_version:adjudication.target_version};
+}

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

@@ -23,6 +23,11 @@ export async function verifyConsumption(data,{root=process.cwd(),sliceRef,consum
   const expectedBase=`docs/handoffs/${receipt.bundle_id}/${receipt.version}`;
   ensure(binding.import_receipt_ref===`${expectedBase}/import-receipt.json` && receipt.package_ref===`${expectedBase}/package`,'导入收据路径与包身份不一致');
   ensure(binding.bundle_digest===receipt.bundle_digest,'战术绑定与导入收据摘要不一致');
+  if(receipt.schema_version===2){
+    const capability=consumer==='frontend'?'frontend-engineering-design':'backend-technical-design';
+    const route=receipt.routes.find(item=>item.capability===capability);
+    ensure(route&&route.activation!=='not-applicable'&&binding.route_id===route.route_id,`${capability} 未绑定当前 Handoff v4 route_id`);
+  }
   const result=spawnSync(process.execPath,[path.join(ROOT,'scripts/verify-context-reconciliation'),'--root',root,safe(root,binding.context_reconciliation_ref)],{encoding:'utf8'});
   ensure(result.status===0,`目标术语对账未通过: ${result.error?.message || result.stderr}`);
   const context=parseContextContract({root});

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

@@ -66,6 +66,7 @@ export function archive(command, source, destination) {
 export function sourceApprovalPolicy(source) {
   const roles=structuredClone(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;
   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)) {

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

@@ -12,13 +12,55 @@ const MAX_BYTES = 512 * 1024 * 1024;
 const own = (a,b) => JSON.stringify(canonical(a)) === JSON.stringify(canonical(b));
 const nonempty = x => typeof x === 'string' && x.trim();
 const bytesDigest = (bytes, kind) => kind === 'canonical-json' ? digest(parse(bytes)) : kind === 'sha256-bytes' ? hash(bytes) : (() => { throw new TypeError(`未知摘要算法: ${kind}`); })();
+const HANDOFF_SCHEMAS = new Map([[3,'docs/process/schemas/strategic-design-handoff-v3.schema.json'],[4,'docs/process/schemas/strategic-design-handoff-v4.schema.json']]);
+const SOURCE_SCHEMAS = new Map([
+  [3,['docs/process/schemas/strategic-handoff-domain-strategy.schema.json','docs/process/schemas/strategic-handoff-stage-decision-package.schema.json']],
+  [4,['docs/process/schemas/strategic-handoff-domain-strategy-v3.schema.json','docs/process/schemas/strategic-handoff-stage-decision-package-v3.schema.json']],
+]);
+const CAPABILITIES=['backend-technical-design','frontend-engineering-design','delivery-coordination'];
+
+function versionSchema(version, schemas, label) {
+  ensure(schemas.has(version), `${label} 未知 schema_version: ${String(version)}；支持版本: ${[...schemas.keys()].join(', ')}；请使用显式迁移器升级`);
+  return schemas.get(version);
+}
+
+function validateConsumerRoutes(handoff, stage) {
+  if(handoff.schema_version!==4)return;
+  const routes=new Map();
+  for(const route of handoff.consumer_routes||[]){
+    ensure(!routes.has(route.capability),`消费者能力重复: ${route.capability}`);
+    ensure(![...routes.values()].some(item=>item.route_id===route.route_id),`消费者 route_id 重复: ${route.route_id}`);
+    routes.set(route.capability,route);
+  }
+  ensure(CAPABILITIES.every(capability=>routes.has(capability)),'Handoff v4 必须完整声明 backend、frontend 与 coordination 三条消费者路由');
+  const impact=stage.impact_assessment||{};
+  const mappingByCapability=new Map();
+  for(const mapping of stage.downstream_mapping||[]){
+    ensure(CAPABILITIES.includes(mapping.consumer_capability),`未知消费者能力: ${mapping.consumer_capability}`);
+    const values=mappingByCapability.get(mapping.consumer_capability)||[];values.push(mapping);mappingByCapability.set(mapping.consumer_capability,values);
+  }
+  const expected=(capability,required)=>required?'required':(mappingByCapability.get(capability)||[]).some(mapping=>mapping.propagation!=='not-applicable')?'optional':'not-applicable';
+  const backend=routes.get('backend-technical-design'),frontend=routes.get('frontend-engineering-design'),coordination=routes.get('delivery-coordination');
+  const backendActive=Boolean(impact.backend||impact.api||impact.data),frontendActive=Boolean(impact.frontend||impact.ui);
+  ensure(backend.activation===expected(backend.capability,backendActive),'backend 消费者路由与批准的 Backend/API/Data 影响矩阵不一致');
+  ensure(frontend.activation===expected(frontend.capability,frontendActive),'frontend 消费者路由与批准的 Frontend/UI 影响矩阵不一致');
+  ensure(coordination.activation===((backend.activation!=='not-applicable'||frontend.activation!=='not-applicable')?'required':'not-applicable'),'coordination 消费者路由与交付影响不一致');
+  const activeBackend=backend.activation!=='not-applicable';
+  ensure(own(frontend.dependencies,activeBackend?[backend.route_id]:[]),'frontend 路由依赖与 backend 路由不一致');
+  ensure(own(coordination.dependencies,[...(backend.activation!=='not-applicable'?[backend.route_id]:[]),...(frontend.activation!=='not-applicable'?[frontend.route_id]:[])]),'coordination 路由依赖与消费者路由不一致');
+  for(const route of routes.values())for(const dependency of route.dependencies)ensure([...routes.values()].some(item=>item.route_id===dependency),`消费者路由依赖悬空: ${dependency}`);
+  for(const [capability,mappings] of mappingByCapability)for(const mapping of mappings){
+    const route=routes.get(capability);
+    ensure(mapping.propagation==='not-applicable'?route.activation==='not-applicable':route.activation!=='not-applicable',`downstream mapping 与消费者路由影响不一致: ${mapping.mapping_id}`);
+  }
+}
 
 export async function sourceApproval(record, roles, root) {
   const options={rolesDoc:roles,requireApproved:true,root,read:ref=>readFileSync(safe(root,path.relative(root,ref).split(path.sep).join('/')))};
   if (roles.user_decision_policy.gates.includes(record.gate_id)) {
     ensure(existsSync(path.join(ROOT,'scripts/lib/user-decision.mjs')), '接收工具不支持源用户决定策略，请升级工具后验包');
-    const { assertUserDecisionRequirement } = await import('./user-decision.mjs');
-    assertUserDecisionRequirement({boundary:record.gate_id,subject_ref:record.subject_ref,scope:record.approval_scope,user_decision_ref:record.user_decision_ref},options);
+    const { assertApprovalUserDecision } = await import('./user-decision-reuse.mjs');
+    assertApprovalUserDecision(record, roles, options);
   }
   validateApprovalRecord(record,options);
 }
@@ -83,7 +125,7 @@ function previewFiles(root, config) {
 
 export async function inspectSource(root, handoffRef) {
   const handoff=read(safe(root,handoffRef));
-  schema(handoff,'docs/process/schemas/strategic-design-handoff.schema.json');
+  schema(handoff,versionSchema(handoff?.schema_version,HANDOFF_SCHEMAS,'Strategic Handoff'));
   ensure(handoff.status==='approved', '交接包尚未批准');
   const config=handoff.package_export;
   schema(config,'docs/process/schemas/strategic-handoff-export.schema.json');
@@ -91,13 +133,15 @@ export async function inspectSource(root, handoffRef) {
   snapshot(handoff.source_context_snapshot,source); checkDelta(handoff,source);
   const strategy=read(safe(root,handoff.source.domain_strategy_ref.persisted_ref));
   const stage=read(safe(root,handoff.source.stage_decision_package_ref.persisted_ref));
-  schemaBatch([[strategy,'docs/process/schemas/strategic-handoff-domain-strategy.schema.json'],[stage,'docs/process/schemas/strategic-handoff-stage-decision-package.schema.json']]);
+  const [strategySchema,stageSchema]=versionSchema(handoff.schema_version,SOURCE_SCHEMAS,'Strategic Handoff source');
+  schemaBatch([[strategy,strategySchema],[stage,stageSchema]]);
   snapshot(strategy.context_snapshot,source); snapshot(stage.context_snapshot,source);
   ensure(strategy.status==='approved' && stage.status==='approved', '战略合同/方案决策包尚未批准');
   ensure(strategy.domain_strategy_id===handoff.source.domain_strategy_ref.id && strategy.domain_version===handoff.source.domain_strategy_ref.version, '战略身份/版本不一致');
   ensure(stage.stage_decision_id===handoff.source.stage_decision_package_ref.id && stage.package_version===handoff.source.stage_decision_package_ref.version, '阶段包身份/版本不一致');
   ensure(stage.domain_strategy_ref.domain_strategy_id===strategy.domain_strategy_id && stage.domain_strategy_ref.domain_version===strategy.domain_version && stage.domain_strategy_ref.status==='approved' && stage.domain_strategy_ref.persisted_ref===handoff.source.domain_strategy_ref.persisted_ref && stage.domain_strategy_ref.digest===digest(strategy), '阶段包引用的战略内容不一致');
   ensure(!(stage.unresolved_items || []).some(x=>x.type==='blocker'), '阶段包含 blocker');
+  validateConsumerRoutes(handoff,stage);
   const indexes=extractTraceability(strategy);
   const sourceRoles=read(safe(root,'docs/agents/digital-human-roles.yaml'));
   const roles=sourceApprovalPolicy(sourceRoles);
@@ -128,6 +172,19 @@ export async function inspectSource(root, handoffRef) {
     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 scope=read(safe(root,record.subject_ref));
+    ensure(scope.kind==='strategic-delivery-scope' && scope.schema_version===1, '交接必须绑定独立的交付范围清单');
+    const {package_export,status,...delivery}=handoff;
+    ensure(scope.delivery_ref && own(read(safe(root,scope.delivery_ref)),delivery), '交付范围清单未覆盖当前交接内容或风险');
+    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=key==='visual_baseline_ref'?`${ref.persisted_ref}/${ref.manifest_ref}`:ref.persisted_ref;
+      const decisionBoundaries=key==='business_ticket_set_ref'?['gate.spec-baseline-approved',terminalGate]:[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}`);
+    }
+  }
   const receipt=previewFiles(root,config.prototype);
   ensure(handoff.source.visual_baseline_ref.case_ids.every(id=>receipt.case_ids.includes(id)), '离线验证未覆盖视觉基线 case');
   return {handoff,config,indexes,strategy,stage};
@@ -140,7 +197,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'].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','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) {
@@ -251,12 +308,46 @@ export async function importBundle({bundle,targetRoot}) {
     mkdirSync(path.dirname(dest),{recursive:true});const stage=mkdtempSync(path.join(path.dirname(dest),'.import-staging-'));
     try {
       cpSync(b.root,path.join(stage,'package'),{recursive:true,errorOnExist:true,force:false});
-      const receipt={schema_version:1,bundle_id:b.manifest.bundle_id,version:b.manifest.version,bundle_digest:b.manifest.bundle_digest,package_ref:`${rel}/package`,target_context_digest:context.document_digest,status:'pending-context-reconciliation'};
-      write(stage,'import-receipt.json',json(receipt));write(stage,'context-reconciliation-draft.json',json({schema_version:1,status:'draft',import_receipt_ref:`${rel}/import-receipt.json`,target_context_digest:context.document_digest,terms}));
-      write(stage,'tactical-traceability-draft.json',json({schema_version:1,import_receipt_ref:`${rel}/import-receipt.json`,bundle_digest:b.manifest.bundle_digest,rows}));
-      write(stage,'upstream-change-impact.json',json({schema_version:1,previous_bundle:b.manifest.previous_bundle,changed_source_ids:[...b.changes.updated,...b.changes.removed],added_source_ids:b.changes.added,status:'requires-lifecycle-reconciliation',policy:'mark-dependent-tactical-and-slice-contracts-stale; unknown-dependency-blocks-all'}));
+      let receipt;
+      if(b.handoff.schema_version===3){
+        receipt={schema_version:1,bundle_id:b.manifest.bundle_id,version:b.manifest.version,bundle_digest:b.manifest.bundle_digest,package_ref:`${rel}/package`,target_context_digest:context.document_digest,status:'pending-context-reconciliation'};
+        write(stage,'import-receipt.json',json(receipt));write(stage,'context-reconciliation-draft.json',json({schema_version:1,status:'draft',import_receipt_ref:`${rel}/import-receipt.json`,target_context_digest:context.document_digest,terms}));
+        write(stage,'tactical-traceability-draft.json',json({schema_version:1,import_receipt_ref:`${rel}/import-receipt.json`,bundle_digest:b.manifest.bundle_digest,rows}));
+        write(stage,'upstream-change-impact.json',json({schema_version:1,previous_bundle:b.manifest.previous_bundle,changed_source_ids:[...b.changes.updated,...b.changes.removed],added_source_ids:b.changes.added,status:'requires-lifecycle-reconciliation',policy:'mark-dependent-tactical-and-slice-contracts-stale; unknown-dependency-blocks-all'}));
+      }else{
+        const profileRef=path.join(target,'docs/process/harness-profile.yaml');
+        const profile=existsSync(profileRef)?read(profileRef):null;
+        const capabilities=profile?.handoff?.consumer_capabilities||CAPABILITIES;
+        ensure(Array.isArray(capabilities)&&capabilities.length&&capabilities.every(capability=>CAPABILITIES.includes(capability)),'目标 profile 未声明受支持的消费者能力');
+        const selected=b.handoff.consumer_routes.filter(route=>capabilities.includes(route.capability));
+        ensure(selected.length===capabilities.length,'目标 profile 的消费者能力在 Handoff v4 中缺失');
+        const commonRefs=[`${rel}/context-reconciliation-draft.json`,`${rel}/upstream-change-impact.json`];
+        const routeRecords=selected.map(route=>{
+          const artifactRefs=[...commonRefs];
+          if(route.activation!=='not-applicable'&&route.capability==='backend-technical-design')artifactRefs.push(`${rel}/backend-technical-traceability-draft.json`);
+          if(route.activation!=='not-applicable'&&route.capability==='frontend-engineering-design')artifactRefs.push(`${rel}/frontend-strategic-preflight-draft.json`,`${rel}/frontend-traceability-draft.json`);
+          if(route.activation!=='not-applicable'&&route.capability==='delivery-coordination')artifactRefs.push(`${rel}/consumer-status-index-draft.json`);
+          return {route_id:route.route_id,capability:route.capability,activation:route.activation,artifact_refs:artifactRefs};
+        });
+        receipt={schema_version:2,bundle_id:b.manifest.bundle_id,version:b.manifest.version,bundle_digest:b.manifest.bundle_digest,package_ref:`${rel}/package`,target_context_digest:context.document_digest,target_profile_id:profile?.profile_id||'yss-full-lifecycle',selected_consumer_capabilities:capabilities,routes:routeRecords,status:'pending-context-reconciliation'};
+        schema(receipt,'docs/process/schemas/strategic-handoff-import-receipt.schema.json');
+        write(stage,'import-receipt.json',json(receipt));
+        write(stage,'context-reconciliation-draft.json',json({schema_version:2,status:'draft',import_receipt_ref:`${rel}/import-receipt.json`,target_context_digest:context.document_digest,route_ids:selected.map(route=>route.route_id),terms}));
+        write(stage,'upstream-change-impact.json',json({schema_version:2,previous_bundle:b.manifest.previous_bundle,routes:selected.map(route=>({route_id:route.route_id,capability:route.capability,activation:route.activation,changed_source_ids:[...b.changes.updated,...b.changes.removed],added_source_ids:b.changes.added,status:'requires-lifecycle-reconciliation'})),policy:'mark-only-known-dependent-contracts-stale; unknown-dependency-or-design-basis-change-blocks-all'}));
+        const backendRoute=b.handoff.consumer_routes.find(route=>route.capability==='backend-technical-design');
+        const frontendRoute=b.handoff.consumer_routes.find(route=>route.capability==='frontend-engineering-design');
+        const coordinationRoute=b.handoff.consumer_routes.find(route=>route.capability==='delivery-coordination');
+        if(capabilities.includes('backend-technical-design')&&backendRoute.activation!=='not-applicable')write(stage,'backend-technical-traceability-draft.json',json({schema_version:2,route_id:backendRoute.route_id,import_receipt_ref:`${rel}/import-receipt.json`,bundle_digest:b.manifest.bundle_digest,rows}));
+        if(capabilities.includes('frontend-engineering-design')&&frontendRoute.activation!=='not-applicable'){
+          const preflight={schema_version:1,status:'draft',route_id:frontendRoute.route_id,capability:frontendRoute.capability,import_receipt_ref:`${rel}/import-receipt.json`,bundle_digest:b.manifest.bundle_digest,context_reconciliation_ref:'',visual_baseline_ref:`${rel}/package/payload/files/${b.handoff.source.visual_baseline_ref.persisted_ref}/${b.handoff.source.visual_baseline_ref.manifest_ref}`,source_rule_refs:rows.map(row=>row.source_id),backend_dependency:{mode:backendRoute.activation==='not-applicable'?'not-applicable':'required',route_id:backendRoute.route_id,...(backendRoute.activation==='not-applicable'?{reason:backendRoute.reason,impact_refs:backendRoute.impact_refs,evidence_refs:backendRoute.evidence_refs}:{})},ready_for_agent:false};
+          schema(preflight,'docs/process/schemas/frontend-strategic-preflight.schema.json');
+          write(stage,'frontend-strategic-preflight-draft.json',json(preflight));write(stage,'frontend-traceability-draft.json',json({schema_version:1,route_id:frontendRoute.route_id,import_receipt_ref:`${rel}/import-receipt.json`,bundle_digest:b.manifest.bundle_digest,rows:rows.map(({tactical_refs,test_seam_refs,...row})=>({...row,frontend_case_refs:[]}))}));
+        }
+        if(capabilities.includes('delivery-coordination')&&coordinationRoute.activation!=='not-applicable')write(stage,'consumer-status-index-draft.json',json({schema_version:1,status:'draft',import_receipt_ref:`${rel}/import-receipt.json`,routes:b.handoff.consumer_routes.map(route=>({route_id:route.route_id,capability:route.capability,activation:route.activation,consumer_status:route.activation==='not-applicable'?'not-applicable':'pending',receipt_refs:[],acceptance_refs:[],feedback_refs:[]}))}));
+      }
       ensure(!existsSync(dest),'导入并发冲突');renameSync(stage,dest);
-      return {result:'imported-pending-reconciliation',receipt_ref:`${rel}/import-receipt.json`,traceability_ref:`${rel}/tactical-traceability-draft.json`};
+      const traceabilityRef=b.handoff.schema_version===3?`${rel}/tactical-traceability-draft.json`:receipt.routes.find(route=>route.capability==='backend-technical-design')?.artifact_refs.find(ref=>ref.endsWith('backend-technical-traceability-draft.json'))||receipt.routes.find(route=>route.capability==='frontend-engineering-design')?.artifact_refs.find(ref=>ref.endsWith('frontend-traceability-draft.json'));
+      return {result:'imported-pending-reconciliation',receipt_ref:`${rel}/import-receipt.json`,...(traceabilityRef?{traceability_ref:traceabilityRef}:{})};
     }finally{rmSync(stage,{recursive:true,force:true});}
   });
 }

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

@@ -0,0 +1,38 @@
+import { assertUserDecisionRequirement, decisionIO, decisionDigest, decisionError } from './user-decision.mjs';
+
+export const DECISION_REUSE_CAPABILITY = 'strategic-decision-reuse-v1';
+const fail = detail => decisionError('user-decision-reuse-invalid', detail);
+const sameSet = (a,b) => Array.isArray(a) && Array.isArray(b) && a.length === new Set(a).size && b.length === new Set(b).size && JSON.stringify([...a].sort()) === JSON.stringify([...b].sort());
+
+// A reuse record is a coverage proof, never a new reply or a substitute for one.
+export function assertApprovalUserDecision(record, roles, options = {}) {
+  const policy = roles.user_decision_policy;
+  const io = decisionIO(options);
+  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('未登记的复用边界或能力');
+  const reuse = io.document(record.decision_reuse_ref);
+  if (reuse.schema_version !== 1 || reuse.kind !== DECISION_REUSE_CAPABILITY || reuse.target_gate !== record.gate_id || reuse.scope_ref !== record.subject_ref || !sameSet(reuse.scope, record.approval_scope)) fail('目标边界、资产或范围不匹配');
+  const manifest = io.document(reuse.scope_ref);
+  if (manifest.schema_version !== 1 || manifest.kind !== 'strategic-delivery-scope' || !Array.isArray(manifest.assets) || !manifest.assets.length || !Array.isArray(manifest.risks) || !Array.isArray(manifest.conditions)) fail('交付范围清单不完整');
+  if (!Array.isArray(reuse.requirements) || !reuse.requirements.length) fail('缺少原决定');
+  const approved = [];
+  for (const requirement of reuse.requirements) {
+    const result = assertUserDecisionRequirement(requirement,{...options,rolesDoc:roles});
+    const source = io.document(requirement.user_decision_ref);
+    for (const item of source.request.items.filter(item => result.validated.some(v => v.item_id === item.id))) approved.push({item, requirement});
+  }
+  const identities = new Set();
+  for (const asset of manifest.assets) {
+    if (!asset.ref || !asset.version || !asset.boundary || !Array.isArray(asset.scope) || !asset.scope.length || identities.has(`${asset.boundary}:${asset.ref}`)) fail('资产缺少身份、专业边界、范围或重复');
+    identities.add(`${asset.boundary}:${asset.ref}`);
+    if (decisionDigest(io.bytes(asset.ref)) !== asset.digest) fail(`资产已变化: ${asset.ref}`);
+    const covering = approved.filter(({item,requirement}) => item.boundary === asset.boundary && asset.scope.every(s => requirement.scope.includes(s)) && [item.subject,...item.basis].some(a => a.ref === asset.ref && a.version === asset.version && a.digest === asset.digest));
+    if (!covering.length) fail(`没有原决定覆盖: ${asset.ref} / ${asset.boundary}`);
+  }
+  const coveredScope = new Set(manifest.assets.flatMap(asset => asset.scope));
+  if (!reuse.scope.length || reuse.scope.some(s => !coveredScope.has(s))) fail('交付范围超出资产批准范围');
+  for (const risk of manifest.risks) if (!approved.some(({item}) => item.risks.includes(risk))) fail(`新增未接受风险: ${risk}`);
+  for (const condition of manifest.conditions) if (!approved.some(({item}) => item.next_actions.includes(condition))) fail(`新增授权条件: ${condition}`);
+  return {reused:true,manifest,validated:approved.map(({item})=>({item_id:item.id,principal_ref:item.responder_ref}))};
+}

package/template/scripts/strategic-feedback

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { verifyConsumerFeedback, verifyFeedbackAdjudication } from './lib/strategic-feedback.mjs';
+
+try{
+  const [command,...args]=process.argv.slice(2);const {values,positionals}=parseArgs({args,options:{root:{type:'string',default:process.cwd()}},allowPositionals:true,strict:true});
+  if(positionals.length!==1||!['verify-feedback','verify-adjudication'].includes(command))throw new TypeError('用法: scripts/strategic-feedback <verify-feedback|verify-adjudication> --root <target> <contract.json>');
+  const result=command==='verify-feedback'?await verifyConsumerFeedback({root:values.root,feedbackRef:positionals[0]}):await verifyFeedbackAdjudication({root:values.root,adjudicationRef:positionals[0]});
+  process.stdout.write(`${JSON.stringify(result,null,2)}\n`);
+}catch(error){process.stderr.write(`${error.message}\n`);process.exitCode=1;}

package/template/scripts/verify-frontend-strategic-preflight

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { verifyFrontendStrategicPreflight } from './lib/frontend-delivery.mjs';
+
+try {
+  const {values,positionals}=parseArgs({options:{root:{type:'string',default:process.cwd()},'expected-digest':{type:'string'}},allowPositionals:true,strict:true});
+  if(positionals.length!==1)throw new TypeError('用法: scripts/verify-frontend-strategic-preflight [--root <frontend>] [--expected-digest <sha256>] <preflight.json>');
+  const result=await verifyFrontendStrategicPreflight({root:values.root,preflightRef:positionals[0],expectedDigest:values['expected-digest']});
+  process.stdout.write(`${JSON.stringify(result,null,2)}\n`);
+}catch(error){
+  process.stderr.write(`${error.message}\n`);process.exitCode=1;
+}

package/template/skills-lock.json

@@ -18,7 +18,7 @@
       "revision": "c4d958f18cc947cb91cbe1bd48783fa4601cc18f"
     },
     "iloveZzz/yss-harness-design-agent": {
-      "revision": "41fb25425928153791f7d92a85eb717f4eb2d546"
+      "revision": "e24465921a8a51d8690a1732842274a35b935c9e"
     },
     "ayghri/i-have-adhd": {
       "revision": "7b9069b39972e269e61bd95c2f66ebb90cac6a02"
@@ -42,7 +42,7 @@
         "source": "tt-a1i/archify",
         "sourceType": "github",
         "skillPath": "archify/SKILL.md",
-        "effectiveHash": "e511c187835772be94ae1203f8fc3d0dd2516271586a629ca1b1a2cc3a96a1c1",
+        "effectiveHash": "f7e3f1643070db1537ad4dfe7f5718c5d90033b27c12cce1762720724ed0e356",
         "sourceRevision": "199360cc6687a7857b54dd188d4922b09e466a4b",
         "upstreamHash": "a04c5666d6a5f46bc6f220a36b851e96aaa69ff0630049631364fb23fa5b2ee5",
         "adaptationRef": "docs/agents/archify-integration.md",
@@ -481,7 +481,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/prototype-review/SKILL.md",
         "effectiveHash": "df6f131bef0f52a96d307d98ab42d74888a9b72c5508911b5622913b334e8eab",
-        "sourceRevision": "41fb25425928153791f7d92a85eb717f4eb2d546",
+        "sourceRevision": "e24465921a8a51d8690a1732842274a35b935c9e",
         "upstreamHash": "9206df8b6c555c1af1351e425c5ec99ec2a40263c6861607f1418b9c520873ab",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -701,7 +701,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-antd-design/SKILL.md",
         "effectiveHash": "92739eb34352fd70fbb52f4d9d6c6ac09aa02bc0155a4bd812a98cd5f933ff70",
-        "sourceRevision": "41fb25425928153791f7d92a85eb717f4eb2d546",
+        "sourceRevision": "e24465921a8a51d8690a1732842274a35b935c9e",
         "upstreamHash": "08ce99d45586d5ea19e25fdd9e9a6ede16e66f18992b70b87e0cd23f92343b16",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -716,7 +716,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-antdv-next-design/SKILL.md",
         "effectiveHash": "c7c07c5dc3716f578904559473d43d92878aa25a6a45c8827e288f0242d42b75",
-        "sourceRevision": "41fb25425928153791f7d92a85eb717f4eb2d546",
+        "sourceRevision": "e24465921a8a51d8690a1732842274a35b935c9e",
         "upstreamHash": "2942ed52dd58a38e51f09eb11254809334aeaed08f21cd081f09f35e6647a68c",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -806,7 +806,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-design-system/SKILL.md",
         "effectiveHash": "e69597b8b6a5ce4de5bd40f67630443b8176202f6b028b2ce146a2a1d062816f",
-        "sourceRevision": "41fb25425928153791f7d92a85eb717f4eb2d546",
+        "sourceRevision": "e24465921a8a51d8690a1732842274a35b935c9e",
         "upstreamHash": "90aaf06b2514353152464a4d032076fa9d5ef56272d8ad526f5544f3c22a2b00",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -1040,7 +1040,7 @@
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-prototype-stage/SKILL.md",
         "effectiveHash": "c87c7c38c9598c04f28cfa759fd6c1c12b2937b49e92f8171992d8346cb179e0",
-        "sourceRevision": "41fb25425928153791f7d92a85eb717f4eb2d546",
+        "sourceRevision": "e24465921a8a51d8690a1732842274a35b935c9e",
         "upstreamHash": "aa78ef758ad3c515e94fb6b87d4e519f39a38e53bb3c82413d707f7d0f96f58b",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
@@ -1117,9 +1117,9 @@
         "source": "iloveZzz/yss-harness-design-agent",
         "sourceType": "git-submodule",
         "skillPath": ".agents/skills/yss-stage-decision/SKILL.md",
-        "effectiveHash": "a9d209ca8cf16bb8d0f9f6ea05cfedf6fb25928216f3872bc5a1ca5ac698d34a",
-        "sourceRevision": "41fb25425928153791f7d92a85eb717f4eb2d546",
-        "upstreamHash": "b9fe9d8f5009db0289123155f1662d8d21b34e26928d6728545da7f0c0bb0de1",
+        "effectiveHash": "ada584c7b996439a47e24153e156c38198f60f3f84250cd37aea6e2a118131aa",
+        "sourceRevision": "e24465921a8a51d8690a1732842274a35b935c9e",
+        "upstreamHash": "8752a1ed6903bd20c33e21b521d52bd4f7a0662b1d25e00152b60ba38333c93b",
         "adaptationRef": "docs/agents/strategic-design-skills-integration.md",
         "targets": [
           ".agents/skills",

package/template.manifest.json

@@ -82,6 +82,7 @@
     "scripts/verify-retired-skill-ids",
     "scripts/verify-skill-governance",
     "scripts/verify-skill-registry",
+    "scripts/verify-strategic-handoff-tools-lock",
     "scripts/verify-template",
     "scripts/verify-template-candidate",
     "scripts/verify-template-fast",

package/template.snapshot.json

@@ -3,15 +3,16 @@
   "templateName": "yss-spec-project-template",
   "templateSource": "github:iloveZzz/yss-spec-project-template",
   "templateRepository": "https://github.com/iloveZzz/yss-spec-project-template.git",
-  "requestedRef": "99061076f951d9fdf2f54eaa24d1edf745aefa65",
-  "templateCommit": "99061076f951d9fdf2f54eaa24d1edf745aefa65",
-  "manifestHash": "d194bb318a47c9c53b04292e97805c563ef7b296c2ca9b507cca498be7f52afe",
+  "requestedRef": "working-tree",
+  "templateCommit": "32fa044c0123f73b8d8091590d1f060440ac9ccb",
+  "sourceState": "working-tree",
+  "manifestHash": "191240f4716de5f93cf1b30ea917a9a14dfd4a29b12dd2ba569c6271fa46009e",
   "encodedPaths": {
     ".codex/skills/data-analytics/.gitignore": ".codex/skills/data-analytics/__yss_dotfile__.gitignore",
     ".codex/skills/product-design/.npmignore": ".codex/skills/product-design/__yss_dotfile__.npmignore",
     ".codex/skills/product-design/templates/prototype/.npmrc": ".codex/skills/product-design/templates/prototype/__yss_dotfile__.npmrc",
     ".gitignore": "__yss_dotfile__.gitignore"
   },
-  "snapshotHash": "7e8bec077d452f2270c479e622009536ae12495f21936b3f36a0298f0085d7aa",
-  "generatedAt": "2026-09-10T17:59:33.887Z"
+  "snapshotHash": "c6c4ab647dbf5a99159098417f05edcd7133c2907fe00aeaae0ea06d5589bf0d",
+  "generatedAt": "2026-09-11T13:22:12.721Z"
 }