create-yss-spec 3.5.0 → 3.5.3

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

@@ -7,13 +7,13 @@ import {renderSliceContractView,diffSliceContracts} from './slice-contract-views
 export const contractKinds=Object.freeze({
  slice:null,plan:null,spec:null,'product-design':null,'prototype-confirmation':null,'visual-baseline':null,
  'technical-design':'.agents/skills/yss-technical-design/references/technical-design.schema.json',
- 'api-decision':'docs/process/schemas/api-contract-decision.schema.json',
- 'data-decision':'docs/process/schemas/data-architecture-decision.schema.json',
- scaffold:'docs/process/schemas/project-scaffold-contract.schema.json',
- 'scaffold-decision':'docs/process/schemas/scaffold-architecture-decisions.schema.json',
- handoff:null,'backend-delivery':'docs/process/schemas/backend-delivery.schema.json',
- 'frontend-acceptance':'docs/process/schemas/frontend-delivery-acceptance.schema.json',approval:null,'user-decision':'docs/process/schemas/user-decision.schema.json',
- 'context-reconciliation':'docs/process/schemas/context-reconciliation.schema.json'
+ 'api-decision':'.template-spec/process/schemas/api-contract-decision.schema.json',
+ 'data-decision':'.template-spec/process/schemas/data-architecture-decision.schema.json',
+ scaffold:'.template-spec/process/schemas/project-scaffold-contract.schema.json',
+ 'scaffold-decision':'.template-spec/process/schemas/scaffold-architecture-decisions.schema.json',
+ handoff:null,'backend-delivery':'.template-spec/process/schemas/backend-delivery.schema.json',
+ 'frontend-acceptance':'.template-spec/process/schemas/frontend-delivery-acceptance.schema.json',approval:null,'user-decision':'.template-spec/process/schemas/user-decision.schema.json',
+ 'context-reconciliation':'.template-spec/process/schemas/context-reconciliation.schema.json'
 });
 const object=v=>v&&typeof v==='object'&&!Array.isArray(v);
 const stringify=v=>typeof v==='string'?v:JSON.stringify(v,null,2);
@@ -59,19 +59,25 @@ function markdown(view){
  return lines.join('\n\n')+'\n';
 }
 export function viewContract(ref,options={}){return withValidationPhase({root:options.root,purpose:'contract-view',slice_id:ref,work_unit_id:options.unit_id,readOnly:true},()=>view(ref,options));}
