create-yss-spec 3.0.1 → 3.1.3

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

@@ -0,0 +1,73 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+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';
+
+function pointer(value, ref) {
+  ensure(ref.startsWith('/')&&!ref.includes('//'),'服务版本 JSON Pointer 无效');
+  return ref.slice(1).split('/').reduce((node,key)=>node?.[key.replace(/~1/g,'/').replace(/~0/g,'~')],value);
+}
+
+export async function probeBackend(delivery) {
+  const base=new URL(delivery.environment.base_url);
+  const url=new URL(delivery.environment.revision_path,base);
+  ensure(['http:','https:'].includes(base.protocol)&&!base.username&&!base.password&&!base.hash&&!base.search,'服务环境 URL 无效或包含凭据');
+  ensure(url.origin===base.origin&&!url.username&&!url.password&&!url.hash&&!url.search,'版本探测必须在登记环境内');
+  const headers={Accept:'application/json'};
+  if(delivery.environment.authorization_env) {
+    const authorization=process.env[delivery.environment.authorization_env];
+    ensure(authorization,'版本探测缺少登记的授权环境配置');headers.Authorization=authorization;
+  }
+  const response=await fetch(url,{method:'GET',redirect:'error',signal:AbortSignal.timeout(5000),headers});
+  ensure(response.ok,`真实接口不可用: HTTP ${response.status}`);
+  const reader=response.body.getReader();let size=0;const chunks=[];
+  try {
+    while(true) { const {done,value}=await reader.read();if(done)break;size+=value.length;ensure(size<=1024*1024,'版本探测响应超限');chunks.push(value); }
+  } finally { await reader.cancel(); }
+  const body=JSON.parse(Buffer.concat(chunks).toString('utf8'));
+  const expected={deployment_id:delivery.environment.deployment_id,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};
+  for(const [key,value] of Object.entries(expected))ensure(pointer(body,delivery.environment.revision_pointers[key])===value,`真实服务版本不匹配: ${key}`);
+  return {command:`GET ${url.href}`,executed_at:new Date().toISOString(),exit_code:0,observed:expected};
+}
+
+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');
+  const acceptanceDigest=hash(readFileSync(file));
+  if(expectedDigest)ensure(expectedDigest===acceptanceDigest,'前端接收记录摘要已变化，需重编译合同');
+  ensure(sliceRef&&acceptance.slice_id===sliceRef,'前端接收记录与执行切片不匹配');
+  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`,'后端收据路径与身份不匹配');
+  ensure(receipt.bundle_digest===binding.bundle_digest,'后端收据与接收记录摘要不匹配');
+  const versions=readdirSync(safe(root,`docs/backend-deliveries/${receipt.delivery_id}`)).filter(name=>/^v[1-9][0-9]*$/.test(name)&&existsSync(safe(root,`docs/backend-deliveries/${receipt.delivery_id}/${name}/import-receipt.json`,{missing:true}))).sort((a,b)=>Number(b.slice(1))-Number(a.slice(1)));
+  ensure(versions[0]===receipt.version,'已接收更新的后端交付，旧前端接收记录 stale');
+  return openBackendDelivery(safe(root,receipt.package_ref),async backend=>{
+    const delivery=backend.delivery;
+    ensure(backend.manifest.bundle_digest===receipt.bundle_digest&&backend.manifest.delivery_id===receipt.delivery_id&&backend.manifest.version===receipt.version,'后端包与收据不一致');
+    ensure(delivery.scope.slice_id===sliceRef&&delivery.strategic_bundle_digest===acceptance.strategic_handoff.bundle_digest,'后端、战略与前端切片版本不一致');
+    const strategic=await verifyConsumption(acceptance,{root,sliceRef,consumer:'frontend'});
+    ensure(strategic.result==='verified',`战略承接阻断: ${JSON.stringify(strategic.issues)}`);
+    const ids=acceptance.frontend_cases.map(item=>item.case_id);
+    ensure(new Set(ids).size===ids.length,'前端验收用例 ID 重复');
+    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) {
+        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)),'前端用例视觉基线悬空');
+        const evidence=readFileSync(safe(root,item.evidence_ref));
+        ensure(evidence.length>0&&hash(evidence)===item.evidence_digest,'前端承接用例说明为空或摘要漂移');
+      }
+    });
+    for(const id of delivery.scope.source_ids) {
+      const row=acceptance.strategic_handoff.rows.find(item=>item.source_id===id);
+      ensure(row?.disposition==='mapped'&&row.dependent_slice_refs.includes(sliceRef),'当前交付规则/场景未承接到当前前端切片');
+    }
+    const actual=await probeBackend(delivery);
+    return {result:'inputs-verified',ready_for_agent:false,slice_id:sliceRef,acceptance_ref:acceptanceRef,acceptance_digest:acceptanceDigest,backend_bundle_digest:receipt.bundle_digest,strategic_bundle_digest:strategic.consumed_bundle_digest,actual_verification:actual,next_action:'prepare-or-revalidate-frontend-plan-and-slice-contract'};
+  });
+}

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,9 +1,12 @@
+import { enforceHarnessSkillScope } from "./harness-execution-scope.mjs";
 import { createHash } from "node:crypto";
 import { readFileSync } from "node:fs";
 import path from "node:path";
 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,
@@ -58,9 +61,15 @@ export function compileImplementationContract({
   conditions = [],
   compiledAt = new Date().toISOString(),
   registryDigest,
-  compilerContractDigest
+  compilerContractDigest,
+  architecture_identity,
+  architecture_evidence,
+  root = ROOT,
+  slice_id,
+  frontend_delivery
 }) {
   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 必须是数组");
   }
@@ -71,6 +80,16 @@ export function compileImplementationContract({
   const knownRecipes = new Map(registry.recipes.map((recipe) => [recipe.id, recipe]));
   for (const recipeId of requestedRecipes) if (!knownRecipes.has(recipeId)) fail(`未知 recipe: ${recipeId}`);
   const orderedRecipes = registry.recipes.filter((recipe) => requestedRecipes.has(recipe.id));
+  const retiredRecipes = new Set(["backend.domain-behavior", "backend.persistence-mybatis", "backend.http-api"]);
+  for (const recipe of orderedRecipes) if (retiredRecipes.has(recipe.id) || recipe.maturity === "deprecated") fail(`deprecated/read-only Recipe ${recipe.id}；必须按架构重新编译`);
+  const architectural = orderedRecipes.some((recipe) => recipe.architecture_family) || requiredCapabilities.some((id) => id.startsWith("layer."));
+  let architectureProfile;
+  if (architectural || architecture_identity) {
+    architectureProfile = validateArchitectureIdentity(architecture_identity, registry);
+    if (!architecture_evidence?.engineering_baseline || !architecture_evidence?.repository_registration || !architecture_evidence?.manifest) fail("缺少工程基线、仓库登记或 Manifest 架构证据");
+    assertArchitectureAgreement(architecture_identity, architecture_evidence, registry);
+    for (const recipe of orderedRecipes) if (recipe.architecture_family && recipe.architecture_family !== architecture_identity.architecture_family) fail(`Recipe ${recipe.id} 与架构族不匹配`);
+  }
 
   const capabilitySources = new Map();
   const orderedCapabilities = [];
@@ -90,6 +109,11 @@ export function compileImplementationContract({
 
   const capabilities = new Map(registry.capabilities.map((capability) => [capability.id, capability]));
   for (const capabilityId of orderedCapabilities) if (!capabilities.has(capabilityId)) fail(`未知 capability: ${capabilityId}`);
+  const dddCapabilities = new Set(["layer.domain", "layer.application", "layer.persistence", "layer.web-adapter"]);
+  for (const id of orderedCapabilities) {
+    const family = capabilities.get(id).architecture_family ?? (dddCapabilities.has(id) ? "domain-driven" : null);
+    if (family && family !== architecture_identity?.architecture_family) fail(`capability ${id} 与 architecture_identity 不匹配`);
+  }
   const knownSkills = new Set(registry.skills.map((skill) => skill.id));
   const conditionSet = new Set(conditions);
   const reasons = new Map();
@@ -138,10 +162,19 @@ 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),
+      profile_maturity: architectureProfile.maturity,
+      readiness_blockers: architectureProfile.maturity === "supported" ? [] : ["backend-profile-not-supported"],
+      skill_profiles: Object.fromEntries(orderedSkills.map((skill) => [skill, architecture_identity.architecture_profile]))
+    } : {}),
     recipe_ids: orderedRecipes.map((recipe) => recipe.id),
     conditions: [...conditionSet].sort(),
     required_capabilities: orderedCapabilities,
@@ -164,13 +197,20 @@ 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 { 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) {
+    try { validateArchitectureIdentity(resolution.architecture_identity, registry); }
+    catch { reasons.push("architecture-identity-invalid"); }
+    if (resolution.architecture_identity_digest !== architectureDigest(resolution.architecture_identity)) reasons.push("architecture-identity-digest-changed");
+  }
   return { freshness: reasons.length ? "stale" : "current", reasons };
 }
 
@@ -183,11 +223,14 @@ export function validateExecutionResult(result, contract, current) {
   const consumed = result.consumed_contract ?? {};
   const resolution = contract.resolution ?? contract;
   const blockers = [];
+  if (resolution.architecture_identity && architectureDigest(result.architecture_identity ?? null) !== resolution.architecture_identity_digest) blockers.push("architecture-identity-mismatch");
+  if (resolution.readiness_blockers?.length) blockers.push(...resolution.readiness_blockers);
   if (consumed.contract_id !== contract.contract_id || consumed.contract_version !== contract.contract_version) blockers.push("contract-version-mismatch");
   if (consumed.registry_digest !== resolution.registry_digest || consumed.compiler_contract_digest !== resolution.compiler_contract_digest) blockers.push("resolution-digest-mismatch");
   if (!Array.isArray(result.verification_results) || !result.verification_results.length) blockers.push("verification-not-executed");
   else for (const item of result.verification_results) {
     if (!item?.command || item.exit_code === undefined || !item.executed_at) blockers.push("verification-result-incomplete");
+    else if (item.exit_code !== 0) blockers.push("verification-failed");
   }
   if (Array.isArray(result.new_impacts) && result.new_impacts.length) blockers.push("new-impacts");
   return { status: blockers.length ? "blocked" : "accepted", blockers: [...new Set(blockers)] };

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

@@ -51,7 +51,10 @@ function canonicalize(value) {
 }
 
 export function semanticProjection(registry) {
-  return COLLECTIONS.flatMap((kind) => registry[kind].map((record) => ({ kind, record: canonicalize(record) })))
+  return COLLECTIONS.flatMap((kind) => registry[kind].map((record) => ({
+    kind,
+    record: canonicalize(Object.fromEntries(Object.entries(record).filter(([key]) => !key.startsWith("public_"))))
+  })))
     .sort((left, right) => left.record.id.localeCompare(right.record.id));
 }
 
@@ -117,6 +120,9 @@ export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {})
       const prefix = collection === "work_units" ? "work-unit." : collection === "evidence" ? "evidence." : `${collection.slice(0, -1)}.`;
       if (!id.startsWith(prefix)) fail(`${id} 与 ${collection} 类型不匹配`);
       if (typeof record.name !== "string" || record.name.length === 0) fail(`${id} 缺少名称`);
+      for (const [key, value] of Object.entries(record).filter(([key]) => key.startsWith("public_"))) {
+        if (typeof value !== "string" || value.trim().length === 0) fail(`${id}.${key} 必须是非空字符串`);
+      }
       ids.set(id, collection);
     }
   }
@@ -143,25 +149,27 @@ export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {})
 }
 
 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}\` 模式：它校验结构和派生文档，不改变运行时状态 schema 或人工批准语义。`, "",
     "## 1. 主阶段", "", "| 稳定 ID | 阶段 | 目标 | 退出标准 |", "|---|---|---|---|"
   ];
