create-yss-spec 3.1.0 → 3.2.0

package/template/scripts/lib/harness-execution-scope.mjs

@@ -0,0 +1,52 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { ROOT, read, safe, ensure } from './strategic-handoff-io.mjs';
+
+export function loadDeliveryProfile(root=ROOT) {
+  const metadata=['backend','frontend'].filter(side=>existsSync(path.join(root,`.yss-harness-${side}.json`)));
+  ensure(metadata.length<=1,'专职 Harness metadata 身份冲突');
+  const profilePath=path.join(root,'docs/process/harness-profile.yaml');
+  ensure(!metadata.length||existsSync(profilePath),'专职 Harness 缺少 profile，不得绕过执行门禁');
+  const profile=existsSync(profilePath)?read(safe(root,'docs/process/harness-profile.yaml')):null;
+  if(metadata.length) {
+    const expected=`harness.${metadata[0]}-delivery`;
+    const record=read(safe(root,`.yss-harness-${metadata[0]}.json`));
+    // Runtime scope checks preserve old projects; the new CLI still refuses their adoption.
+    const newIdentity=record.metadataSchemaVersion===2 && !('schema_version' in record) && !('profile_id' in record)
+      && record.profileId===expected && record.templateSource===`github:iloveZzz/yss-harness-${metadata[0]}-agent`
+      && profile?.instantiation?.cli_package===`create-yss-harness-${metadata[0]}`;
+    const oldIdentity=record.schema_version===1 && !('metadataSchemaVersion' in record) && record.profile_id===expected;
+    ensure((newIdentity||oldIdentity)&&profile?.profile_id===expected,'专职 Harness metadata 与 profile 不一致');
+  }
+  return profile;
+}
+
+function activeProfile(root) {
+  const profile=loadDeliveryProfile(root);
+  if (!['harness.backend-delivery','harness.frontend-delivery'].includes(profile?.profile_id)) return null;
+  const identity=read(safe(root,'yss-project.yaml'));
+  ensure(identity.schema_version===1&&['template-source','project-instance'].includes(identity.repository_mode),'专职 Harness 仓库身份无效');
+  return identity.repository_mode==='project-instance'?profile:null;
+}
+
+export function enforceHarnessTaskScope(task,{root=ROOT}={}) {
+  const profile=activeProfile(root);
+  if (!profile) return;
+  ensure(task.contract?.kind!=='template-maintenance','专职产品项目不得派发模板维护任务');
+  const local=[...profile.audience.target_user_roles,...profile.audience.control_plane_roles];
+  const crossReview=['Explorer','Reviewer'].includes(task.execution_state)&&task.allowed_write_paths.length===0;
+  ensure(local.includes(task.role_id)||crossReview,'专职 Harness 不允许派发另一端的实现/起草任务');
+  const opposite=profile.profile_id==='harness.frontend-delivery'?'backend':'frontend';
+  ensure(task.allowed_write_paths.every(ref=>!new RegExp(`^apps/${opposite}(?:/|$)`).test(ref)),'专职 Harness 不允许写入另一端工程');
+}
+
+export function enforceHarnessSkillScope(skills,registry,{root=ROOT}={}) {
+  const profile=activeProfile(root);
+  if (!profile) return;
+  const side=profile.profile_id==='harness.frontend-delivery'?'frontend':'backend';
+  const opposite=side==='frontend'?'backend':'frontend';
+  for (const id of skills) {
+    const impacts=registry.skills.find(skill=>skill.id===id)?.impacts||[];
+    ensure(!impacts.includes(opposite)||impacts.includes(side)||impacts.includes('lifecycle'),`专职 Harness 不允许编译另一端技能: ${id}`);
+  }
+}

package/template/scripts/lib/implementation-contract-compiler.mjs

@@ -1,3 +1,5 @@
+import { enforceTechnicalDesign } from './technical-design-boundary.mjs';
+import { enforceHarnessSkillScope } from "./harness-execution-scope.mjs";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import path from "node:path";
@@ -5,6 +7,7 @@ import { parseDocument } from "../vendor/yaml.mjs";
 import { DEFAULT_REGISTRY, loadSkillRegistry } from "./skill-registry.mjs";
 import { ROOT } from "./skill-supply-chain.mjs";
 import { architectureDigest, assertArchitectureAgreement, validateArchitectureIdentity } from "./backend-architecture.mjs";