-function view(ref,{root=process.cwd(),kind,profile='review',unit_id}={}){
+function view(ref,{root=process.cwd(),kind,profile='review',unit_id,task_layout='legacy'}={}){
  validateKind(kind);if(!['review','task','full'].includes(profile))throw new TypeError(`未知阅读档位 ${profile}`);
+ if(!['legacy','focused'].includes(task_layout))throw new TypeError(`未知 task layout ${task_layout}`);
  let binding,content,checks=['可读取'],blockers=[],sourceChecks=[];
  if(kind==='slice'){
   const loaded=readSliceContract(ref,{root,diagnostic:true});binding=loaded.binding;blockers.push(...declaredBlockers(loaded.raw));
   const legacy=renderSliceContractView(ref,{root,unit_id:profile==='task'?unit_id:undefined});
   checks.push('Slice 结构及绑定来源');
-  if(legacy.diagnostic_only){content={诊断:legacy.blockers};blockers=legacy.blockers.map(b=>b.reason);}
+  if(legacy.diagnostic_only){content={诊断:legacy.blockers,未校验的原合同:loaded.raw};blockers=legacy.blockers.map(b=>b.reason);}
   else if(profile==='full')content={权威合同:loaded.raw,完整视图:legacy};
   else if(profile==='review'){
    content={...legacy.summary,验收:legacy.acceptance,实施范围:{工程:loaded.raw.scope?.project_roots||legacy.constraints.project_roots,允许写入:loaded.raw.scope?.allowed_write_paths||legacy.constraints.allowed_write_paths},关键约束:loaded.raw.scope?.forbidden_patterns||legacy.constraints.forbidden_patterns,停止条件:'来源或批准过期、越界、缺证据、验证失败、drift / violation / new_impacts 时停止并回交。'};
    for(const key of ['risks','risk_acceptance','blockers','pending_decisions','constraints'])if(loaded.raw[key])content[key]=loaded.raw[key];
    for(const [label,pattern]of [['风险',/风险/],['关键取舍',/取舍/],['待决定事项',/待|决定/],['变化',/变化|变更/]])if(!Object.keys(content).some(k=>pattern.test(k)))content[label]='来源未说明，审阅时核实。';
+   const reviewKnown=new Set(['schema_version','contract_id','contract_version','slice_id','status','basis','scope','common','lifecycle_refs','applicability','resolution','acceptance','verification','work_units','extensions','ticket_policy']);
+   content.未分类约束=Object.fromEntries(Object.entries(loaded.raw).filter(([key])=>!reviewKnown.has(key)));
+   // Normalization preserves raw v2 common / v3 scope, including nested unknown constraints.
+   content.全局约束=legacy.constraints;
+   content.专项约束=loaded.raw.extensions;content.适用性=loaded.raw.applicability;
    const extensions=loaded.raw.extensions||{};
    for(const [name,extension]of Object.entries(extensions))for(const [key,value]of Object.entries(extension))if(/risk|constraint|decision|block|exception|unknown/.test(key))content[`${name}.${key}`]=value;
   }else{
@@ -80,12 +86,19 @@ function view(ref,{root=process.cwd(),kind,profile='review',unit_id}={}){
    content={当前任务:units[0].work_unit||units[0],全局约束:legacy.constraints,专项约束:legacy.extensions,编译约束:loaded.raw.resolution,适用性:loaded.raw.applicability,验收:legacy.acceptance,上游引用:Object.fromEntries(Object.entries(loaded.sources).map(([k,v])=>[k,{ref:v.ref,version:v.version}])),停止条件:'来源或批准过期、越界、缺证据、验证失败、drift / violation / new_impacts 时停止并回交。'};
    const known=new Set(['schema_version','contract_id','contract_version','slice_id','status','basis','scope','applicability','resolution','acceptance','verification','work_units','extensions','ticket_policy']);
    content.其他约束=Object.fromEntries(Object.entries(loaded.raw).filter(([k])=>!known.has(k)));
+   if(task_layout==='focused' && loaded.raw.schema_version===3){
+    const task=units[0].work_unit||units[0];
+    const ids=new Set([...(task.acceptance_refs||[]),...(task.verification||[]).flatMap(v=>v.acceptance_refs||[])]);
+    content={当前任务:task,验收:Object.fromEntries(Object.entries(legacy.acceptance).filter(([id])=>ids.has(id))),全局约束:{...legacy.constraints,verification_commands:task.verification_commands,expected_evidence_files:task.expected_evidence},专项约束:legacy.extensions,编译约束:loaded.raw.resolution,适用性:loaded.raw.applicability,上游引用:content.上游引用,其他约束:content.其他约束,停止条件:content.停止条件,
+     恢复动作:['读取主 tracker 或当前任务包，核对实际运行结果；运行状态未知时不重复派发','复验当前来源、批准和适用门禁；失效时回交，不能沿用旧完成结论'],
+     完整验收引用:{ref,digest:binding.digest,profile:'full',omitted_acceptance_ids:Object.keys(legacy.acceptance).filter(id=>!ids.has(id))}};
+   }
   }
  }else{
   const {bytes,raw}=load(ref,root);binding={ref,id:raw.contract_id||raw.technical_design_id||raw.decision_id||raw.request?.request_id||raw.handoff_id||raw.baseline_id||raw.spec_id||raw.plan_id||raw.id||null,version:raw.contract_version||raw.decision_version||raw.handoff_version||raw.version||null,digest:hash(bytes)};
   blockers.push(...declaredBlockers(raw));
-  let schemaRef=contractKinds[kind];if(kind==='api-decision'&&raw.schema_version===2)schemaRef='docs/process/schemas/api-contract-decision-v2.schema.json';
-  if(kind==='frontend-acceptance'&&[1,3].includes(raw.schema_version))schemaRef=`docs/process/schemas/frontend-delivery-acceptance${raw.schema_version===1?'-v1':'-v3'}.schema.json`;
+  let schemaRef=contractKinds[kind];if(kind==='api-decision'&&raw.schema_version===2)schemaRef='.template-spec/process/schemas/api-contract-decision-v2.schema.json';
+  if(kind==='frontend-acceptance'&&[1,3].includes(raw.schema_version))schemaRef=`.template-spec/process/schemas/frontend-delivery-acceptance${raw.schema_version===1?'-v1':'-v3'}.schema.json`;
   if(schemaRef)try{schema(raw,schemaRef);checks.push('结构校验');}catch(error){blockers.push(error.message);}
   else checks.push('结构与批准未核验，按资产所有者规则继续');
   sourceChecks=references(raw,root);if(sourceChecks.length)checks.push(`核对 ${sourceChecks.length} 项可识别来源摘要；其余语义由资产所有者核验`);for(const source of sourceChecks)if(!source.current)blockers.push(`来源不可读或过期：${source.ref}`);
@@ -107,3 +120,45 @@ export function diffContract(beforeRef,afterRef,{root=process.cwd(),beforeRoot=r
  walk(before.raw,after.raw,'');const source_checks=[...references(before.raw,beforeRoot).map(x=>({...x,side:'before'})),...references(after.raw,root).map(x=>({...x,side:'after'}))];
  return{read_only:true,approval_reusable:false,execution_allowed:false,before:{ref:beforeRef,digest:hash(before.bytes)},after:{ref:afterRef,digest:hash(after.bytes)},bytes_changed:!before.bytes.equals(after.bytes),changes,source_checks,decision_impact:'必须按当前差异和授权延续协议核验；无法读取旧来源时影响未知。'};
 }
+
+/** Mechanical review material only; original decisions and semantic review remain authoritative. */
+export function prepareContractReview(beforeRef, afterRef, options = {}) {
+  const root = options.root || process.cwd();
+  return withValidationPhase({root,purpose:'prepare-contract-review',readOnly:true}, () => {
+    validateKind(options.kind);
+    const gaps = [];
+    const gap = (code, source_ref, reason, recovery) => gaps.push({code,source_ref,reason,recovery});
+    const readView = (ref, side, sourceRoot) => {
+      try {
+        const value = viewContract(ref,{...options,root:sourceRoot,profile:'full'});
+        for(const blocker of value.blockers)gap('SOURCE_INVALID',ref,blocker,'恢复当前权威来源并重新校验');
+        return value;
+      } catch(error) { gap('SOURCE_UNREADABLE',ref,`${side}: ${error.message}`,'提供可读取的原始资产；不推断历史内容');return null; }
+    };
+    const before = readView(beforeRef,'before',options.beforeRoot||root), after = readView(afterRef,'after',root);
+    if(before?.binding.id && after?.binding.id && before.binding.id!==after.binding.id)gap('IDENTITY_CONFLICT',afterRef,'前后资产 ID 不一致','选择同一资产的前后版本');
+    if(before?.binding.version && before.binding.version===after?.binding.version && before.binding.digest!==after.binding.digest)gap('VERSION_CONFLICT',afterRef,'相同版本包含不同字节','形成新候选版本并重新核验');
+    let diff = null;
+    if(before&&after)try{diff=diffContract(beforeRef,afterRef,options);}catch(error){gap('DIFF_UNAVAILABLE',afterRef,error.message,'先修复来源绑定与版本冲突');}
+    let originalDecision = null;
+    if(options.decision_ref) {
+      try {
+        const loaded=load(options.decision_ref,root);
+        schema(loaded.raw,'.template-spec/process/schemas/user-decision.schema.json');
+        originalDecision={ref:options.decision_ref,digest:hash(loaded.bytes),record:loaded.raw};
+        for(const row of references(loaded.raw,root))if(!row.current)gap('DECISION_SOURCE_STALE',row.ref,row.error||'原决定来源摘要不匹配','恢复原决定快照；不得重绑旧回复');
+      }catch(error){gap('DECISION_UNAVAILABLE',options.decision_ref,error.message,'提供有效的原始决定；本材料不能替代用户回复');}
+    }
+    if(!options.decision_ref)gaps.push({code:'DECISION_NOT_PROVIDED',source_ref:null,reason:'未提供原决定，不能判断批准延续',recovery:'需要沿用批准时提供原决定及原始回复来源',blocking:false});
+    return {
+      schema_version:1,kind:'contract-review-preparation',read_only:true,execution_allowed:false,
+      approval_reusable:false,approval_validity:'not-checked',semantic_equivalence:'requires-independent-review',
+      before:before?.binding||null,after:after?.binding||null,original_decision:originalDecision,
+      decision_status:options.decision_ref?(originalDecision?'requires-validation':'missing-or-invalid'):'not-provided',
+      source_views:{before:before?.content||null,after:after?.content||null},diff,gaps,
+      review_required:['business_scope','acceptance','contract_commitments','authorization','risk_acceptance','quality','external_commitments'],
+      next_action:gaps.some(x=>x.blocking!==false)?'repair-source-gaps':'independent-semantic-review',
+      blockers:gaps.filter(x=>x.blocking!==false).map(item=>item.reason)
+    };
+  });
+}

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

@@ -28,7 +28,7 @@ export function invalidPreflightInput(message) {
 
 /** Installed profile owns backend technical authoring; caller governance_root cannot grant it. */
 export function backendPreflightCapability() {
-  const profileRef=path.join(ROOT,'docs/process/harness-profile.yaml');
+  const profileRef=path.join(ROOT,'.template-spec/process/harness-profile.yaml');
   const profile=existsSync(profileRef)?read(profileRef):null;
   const profileId=profile?.profile_id||'template.full';
   const ownsBackend=!profile||profileId==='harness.backend-delivery';
@@ -49,7 +49,7 @@ function requireBackendCapability(key) {
 /** Read-only: never executes input commands, starts services, unpacks archives or writes receipts. */
 export async function preflightDelivery(input,options={}) {return withValidationPhase({root:path.resolve(options.root||process.cwd(),typeof input?.governance_root==='string'?input.governance_root:'.'),purpose:`delivery-${options.stage}`,slice_id:input?.scope?.slice_id,work_unit_id:options.work_unit_id,readOnly:true,signal:options.signal},()=>preflight(input,options));}
 async function preflight(input,{stage,root=process.cwd(),work_unit_id}={}) {
-  try { ensure(STAGES.includes(stage),'未知阶段；必须是 prepare|build|export|accept');schema(input,'docs/process/schemas/delivery-preflight-input.schema.json'); }
+  try { ensure(STAGES.includes(stage),'未知阶段；必须是 prepare|build|export|accept');schema(input,'.template-spec/process/schemas/delivery-preflight-input.schema.json'); }
   catch(error) { return invalidPreflightInput(error.message); }
   root=path.resolve(root,input.governance_root||'.');
   const deliveryKind=input.delivery_kind||'complete';
@@ -121,7 +121,7 @@ async function preflight(input,{stage,root=process.cwd(),work_unit_id}={}) {
 async function approved(root,binding,gates) {
   ensure(binding.approval_ref&&binding.id&&binding.version,'缺少当前资产 id/version/approval_ref');
   const record=read(safe(root,binding.approval_ref));
-  const roles=sourceApprovalPolicy(read(safe(root,'docs/agents/digital-human-roles.yaml')));
+  const roles=sourceApprovalPolicy(read(safe(root,'.template-spec/agents/digital-human-roles.yaml')));
   validateApprovalRecord(record,{rolesDoc:roles,requireApproved:true,root,read:ref=>readFileSync(safe(root,path.relative(root,ref).split(path.sep).join('/')))});
   ensure(gates.includes(record.gate_id),'资产批准使用错误门禁');
   ensure(record.artifact_bindings?.some(x=>x.id===binding.id&&x.version===binding.version&&x.digest===binding.digest),'stale: 批准未绑定当前资产身份、版本及字节');
@@ -186,7 +186,7 @@ async function verifyAsset(key,data,binding,{root,input,documents,assets,executi
     await approved(root,binding,['gate.product-design-approved','gate.user-confirmation']);
   } else if(key==='build') {
     // Same build shape used by backend-delivery, captured independently before packaging.
-    const deliverySchema=read(safe(ROOT,'docs/process/schemas/backend-delivery.schema.json'));
+    const deliverySchema=read(safe(ROOT,'.template-spec/process/schemas/backend-delivery.schema.json'));
     const buildRules=deliverySchema.properties.build;
     // Validate in memory to avoid writing a generated schema: check the published required fields.
     for(const field of buildRules.required||[])ensure(Object.hasOwn(data,field),`构建缺少交付协议字段: ${field}`);
@@ -195,7 +195,7 @@ async function verifyAsset(key,data,binding,{root,input,documents,assets,executi
     ensure(/^sha256:[0-9a-f]{64}$/.test(data.artifact_digest),'构建制品摘要无效');
     ensure(Object.keys(data).every(key=>Object.hasOwn(buildRules.properties,key)),'构建包含交付协议未定义字段');
   } else if(key==='deployment') {
-    schema(data,'docs/process/schemas/backend-delivery-verification.schema.json');
+    schema(data,'.template-spec/process/schemas/backend-delivery-verification.schema.json');
     ensure(data.kind==='backend-deployment','部署证据 kind 必须为 backend-deployment');
     for(const result of data.results) {
       ensure(result.exit_code===0&&Number.isFinite(Date.parse(result.executed_at))&&Date.parse(result.executed_at)<=Date.now()+60000,'部署执行结果或时间无效');
@@ -206,7 +206,7 @@ async function verifyAsset(key,data,binding,{root,input,documents,assets,executi
       ensure(data.subject_digest===backendDeliveryBasis(documents.backend_delivery),'stale: 部署验证未绑定当前交付依据');
     }
   } else if(key==='backend_delivery') {
-    schema(data,`docs/process/schemas/backend-delivery${data.schema_version===2?'-v2':''}.schema.json`);
+    schema(data,`.template-spec/process/schemas/backend-delivery${data.schema_version===2?'-v2':''}.schema.json`);
     ensure(data.scope.slice_id===input.scope.slice_id&&input.scope.operation_ids.every(id=>data.scope.operation_ids.includes(id)),'后端交付切片/接口范围不匹配');
     for(const asset of ['openapi','slice_contract'])if(assets[asset])ensure(data[asset].ref===assets[asset].ref&&data[asset].digest===assets[asset].digest,'后端交付引用与预检输入不一致');
     for(const asset of [data.environment.test_data,...Object.values(data.verification)])fileBinding(root,asset);

package/template/scripts/lib/design-md.mjs

@@ -8,9 +8,9 @@ import { parseDocument } from "../vendor/yaml.mjs";
 
 const repositoryRoot = path.resolve(new URL("../..", import.meta.url).pathname);
 const designPath = path.join(repositoryRoot, "DESIGN.md");
-const projectionDir = path.join(repositoryRoot, "docs/design/tokens");
+const projectionDir = path.join(repositoryRoot, ".template-spec/design/tokens");
 const manifestPath = path.join(projectionDir, ".design-md-projection.json");
-const syncMetadataPath = path.join(repositoryRoot, "docs/design/design-system-sync.yaml");
+const syncMetadataPath = path.join(repositoryRoot, ".template-source/design/design-system-sync.yaml");
 const expectedSections = ["Overview", "Colors", "Typography", "Layout", "Elevation & Depth", "Shapes", "Components", "Do's and Don'ts"];
 const requiredFrontmatter = ["version", "name", "description", "colors", "typography", "rounded", "spacing", "components"];
 const componentProperties = new Set(["backgroundColor", "textColor", "typography", "rounded", "padding", "size", "height", "width"]);

package/template/scripts/lib/digital-human-roles.mjs

@@ -4,7 +4,7 @@ import { parseDocument } from "../vendor/yaml.mjs";
 import { loadRegistry, ROOT } from "./lifecycle-registry.mjs";
 import { loadSkillRegistry } from "./skill-registry.mjs";
 
-export const DEFAULT_DIGITAL_HUMAN_ROLES = path.join(ROOT, "docs/agents/digital-human-roles.yaml");
+export const DEFAULT_DIGITAL_HUMAN_ROLES = path.join(ROOT, ".template-spec/agents/digital-human-roles.yaml");
 
 const ROLE_ID = /^role\.[a-z0-9][a-z0-9-]*$/;
 const GROUP_ID = /^group\.[a-z0-9][a-z0-9-]*$/;
@@ -259,7 +259,7 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
   if (doc.registry_id !== "yss.digital-human-roles") fail("registry_id 必须为 yss.digital-human-roles");
   if (doc.status !== "active") fail("status 必须为 active");
   requireString(doc.description, "description");
-  if (doc.canonical_path !== "docs/agents/digital-human-roles.yaml") fail("canonical_path 必须为 docs/agents/digital-human-roles.yaml");
+  if (doc.canonical_path !== ".template-spec/agents/digital-human-roles.yaml") fail("canonical_path 必须为 .template-spec/agents/digital-human-roles.yaml");
   rejectGrokCoupling(doc.runtime_policy, "runtime_policy");
   rejectGrokCoupling(doc.gate_policy, "gate_policy");
   const runtime = doc.runtime_policy;

package/template/scripts/lib/execution-evidence.mjs

@@ -0,0 +1,51 @@
+import {readFileSync,existsSync} from './validation-phase.mjs';
+import {safe, hash} from './strategic-handoff-io.mjs';
+
+/** Checks binding, not the truth of arbitrary prose. Owner tests/review remain mandatory. */
+export function executionEvidenceBlockers(result, contract, current) {
+  const blockers=[];
+  if(result.evidence_binding_version!==1)return ['legacy-evidence-binding-missing'];
+  const unit=contract.work_units.find(u=>u.id===result.work_unit_id);
+  if(!unit)return ['work-unit-mismatch'];
+  try {
+    const approved=current.approved_slice;
+    if(!approved || result.consumed_contract?.contract_digest!==approved.digest || hash(readFileSync(safe(current.root,approved.ref)))!==approved.digest)blockers.push('evidence-contract-digest-mismatch');
+    const evidence=result.evidence_files||[];
+    const checks=unit.work_unit.verification;
+    const evidenceRoot=contract.repositories?unit.project_root:current.root;
+    for(const check of checks) {
+      const rows=(result.verification_results||[]).filter(r=>r.verification_id===check.id);
+      if(rows.length!==1){blockers.push('verification-id-missing-or-duplicate');continue;}
+      const row=rows[0];
+      if(row.command!==check.command||row.cwd!==check.cwd||row.exit_code!==0||!Number.isFinite(Date.parse(row.executed_at)))blockers.push('verification-binding-mismatch');
+      if(!Array.isArray(row.acceptance_refs)||row.acceptance_refs.length!==new Set(row.acceptance_refs).size||JSON.stringify([...row.acceptance_refs].sort())!==JSON.stringify([...check.acceptance_refs].sort()))blockers.push('acceptance-evidence-coverage-missing');
+      if(!Array.isArray(row.evidence_refs)||!check.expected_evidence.every(ref=>row.evidence_refs.includes(ref)))blockers.push('verification-evidence-link-missing');
+      const covered=new Set();
+      for(const ref of row.evidence_refs||[]) {
+        const matches=evidence.filter(e=>typeof e==='object'&&e.path===ref&&(!contract.repositories||e.project_root===unit.project_root));
+        if(!matches.length)blockers.push('verification-evidence-link-missing');
+        for(const entry of matches) {
+          if(!check.acceptance_refs.includes(entry.behavior_ref))blockers.push('evidence-behavior-unrelated');
+          else covered.add(entry.behavior_ref);
+          if(hash(readFileSync(safe(evidenceRoot,ref)))!==entry.digest)blockers.push('evidence-digest-mismatch');
+        }
+      }
+      if(check.acceptance_refs.some(id=>!covered.has(id)))blockers.push('acceptance-evidence-coverage-missing');
+    }
+    // Bind declared execution inputs too: changed source bytes cannot reuse an earlier result.
+    if(!Array.isArray(result.source_bindings)||!result.source_bindings.length)blockers.push('execution-source-bindings-missing');
+    for(const entry of result.source_bindings||[]) {
+      const root=entry.project_root||unit.project_root;
+      const allowedRoots=new Set([unit.project_root,...checks.flatMap(check=>check.dependency_roots||[])]);
+      if(!allowedRoots.has(root)||(contract.repositories&&!contract.repositories[root])){blockers.push('execution-source-repository-mismatch');continue;}
+      if(entry.deleted===true) {
+        if(existsSync(safe(root,entry.path,{missing:true})) || entry.digest!==null)blockers.push('execution-source-drift');
+      } else if(hash(readFileSync(safe(root,entry.path)))!==entry.digest)blockers.push('execution-source-drift');
+    }
+    for(const changed of result.changed_files||[]) {
+      const ref=typeof changed==='string'?changed:changed.path;
+      if(!result.source_bindings?.some(b=>b.path===ref&&(b.project_root||unit.project_root)===(typeof changed==='object'&&changed.project_root||unit.project_root)))blockers.push('changed-source-binding-missing');
+    }
+  } catch(error) {blockers.push(`execution-evidence-unreadable: ${error.message}`);}
+  return [...new Set(blockers)];
+}

package/template/scripts/lib/existing-backend-architecture.mjs

@@ -111,7 +111,7 @@ export function verifyExistingArchitecture(identity,bindings,{root,registry,exec
  requireThat(Array.isArray(baseline.verification_commands)&&baseline.verification_commands.length&&Array.isArray(registration.verification_commands),'ARCH_VERIFICATION_MISSING','缺少登记验证命令');
  same(baseline.verification_commands,registration.verification_commands,'ARCH_VERIFICATION_CONFLICT','验证入口不一致');
  const review=bound(root,baseline.boundary_review);
- const rolesFile=path.join(root,'docs/agents/digital-human-roles.yaml');
+ const rolesFile=path.join(root,'.template-spec/agents/digital-human-roles.yaml');
  const roles=parse(readFileSync(rolesFile));
  validateApprovalRecord(review,{rolesDoc:roles,requireApproved:true,root});
  requireThat(['check.architecture-reviewed','gate.technical-design-approved'].includes(review.gate_id)&&text(baseline.id)&&text(baseline.version),'ARCH_REVIEW_MISSING','需要架构边界审查');

package/template/scripts/lib/existing-ui-baseline.mjs

@@ -7,7 +7,7 @@ export function validateExistingUiBaseline(data,options={}) {return inValidation
 function validate(data, { bundleRoot } = {}) {
   const errors=[];
   try {
-    schema(data,'docs/process/schemas/existing-ui-baseline.schema.json');
+    schema(data,'.template-spec/process/schemas/existing-ui-baseline.schema.json');
     ensure(bundleRoot,'existing-ui-baseline 需要原始 bundleRoot');
     const consumed=new Set(['existing-ui-baseline.json']);
     const allFiles=files(bundleRoot);

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

@@ -7,7 +7,7 @@ import { openBundle } from './strategic-handoff.mjs';
 import { verifyConsumption } from './strategic-handoff-consumption.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'],[3,'docs/process/schemas/frontend-delivery-acceptance-v3.schema.json']]);
+const ACCEPTANCE_SCHEMAS=new Map([[1,'.template-spec/process/schemas/frontend-delivery-acceptance-v1.schema.json'],[2,'.template-spec/process/schemas/frontend-delivery-acceptance.schema.json'],[3,'.template-spec/process/schemas/frontend-delivery-acceptance-v3.schema.json']]);
 
 function acceptanceSchema(version) {
   ensure(ACCEPTANCE_SCHEMAS.has(version),`Frontend Delivery Acceptance 未知 schema_version: ${String(version)}；支持版本: 1, 2, 3；既有 UI 接收请使用 3`);
@@ -18,7 +18,7 @@ export async function verifyFrontendStrategicPreflight({root=process.cwd(),prefl
   project(root);
   const file=safe(root,preflightRef),preflight=read(file);
   ensure([1,2].includes(preflight.schema_version),'Frontend Strategic Preflight 未知 schema_version');
-  schema(preflight,preflight.schema_version===2?'docs/process/schemas/frontend-strategic-preflight-v2.schema.json':'docs/process/schemas/frontend-strategic-preflight.schema.json');
+  schema(preflight,preflight.schema_version===2?'.template-spec/process/schemas/frontend-strategic-preflight-v2.schema.json':'.template-spec/process/schemas/frontend-strategic-preflight.schema.json');
   const preflightDigest=hash(readFileSync(file));
   if(expectedDigest)ensure(expectedDigest===preflightDigest,'前端战略预检摘要已变化，需重编译合同');
   ensure(preflight.status==='verified','前端战略预检尚未 verified');

package/template/scripts/lib/governance-layout.mjs

@@ -0,0 +1,74 @@
+import { existsSync, lstatSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const requiredShared = [
+  ".template-spec/agents/yss-skill-registry.yaml",
+  ".template-spec/agents/digital-human-roles.yaml",
+  ".template-spec/agents/issue-tracker.md",
+  ".template-spec/process/lifecycle-registry.yaml",
+  ".template-spec/process/lifecycle-artifact-map.md",
+];
+const oldStaticDirs = [
+  "docs/agents", "docs/process", "docs/templates", "docs/user-guide",
+  "docs/plan/templates", "docs/api/templates", "docs/architecture/templates",
+  "docs/design/templates", "docs/design/tokens", "docs/design/schemas",
+  "docs/design/diagrams", "docs/discovery/templates",
+];
+const oldStaticFiles = new Set([
+  "docs/adr/README.md", "docs/architecture/README.md",
+  "docs/plan/README.md", "docs/plan/entry-review.md",
+  "docs/discovery/README.md", "docs/discovery/IDEATION.md",
+  "docs/design/README.md", "docs/design/design.md",
+  "docs/design/design-system-sync.yaml", "docs/design/preview.html",
+  "docs/design/preview-dark.html", "docs/design/preview.css",
+  "docs/design/preview.js", "docs/engineering/backend-platforms.json",
+  "docs/engineering/backend-platforms.md",
+]);
+
+function staticPath(ref) {
+  return oldStaticFiles.has(ref) || oldStaticDirs.some((directory) => ref.startsWith(`${directory}/`));
+}
+
+function filesBelow(root, relativePath) {
+  const full = path.join(root, relativePath);
+  if (!existsSync(full)) return [];
+  const entry = lstatSync(full);
+  if (!entry.isDirectory()) return [relativePath];
+  return readdirSync(full).filter((name) => name !== ".DS_Store")
+    .flatMap((name) => filesBelow(root, `${relativePath}/${name}`));
+}
+
+export function verifyGovernanceLayout(root, mode) {
+  if (!["template-source", "project-instance"].includes(mode)) {
+    throw new TypeError(`不支持的仓库身份: ${mode}`);
+  }
+  for (const ref of requiredShared) {
+    if (!existsSync(path.join(root, ref))) throw new TypeError(`缺少共享治理资产: ${ref}`);
+  }
+  let oldFiles;
+  if (mode === "template-source") {
+    const result = spawnSync("git", ["ls-files", "-z", "--", "docs"], { cwd: root, encoding: "utf8" });
+    if (result.status !== 0) throw new TypeError(result.stderr || "无法读取模板源受控文件清单");
+    oldFiles = result.stdout.split("\0").filter(Boolean).filter(staticPath);
+    for (const ref of [
+      ".template-source/process/maintenance-intensity.yaml",
+      ".template-source/process/template-verification-profiles.yaml",
+      ".template-source/agents/skills-maintenance.md",
+    ]) {
+      if (!existsSync(path.join(root, ref))) throw new TypeError(`缺少模板维护资产: ${ref}`);
+    }
+  } else {
+    oldFiles = [...new Set([
+      ...oldStaticDirs.flatMap((ref) => filesBelow(root, ref)),
+      ...[...oldStaticFiles].filter((ref) => existsSync(path.join(root, ref))),
+    ])];
+    if (existsSync(path.join(root, ".template-source"))) {
+      throw new TypeError("项目实例不得包含 .template-source");
+    }
+  }
+  if (oldFiles.length) {
+    throw new TypeError(`旧治理文件仍位于 docs/，需显式迁移: ${oldFiles.sort().join(", ")}`);
+  }
+  return { mode, shared: requiredShared.length, legacy: 0 };
+}

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

@@ -6,9 +6,9 @@ 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');
+  const profilePath=path.join(root,'.template-spec/process/harness-profile.yaml');
   ensure(!metadata.length||existsSync(profilePath),'专职 Harness 缺少 profile，不得绕过执行门禁');
-  const profile=existsSync(profilePath)?read(safe(root,'docs/process/harness-profile.yaml')):null;
+  const profile=existsSync(profilePath)?read(safe(root,'.template-spec/process/harness-profile.yaml')):null;
   if(metadata.length) {
     const expected=`harness.${metadata[0]}-delivery`;
     const record=read(safe(root,`.yss-harness-${metadata[0]}.json`));
@@ -33,7 +33,7 @@ function activeProfile(root) {
 export function enforceHarnessTaskScope(task,{root=ROOT}={}) {
   const scope=loadExecutionScope(root);
   if(scope) {
-    assertScopeWorkUnit(task.contract?.kind==='slice-implementation'?'work-unit.slice-implementation':task.work_unit_id,{root});
+    assertScopeWorkUnit(task.contract?.kind==='slice-implementation'?'work-unit.slice-implementation':task.work_unit_id,{root,readOnly:task.contract?.kind==='read-only-intake'});
     ensure(task.role_id!=='role.frontend-engineer','后端职责不允许派发前端实现');
     ensure(task.allowed_write_paths.every(ref=>!/^apps\/frontend(?:\/|$)/.test(ref)),'禁止写入前端工程');
   }

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

@@ -1,4 +1,5 @@
 import { resolveBackendPlatform, resolveComponentCapabilities } from "./backend-platform.mjs";
+import { executionEvidenceBlockers } from './execution-evidence.mjs';
 import { safe } from './strategic-handoff-io.mjs';
 import { selectSliceWorkUnit, normalizeSliceContract, withinSlicePath } from './slice-contract.mjs';
 import { createApprovedExecutionContext, createApprovedRecompilationContext, assertApprovedExecutionContext } from './approved-execution-context.mjs';
@@ -349,6 +350,7 @@ export function validateExecutionResult(result, contract, current) {
     else if (item.exit_code !== 0) blockers.push("verification-failed");
   }
   if(contract.schema_version===3) {
+    blockers.push(...executionEvidenceBlockers(result, contract, {...current, root: current.root || ROOT}));
     const unit=contract.work_units.find(item=>item.id===result.work_unit_id);
     if(!unit)blockers.push('work-unit-mismatch');
     else {

package/template/scripts/lib/lifecycle-context-query.mjs

@@ -1,14 +1,14 @@
 import { loadExecutionScope, assertScopeWorkUnit, scopedNextRoutes } from './lifecycle-execution-scope.mjs';
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { readFileSync, withValidationPhase, validationDependencies } from "./validation-phase.mjs";
 import path from "node:path";
 import { parseDocument } from "../vendor/yaml.mjs";
 import { ROOT, loadRegistry, semanticDigest, validateRegistry } from "./lifecycle-registry.mjs";
 import { loadSkillRegistry } from "./skill-registry.mjs";
 
-const LIFECYCLE_REGISTRY_REF = "docs/process/lifecycle-registry.yaml";
+const LIFECYCLE_REGISTRY_REF = ".template-spec/process/lifecycle-registry.yaml";
 const ORCHESTRATION_CONTRACT_REF = ".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml";
-const SKILL_REGISTRY_REF = "docs/agents/yss-skill-registry.yaml";
+const SKILL_REGISTRY_REF = ".template-spec/agents/yss-skill-registry.yaml";
 
 function read(relativePath) {
   return readFileSync(path.join(ROOT, relativePath), "utf8");
@@ -63,11 +63,19 @@ function selectedSkills(route, skillRegistry) {
   return skillRegistry.skills.filter((skill) => ids.has(skill.id));
 }
 
-export function queryLifecycleContext({ mode, stageId, workUnitId, include = [] } = {}) {
+export function queryLifecycleContext(options = {}) {
+  return withValidationPhase({ root: ROOT, purpose: "lifecycle-context-query", readOnly: true }, () => querySnapshot(options));
+}
+
+function querySnapshot({ mode, stageId, workUnitId, include = [] } = {}) {
   if (!mode && !stageId && !workUnitId && include.length === 0) {
     throw new TypeError("至少提供 --mode、--stage、--work-unit 或 --include 之一");
   }
 
+  const identity = loadYaml("yss-project.yaml", "仓库身份");
+  if (identity.schema_version !== 1 || !["template-source", "project-instance"].includes(identity.repository_mode)) {
+    throw new TypeError("仓库身份或版本无效");
+  }
   const scope = loadExecutionScope();
   if (workUnitId) assertScopeWorkUnit(workUnitId, { readOnly: true });
   const lifecycle = validateRegistry(loadRegistry());
@@ -88,6 +96,12 @@ export function queryLifecycleContext({ mode, stageId, workUnitId, include = []
   }
 
   const route = workUnitId ? orchestration.work_unit_routes?.[workUnitId] ?? null : null;
+  if (workUnit?.scope === "project-instance" && workUnit.id !== "work-unit.entry-triage" && !route) {
+    throw new TypeError(`项目工作单元缺少执行路由: ${workUnit.id}`);
+  }
+  if (workUnit?.scope === "project-instance" && workUnit.id !== "work-unit.entry-triage" && !Object.hasOwn(orchestration.transition_graph?.routes ?? {}, workUnit.id)) {
+    throw new TypeError(`项目工作单元缺少流转路由: ${workUnit.id}`);
+  }
   const gates = lifecycle.gates.filter((gate) => gate.stage === stageId || (loadPlan && gate.stage === 'stage.plan'));
   const checks = lifecycle.checks.filter(check => check.stage === stageId || gates.some(gate => gate.requires_checks?.includes(check.id)));
   const artifacts = lifecycle.artifacts.filter((artifact) => artifact.stage === stageId || (loadPlan && artifact.stage === 'stage.plan'));
@@ -108,9 +122,11 @@ export function queryLifecycleContext({ mode, stageId, workUnitId, include = []
       work_unit: workUnitId ?? null,
     },
     sources: {
+      repository_identity: { ref: "yss-project.yaml", sha256: sha256(read("yss-project.yaml")) },
       lifecycle_registry: {
         ref: LIFECYCLE_REGISTRY_REF,
         semantic_sha256: semanticDigest(lifecycle),
+        sha256: sha256(read(LIFECYCLE_REGISTRY_REF)),
         status: lifecycle.status,
       },
       orchestration_contract: {
@@ -125,7 +141,9 @@ export function queryLifecycleContext({ mode, stageId, workUnitId, include = []
     },
     lifecycle: {
       artifacts,
-      evidence: lifecycle.evidence.filter((item) => evidenceIds.has(item.id)),
+      evidence: lifecycle.evidence.filter((item) => evidenceIds.has(item.id)).map(({ public_description, ...item }) => ({
+        ...item, description: public_description ?? item.description
+      })),
       gates,
       checks,
       stage,
@@ -144,5 +162,7 @@ export function queryLifecycleContext({ mode, stageId, workUnitId, include = []
   result.references = [...collectPathReferences(result), LIFECYCLE_REGISTRY_REF, ORCHESTRATION_CONTRACT_REF, SKILL_REGISTRY_REF]
     .filter((value, index, all) => all.indexOf(value) === index)
     .sort();
-  return canonicalize(result);
+  result.sources.read_set = validationDependencies().files.map(row=>({ref:path.relative(ROOT,row.file).split(path.sep).join("/"),sha256:row.digest})).sort((a,b)=>a.ref.localeCompare(b.ref,"en"));
+  const canonical = canonicalize(result);
+  return { ...canonical, context_sha256: sha256(JSON.stringify(canonical)) };
 }

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

@@ -6,8 +6,8 @@ import { fileURLToPath } from "node:url";
 import { parseDocument } from "../vendor/yaml.mjs";
 
 export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
-export const DEFAULT_REGISTRY = path.join(ROOT, "docs/process/lifecycle-registry.yaml");
-export const DEFAULT_BASELINE = path.join(ROOT, "docs/process/lifecycle-registry-baseline.json");
+export const DEFAULT_REGISTRY = path.join(ROOT, ".template-spec/process/lifecycle-registry.yaml");
+export const DEFAULT_BASELINE = path.join(ROOT, ".template-spec/process/lifecycle-registry-baseline.json");
 const ID_PATTERN = /^(stage|gate|check|artifact|work-unit|evidence)\.[a-z0-9][a-z0-9-]*$/;
 const COLLECTIONS = ["stages", "gates", "checks", "artifacts", "work_units", "evidence"];
 
@@ -63,6 +63,12 @@ export function semanticDigest(registry) {
   return createHash("sha256").update(JSON.stringify(semanticProjection(registry))).digest("hex");
 }
 
+export function semanticHashesById(registry) {
+  return Object.fromEntries(semanticProjection(registry).map(({ record }) => [
+    record.id, createHash("sha256").update(JSON.stringify(record)).digest("hex")
+  ]));
+}
+
 function validateBaseline(registry, ids, baselinePath) {
   let baseline;
   try {
@@ -72,7 +78,7 @@ function validateBaseline(registry, ids, baselinePath) {
     if (error instanceof SyntaxError) fail(`无法解析生命周期已发布基线: ${error.message}`);
     throw error;
   }
-  if (baseline.schema_version !== 1 || baseline.registry_id !== registry.registry_id) {
+  if (![1, 2].includes(baseline.schema_version) || baseline.registry_id !== registry.registry_id) {
     fail("生命周期已发布基线版本或 registry_id 不匹配");
   }
   const publishedIds = baseline.published_ids;
@@ -91,7 +97,26 @@ function validateBaseline(registry, ids, baselinePath) {
   if (JSON.stringify(activeIds) !== JSON.stringify(expected)) {
     fail("生命周期活跃 ID 与已发布基线不一致；新增、移除或弃用必须先更新发布基线");
   }
-  if (baseline.semantic_sha256 !== semanticDigest(registry)) fail("生命周期稳定 ID 的语义快照已变化；不得复用已发布 ID");
+  if (baseline.schema_version === 1) {
+    if (baseline.semantic_sha256 !== semanticDigest(registry)) fail("生命周期稳定 ID 的语义快照已变化；不得复用已发布 ID");
+    return;
+  }
+  const archivedPath = path.resolve(ROOT, baseline.historical_baseline ?? "");
+  if (baseline.historical_baseline !== ".template-spec/process/lifecycle-registry-baseline-v1.json") fail("生命周期历史基线路径无效");
+  const archivedBytes = readFileSync(archivedPath);
+  if (createHash("sha256").update(archivedBytes).digest("hex") !== baseline.historical_sha256) fail("生命周期历史基线摘要不匹配");
+  const archived = JSON.parse(archivedBytes.toString("utf8"));
+  if (archived.schema_version !== 1 || archived.registry_id !== registry.registry_id || !archived.published_ids.every((id) => publishedIds.includes(id))) fail("生命周期历史基线与当前发布 ID 不兼容");
+  const migrations = baseline.migrations;
+  if (!migrations || typeof migrations !== "object" || Array.isArray(migrations)) fail("生命周期迁移映射无效");
+  for (const [oldId, newId] of Object.entries(migrations)) {
+    if (!archived.published_ids.includes(oldId) || !deprecated.includes(oldId) || !activeIds.includes(newId) || oldId.split(".")[0] !== newId.split(".")[0]) fail(`生命周期迁移映射无效: ${oldId} -> ${newId}`);
+  }
+  const hashes = semanticHashesById(registry);
+  if (!baseline.semantic_sha256_by_id || JSON.stringify(Object.keys(baseline.semantic_sha256_by_id).sort()) !== JSON.stringify(activeIds)) fail("生命周期逐 ID 语义基线与活跃 ID 不一致");
+  for (const [id, digest] of Object.entries(hashes)) {
+    if (baseline.semantic_sha256_by_id[id] !== digest) fail(`生命周期稳定 ID 的语义快照已变化: ${id}`);
+  }
 }
 
 export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {}) {
@@ -108,7 +133,7 @@ export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {})
   }
   if (policy.published_ids_immutable !== true) fail("published_ids_immutable 必须为 true");
   if (policy.pattern !== "^(stage|gate|check|artifact|work-unit|evidence)\\.[a-z0-9][a-z0-9-]*$") fail("id_policy.pattern 不符合固定命名空间");
-  if (policy.baseline !== "docs/process/lifecycle-registry-baseline.json") fail("id_policy.baseline 必须指向发布基线");
+  if (policy.baseline !== ".template-spec/process/lifecycle-registry-baseline.json") fail("id_policy.baseline 必须指向发布基线");
   if (!Array.isArray(policy.deprecated_ids)) fail("deprecated_ids 必须是数组");
   const ids = new Map();
   for (const collection of COLLECTIONS) {
@@ -159,6 +184,20 @@ export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {})
   for (const artifact of registry.artifacts) {
     requireReference(ids, artifact.stage, `${artifact.id}.stage`);
     if (ids.get(artifact.stage) !== "stages") fail(`${artifact.id}.stage 必须引用 stage.*`);
+    for (const reference of artifact.trigger.match(/\b(?:stage|gate|check|artifact|work-unit|evidence)\.[a-z0-9][a-z0-9-]*\b/g) ?? []) {
+      requireReference(ids, reference, `${artifact.id}.trigger`);
+    }
+  }
+  // Human-readable rules are execution instructions too. A retired control ID
+  // must never survive in an active trigger or completion sentence.
+  for (const collection of COLLECTIONS) for (const record of registry[collection]) {
+    for (const [field, value] of Object.entries(record)) {
+      if (field === "id" || typeof value !== "string") continue;
+      for (const reference of value.match(/\b(?:gate|check)\.[a-z0-9][a-z0-9-]*\b/g) ?? []) {
+        requireReference(ids, reference, `${record.id}.${field}`);
+        if (ids.get(reference) !== `${reference.split(".")[0]}s`) fail(`${record.id}.${field} 引用类型不匹配: ${reference}`);
+      }
+    }
   }
   if (baseline) validateBaseline(registry, ids, baseline);
   return registry;
@@ -168,7 +207,7 @@ export function renderLifecycleStructure(registry) {
   const display = (record, field) => record[`public_${field}`] ?? record[field];
   const lines = [
     "<!-- lifecycle-registry:structure:start -->",
-    `> 此结构区由 \`docs/process/lifecycle-registry.yaml\` 生成。当前为 \`${registry.status}\` 模式：正式门禁、内部检查和派生文档共同消费此事实源。`, "",
+    `> 此结构区由 \`.template-spec/process/lifecycle-registry.yaml\` 生成。当前为 \`${registry.status}\` 模式：正式门禁、内部检查和派生文档共同消费此事实源。`, "",
     "## 1. 主阶段", "", "| 稳定 ID | 阶段 | 目标 | 退出标准 |", "|---|---|---|---|"
   ];
   for (const stage of registry.stages) lines.push(`| \`${stage.id}\` | ${display(stage, "name")} | ${display(stage, "goal")} | ${display(stage, "exit_criteria")} |`);
@@ -186,7 +225,7 @@ export function renderLifecycleStructure(registry) {
 
 export function renderWorkUnits(registry) {
   const display = (record, field) => record[`public_${field}`] ?? record[field];
-  const lines = ["<!-- lifecycle-registry:work-units:start -->", "> 此表由 `docs/process/lifecycle-registry.yaml` 生成；工作单元按 `scope` 区分模板维护与项目实例流程。", "", "| 稳定 ID | 范围 | 工作单元 | 输入 | 输出 | 完成条件 |", "|---|---|---|---|---|---|"];
+  const lines = ["<!-- lifecycle-registry:work-units:start -->", "> 此表由 `.template-spec/process/lifecycle-registry.yaml` 生成；工作单元按 `scope` 区分模板维护与项目实例流程。", "", "| 稳定 ID | 范围 | 工作单元 | 输入 | 输出 | 完成条件 |", "|---|---|---|---|---|---|"];
   for (const unit of registry.work_units) lines.push(`| \`${unit.id}\` | ${unit.scope} | ${display(unit, "name")} | ${display(unit, "input")} | ${display(unit, "output")} | ${display(unit, "completion")} |`);
   lines.push("<!-- lifecycle-registry:work-units:end -->");
   return `${lines.join("\n")}\n`;