-  for (const stage of registry.stages) lines.push(`| \`${stage.id}\` | ${stage.name} | ${stage.goal} | ${stage.exit_criteria} |`);
+  for (const stage of registry.stages) lines.push(`| \`${stage.id}\` | ${display(stage, "name")} | ${display(stage, "goal")} | ${display(stage, "exit_criteria")} |`);
   lines.push("", "## 2. 生命周期对象", "", "门禁是需要裁决的审查点；产物、工作单元和证据不是门禁的同义词。未命中条件的门禁记录 \`not-applicable\` 及原因，不生成空文档。", "", "### 2.1 条件门禁", "", "| 稳定 ID | 门禁 | 所属阶段 | 触发条件 | 前置门禁 | 必须留下的证据 |", "|---|---|---|---|---|---|");
-  for (const gate of registry.gates) lines.push(`| \`${gate.id}\` | ${gate.name} | \`${gate.stage}\` | ${gate.trigger} | ${(gate.requires_gates ?? []).map((id) => `\`${id}\``).join("、") || "无"} | ${gate.evidence.map((id) => `\`${id}\``).join("、")} |`);
+  for (const gate of registry.gates) lines.push(`| \`${gate.id}\` | ${display(gate, "name")} | \`${gate.stage}\` | ${display(gate, "trigger")} | ${(gate.requires_gates ?? []).map((id) => `\`${id}\``).join("、") || "无"} | ${gate.evidence.map((id) => `\`${id}\``).join("、")} |`);
   lines.push("", "### 2.2 生命周期产物", "", "| 稳定 ID | 产物 | 所属阶段 | 触发条件 |", "|---|---|---|---|");
-  for (const artifact of registry.artifacts) lines.push(`| \`${artifact.id}\` | ${artifact.name} | \`${artifact.stage}\` | ${artifact.trigger} |`);
+  for (const artifact of registry.artifacts) lines.push(`| \`${artifact.id}\` | ${display(artifact, "name")} | \`${artifact.stage}\` | ${display(artifact, "trigger")} |`);
   lines.push("", "### 2.3 执行证据", "", "| 稳定 ID | 证据 | 说明 |", "|---|---|---|");