+import { enforceFrontendDelivery } from "./frontend-delivery-boundary.mjs";
 
 export const DEFAULT_COMPILER_CONTRACT = path.join(
   ROOT,
@@ -61,9 +64,14 @@ export function compileImplementationContract({
   registryDigest,
   compilerContractDigest,
   architecture_identity,
-  architecture_evidence
+  architecture_evidence,
+  root = ROOT,
+  slice_id,
+  frontend_delivery,
+  technical_design
 }) {
   assertV2(registry, compilerContract);
+  const deliveryInput = enforceFrontendDelivery({ slice_id, frontend_delivery }, { root });
   if (!Array.isArray(recipeIds) || !Array.isArray(requiredCapabilities) || !Array.isArray(conditions)) {
     fail("recipeIds、requiredCapabilities 与 conditions 必须是数组");
   }
@@ -85,6 +93,8 @@ export function compileImplementationContract({
     for (const recipe of orderedRecipes) if (recipe.architecture_family && recipe.architecture_family !== architecture_identity.architecture_family) fail(`Recipe ${recipe.id} 与架构族不匹配`);
   }
 
+  enforceTechnicalDesign({ technical_design, conditions, architecture_identity, slice_id }, { root });
+
   const capabilitySources = new Map();
   const orderedCapabilities = [];
   const addCapability = (capabilityId, source) => {
@@ -156,10 +166,12 @@ export function compileImplementationContract({
     orderedSkills.push(skill);
   };
   for (const root of roots) visit(root);
+  enforceHarnessSkillScope(orderedSkills, registry, { root });
 
   return {
     schema_version: 2,
     status: "draft",
+    ...(deliveryInput.result === "inputs-verified" ? { slice_id: deliveryInput.slice_id, frontend_delivery: { acceptance_ref: deliveryInput.acceptance_ref, digest: deliveryInput.acceptance_digest } } : {}),
     ...(architecture_identity ? {
       architecture_identity: structuredClone(architecture_identity),
       architecture_identity_digest: architectureDigest(architecture_identity),
@@ -167,6 +179,7 @@ export function compileImplementationContract({
       readiness_blockers: architectureProfile.maturity === "supported" ? [] : ["backend-profile-not-supported"],
       skill_profiles: Object.fromEntries(orderedSkills.map((skill) => [skill, architecture_identity.architecture_profile]))
     } : {}),
+    ...(technical_design ? { technical_design, slice_id } : {}),
     recipe_ids: orderedRecipes.map((recipe) => recipe.id),
     conditions: [...conditionSet].sort(),
     required_capabilities: orderedCapabilities,
@@ -189,11 +202,15 @@ export function compileDefaultImplementationContract(input = {}) {
   });
 }
 
-export function evaluateContractFreshness(contract, { registry, compilerContract }) {
+export function evaluateContractFreshness(contract, { registry, compilerContract, root = ROOT }) {
   assertV2(registry, compilerContract);
   if (contract?.schema_version !== 2) fail("Slice Implementation Contract schema v1 已停止支持；必须重新编译 v2 合同");
   const resolution = contract.resolution ?? contract;
   const reasons = [];
+  try { enforceTechnicalDesign({ ...resolution, slice_id: contract.slice_id ?? resolution.slice_id }, { root }); }
+  catch { reasons.push("technical-design-stale-or-unavailable"); }
+  try { enforceFrontendDelivery(contract, { root }); }
+  catch { reasons.push("frontend-delivery-stale-or-unavailable"); }
   if (resolution.registry_digest !== digestDocument(registry)) reasons.push("registry-digest-changed");
   if (resolution.compiler_contract_digest !== digestDocument(compilerContract)) reasons.push("compiler-contract-digest-changed");
   if (resolution.architecture_identity) {

package/template/scripts/lib/lifecycle-transition.mjs

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { parseDocument } from "../vendor/yaml.mjs";
 import { assertWorkUnitUserDecision, assertImplementationDecision } from "./user-decision.mjs";
+import { enforceFrontendDelivery } from "./frontend-delivery-boundary.mjs";
 
 const IMPLEMENTATION_WORK_UNIT = "work-unit.slice-implementation";
 const TICKET_DECOMPOSITION_WORK_UNIT = "work-unit.ticket-decomposition";
@@ -112,6 +113,10 @@ function validateTicketReference(ref, trackerKind) {
  * by `validateWorkflowExecutionResult` before this function is called.
  */
 export function validateNextRoute(currentWorkUnit, nextRoute, decisionState, options = {}) {
+  if (["work-unit.technical-analysis", TICKET_DECOMPOSITION_WORK_UNIT, IMPLEMENTATION_WORK_UNIT, "work-unit.frontend-implementation-verification"].includes(nextRoute)) {
+    try { enforceFrontendDelivery(decisionState, { root: options.root, phase: nextRoute === IMPLEMENTATION_WORK_UNIT ? "implementation" : "inputs" }); }
+    catch (error) { return blockedResult(["frontend-delivery-blocked"], [error.message]); }
+  }
   const routes = NEXT_ROUTES[currentWorkUnit];
   if (!routes) return blockedResult([BLOCKING_SIGNALS.invalidRoute], ["known_current_work_unit"]);
   if (nextRoute === null && routes.length === 0) {
@@ -138,6 +143,8 @@ function validateDecisionBoundary(workUnit, state, options) {
  * `exists` is injectable so external adapters can resolve their own tracker refs.
  */
 export function validateTicketFormalization(state, { exists = existsSync, read = (ref) => readFileSync(ref, "utf8"), ...decisionOptions } = {}) {
+  try { enforceFrontendDelivery(state, { root: decisionOptions.root, phase: "implementation" }); }
+  catch (error) { return blockedResult(["frontend-delivery-blocked"], [error.message]); }
   const decomposition = state?.ticket_decomposition_result;
   const ticket = state?.vertical_slice_ticket;
   const contract = state?.slice_contract;

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

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { openBundle } from './strategic-handoff.mjs';
 import { read, safe, ensure, ROOT, digest, project } from './strategic-handoff-io.mjs';
+import { designTargets } from './strategic-handoff-design-targets.mjs';
 import { parseContextContract } from './context-contract.mjs';
 const present=x=>typeof x==='string'&&x.trim();
 const list=x=>Array.isArray(x)&&x.length&&x.every(present);
@@ -11,9 +12,11 @@ const strategyBasis=value=>({
   ...without(value,['domain_version','approval','rule_catalog','scenarios','invariants']),
   invariants:(value.invariants||[]).map(item=>without(item,['statement'])),
 });
-export async function verifyConsumption(data,{root=process.cwd(),sliceRef}={}) {
+export async function verifyConsumption(data,{root=process.cwd(),sliceRef,consumer='tactical'}={}) {
   project(root);
-  if (sliceRef) ensure(data.status === "approved", "切片只能消费 approved 战术合同");
+  ensure(['tactical','frontend'].includes(consumer),'未知战略消费者');
+  if (data.schema_version === 2 && consumer === 'tactical') ensure(['domain-driven','layered-mvc'].includes(data.architecture?.family), '未知技术设计架构');
+  if (sliceRef) ensure(data.status === (consumer==='frontend'?'accepted':'approved'), consumer==='frontend'?'前端接收记录尚未 accepted':'切片只能消费 approved 战术合同');
   const binding=data.strategic_handoff;
   ensure(binding && present(binding.import_receipt_ref) && present(binding.context_reconciliation_ref),'缺少战略交接导入收据与目标对账引用');
   const receipt=read(safe(root,binding.import_receipt_ref));
@@ -41,18 +44,22 @@ export async function verifyConsumption(data,{root=process.cwd(),sliceRef}={}) {
       const rows=new Map();for(const row of binding.rows){ensure(!rows.has(row.source_id),`重复承接: ${row.source_id}`);rows.set(row.source_id,row);}
       const issues=[], blocked=new Set();let all=false;
       const mark=(id,reason,row)=>{issues.push({source_id:id,reason});if(row?.dependency_status!=='known'||!list(row.dependent_slice_refs))all=true;else row.dependent_slice_refs.forEach(x=>blocked.add(x));};
-      const catalogs=['aggregate_catalog','entity_catalog','value_object_catalog','behavior_catalog','invariant_catalog','state_transition_catalog','domain_event_catalog','gateway_catalog'];
-      const ids=new Set(catalogs.flatMap(k=>(data[k]||[]).flatMap(x=>Object.entries(x).filter(([k])=>k.endsWith('_id')).map(([,v])=>v))));
-      const seams=new Map((data.test_seams||[]).map(x=>[x.seam_id,x]));
+      const { ids, seams } = designTargets(data);
+      const cases=new Map((data.frontend_cases||[]).map(x=>[x.case_id,x]));
       for(const[id,source]of known){
         const row=rows.get(id);
         if(!row){mark(id,'missing-mapping');continue;}
         ensure(['known','unknown'].includes(row.dependency_status) && Array.isArray(row.dependent_slice_refs),'缺少切片依赖判定');
         if(row.source_digest!==source.source_digest){mark(id,'stale-source',row);continue;}
-        if(row.disposition==='implemented'){
-          ensure(list(row.tactical_refs)&&row.tactical_refs.every(x=>ids.has(x)),`战术落点悬空: ${id}`);
-          ensure(list(row.test_seam_refs)&&row.test_seam_refs.every(x=>seams.has(x)&&row.tactical_refs.includes(seams.get(x).subject_ref)),`测试 seam 未关联战术落点: ${id}`);
-          if(id.startsWith('scenario.'))ensure(['success','failure'].every(outcome=>(row.scenario_tests||[]).some(x=>x.outcome===outcome&&row.test_seam_refs.includes(x.seam_ref))),`关键场景缺少成功/失败测试: ${id}`);
+        if(row.disposition===(consumer==='frontend'?'mapped':'implemented')){
+          if(consumer==='frontend'){
+            ensure(list(row.frontend_case_refs)&&row.frontend_case_refs.every(ref=>cases.has(ref)&&cases.get(ref).source_ids.includes(id)),`前端用例未承接源规则/场景: ${id}`);
+            if(id.startsWith('scenario.'))ensure(['success','failure'].every(outcome=>row.frontend_case_refs.some(ref=>cases.get(ref).outcome===outcome)),`前端关键场景缺少成功/失败用例: ${id}`);
+          }else{
+            ensure(list(row.tactical_refs)&&row.tactical_refs.every(x=>ids.has(x)),`战术落点悬空: ${id}`);
+            ensure(list(row.test_seam_refs)&&row.test_seam_refs.every(x=>seams.has(x)&&row.tactical_refs.includes(seams.get(x).subject_ref)),`测试 seam 未关联战术落点: ${id}`);
+            if(id.startsWith('scenario.'))ensure(['success','failure'].every(outcome=>(row.scenario_tests||[]).some(x=>x.outcome===outcome&&row.test_seam_refs.includes(x.seam_ref))),`关键场景缺少成功/失败测试: ${id}`);
+          }
           ensure(list(row.evidence_refs),`缺少落实证据: ${id}`);row.evidence_refs.forEach(ref=>safe(root,ref));
         }else if(row.disposition==='deferred'){
           for(const key of ['reason','risk','owner','followup_ticket_ref','verification_plan','target_version'])ensure(present(row[key]),`延期缺少 ${key}: ${id}`);
@@ -70,7 +77,7 @@ export async function verifyConsumption(data,{root=process.cwd(),sliceRef}={}) {
         all=true;issues.push({source_id:'strategic-design-basis',reason:'upstream-design-stale'});
       }
       const blockedHere=all||(sliceRef?blocked.has(sliceRef):issues.length>0);
-      return {result:blockedHere?'blocked':'verified',bundle_digest:current.manifest.bundle_digest,consumed_bundle_digest:receipt.bundle_digest,tactical_digest:digest(data),scope:sliceRef||'whole-tactical-design',coverage_complete:[...known.keys()].every(id=>rows.has(id)),block_all:all,blocked_slice_refs:[...blocked].sort(),issues};
+      return {result:blockedHere?'blocked':'verified',bundle_digest:current.manifest.bundle_digest,consumed_bundle_digest:receipt.bundle_digest,...(consumer==='frontend'?{frontend_acceptance_digest:digest(data)}:{tactical_digest:digest(data), ...(data.schema_version === 2 ? {technical_design_digest:digest(data)} : {})}),scope:sliceRef||`whole-${consumer}-design`,coverage_complete:[...known.keys()].every(id=>rows.has(id)),block_all:all,blocked_slice_refs:[...blocked].sort(),issues};
     });
   });
 }

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

@@ -0,0 +1,15 @@
+import { ensure } from './strategic-handoff-io.mjs';
+
+export function designTargets(data) {
+  const design = data.schema_version === 2 ? data.design : data;
+  const catalogs = data.schema_version === 2 && data.architecture?.family === 'layered-mvc'
+    ? ['module_catalog', 'use_case_catalog', 'rule_catalog', 'state_transition_catalog', 'persistence_mapping', 'integration_catalog']
+    : ['aggregate_catalog', 'entity_catalog', 'value_object_catalog', 'behavior_catalog', 'invariant_catalog', 'state_transition_catalog', 'domain_event_catalog', 'gateway_catalog'];
+  const primaryKeys = { module_catalog: 'module_id', use_case_catalog: 'use_case_id', rule_catalog: 'rule_id', state_transition_catalog: 'transition_id', persistence_mapping: 'mapping_id', integration_catalog: 'integration_id', aggregate_catalog: 'aggregate_id', entity_catalog: 'entity_id', value_object_catalog: 'value_object_id', behavior_catalog: 'behavior_id', invariant_catalog: 'invariant_id', domain_event_catalog: 'event_id', gateway_catalog: 'gateway_id' };
+  const ids = catalogs.flatMap(key => (design?.[key] || []).map(item => item[primaryKeys[key]]).filter(Boolean));
+  ensure(new Set(ids).size === ids.length, '设计对象 ID 重复');
+  const seams = design?.test_seams || [];
+  ensure(new Set(seams.map(item => item.seam_id)).size === seams.length, '测试 seam ID 重复');
+  return { ids: new Set(ids), seams: new Map(seams.map(item => [item.seam_id, item])) };
+}
+

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

@@ -13,7 +13,7 @@ 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}`); })();
 
-async function sourceApproval(record, roles, root) {
+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')), '接收工具不支持源用户决定策略，请升级工具后验包');

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

@@ -6,6 +6,8 @@ import { loadRegistry, ROOT } from "./lifecycle-registry.mjs";
 import { loadMaintenanceCheckpoint, validateMaintenanceCheckpoint } from "./maintenance-intensity.mjs";
 import { assertImplementationDecision } from "./user-decision.mjs";
 import { validateNextRoute } from "./lifecycle-transition.mjs";
+import { enforceHarnessTaskScope } from "./harness-execution-scope.mjs";
+import { enforceFrontendDelivery } from "./frontend-delivery-boundary.mjs";
 import { LEGACY_TASK_PACKAGE_SCHEMA, TASK_PACKAGE_SCHEMA, validateTaskPackageSchema } from "./task-package-schema.mjs";
 
 export { LEGACY_TASK_PACKAGE_SCHEMA, TASK_PACKAGE_SCHEMA, validateTaskPackageSchema };
@@ -181,6 +183,11 @@ function validateContract(value, registry, lifecycle) {
 
 export function validateTaskPackage(value, { rolesDoc, lifecycleDoc } = {}) {
   validateTaskPackageSchema(value);
+  enforceHarnessTaskScope(value);
+  const intake = value.execution_state === "Explorer" && value.allowed_write_paths.length === 0 && ["work-unit.entry-triage", "work-unit.harness-entry"].includes(value.work_unit_id);
+  if (!intake) {
+    enforceFrontendDelivery(value, { phase: value.contract.kind === "slice-implementation" ? "implementation" : "inputs" });
+  }
   const registry = rolesDoc || loadDigitalHumanRoles();
   const lifecycle = lifecycleDoc || loadRegistry();
   validateCommon(value, registry, lifecycle);

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

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { ROOT, read, safe, ensure, hash } from './strategic-handoff-io.mjs';
+
+// The compiler's synchronous boundary reruns the design verifier against current files.
+export function enforceTechnicalDesign(state = {}, { root = ROOT } = {}) {
+  const binding = state.technical_design;
+  const affected = (state.conditions || []).some(value => ['backend-technical-design-impact','tactical-domain','tactical-domain-impact','aggregate-impact','state-machine-impact','invariant-impact','consistency-impact','domain-event-impact','gateway-boundary-impact','persistence-mapping-impact'].includes(value));
+  if (!binding && !affected) return;
+  ensure(binding?.ref && binding?.digest && binding?.version, '缺少已批准技术设计绑定');
+  ensure(state.slice_id, '技术设计消费必须绑定切片 ID');
+  const file = safe(root, binding.ref);
+  ensure(hash(readFileSync(file)) === binding.digest, '技术设计绑定摘要漂移');
+  const data = read(file);
+  ensure(data.status === 'approved' && data.version === binding.version, '技术设计必须为批准且绑定版本');
+  const family = data.schema_version === 1 && binding.legacy_ddd === true ? 'domain-driven' : data.architecture?.family;
+  ensure(family && family === state.architecture_identity?.architecture_family, '技术设计与实现架构不匹配');
+  const args = [path.join(ROOT, '.agents/skills/yss-technical-design/scripts/validate-technical-design.mjs'), file, '--root', root, '--slice', state.slice_id];
+  if (binding.legacy_ddd === true) args.push('--legacy-ddd');
+  const verified = spawnSync(process.execPath, args, { cwd: root, encoding: 'utf8', timeout: 60000, maxBuffer: 2 * 1024 * 1024 });
+  ensure(verified.status === 0, `技术设计不可消费: ${verified.error?.message || verified.stderr}`);
+}

package/template/scripts/sync-strategic-handoff-tools

@@ -5,14 +5,17 @@ import path from 'node:path';
 import { inspectWorkingTreeScope } from './lib/repository-scope-policy.mjs';
 const root=path.resolve(import.meta.dirname,'..');
 const check=process.argv.includes('--check');
-const targets=['submodules/yss-harness-design-agent','submodules/yss-harness-dev-agent'];
+const targets=['submodules/yss-harness-design-agent','submodules/yss-harness-dev-agent','submodules/yss-harness-backend-agent','submodules/yss-harness-frontend-agent'];
 const shared=['scripts/strategic-handoff','scripts/verify-strategic-handoff-consumption','scripts/verify-strategic-handoff-package-scenarios','scripts/verify-strategic-context-import','scripts/verify-strategic-context-import-scenarios','scripts/lib/context-contract.mjs','docs/process/strategic-handoff-package.md','docs/process/schemas/strategic-design-handoff.schema.json',...readdirSync(path.join(root,'scripts/lib')).filter(x=>x.startsWith('strategic-handoff-')||x==='strategic-handoff.mjs').map(x=>`scripts/lib/${x}`),...readdirSync(path.join(root,'docs/process/schemas')).filter(x=>x.startsWith('strategic-handoff-')).map(x=>`docs/process/schemas/${x}`),...readdirSync(path.join(root,'scripts/fixtures/strategic-handoff')).map(x=>`scripts/fixtures/strategic-handoff/${x}`)];
+shared.push('scripts/instantiate-harness','scripts/backend-delivery','scripts/verify-frontend-delivery','scripts/lib/backend-delivery.mjs','scripts/lib/frontend-delivery.mjs','scripts/lib/frontend-delivery-boundary.mjs','docs/process/frontend-backend-delivery.md','docs/process/schemas/backend-delivery.schema.json','docs/process/schemas/backend-delivery-verification.schema.json','docs/process/schemas/frontend-delivery-acceptance.schema.json');
 let differences=[];
-function sync(source,dest){const bytes=readFileSync(source);if(!existsSync(dest)||!bytes.equals(readFileSync(dest))){differences.push(path.relative(root,dest));if(!check){mkdirSync(path.dirname(dest),{recursive:true});writeFileSync(dest,bytes);}}if(!check&&path.basename(path.dirname(dest))==='scripts'&&!path.extname(dest))chmodSync(dest,0o755);}
+// 专职执行范围由各模板持有；后端只消费 wire 校验器，不恢复原型构建技能。
+function sync(source,dest){let bytes=readFileSync(source);if(dest.includes('/yss-harness-backend-agent/')){let content=bytes.toString();if(dest.endsWith('/scripts/lib/strategic-handoff.mjs'))content=content.replace('../../.agents/skills/yss-prototype-stage/scripts/visual-baseline-contract.mjs','./visual-baseline-contract.mjs');if(dest.endsWith('/scripts/fixtures/strategic-handoff/fixture.mjs'))content=content.replace('../../../.agents/skills/yss-prototype-stage/scripts/visual-baseline-contract.mjs','../../lib/visual-baseline-contract.mjs');bytes=Buffer.from(content);}if(!existsSync(dest)||!bytes.equals(readFileSync(dest))){differences.push(path.relative(root,dest));if(!check){mkdirSync(path.dirname(dest),{recursive:true});writeFileSync(dest,bytes);}}if(!check&&path.basename(path.dirname(dest))==='scripts'&&!path.extname(dest))chmodSync(dest,0o755);}
 for(const kind of ['domain-strategy','stage-decision-package'])sync(path.join(root,`.agents/skills/yss-stage-decision/references/${kind}.schema.json`),path.join(root,`docs/process/schemas/strategic-handoff-${kind}.schema.json`));
 for(const target of targets){
  if(!existsSync(path.join(root,target,'.git')))continue;
  if(!check){const state=inspectWorkingTreeScope(root,{project_root:target,repository_scope:'git-submodule',checkout_state:'attached-branch'});if(!state.writable)throw new Error(`${target}: ${state.violation}`);}
+ if(!target.endsWith('design-agent'))for(const ref of ['scripts/verify-frontend-delivery-scenarios','scripts/fixtures/backend-delivery/revision-server.mjs'])sync(path.join(root,ref),path.join(root,target,ref));
  for(const ref of new Set(shared))sync(path.join(root,ref),path.join(root,target,ref));
 }
 if(check&&differences.length){process.stderr.write(`交接工具同步漂移: ${differences.join(', ')}\n`);process.exitCode=1;}else process.stdout.write(`战略交接共享工具 ${check?'同步检查通过':`同步 ${differences.length} 文件`}\n`);

package/template/scripts/verify-frontend-delivery

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

package/template/scripts/verify-frontend-delivery-scenarios

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { fork } from 'node:child_process';
+import { once } from 'node:events';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync, cpSync, existsSync } from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { tmpdir } from 'node:os';
+import { fixture, context } from './fixtures/strategic-handoff/fixture.mjs';
+import { exportBundle } from './lib/strategic-handoff.mjs';
+const backendTools=process.env.YSS_DELIVERY_TEST_BACKEND_ROOT;
+const frontendTools=process.env.YSS_DELIVERY_TEST_FRONTEND_ROOT;
+const { backendDeliveryBasis, exportBackendDelivery, openBackendDelivery, inspectBackendDelivery } = await import(backendTools?pathToFileURL(path.join(backendTools,'scripts/lib/backend-delivery.mjs')):'./lib/backend-delivery.mjs');
+const {importBackendDelivery}=await import(frontendTools?pathToFileURL(path.join(frontendTools,'scripts/lib/backend-delivery.mjs')):'./lib/backend-delivery.mjs');
+const { verifyFrontendDelivery } = await import(frontendTools?pathToFileURL(path.join(frontendTools,'scripts/lib/frontend-delivery.mjs')):'./lib/frontend-delivery.mjs');
+const { enforceFrontendDelivery } = await import(frontendTools?pathToFileURL(path.join(frontendTools,'scripts/lib/frontend-delivery-boundary.mjs')):'./lib/frontend-delivery-boundary.mjs');
+const { compileDefaultImplementationContract } = await import(frontendTools?pathToFileURL(path.join(frontendTools,'scripts/lib/implementation-contract-compiler.mjs')):'./lib/implementation-contract-compiler.mjs');
+const { validateNextRoute, validateImplementationEntry } = await import(frontendTools?pathToFileURL(path.join(frontendTools,'scripts/lib/lifecycle-transition.mjs')):'./lib/lifecycle-transition.mjs');
+import { read, hash, json, ROOT } from './lib/strategic-handoff-io.mjs';
+const runtimeRegistry=read(path.join(frontendTools||ROOT,'docs/process/lifecycle-registry.yaml'));
+const frontendStage=runtimeRegistry.stages.find(x=>x.id==='stage.frontend-engineering-design')?.id||runtimeRegistry.stages.find(x=>x.id==='stage.tactical-design')?.id||'stage.system-data-engineering';
+const frontendWorkUnit=frontendStage==='stage.frontend-engineering-design'?'work-unit.frontend-engineering-design':frontendStage==='stage.tactical-design'?'work-unit.tactical-design':'work-unit.technical-analysis';
+
+test('战略与后端交付联合接收：便携、真实服务、拒绝不完整/过期输入及执行入口绕过',async t=>{
+  const base=mkdtempSync(path.join(tmpdir(),'frontend-delivery-test-'));
+  const put=(root,ref,value)=>{mkdirSync(path.dirname(path.join(root,ref)),{recursive:true});writeFileSync(path.join(root,ref),typeof value==='string'?value:json(value));};
+  const source=path.join(base,'strategy'), backend=path.join(base,'backend'), frontend=path.join(base,'frontend');
+  [source,backend,frontend].forEach(root=>mkdirSync(root));
+  if(backendTools)cpSync(backendTools,backend,{recursive:true});
+  if(frontendTools)cpSync(frontendTools,frontend,{recursive:true});
+  const f=await fixture(source);
+  for(const root of [backend,frontend]) {put(root,'yss-project.yaml','schema_version: 1\nrepository_mode: project-instance\n');put(root,'CONTEXT.md',context);}
+  const strategic=await exportBundle({sourceRoot:source,handoffRef:'handoff.yaml',output:path.join(backend,'strategy-package')});
+  const roles=read(path.join(source,'docs/agents/digital-human-roles.yaml'));
+  for(const gate of ['gate.openapi-frozen','gate.slice-contract-approved']) {
+    roles.gate_policy.biological_human=(roles.gate_policy.biological_human||[]).filter(x=>x!==gate);
+    roles.gate_policy.digital_human_review=(roles.gate_policy.digital_human_review||[]).filter(x=>x.gate!==gate);
+    roles.gate_policy.digital_human_review.push({gate,countersigners:['role.product-manager']});
+  }
+  put(backend,'docs/agents/digital-human-roles.yaml',roles);
+  put(backend,'api.yaml',{openapi:'3.1.0',info:{title:'Synthetic supplier API',version:'1'},paths:{'/suppliers':{post:{operationId:'submitSupplier',responses:{'200':{description:'OK'}}}}}});
+  put(backend,'slice.json',{schema_version:2,contract_id:'contract.backend',contract_version:'v1',slice_id:'slice.submit',status:'approved'});
+  put(backend,'data.md','Synthetic data setup for maintenance tests, not product verification.');
+  put(backend,'verification.log','Synthetic test fixture: successful/failed submissions exercised.');
+  const file=ref=>({ref,digest:hash(readFileSync(path.join(backend,ref)))});
+  const approved=(ref,id,gate)=>{
+    const binding={...file(ref),id,version:'v1',approval_ref:`approvals/${id}.json`};
+    put(backend,binding.approval_ref,{schema_version:1,gate_id:gate,decision:'approved',actor_kind:'digital-human',role_id:'role.product-manager',runtime_id:'runtime.generic',principal_ref:'synthetic-maintenance-fixture',artifact_bindings:[{id,version:'v1',digest:binding.digest}]});return binding;
+  };
+  const serverState=path.join(base,'server.json');put(base,'server.json',{body:{}});
+  const server=fork(path.join(ROOT,'scripts/fixtures/backend-delivery/revision-server.mjs'),[serverState],{stdio:['ignore','ignore','inherit','ipc']});
+  t.after(()=>{server.kill();rmSync(base,{recursive:true,force:true});});
+  const [{port}]=await once(server,'message');
+  const delivery={schema_version:1,delivery_id:'backend-delivery.supplier',version:'v1',status:'verified',strategic_bundle_ref:'strategy-package',strategic_bundle_digest:strategic.bundle_digest,scope:{slice_id:'slice.submit',source_ids:['rule.complete','scenario.submit'],operation_ids:['submitSupplier']},openapi:approved('api.yaml','api.supplier','gate.openapi-frozen'),slice_contract:approved('slice.json','contract.backend','gate.slice-contract-approved'),build:{source_commit:'a'.repeat(40),artifact_digest:`sha256:${'b'.repeat(64)}`},environment:{id:'fixture-local',base_url:`http://127.0.0.1:${port}`,deployment_id:'fixture-v1',revision_path:'/version',revision_pointers:{deployment_id:'/deployment_id',source_commit:'/source_commit',openapi_digest:'/openapi_digest',artifact_digest:'/artifact_digest',test_data_digest:'/test_data_digest'},test_data:file('data.md')},verification:{},supporting_files:[]};
+  const record=kind=>({schema_version:1,kind,subject_digest:backendDeliveryBasis(delivery),results:[{command:'synthetic-maintenance-test',executed_at:new Date().toISOString(),exit_code:0,evidence:[file('verification.log')]}],operation_ids:['submitSupplier'],coverage:[{source_id:'scenario.submit',outcome:'success'},{source_id:'scenario.submit',outcome:'failure'}]});
+  put(backend,'contract-test.json',record('backend-contract'));put(backend,'deployment-test.json',record('backend-deployment'));
+  delivery.verification={contract:file('contract-test.json'),deployment:file('deployment-test.json')};put(backend,'delivery.json',delivery);
+  const body={deployment_id:'fixture-v1',source_commit:delivery.build.source_commit,openapi_digest:delivery.openapi.digest,artifact_digest:delivery.build.artifact_digest,test_data_digest:delivery.environment.test_data.digest};
+  put(base,'server.json',{body});
+  await t.test('导出拒绝缺失场景、篡改接口及错误批准',async()=>{
+    const bytes=readFileSync(path.join(backend,'api.yaml'));put(backend,'api.yaml','changed');
+    await assert.rejects(()=>inspectBackendDelivery(backend,'delivery.json'),/摘要不一致/);writeFileSync(path.join(backend,'api.yaml'),bytes);
+    const approval=read(path.join(backend,delivery.openapi.approval_ref));put(backend,delivery.openapi.approval_ref,{...approval,artifact_bindings:[]});
+    await assert.rejects(()=>inspectBackendDelivery(backend,'delivery.json'),/批准未绑定/);put(backend,delivery.openapi.approval_ref,approval);
+    const tests=record('backend-contract');tests.coverage.pop();put(backend,'contract-test.json',tests);
+    const broken=structuredClone(delivery);broken.verification.contract=file('contract-test.json');put(backend,'delivery.json',broken);
+    await assert.rejects(()=>inspectBackendDelivery(backend,'delivery.json'),/成功\/失败/);
+    put(backend,'contract-test.json',record('backend-contract'));delivery.verification.contract=file('contract-test.json');put(backend,'delivery.json',delivery);
+  });
+  const output=path.join(base,'package');await exportBackendDelivery({sourceRoot:backend,deliveryRef:'delivery.json',output,zip:true});
+  const imported=await importBackendDelivery({bundle:`${output}.zip`,targetRoot:frontend});
+  assert.equal((await importBackendDelivery({bundle:output,targetRoot:frontend})).result,'already-imported');
+  const acceptance=read(path.join(frontend,imported.acceptance_ref));
+  await t.test('草案/缺少两类产物不能进入前端任务',async()=>{
+    await assert.rejects(()=>verifyFrontendDelivery({root:frontend,acceptanceRef:imported.acceptance_ref,sliceRef:'slice.submit'}),/schema/);
+    const profileRef=path.join(frontend,'docs/process/harness-profile.yaml');
+    const profile=existsSync(profileRef)?read(profileRef):{schema_version:1,profile_id:'harness.frontend-delivery'};
+    put(frontend,'docs/process/harness-profile.yaml',{...profile,frontend_delivery:{required:true}});
+    assert.throws(()=>enforceFrontendDelivery({}, {root:frontend}),/frontend-delivery-required/);
+    assert.throws(()=>compileDefaultImplementationContract({root:frontend}),/frontend-delivery-required/);
+    assert.throws(()=>enforceFrontendDelivery({contract:{kind:'template-maintenance'}},{root:frontend}),/不得用模板维护/);
+    assert.equal(validateNextRoute(frontendWorkUnit==='work-unit.technical-analysis'?'work-unit.spec-synthesis':'work-unit.harness-entry',frontendWorkUnit,undefined,{root:frontend}).result,'blocked');
+    assert.equal(validateImplementationEntry({}, {root:frontend}).blocking_signals[0],'frontend-delivery-blocked');
+  });
+  put(frontend,'reconciliation.json',{schema_version:1,repository_mode:'project-instance',stage:frontendStage,work_unit:frontendWorkUnit,status:'reconciled',context_snapshot:f.snapshot,changes:{added:['Global/Supplier'],updated:[],deprecated:[]},unresolved_terms:[],evidence_refs:['CONTEXT.md']});
+  put(frontend,'cases.md','Synthetic planned UI cases: complete submission succeeds; incomplete submission fails.');
+  acceptance.status='accepted';acceptance.strategic_handoff.context_reconciliation_ref='reconciliation.json';
+  acceptance.frontend_cases=['success','failure'].map(outcome=>({case_id:`submit-${outcome}`,source_ids:['rule.complete','scenario.submit'],outcome,operation_ids:['submitSupplier'],visual_case_ids:['primary-desktop','primary-narrow'],evidence_ref:'cases.md',evidence_digest:hash(readFileSync(path.join(frontend,'cases.md')))}));
+  for(const row of acceptance.strategic_handoff.rows)Object.assign(row,{disposition:'mapped',frontend_case_refs:acceptance.frontend_cases.map(x=>x.case_id),dependency_status:'known',dependent_slice_refs:['slice.submit'],evidence_refs:['cases.md']});
+  put(frontend,imported.acceptance_ref,acceptance);
+  const check=()=>verifyFrontendDelivery({root:frontend,acceptanceRef:imported.acceptance_ref,sliceRef:'slice.submit'});
+  await t.test('源仓消失后可验 ZIP 并独立恢复；输入就绪不授予代码实施',async()=>{
+    rmSync(source,{recursive:true});rmSync(backend,{recursive:true});
+    assert.equal(await openBackendDelivery(`${output}.zip`,b=>b.delivery.scope.slice_id),'slice.submit');
+    const verified=await check();assert.equal(verified.result,'inputs-verified');assert.equal(verified.ready_for_agent,false);
+    assert.equal(verified.actual_verification.observed.deployment_id,'fixture-v1');
+    const draft=compileDefaultImplementationContract({root:frontend,slice_id:'slice.submit',frontend_delivery:{acceptance_ref:imported.acceptance_ref},requiredCapabilities:['governance.implementation-contract']});
+    assert.equal(draft.status,'draft');assert.equal(draft.slice_id,'slice.submit');assert.equal(draft.frontend_delivery.digest,verified.acceptance_digest);
+    assert.equal(enforceFrontendDelivery({slice_id:'slice.submit',frontend_delivery:{acceptance_ref:imported.acceptance_ref}}, {root:frontend}).result,'inputs-verified');
+    assert.throws(()=>enforceFrontendDelivery({slice_id:'slice.submit',frontend_delivery:{acceptance_ref:imported.acceptance_ref}}, {root:frontend,phase:'implementation'}),/approved Slice Contract/);
+  });
+  await t.test('实现边界读取持久化合同并冻结接收记录及用例字节',async()=>{
+    const binding={acceptance_ref:imported.acceptance_ref,digest:hash(readFileSync(path.join(frontend,imported.acceptance_ref)))};
+    put(frontend,'frontend-contract.json',{status:'approved',slice_id:'slice.submit',frontend:{delivery:binding}});
+    assert.equal(enforceFrontendDelivery({slice_contract_ref:'frontend-contract.json'},{root:frontend,phase:'implementation'}).result,'inputs-verified');
+    put(frontend,'cases.md','changed case');await assert.rejects(check,/摘要漂移/);
+    put(frontend,'cases.md','Synthetic planned UI cases: complete submission succeeds; incomplete submission fails.');
+    put(frontend,'frontend-contract.json',{status:'draft',slice_id:'slice.submit',frontend:{delivery:binding}});
+    assert.throws(()=>enforceFrontendDelivery({slice_contract_ref:'frontend-contract.json'},{root:frontend,phase:'implementation'}),/approved Slice Contract/);
+  });
+  await t.test('部署版本/数据失配与服务失败使旧接收记录失效',async()=>{
+    for(const field of ['deployment_id','source_commit','openapi_digest','artifact_digest','test_data_digest']) {
+      put(base,'server.json',{body:{...body,[field]:'wrong'}});await assert.rejects(check,/真实服务版本不匹配/);
+    }
+    put(base,'server.json',{status:503,body});await assert.rejects(check,/真实接口不可用/);put(base,'server.json',{body});
+  });
+  await t.test('范围、摘要和逐条承接缺口均拒绝',async()=>{
+    await assert.rejects(()=>verifyFrontendDelivery({root:frontend,acceptanceRef:imported.acceptance_ref,sliceRef:'slice.other'}),/切片不匹配/);
+    await assert.rejects(()=>verifyFrontendDelivery({root:frontend,acceptanceRef:imported.acceptance_ref,sliceRef:'slice.submit',expectedDigest:`sha256:${'0'.repeat(64)}`}),/摘要已变化/);
+    for(const mutate of [a=>a.frontend_cases.pop(),a=>a.strategic_handoff.rows[0].disposition='pending',a=>a.frontend_cases[0].operation_ids=['unknown'],a=>a.strategic_handoff.bundle_digest=`sha256:${'0'.repeat(64)}`]) {
+      const changed=structuredClone(acceptance);mutate(changed);put(frontend,imported.acceptance_ref,changed);await assert.rejects(check);
+    }
+    put(frontend,imported.acceptance_ref,acceptance);
+  });
+  await t.test('已导入更新版本阻断旧切片；包篡改拒绝',async()=>{
+    const receipt=read(path.join(frontend,imported.receipt_ref));const newer=path.posix.dirname(path.posix.dirname(imported.receipt_ref))+'/v2';
+    put(frontend,`${newer}/import-receipt.json`,{...receipt,version:'v2'});await assert.rejects(check,/旧前端接收记录 stale/);rmSync(path.join(frontend,newer),{recursive:true});
+    const changed=path.join(base,'tampered');cpSync(output,changed,{recursive:true});put(changed,'extra.txt','extra');await assert.rejects(()=>openBackendDelivery(changed,()=>null),/未登记文件/);
+  });
+});

package/template/scripts/verify-frontend-implementation-evidence

@@ -6,6 +6,7 @@ import { parseArgs } from "node:util";
 import { fileURLToPath } from "node:url";
 import { parseDocument } from "./vendor/yaml.mjs";
 import { validateVisualBaseline } from "../.agents/skills/yss-prototype-stage/scripts/visual-baseline-contract.mjs";
+import { enforceFrontendDelivery } from "./lib/frontend-delivery-boundary.mjs";
 
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const schemaPath = path.join(repoRoot, "docs/process/schemas/frontend-implementation-evidence.schema.json");
@@ -29,6 +30,7 @@ try {
   const document = parseDocument(readFileSync(path.resolve(positionals[0]), "utf8"), { maxAliasCount: 0, uniqueKeys: true });
   if (document.errors.length) throw new TypeError(document.errors[0].message);
   const value = document.toJS({ maxAliasCount: 0 });
+  if (!values["allow-template"]) enforceFrontendDelivery(value, { root, phase: value.kind === "verification" ? "implementation" : "inputs" });
   if (value.schema_version === 1 && !values["allow-template"]) throw new TypeError("migration-required: frontend implementation evidence v1 是只读历史资产；在途 UI 工作必须升级 v2 并绑定 Visual Baseline case_id");
   const result = spawnSync("python3", ["-c", validator, schemaPath], { cwd: repoRoot, encoding: "utf8", input: JSON.stringify(value) });
   if (result.status !== 0) throw new TypeError(`${result.stdout}${result.stderr}`.trim());

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

@@ -9,7 +9,7 @@ import { fixture, context } from './fixtures/strategic-handoff/fixture.mjs';
 import { exportBundle, openBundle, importBundle } from './lib/strategic-handoff.mjs';
 import { read, json, hash, digest } from './lib/strategic-handoff-io.mjs';
 import { parseContextContract } from './lib/context-contract.mjs';
-const setup=async t=>{const base=mkdtempSync(path.join(tmpdir(),'handoff-test-'));t.after(()=>rmSync(base,{recursive:true,force:true}));const source=path.join(base,'source');mkdirSync(source);return{base,source,...await fixture(source)};};
+const setup=async t=>{const base=mkdtempSync(path.join(tmpdir(),'handoff-test-'));t.after(()=>rmSync(base,{recursive:true,force:true}));const source=path.join(base,'source');mkdirSync(source);return{base,source,...await fixture(source,{technicalDesign:true})};};
 function advanceStrategy(f,version='v2') {
  f.handoff.handoff_version=version;
  f.strategy.domain_version=version;
@@ -79,6 +79,12 @@ test('受控延期只阻断依赖切片；未知依赖扩大阻断；目标未
  writeFileSync(path.join(target,'reconciliation.yaml'),json(record));
  for(const row of tactical.strategic_handoff.rows)Object.assign(row,{disposition:'implemented',tactical_refs:['behavior.submit'],test_seam_refs:['test-seam.submit'],scenario_tests:[{outcome:'success',seam_ref:'test-seam.submit'},{outcome:'failure',seam_ref:'test-seam.submit'}],evidence_refs:['CONTEXT.md'],dependency_status:'known',dependent_slice_refs:['slice.submit']});
  assert.equal((await verifyConsumption(tactical,{root:target})).result,'verified');
+ const mvc={schema_version:2,status:'approved',architecture:{family:'layered-mvc'},strategic_handoff:structuredClone(tactical.strategic_handoff),design:{use_case_catalog:[{use_case_id:'use-case.submit'}],test_seams:[{seam_id:'test-seam.submit',subject_ref:'use-case.submit'}]}};
+ for(const row of mvc.strategic_handoff.rows)row.tactical_refs=['use-case.submit'];
+ assert.equal((await verifyConsumption(mvc,{root:target})).result,'verified');
+ mvc.strategic_handoff.rows[0].tactical_refs=['aggregate.fake'];
+ await assert.rejects(()=>verifyConsumption(mvc,{root:target}),/落点悬空/);
+
  const row=tactical.strategic_handoff.rows[0];Object.assign(row,{disposition:'deferred',reason:'分批实现',risk:'不能提交',owner:'需求负责人',followup_ticket_ref:'ticket.followup',verification_plan:'提交测试',target_version:'v2'});
  assert.equal((await verifyConsumption(tactical,{root:target,sliceRef:'slice.submit'})).result,'blocked');
  assert.equal((await verifyConsumption(tactical,{root:target,sliceRef:'slice.other'})).result,'verified');