-  for (const evidence of registry.evidence) lines.push(`| \`${evidence.id}\` | ${evidence.name} | ${evidence.description} |`);
+  for (const evidence of registry.evidence) lines.push(`| \`${evidence.id}\` | ${display(evidence, "name")} | ${display(evidence, "description")} |`);
   lines.push("<!-- lifecycle-registry:structure:end -->");
   return `${lines.join("\n")}\n`;
 }
 
 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 | 范围 | 工作单元 | 输入 | 输出 | 完成条件 |", "|---|---|---|---|---|---|"];
-  for (const unit of registry.work_units) lines.push(`| \`${unit.id}\` | ${unit.scope} | ${unit.name} | ${unit.input} | ${unit.output} | ${unit.completion} |`);
+  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`;
 }

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

@@ -1,5 +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";
@@ -110,10 +112,17 @@ function validateTicketReference(ref, trackerKind) {
  * Workflow Execution Result may omit a route; completed results are checked
  * by `validateWorkflowExecutionResult` before this function is called.
  */
-export function validateNextRoute(currentWorkUnit, nextRoute) {
+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) return allowedResult();
+  if (nextRoute === null && routes.length === 0) {
+    if (decisionState) return validateDecisionBoundary(currentWorkUnit, decisionState, options);
+    return allowedResult();
+  }
   if (!hasText(nextRoute) || !routes.includes(nextRoute)) {
     const signals = [BLOCKING_SIGNALS.invalidRoute];
     if (nextRoute === IMPLEMENTATION_WORK_UNIT && currentWorkUnit !== TICKET_DECOMPOSITION_WORK_UNIT) {
@@ -121,14 +130,21 @@ export function validateNextRoute(currentWorkUnit, nextRoute) {
     }
     return blockedResult(signals, ["allowed_next_route"]);
   }
-  return allowedResult();
+  return decisionState ? validateDecisionBoundary(currentWorkUnit, decisionState, options) : allowedResult();
+}
+
+function validateDecisionBoundary(workUnit, state, options) {
+  try { assertWorkUnitUserDecision(workUnit, state, options); return allowedResult(); }
+  catch (error) { return blockedResult([error.code || "user-decision-invalid"], [error.message]); }
 }
 
 /**
  * Validate that Ticket formalization produced a real, implementable vertical slice.
  * `exists` is injectable so external adapters can resolve their own tracker refs.
  */
-export function validateTicketFormalization(state, { exists = existsSync, read = (ref) => readFileSync(ref, "utf8") } = {}) {
+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;
@@ -233,6 +249,12 @@ export function validateTicketFormalization(state, { exists = existsSync, read =
     missing.push("ticket formalization inputs are current");
   }
 
+  try {
+    assertImplementationDecision(state, { ...decisionOptions, read });
+  } catch (error) {
+    signals.push(error.code || "user-decision-invalid");
+    missing.push(error.message);
+  }
   return signals.length === 0 ? allowedResult(evidenceRefs) : blockedResult(signals, missing, evidenceRefs);
 }
 

package/template/scripts/lib/scaffold-local-database.mjs

@@ -0,0 +1,26 @@
+/** 新后端骨架仅提供显式本地验证配置；不绑定生产数据库。 */
+export const VERIFICATION_DATABASE = "h2";
+export const PRODUCTION_DATABASE = "not-bound";
+
+export function assertLocalDatabaseProfile(profiles) {
+  if (profiles?.verification_database !== VERIFICATION_DATABASE || profiles?.production_database !== PRODUCTION_DATABASE || Object.hasOwn(profiles ?? {}, "database")) {
+    throw new Error("新脚手架必须声明 verification_database=h2、production_database=not-bound；旧 database Profile 必须重新批准，不作静默迁移");
+  }
+}
+
+export function localDatabaseConfiguration(name) {
+  return `# 仅通过 scaffold-local 显式启用；不用于生产。\nspring:\n  datasource:\n    url: jdbc:h2:mem:${name.replaceAll("-", "_")};DB_CLOSE_DELAY=-1\n    username: sa\n    password: \"\"\n    driver-class-name: org.h2.Driver\n  sql:\n    init:\n      mode: never\n  cloud:\n    discovery:\n      enabled: false\n    service-registry:\n      auto-registration:\n        enabled: false\n    nacos:\n      discovery:\n        enabled: false\n      config:\n        enabled: false\n  cache:\n    type: none\n`;
+}
+
+export function scaffoldArchitectureIdentity(contract, contractDigest) {
+  return {
+    architecture_family: contract.architecture_family,
+    architecture_profile: contract.architecture_profile,
+    generator_skill: contract.generator_skill,
+    requested_capabilities: contract.module_profile.requested_capabilities,
+    resolved_modules: contract.module_profile.resolved_modules,
+    contract_digest: contractDigest,
+    verification_database: VERIFICATION_DATABASE,
+    production_database: PRODUCTION_DATABASE
+  };
+}

package/template/scripts/lib/scenario-checks.mjs

@@ -1,5 +1,7 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, mkdtempSync, rmSync } from "node:fs";
 import path from "node:path";
+import os from "node:os";
+import { buildDecisionFixture, buildImplementationFixture } from "../fixtures/user-decision/build-fixture.mjs";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
 import { parseDocument } from "../vendor/yaml.mjs";
@@ -15,10 +17,8 @@ const virtualTicketDecompositionRef = "docs/.scratch/demo/evidence/ticket-decomp
 const virtualTicketDecomposition = "result_schema: workflow-execution-result-v1\nwork_unit: work-unit.ticket-decomposition\nresult: completed\nevidence_refs:\n  - docs/.scratch/demo/evidence/ticket-decomposition-result.yaml\n";
 
 function validateMattContract(data) {
-  const direct = data.entry_routing?.direct_matt_entry;
-  ensure(direct?.skill === "ask-matt" && direct?.delegate_to === "yss-product-lifecycle" && direct?.requires_valid_manifest === true && direct?.action === "navigate-only" && direct?.lifecycle_state_mutation === "forbidden" && direct?.lifecycle_artifact_write === "forbidden" && direct?.return_to_orchestrator === "required", "ask-matt 导航入口尚未形成验明身份、只导航、禁止生命周期写入并强制回交主控的完整契约");
   const formal = data.entry_routing?.formal_user_entry;
-  ensure(includesAll(formal?.skills, ["setup-matt-pocock-skills", "grill-with-docs", "to-spec", "to-tickets", "implement"]) && formal?.action === "lifecycle-validate-and-accept" && formal?.lifecycle_artifact_write === "conditional-explicit-user-entry" && formal?.return_to_orchestrator === "required", "正式用户入口未区分于 ask-matt 导航入口");
+  ensure(includesAll(formal?.skills, ["setup-matt-pocock-skills", "grill-with-docs", "to-spec", "to-tickets", "implement"]) && formal?.action === "lifecycle-validate-and-accept" && formal?.lifecycle_artifact_write === "conditional-explicit-user-entry" && formal?.return_to_orchestrator === "required", "正式用户入口缺少生命周期预检与回交约束");
   const setup = data.setup_readiness;
   ensure(setup?.missing_action === "needs-human" && setup?.requested_skill === "setup-matt-pocock-skills" && setup?.resume_route === "setup-readiness" && setup?.lifecycle_may_invoke_setup === false, "setup 缺失时未限制为显式用户入口暂停");
   ensure(includesAll(setup?.preserves, ["lifecycle.status", "gate.status", "ticket.role"]) && setup?.legacy_artifacts_detected?.action === "migration-check" && setup.legacy_artifacts_detected.setup === "forbidden" && setup.legacy_artifacts_detected.write === "paused", "setup 暂停或旧资产迁移暂停契约不完整");
@@ -39,8 +39,8 @@ function validateMattContract(data) {
 
 function validateInvocationBoundary(data) {
   const boundary = data.matt_invocation_boundary;
-  const expectedUserInvoked = ["ask-matt", "grill-me", "grill-with-docs", "handoff", "implement", "improve-codebase-architecture", "loop-me", "setup-matt-pocock-skills", "setup-ts-deep-modules", "teach", "to-questionnaire", "to-spec", "to-tickets", "triage", "wait-what", "wayfinder", "writing-beats", "writing-fragments", "writing-shape"];
-  const expectedModelInvoked = ["code-review", "codebase-design", "diagnosing-bugs", "domain-modeling", "grilling", "migrate-to-shoehorn", "prototype", "resolving-merge-conflicts", "scaffold-exercises", "setup-pre-commit", "tdd", "writing-for-agents", "yss-research"];
+  const expectedUserInvoked = ["grill-me", "grill-with-docs", "handoff", "implement", "improve-codebase-architecture", "setup-matt-pocock-skills", "to-questionnaire", "to-spec", "to-tickets", "triage", "wait-what", "wayfinder"];
+  const expectedModelInvoked = ["code-review", "codebase-design", "diagnosing-bugs", "domain-modeling", "grilling", "prototype", "resolving-merge-conflicts", "tdd", "writing-for-agents", "yss-research"];
   const expectedLifecycleModelInvoked = ["code-review", "codebase-design", "diagnosing-bugs", "domain-modeling", "grilling", "prototype", "tdd", "yss-research"];
   ensure(JSON.stringify(boundary?.user_invoked_skills) === JSON.stringify(expectedUserInvoked), "Matt user-invoked skills 清单不完整或已漂移");
   ensure(JSON.stringify(boundary?.lifecycle_managed_user_entries) === JSON.stringify(["setup-matt-pocock-skills", "grill-with-docs", "to-spec", "to-tickets", "implement"]), "生命周期管理的显式用户入口清单不完整");
@@ -53,10 +53,10 @@ function validateInvocationBoundary(data) {
   const result = data.workflow_execution_result;
   ensure(data.matt_skill_result?.status === "compatibility-read-only" && data.matt_skill_result?.may_influence_routing === false && data.matt_skill_result?.normalize_to === "workflow-execution-result-v1", "旧 Matt Skill Result 未限制为只读兼容 adapter");
   ensure(result?.canonical_output_schema === "workflow-execution-result-v1" && JSON.stringify(result?.accepted_input_schemas) === JSON.stringify(["workflow-execution-result-v1"]) && result?.legacy?.["matt-skill-result-v1"]?.status === "compatibility-read-only" && result.legacy["matt-skill-result-v1"].may_influence_routing === false && result.legacy["matt-skill-result-v1"].normalize_to === "workflow-execution-result-v1", "Workflow Execution Result 未将旧 Matt Skill Result 限制为只读兼容");
-  ensure(includesAll(result?.required, ["result_schema", "work_unit", "workflow_reference", "result", "evidence_refs", "changed_artifacts", "new_impacts", "stale_candidates", "next_route", "blocking_signals"]) && includesAll(result?.result_values, ["completed", "blocked", "needs-human", "failed"]) && includesAll(result?.blocking_signals, ["drift", "new_impacts", "violation", "missing_evidence", "stale_candidates"]) && includesAll(result?.completed_requires_empty, ["new_impacts", "stale_candidates"]) && includesAll(result?.completed_requires_non_empty, ["evidence_refs"]) && result?.completed_requires_readable_evidence_refs === true && result?.evidence_ref_validation === "readable-or-resolvable" && result?.completed_requires_no_blocking_signals === true && includesAll(result?.workflow_reference?.required, ["source", "skill", "invocation_mode"]), "Workflow Execution Result 的完成态证据、阻断信号或 workflow_reference 契约不完整");
+  ensure(includesAll(result?.required, ["result_schema", "work_unit", "workflow_reference", "result", "context_reconciliation", "evidence_refs", "changed_artifacts", "new_impacts", "stale_candidates", "next_route", "blocking_signals"]) && includesAll(result?.result_values, ["completed", "blocked", "needs-human", "failed"]) && includesAll(result?.blocking_signals, ["drift", "new_impacts", "violation", "missing_evidence", "stale_candidates"]) && includesAll(result?.completed_requires_empty, ["new_impacts", "stale_candidates"]) && includesAll(result?.completed_requires_non_empty, ["evidence_refs"]) && result?.completed_requires_readable_evidence_refs === true && result?.evidence_ref_validation === "readable-or-resolvable" && result?.completed_requires_no_blocking_signals === true && result?.context_reconciliation?.creates_gate === false && includesAll(result?.workflow_reference?.required, ["source", "skill", "invocation_mode"]), "Workflow Execution Result 的完成态证据、阻断信号、context_reconciliation 或 workflow_reference 契约不完整");
   const native = data.lifecycle_native_entries;
   ensure(native?.default_entry === "yss-product-lifecycle" && native?.formal_artifact_owner === "yss-product-lifecycle", "生命周期原生入口未持有默认正式资产所有权");
-  ensure(JSON.stringify(native?.user_confirmation_required_at) === JSON.stringify(["spec-baseline", "prototype-confirmation", "openapi-freeze", "merge-or-release"]), "生命周期人工门禁集合已漂移");
+  ensure(native?.user_confirmation_policy_ref === "docs/agents/digital-human-roles.yaml#user_decision_policy", "生命周期人工门禁集合已漂移");
   const routes = data.work_unit_routes;
   ensure(routes?.["work-unit.discovery-requirements"]?.skills?.includes("grilling") && routes?.["work-unit.discovery-requirements"]?.skills?.includes("domain-modeling"), "需求分析工作单元缺少 grilling/domain-modeling");
   ensure(routes?.["work-unit.discovery-opportunity"]?.route_by?.market_or_competitor_fact === "competitive-intelligence" && routes["work-unit.discovery-opportunity"].route_by.technical_or_standard_fact === "yss-research:technical-evidence" && routes["work-unit.discovery-opportunity"].route_by.strategy_fact === "yss-research:strategy-evidence", "机会调研事实路由不准确");
@@ -69,7 +69,7 @@ function validateInvocationBoundary(data) {
   ensure(JSON.stringify(Object.keys(prototypeRoute?.profile_contract?.profiles ?? {})) === JSON.stringify(["H1", "H2"]) && prototypeRoute?.version_boundary?.prototype_must_not_call === "yss-ui", "原型档位必须仅包含 H1/H2 并明确 yss-ui 边界");
   ensure(routes?.["work-unit.slice-implementation"]?.skills?.includes("tdd") && routes?.["work-unit.slice-implementation"]?.skills?.includes("yss-ui") && routes?.["work-unit.slice-implementation"]?.skills?.includes("yss-ui-business-page-generation"), "原生实现工作单元缺少 TDD、UI 或业务页面生成路由");
   const frontendRoute = routes?.["work-unit.slice-implementation"]?.frontend_route;
-  ensure(frontendRoute?.primary_skill === "yss-ui" && frontendRoute?.page_generation_skill === "yss-ui-business-page-generation" && frontendRoute?.page_orchestration_skill === "yss-page-module-development", "前端实现路由缺少 yss-ui 主入口、业务页面生成或页面编排技能");
+  ensure(frontendRoute?.primary_skill === "yss-ui" && frontendRoute?.page_generation_skill === "yss-ui-business-page-generation" && frontendRoute?.page_orchestration_skill === "yss-ui-business-page-generation", "前端实现路由缺少 yss-ui 主入口或统一业务页面技能");
   for (const impact of ["api_impact", "formily_impact", "table_impact", "tree_impact", "height_impact", "export_impact", "theme_impact"]) {
     ensure(Array.isArray(frontendRoute?.conditional_skills?.[impact]) && frontendRoute.conditional_skills[impact].length > 0 && typeof frontendRoute.not_applicable_reasons?.[impact] === "string", `前端条件专项路由缺少 ${impact}`);
   }
@@ -105,8 +105,10 @@ function validateWorkflowExecutionResult(payload, contract, workUnitRoutes) {
   const workUnit = workUnitRoutes?.[payload.work_unit];
   ensure(workUnit, `未知 Workflow Execution Result work_unit: ${payload.work_unit}`);
   if (payload.result === "completed") {
-    const routeResult = validateNextRoute(payload.work_unit, payload.next_route);
+    const routeResult = validateNextRoute(payload.work_unit, payload.next_route, payload);
     ensure(routeResult.result === "allowed", `Workflow Execution Result next_route 非法: ${routeResult.blocking_signals.join(", ")}`);
+    ensure(payload.context_reconciliation?.status === "reconciled", "project-instance 完成态必须具有 reconciled context_reconciliation");
+    ensure(hasText(payload.context_reconciliation?.ref) && payload.evidence_refs.includes(payload.context_reconciliation.ref) && exists(payload.context_reconciliation.ref), "context_reconciliation.ref 必须可读并包含在 evidence_refs 中");
   }
   const accepted = [workUnit.native, workUnit.compatibility].filter(Boolean);
   ensure(contract.workflow_reference.allowed_sources.includes(payload.workflow_reference.source) && accepted.some((route) => route.source === payload.workflow_reference.source && route.skill === payload.workflow_reference.skill && route.invocation_mode === payload.workflow_reference.invocation_mode), "Workflow Execution Result workflow_reference 与 work_unit route 不匹配");
@@ -121,6 +123,8 @@ function validateWorkflowExecutionResult(payload, contract, workUnitRoutes) {
   }
   if (payload.work_unit === "work-unit.slice-implementation" && payload.result === "completed") {
     const implementationState = {
+      user_decisions: payload.user_decisions,
+      slice_contract_ref: payload.slice_contract_ref,
       tracker_kind: payload.tracker_kind,
       predecessor_work_unit: payload.predecessor_work_unit,
       ready_for_agent: payload.ready_for_agent,
@@ -141,7 +145,7 @@ function validateWorkflowExecutionResult(payload, contract, workUnitRoutes) {
       // The scenario uses one explicit virtual fixture; arbitrary local refs
       // must still pass the real readability check and cannot use a fallback.
       exists: (ref) => exists(ref) || ref === "docs/.scratch/demo/issues/01-valid-slice.md" || ref === virtualTicketDecompositionRef,
-      read: (ref) => ref === virtualTicketDecompositionRef ? virtualTicketDecomposition : readFileSync(path.join(root, ref), "utf8"),
+      read: (ref) => ref === virtualTicketDecompositionRef ? virtualTicketDecomposition : readFileSync(path.resolve(root, ref), "utf8"),
     });
     ensure(semantic.result === "allowed", `Workflow Execution Result implementation Ticket 语义非法: ${semantic.blocking_signals.join(", ")}`);
   }
@@ -256,11 +260,17 @@ export function runScenario(name) {
     const data = contract.toJS({ maxAliasCount: 0 });
     validateMattContract(data);
     validateInvocationBoundary(data);
+    const decisionTemp = mkdtempSync(path.join(os.tmpdir(), "matt-decision-test-"));
+    process.on("exit", () => rmSync(decisionTemp, { recursive: true, force: true }));
+    const specDecision = buildDecisionFixture(path.join(decisionTemp, "spec"));
+    const implementationDecision = buildImplementationFixture(path.join(decisionTemp, "implementation"), "docs/.scratch/demo/issues/01-valid-slice.md");
     const validResult = {
+      user_decisions: [specDecision.requirement],
       result_schema: "workflow-execution-result-v1",
       work_unit: "work-unit.spec-synthesis",
       workflow_reference: { source: "yss-product-lifecycle", skill: "yss-product-lifecycle", invocation_mode: "model-invoked" },
       result: "completed",
+      context_reconciliation: { status: "reconciled", ref: "docs/process/lifecycle-registry.yaml" },
       evidence_refs: ["docs/process/lifecycle-registry.yaml"],
       changed_artifacts: [],
       new_impacts: [],
@@ -279,6 +289,7 @@ export function runScenario(name) {
     validateWorkflowExecutionResult(validTicketResult, data.workflow_execution_result, data.work_unit_routes);
     const validImplementationResult = {
       ...validResult,
+      ...implementationDecision.state,
       evidence_refs: [virtualTicketDecompositionRef, "docs/process/lifecycle-registry.yaml"],
       work_unit: "work-unit.slice-implementation",
       next_route: "work-unit.code-review",
@@ -324,6 +335,8 @@ export function runScenario(name) {
     validateWorkflowExecutionResult(compatibleResult, data.workflow_execution_result, data.work_unit_routes);
     for (const mutate of [
       (item) => { delete item.workflow_reference; },
+      (item) => { delete item.context_reconciliation; },
+      (item) => { item.context_reconciliation.status = "blocked"; },
       (item) => { item.evidence_refs = []; },
       (item) => { item.evidence_refs = ["docs/process/not-found.md"]; },
       (item) => { item.blocking_signals = ["drift"]; },
@@ -344,7 +357,7 @@ export function runScenario(name) {
     } catch { metadataRejected = true; }
     ensure(metadataRejected, "user-invoked front matter 变异未被 baseline oracle 拒绝");
     const mutations = [
-      (item) => { delete item.entry_routing.direct_matt_entry.return_to_orchestrator; },
+      (item) => { delete item.entry_routing.formal_user_entry.return_to_orchestrator; },
       (item) => { item.entry_routing.formal_user_entry.lifecycle_artifact_write = "forbidden"; },
       (item) => { item.matt_invocation_boundary.user_invoked_skills.push("unexpected-user-entry"); },
       (item) => { item.setup_readiness.lifecycle_may_invoke_setup = true; },

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

@@ -14,7 +14,19 @@ function fail(message) {
 export function validateSkillGovernance({ read = (relative) => readFileSync(path.join(ROOT, relative), "utf8"), exists = (relative) => existsSync(path.join(ROOT, relative)) } = {}) {
   const globalRules = read(".agents/rules/yss-ai-skills.md");
   const tableSkill = read(".agents/skills/ytable-usage/SKILL.md");
-  const pageSkill = read(".agents/skills/yss-page-module-development/SKILL.md");
+  const pageSkill = read(".agents/skills/yss-ui-business-page-generation/SKILL.md");
+
+  for (const marker of ["trigger: always_on", "docs/agents/yss-skill-registry.yaml", ".agents/skills/yss-ui/SKILL.md", "原型阶段"]) {
+    if (!globalRules.includes(marker)) fail(`YSS UI 薄入口缺少路由标记: ${marker}`);
+  }
+  for (const staleHeading of ["## Available Skills", "## Mandatory Workflow"]) {
+    if (globalRules.includes(staleHeading)) fail(`YSS UI 薄入口不得回流技能清单或实现步骤: ${staleHeading}`);
+  }
+  const cursorRules = read(".cursorrules");
+  for (const marker of ["yss-project.yaml", "docs/agents/yss-skill-registry.yaml", "yss-ui-business-page-generation", ".cursor/skills"]) {
+    if (!cursorRules.includes(marker)) fail(`Cursor 薄入口缺少路由标记: ${marker}`);
+  }
+  if (cursorRules.includes("YSS AI SKILLS START")) fail("Cursor 薄入口不得回流技能清单");
 
   if (/toolbar-config\.custom.{0,30}(必须|必需)|必须.{0,30}toolbar-config\.custom/.test(globalRules)) {
     fail("全局规则不得把 toolbar-config.custom 作为无条件要求");
@@ -25,8 +37,8 @@ export function validateSkillGovernance({ read = (relative) => readFileSync(path
   for (const marker of ["无需配置 `:toolbar-config=\"{ custom: true }\"`", "仅在业务明确需要列设置时才传入"]) {
     if (!tableSkill.includes(marker)) fail(`YTable 专项技能缺少条件化工具栏规则: ${marker}`);
   }
-  if (!pageSkill.includes("只有确实需要列设置时才启用 `toolbar-config.custom`")) {
-    fail("页面模块 canonical 技能缺少条件化 toolbar-config 规则");
+  if (!pageSkill.includes("仅在业务明确需要列设置时才传入")) {
+    fail("业务页面 canonical 技能缺少条件化 toolbar-config 规则");
   }
 
   const yssUiManifest = validateYssUiSkillManifest(JSON.parse(read(".agents/skills/.yss-skills-manifest.json")));
@@ -64,9 +76,9 @@ export function validateSkillGovernance({ read = (relative) => readFileSync(path
   }
 
   const strategicManifest = validateStrategicDesignSkillManifest(JSON.parse(read(".agents/skills/.strategic-design-skills-manifest.json")));
-  const strategicIds = ["prototype-review", "yss-prototype-stage", "yss-design-system", "yss-antd-design", "yss-stage-decision"];
+  const strategicIds = ["prototype-review", "yss-prototype-stage", "yss-design-system", "yss-antd-design", "yss-antdv-next-design", "yss-stage-decision"];
   if (JSON.stringify(strategicManifest.skills.map(({ canonical }) => canonical).sort()) !== JSON.stringify(strategicIds.slice().sort())) {
-    fail("战略设计 skills 清单必须恰好覆盖五项公共技能");
+    fail("战略设计 skills 清单必须恰好覆盖六项公共技能");
   }
   for (const skill of strategicManifest.skills) {
     if (isTemplateSource(ROOT)) {
@@ -86,11 +98,14 @@ export function validateSkillGovernance({ read = (relative) => readFileSync(path
   const registry = loadSkillRegistry();
   const canonicalIds = new Set(registry.skills.map((skill) => skill.id));
   const aliases = new Map(registry.skills.flatMap((skill) => skill.aliases.map((alias) => [alias, skill.id])));
-  const legacy = new Set(["api-integration", "page-module-development", "use-table-height", "use-tree-height"]);
+  const legacy = new Set(["api-integration", "use-table-height", "use-tree-height"]);
   for (const alias of legacy) {
     if (exists(`.agents/skills/${alias}`)) fail(`legacy alias 不得存在独立 canonical 目录: ${alias}`);
     if (!aliases.has(alias)) fail(`legacy alias 未登记: ${alias}`);
   }
+  if (exists(".agents/skills/page-module-development") || exists(".agents/skills/yss-page-module-development") || aliases.has("page-module-development")) {
+    fail("page-module-development / yss-page-module-development 已退役，不得保留物理目录或运行时 alias");
+  }
   if (exists(".agents/skills/high-fidelity-html-prototype") || aliases.has("high-fidelity-html-prototype")) {
     fail("high-fidelity-html-prototype 已退役，不得保留物理目录或运行时 alias");
   }
@@ -99,14 +114,14 @@ export function validateSkillGovernance({ read = (relative) => readFileSync(path
   const prototypeEvidence = read("docs/design/templates/prototype-evidence-template.yaml");
   const projectDesign = read("docs/design/design.md");
   const antdvCompatibility = read(".agents/skills/yss-ui/references/antdv-compatibility.md");
-  for (const marker of ["product-design-adapter.md", "schema v3", "H1", "H2", "原型阶段不得调用 `yss-ui`"]) {
+  for (const marker of ["product-design-adapter.md", "Prototype Evidence schema v4", "Visual Baseline schema v1", "H1", "H2", "原型阶段不得调用 `yss-ui`"]) {
     if (!prototypeStage.includes(marker)) fail(`原型阶段合同缺少 YSS adapter 标记: ${marker}`);
   }
-  for (const marker of ["prepare-static", "prepare-flow", "fact pack", "ConfigProvider", "1440x900", "390x844"]) {
+  for (const marker of ["prepare-static", "prepare-flow", "vue-antdv-next", "react-antd-6", "fact pack", "ConfigProvider", "1440x900", "390x844"]) {
     if (!prototypeAdapter.includes(marker)) fail(`Product Design adapter 缺少执行约束: ${marker}`);
   }
-  for (const marker of ["schema_version: 3", "prototype_profile", "visual_review", "flow_review", "implementation_handoff", "project_token_baseline_digest", "verification/design-qa.md"]) {
-    if (!prototypeEvidence.includes(marker)) fail(`原型证据模板缺少 schema v3 字段: ${marker}`);
+  for (const marker of ["schema_version: 4", "visual_baseline", "prototype_profile", "visual_review", "flow_review", "implementation_handoff", "project_token_baseline_digest", "verification/design-qa.md"]) {
+    if (!prototypeEvidence.includes(marker)) fail(`原型证据模板缺少 schema v4 字段: ${marker}`);
   }
   if (prototypeEvidence.includes("与官方 #1677ff / Inter / 8px")) fail("原型证据模板仍把 Inter/8px 误写为官方 v6 默认差异");
   if (projectDesign.includes("`antdv6-design.md`")) fail("design.md 仍引用不存在的 antdv6-design.md");