create-yss-spec 3.3.1 → 3.3.3

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

@@ -1,405 +0,0 @@
-import { existsSync, readFileSync, mkdtempSync, rmSync } from "node:fs";
-import path from "node:path";
-import { buildPlanFixture } from "../fixtures/user-decision/plan-fixture.mjs";
-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";
-import { lifecycleTransitionContract, validateImplementationEntry, validateNextRoute } from "./lifecycle-transition.mjs";
-
-const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
-const read = (relative) => readFileSync(path.join(root, relative), "utf8");
-function ensure(condition, message) { if (!condition) throw new TypeError(message); }
-function exists(relative) { return existsSync(path.join(root, relative)); }
-function includesAll(actual, expected) { return Array.isArray(actual) && expected.every((item) => actual.includes(item)); }
-function hasText(value) { return typeof value === "string" && value.trim().length > 0; }
-const virtualTicketDecompositionRef = "docs/.scratch/demo/evidence/ticket-decomposition-result.yaml";
-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 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", "正式用户入口缺少生命周期预检与回交约束");
-  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 暂停或旧资产迁移暂停契约不完整");
-  const grill = data.grill_exit;
-  ensure(includesAll(grill?.required, ["frontier_empty", "facts_resolved_or_routed", "decisions_confirmed", "shared_understanding_confirmed", "no_unresolved_runnable_blocker"]) && grill?.user_confirmation_required === true, "grill_exit 缺少 frontier、事实路由、决策、共同理解、用户确认或 runnable blocker 条件");
-  ensure(grill?.facts_resolved_or_routed?.technical_fact === "yss-research" && grill.facts_resolved_or_routed.runnable_question === "handoff-prototype-handoff" && grill.facts_resolved_or_routed.external_decision === "external-input-required", "grill_exit 的事实、runnable 问题或外部决策路由不完整");
-  const git = data.git_authorization;
-  for (const action of ["commit", "push"]) {
-    const prefix = action === "commit" ? "commit" : "push";
-    const rule = git?.[action];
-    ensure(git?.natural_language_intent_is_authorization === false && rule?.requires_explicit_user_authorization === true && rule?.authorized_value === true && rule?.unauthorized_action === "checkpoint-only", `${action} 授权边界不完整`);
-    ensure(includesAll(rule?.required, [`${prefix}_authorized`, `${prefix}_scope`, `${prefix}_authorization_ref`]) && includesAll(rule?.non_empty, [`${prefix}_scope`, `${prefix}_authorization_ref`]), `${action} 授权必填字段不完整`);
-  }
-  const submodule = git?.git_submodule;
-  ensure(submodule?.applies_when === "repository_scope=git-submodule" && submodule?.forbid_commit_on_detached_head === true && submodule?.empty_gitlink_scaffold === "blocked" && submodule?.treat_empty_gitlink_as_regular_dir === "blocked" && submodule?.treat_detached_head_as_regular_dir === "blocked" && submodule?.force_overlay_mount === "blocked" && submodule?.write_inside_detached_head === "blocked" && submodule?.require_git_entry_mode === "160000" && submodule?.working_tree_declared_scope_must_match === true && submodule?.copy_source_into_harness === "forbidden" && submodule?.clone_requires_recurse_submodules === true && submodule?.push_recurse_submodules === "check" && submodule?.delivery_order_must_include === "superproject-gitlink-update" && submodule?.nested_authorization === "per-repository" && submodule?.inspect_working_tree_writable === "explicit-boolean" && submodule?.empty_gitlink_writable === false && submodule?.force_overlay_regular_dir_path === "blocked", "git-submodule Git 授权契约不完整");
-  ensure(JSON.stringify(submodule?.commit_order) === JSON.stringify(["submodule-repositories", "superproject-gitlink"]) && JSON.stringify(submodule?.push_order) === JSON.stringify(["submodule-repositories", "superproject-gitlink"]), "git-submodule 先子后父顺序不完整");
-}
-
-function validateInvocationBoundary(data) {
-  const boundary = data.matt_invocation_boundary;
-  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"]), "生命周期管理的显式用户入口清单不完整");
-  ensure(boundary?.lifecycle_may_invoke_user_invoked === false && boundary?.formal_artifact_owner === "explicit-user-entry", "生命周期仍可能自动调用 user-invoked skill 或产出其正式资产");
-  ensure(JSON.stringify(boundary?.model_invoked_skills) === JSON.stringify(expectedModelInvoked) && JSON.stringify(boundary?.lifecycle_allowed_model_invoked_skills) === JSON.stringify(expectedLifecycleModelInvoked) && boundary?.continuous_orchestration === "compatibility-prepare-and-validate-only", "Matt invocation inventory 或生命周期 model-invoked 白名单不完整");
-  ensure(JSON.stringify(data.skill_source_contract?.source_revisions_required) === JSON.stringify(["mattpocock/skills", "iloveZzz/yss-ui"]) && data.skill_source_contract?.adaptation_ref_required_when_effective_diff === true && data.skill_source_contract?.retired_shared_skills?.includes("batch-grill-me"), "上游来源或退役 skill 供应链契约不完整");
-  validateInvocationMetadata(boundary, (skill) => read(`.agents/skills/${skill}/SKILL.md`));
-  const setup = data.setup_readiness;
-  ensure(setup?.missing_action === "needs-human" && setup?.requested_skill === "setup-matt-pocock-skills" && setup?.resume_route === "setup-readiness" && setup?.preserves?.includes("lifecycle.status"), "readiness=missing 未形成显式用户 setup 的结构化暂停");
-  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", "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(native?.user_confirmation_policy_ref === "docs/agents/digital-human-roles.yaml#user_decision_policy", "生命周期人工门禁集合已漂移");
-  const routes = data.work_unit_routes;
-  ensure(routes?.["work-unit.plan-requirements"]?.skills?.includes("grilling") && routes?.["work-unit.plan-requirements"]?.skills?.includes("domain-modeling"), "需求分析工作单元缺少 grilling/domain-modeling");
-  ensure(routes?.["work-unit.plan-opportunity"]?.route_by?.market_or_competitor_fact === "competitive-intelligence" && routes["work-unit.plan-opportunity"].route_by.technical_or_standard_fact === "yss-research:technical-evidence" && routes["work-unit.plan-opportunity"].route_by.strategy_fact === "yss-research:strategy-evidence", "机会调研事实路由不准确");
-  const strategyResearch = routes?.["work-unit.domain-strategy-design"]?.research_contract;
-  ensure(strategyResearch?.profile === "strategy-evidence" && strategyResearch.mode_before_gate === "evidence-audited" && strategyResearch.artifact_owner === "yss-research" && strategyResearch.downstream_owner === "yss-stage-decision", "领域战略研究合同缺少 profile、门禁前审计或资产所有权边界");
-  const stageDecisionResearch = routes?.["work-unit.stage-decision"]?.research_contract;
-  ensure(routes?.["work-unit.stage-decision"]?.skills?.includes("yss-research") && stageDecisionResearch?.profile === "strategy-evidence" && stageDecisionResearch.mode_before_gate === "evidence-audited" && stageDecisionResearch.artifact_owner === "yss-research" && stageDecisionResearch.downstream_owner === "yss-stage-decision", "阶段决策工作单元缺少 evidence-audited 战略研究合同");
-  const prototypeRoute = routes?.["work-unit.prototype-design"];
-  ensure(!prototypeRoute?.skills?.includes("yss-ui") && !prototypeRoute?.supporting_skills?.includes("yss-ui"), "原型工作单元不得调用生产实现技能 yss-ui");
-  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-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}`);
-  }
-  ensure(routes?.["work-unit.frontend-implementation-verification"]?.skills?.includes("code-review") && routes?.["work-unit.frontend-implementation-verification"]?.applies_when === "ui_impact", "前端还原验证未绑定 UI fidelity 审查轴");
-  const reviewRoute = routes?.["work-unit.code-review"];
-  ensure(reviewRoute?.primary_skill === "code-review" && reviewRoute?.review_standards_route?.unique_default_skill === "code-review" && reviewRoute?.review_standards_route?.second_generic_review_skill === "forbidden", "code-review 不是唯一默认审查入口或允许第二套通用审查 skill");
-  ensure(includesAll(reviewRoute?.supporting_skills, ["alibaba-java-code-style", "yss-ui", "yss-domain", "yss-repository", "yss-mybatis"]) && includesAll(reviewRoute?.skills, ["code-review", "alibaba-java-code-style", "yss-ui", "yss-repository", "yss-mybatis"]), "审查工作单元缺少 YSS / Alibaba / Repository / MyBatis 专项检查输入");
-  const reviewScope = reviewRoute?.review_standards_route?.project_scope;
-  ensure(includesAll(reviewScope?.sources, ["candidate-project-root", "implementation-repository-registry", "slice-project-roots", "allowed-write-paths"]) && includesAll(reviewScope?.include, ["project-itself", "registered-backend-development-projects"]) && includesAll(reviewScope?.exclude, ["frontend-projects", "unrelated-submodules", "vendor", "unregistered-directories"]) && reviewScope?.fixed_apps_backend_assumption === "forbidden", "后端审查范围未绑定本体项目与已登记后端研发项目，或仍固定为 apps/backend");
-  const disposition = reviewRoute?.review_standards_route?.finding_disposition;
-  ensure(includesAll(disposition?.same_loop_for, ["product-slice", "template-maintenance"]) && disposition?.reviewer_write_implementation === "forbidden", "审查 finding 闭环未同时覆盖产品切片与模板维护，或允许审查者写实现");
-  ensure(includesAll(disposition?.repair_then_full_rereview?.kinds, ["violation", "machine_check_failure", "blank_applicable_row", "missing_evidence"]) && disposition?.repair_then_full_rereview?.actor === "implementer" && disposition?.repair_then_full_rereview?.then === "recapture_candidate_and_rerun_all_axes", "violation 类 finding 未要求实现者修复后全轴复审");
-  ensure(includesAll(disposition?.stale_and_reroute?.kinds, ["drift", "new_impacts", "required_skills_mismatch"]) && disposition?.stale_and_reroute?.continue_coding_on_old_contract === "forbidden" && disposition?.stale_and_reroute?.next === "compiler-or-earlier-lifecycle", "drift / new_impacts 未要求合同 stale 并回 实现合同编译器");
-  ensure(disposition?.exemption_policy?.not_applicable === "impact_not_triggered_only" && disposition?.exemption_policy?.mandatory_waiver === "forbidden" && includesAll(disposition?.exemption_policy?.allowed_exits, ["repair", "seam-deferred-complete"]) && disposition?.exemption_policy?.new_human_waiver_gate === "forbidden", "审查豁免策略允许未命中以外的 not-applicable 或 mandatory 豁免");
-  ensure(data.review_input?.unique_default_skill === "code-review" && data.review_input?.second_generic_review_skill === "forbidden" && data.review_input?.completed_requires_specialist_coverage === true && data.review_input?.finding_disposition_required === true && data.review_input?.completed_requires_no_open_mandatory_violations === true && data.review_input?.completed_requires_no_blank_applicable_rows === true && data.review_input?.reviewer_write_implementation === "forbidden" && includesAll(data.review_input?.standards_sources, ["slice_contract_required_skills", "specialist_check_inputs", "review_report_template"]), "review_input 未强制专项检查覆盖或 finding 闭环完成条件");
-  for (const id of ["work-unit.spec-synthesis", "work-unit.ticket-decomposition", "work-unit.slice-implementation"]) {
-    ensure(routes?.[id]?.native?.source === "yss-product-lifecycle" && routes[id].compatibility?.source === "mattpocock/skills" && routes[id].compatibility.formal_artifact_owner === "explicit-user-entry", `${id} 未分离原生执行定义与 Matt 兼容输入`);
-  }
-  for (const route of Object.values(routes ?? {})) {
-    for (const skill of route.skills ?? []) ensure(!boundary.user_invoked_skills.includes(skill), `工作单元不能自动调用 user-invoked skill: ${skill}`);
-    for (const skill of route.skills ?? []) if (boundary.model_invoked_skills.includes(skill)) ensure(boundary.lifecycle_allowed_model_invoked_skills.includes(skill), `工作单元调用了未进入生命周期白名单的 model-invoked skill: ${skill}`);
-  }
-}
-
-function validateWorkflowExecutionResult(payload, contract, workUnitRoutes, options = {}) {
-  for (const field of contract.required) ensure(Object.hasOwn(payload, field), `Workflow Execution Result 缺少 ${field}`);
-  ensure(contract.result_values.includes(payload.result), "Workflow Execution Result result 无效");
-  if (Object.hasOwn(payload, "unavailable_skill")) {
-    ensure(payload.result === contract.unavailable_skill.blocking_result, "技能不可用必须将 Workflow Execution Result 标记为 blocked");
-    for (const field of contract.unavailable_skill.required) {
-      ensure(typeof payload.unavailable_skill?.[field] === "string" && payload.unavailable_skill[field].trim(), `unavailable_skill.${field} 无效`);
-    }
-  }
-  for (const field of contract.workflow_reference.required) ensure(typeof payload.workflow_reference?.[field] === "string" && payload.workflow_reference[field].trim(), `workflow_reference.${field} 无效`);
-  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, payload, options);
-    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 不匹配");
-  const workUnitRequirements = contract.work_unit_requirements?.[payload.work_unit];
-  if (workUnitRequirements && payload.result === "completed") {
-    for (const field of [...(workUnitRequirements.required ?? []), ...(workUnitRequirements.completed_requires ?? [])]) {
-      ensure(hasText(payload[field]), `Workflow Execution Result ${payload.work_unit} 缺少 ${field}`);
-    }
-    for (const field of workUnitRequirements.boolean_required ?? []) {
-      ensure(typeof payload[field] === "boolean", `Workflow Execution Result ${payload.work_unit} 缺少布尔字段 ${field}`);
-    }
-  }
-  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,
-      delivery_impacts: payload.delivery_impacts,
-      implementation_repository_preparation: payload.implementation_repository_preparation,
-      tracker_kind: payload.tracker_kind,
-      predecessor_work_unit: payload.predecessor_work_unit,
-      ready_for_agent: payload.ready_for_agent,
-      ticket_decomposition_result_ref: payload.ticket_decomposition_result_ref,
-      vertical_slice_ticket_ref: payload.vertical_slice_ticket_ref,
-      vertical_slice_ticket_role: payload.vertical_slice_ticket_role,
-      vertical_slice_ticket_kind: payload.vertical_slice_ticket_kind,
-      ticket_decomposition_result: { result: payload.ticket_decomposition_result_status, evidence_refs: payload.evidence_refs },
-      vertical_slice_ticket: { ref: payload.vertical_slice_ticket_ref, role: payload.vertical_slice_ticket_role, kind: payload.vertical_slice_ticket_kind },
-      slice_contract: {
-        ticket_ref: payload.slice_contract_ticket_ref,
-        status: payload.slice_contract_status,
-        persisted: payload.slice_contract_persisted,
-        current_version: payload.slice_contract_current_version,
-      },
-    };
-    const semantic = validateImplementationEntry(implementationState, {
-      // 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.resolve(root, ref), "utf8"),
-    });
-    ensure(semantic.result === "allowed", `Workflow Execution Result implementation Ticket 语义非法: ${semantic.blocking_signals.join(", ")}`);
-  }
-  if (payload.result !== "completed") return;
-  for (const field of contract.completed_requires_empty) ensure(Array.isArray(payload[field]) && payload[field].length === 0, `completed 的 ${field} 必须为空`);
-  for (const field of contract.completed_requires_non_empty) ensure(Array.isArray(payload[field]) && payload[field].length > 0, `completed 的 ${field} 不能为空`);
-  if (contract.completed_requires_readable_evidence_refs) {
-    for (const reference of payload.evidence_refs) ensure(typeof reference === "string" && reference.trim() && (exists(reference) || reference === virtualTicketDecompositionRef), `completed 证据不可读取: ${reference}`);
-  }
-  if (contract.completed_requires_no_blocking_signals) ensure(Array.isArray(payload.blocking_signals) && payload.blocking_signals.length === 0, "completed 不得携带 blocking_signals");
-}
-
-function validateInvocationMetadata(boundary, skillContents) {
-  for (const skill of boundary.user_invoked_skills) ensure(skillContents(skill).includes("disable-model-invocation: true"), `${skill} 未声明为 user-invoked skill`);
-  for (const skill of boundary.lifecycle_managed_user_entries) ensure(skillContents(skill).includes("disable-model-invocation: true"), `${skill} 未声明为生命周期管理的 user-invoked skill`);
-  for (const skill of boundary.model_invoked_skills) ensure(!skillContents(skill).includes("disable-model-invocation: true"), `${skill} 不应出现在 model-invoked 白名单`);
-}
-
-function validateLifecycleEntrySkill(skill) {
-  ensure(/^---\nname: yss-product-lifecycle\n/m.test(skill), "生命周期入口缺少有效 frontmatter");
-  ensure(Buffer.byteLength(skill) <= 8192, "生命周期入口超过 8KB 上下文预算");
-  for (const reference of ["docs/process/lifecycle-registry.yaml", "references/orchestration-contract.yaml", "docs/agents/yss-skill-registry.yaml", "scripts/query-lifecycle-context"]) {
-    ensure(skill.includes(reference), `生命周期入口缺少权威引用: ${reference}`);
-  }
-  for (const heading of ["### 仓库身份", "### 流转与实现", "### 用户决定", "### 外部副作用与 Git"]) {
-    ensure(skill.includes(heading), `生命周期入口缺少边界分组: ${heading}`);
-  }
-}
-
-const profiles = {
-  lifecycle: {
-    message: "六类生命周期压力场景验证通过",
-    files: [".agents/skills/yss-product-lifecycle/SKILL.md", ".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml", "docs/process/lifecycle-registry.yaml"],
-    markers: [[".agents/skills/yss-product-lifecycle/SKILL.md", "template-source-product-artifact-forbidden"], [".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml", "ready-for-agent"]]
-  },
-  matt: {
-    message: "Matt/YSS 集成压力场景验证通过",
-    files: [".agents/skills/yss-product-lifecycle/references/matt-yss-adapter.md", ".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml", "docs/process/templates/lifecycle-checkpoint-template.yaml", "docs/process/templates/frontend-implementation-plan-template.yaml", "docs/process/templates/frontend-implementation-verification-template.yaml"],
-    markers: [[".agents/skills/yss-product-lifecycle/SKILL.md", "Workflow Execution Result"]]
-  },
-  prototype: {
-    message: "原型到后端脚手架及后续 YSS 代码生成压力场景验证通过",
-    files: [".agents/skills/yss-ddd-scaffold-generator/scripts/generate_scaffold.mjs", ".agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml"],
-    markers: [[".agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml", "controlled-generation"]]
-  },
-  implementationContractCompiler: {
-    message: "YSS implementation contract compiler stage 7 scenarios passed",
-    files: [".agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml", ".agents/skills/yss-implementation-contract-compiler/SKILL.md"],
-    markers: [[".agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml", "impact_to_capabilities"], [".agents/skills/yss-implementation-contract-compiler/SKILL.md", "required_capabilities"]]
-  },
-  openapiYaml: {
-    message: "OpenAPI YAML-first 场景验证通过",
-    files: ["docs/templates/openapi-spec-template.yaml", ".agents/skills/yss-openapi-governance/SKILL.md"],
-    markers: [["docs/templates/openapi-spec-template.yaml", "openapi: 3.1.0"], [".agents/skills/yss-openapi-governance/SKILL.md", "YAML-first"]]
-  },
-  openapiJson: {
-    message: "OpenAPI YAML-first JSON handoff scenarios passed",
-    files: ["docs/api/templates/openapi-json-export-record-template.md", ".agents/skills/yss-api-integration/SKILL.md"],
-    markers: [[".agents/skills/yss-api-integration/SKILL.md", "SHA-256"]]
-  },
-  yssDtoWire: {
-    message: "YSS DTO OpenAPI wire-shape scenarios passed",
-    files: [
-      ".agents/skills/yss-dto/references/openapi-wire-profile.yaml",
-      ".agents/skills/yss-dto/SKILL.md",
-      ".agents/skills/yss-openapi-governance/SKILL.md",
-      ".agents/skills/yss-openapi-draft-review/SKILL.md",
-      "docs/api/templates/openapi-draft-review-checklist.md",
-      "scripts/verify-yss-dto-openapi-profile"
-    ],
-    markers: [
-      [".agents/skills/yss-dto/SKILL.md", "x-yss-response-wrapper"],
-      [".agents/skills/yss-openapi-governance/SKILL.md", "verify-yss-dto-openapi-profile"],
-      [".agents/skills/yss-openapi-draft-review/SKILL.md", "offset`, `needTotalCount`, and `tempTotalCount"],
-      ["docs/api/templates/openapi-draft-review-checklist.md", "DTO wire shape"]
-    ]
-  }
-};
-
-export function runScenario(name) {
-  const profile = profiles[name];
-  if (!profile) throw new TypeError(`未知 Node 场景: ${name}`);
-  for (const file of profile.files) ensure(exists(file), `缺少场景资产: ${file}`);
-  for (const [file, marker] of profile.markers) ensure(read(file).includes(marker), `场景资产缺少标记 ${marker}: ${file}`);
-  if (name === "lifecycle") {
-    const result = spawnSync("scripts/verify-lifecycle-registry", [], { cwd: root, encoding: "utf8" });
-    ensure(result.status === 0, result.stderr || result.stdout);
-    const registry = parseDocument(read("docs/process/lifecycle-registry.yaml"), { uniqueKeys: true }).toJS({ maxAliasCount: 0 });
-    const releaseGate = registry.gates.find((gate) => gate.id === "gate.release-ready");
-    ensure(releaseGate?.requires_gates?.includes("gate.frontend-implementation-verified"), "发布就绪未依赖前端实现还原门禁");
-    const contract = parseDocument(read(".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml"), { uniqueKeys: true }).toJS({ maxAliasCount: 0 });
-    ensure(contract.ready_for_agent?.requires_vertical_slice_ticket === true && contract.ready_for_agent?.parent_ticket_as_implementation_ref === "forbidden", "ready_for_agent 未强制垂直切片且禁止父 Ticket 实现引用");
-    ensure(includesAll(contract.ready_for_agent?.required, ["ticket_decomposition_result_ref", "vertical_slice_ticket_ref", "vertical_slice_ticket_role", "vertical_slice_ticket_kind"]), "ready_for_agent 缺少 Ticket 正式化必填字段");
-    ensure(contract.ticket_formalization?.implementation_predecessor === "work-unit.ticket-decomposition" && contract.ticket_formalization?.vertical_slice_ticket?.parent_ticket_ref_forbidden === true, "Ticket 正式化实现前置或父 Ticket 禁止规则缺失");
-    ensure(contract.transition_graph?.implementation_requires_predecessor === "work-unit.ticket-decomposition", "生命周期转换图未声明实现前置工作单元");
-    ensure(JSON.stringify(contract.transition_graph?.forbidden_shortcuts) === JSON.stringify([
-      { from: "work-unit.spec-synthesis", to: "work-unit.slice-implementation" },
-      { from: "work-unit.prototype-design", to: "work-unit.slice-implementation" },
-      { from: "work-unit.technical-analysis", to: "work-unit.slice-implementation" },
-      { from: "work-unit.technical-analysis", to: "work-unit.ticket-decomposition" },
-    ]), "生命周期转换图缺少工程准备、Ticket 正式化与实现越级阻断");
-    ensure(contract.transition_graph?.routes?.["work-unit.implementation-repository-preparation"]?.includes("work-unit.ticket-decomposition"), "实现仓库准备未成为 Ticket 正式化前置");
-    ensure(contract.implementation_repository_preparation?.gate === "gate.implementation-repositories-ready", "实现仓库准备聚合门禁缺失");
-    ensure(lifecycleTransitionContract.next_routes["work-unit.ticket-decomposition"]?.includes("work-unit.slice-implementation"), "转换校验器未允许 Ticket 正式化后进入实现");
-    ensure(contract.release_readiness?.conditional?.ui_impact?.includes("gate.frontend-implementation-verified") && contract.frontend_implementation_plan?.acceptance?.includes("no_template_placeholders"), "发布公式或前端计划实质校验不完整");
-    const templateRejected = spawnSync("scripts/verify-frontend-implementation-evidence", ["docs/process/templates/frontend-implementation-plan-template.yaml"], { cwd: root, encoding: "utf8" });
-    ensure(templateRejected.status !== 0 && templateRejected.stderr.includes("template: false"), "前端实现计划占位模板可冒充正式批准证据");
-  }
-  if (name === "matt") {
-    const contract = parseDocument(read(".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml"), { uniqueKeys: true });
-    ensure(contract.errors.length === 0, contract.errors[0]?.message || "生命周期编排契约无法解析");
-    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 planFixture = buildPlanFixture(path.join(decisionTemp, 'plan'));
-    const validResult = {
-      ...planFixture.state,
-      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: [],
-      stale_candidates: [],
-      next_route: "work-unit.implementation-repository-preparation",
-      blocking_signals: []
-    };
-    validateWorkflowExecutionResult(validResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
-    const validTicketResult = {
-      ...validResult,
-      work_unit: "work-unit.ticket-decomposition",
-      next_route: "work-unit.slice-implementation",
-      ticket_decomposition_result_ref: "docs/.scratch/demo/evidence/ticket-decomposition-result.yaml",
-      vertical_slice_ticket_ref: "docs/.scratch/demo/issues/01-valid-slice.md",
-    };
-    validateWorkflowExecutionResult(validTicketResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
-    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",
-      predecessor_work_unit: "work-unit.ticket-decomposition",
-      ready_for_agent: true,
-      ticket_decomposition_result_ref: "docs/.scratch/demo/evidence/ticket-decomposition-result.yaml",
-      ticket_decomposition_result_status: "completed",
-      vertical_slice_ticket_ref: "docs/.scratch/demo/issues/01-valid-slice.md",
-      vertical_slice_ticket_role: "ready-for-agent",
-      vertical_slice_ticket_kind: "vertical-slice-ticket",
-      slice_contract_ticket_ref: "docs/.scratch/demo/issues/01-valid-slice.md",
-      slice_contract_status: "approved",
-      slice_contract_persisted: true,
-      slice_contract_current_version: true,
-      delivery_impacts: { backend: true, frontend: false },
-      implementation_repository_preparation: {
-        result: "completed", current_version: true, evidence_refs: ["docs/process/lifecycle-registry.yaml"],
-        projects: [
-          { project_id: "backend", delivery_role: "backend", status: "existing-and-onboarded", repository_ref: "git://backend", project_root: "/workspace/backend", repository_scope: "external-repository", onboarding_result: { status: "completed", ref: "docs/process/lifecycle-registry.yaml" } },
-          { project_id: "frontend-na", delivery_role: "frontend", status: "not-applicable", reason: "no frontend impact" },
-        ],
-      },
-    };
-    validateWorkflowExecutionResult(validImplementationResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
-    for (const mutate of [
-      (item) => { item.vertical_slice_ticket_role = "ready-for-human"; },
-      (item) => { item.vertical_slice_ticket_kind = "parent-ticket"; },
-      (item) => { item.vertical_slice_ticket_ref = "docs/.scratch/demo/parent-ticket.md"; },
-      (item) => { item.slice_contract_ticket_ref = "docs/.scratch/demo/issues/02-other.md"; },
-      (item) => { item.predecessor_work_unit = "work-unit.spec-synthesis"; },
-      (item) => { item.ticket_decomposition_result_status = "blocked"; },
-      (item) => { item.ticket_decomposition_result_status = "needs-human"; },
-    ]) {
-      const invalid = structuredClone(validImplementationResult); mutate(invalid);
-      let rejected = false;
-      try { validateWorkflowExecutionResult(invalid, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root }); } catch { rejected = true; }
-      ensure(rejected, "实现 Workflow Execution Result 的 Ticket 语义变异未被拒绝");
-    }
-    const unavailableResult = structuredClone(validResult);
-    unavailableResult.result = "blocked";
-    unavailableResult.unavailable_skill = { skill: "yss-ui", provider: "codex", fallback: "manual-review", resolution: "needs-human" };
-    unavailableResult.blocking_signals = ["missing_evidence"];
-    validateWorkflowExecutionResult(unavailableResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
-    const malformedUnavailable = structuredClone(unavailableResult);
-    delete malformedUnavailable.unavailable_skill.fallback;
-    let unavailableRejected = false;
-    try { validateWorkflowExecutionResult(malformedUnavailable, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root }); } catch { unavailableRejected = true; }
-    ensure(unavailableRejected, "技能不可用结果缺少 fallback 时未被拒绝");
-    const compatibleResult = structuredClone(validResult);
-    compatibleResult.workflow_reference = { source: "mattpocock/skills", skill: "to-spec", invocation_mode: "reference" };
-    validateWorkflowExecutionResult(compatibleResult, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root });
-    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"]; },
-      (item) => { item.new_impacts = ["new-api"]; },
-      (item) => { item.workflow_reference.source = "untrusted/source"; },
-      (item) => { item.workflow_reference.skill = "implement"; },
-      (item) => { item.workflow_reference.invocation_mode = "reference"; },
-      (item) => { item.next_route = "work-unit.slice-implementation"; }
-    ]) {
-      const invalid = structuredClone(validResult); mutate(invalid);
-      let rejected = false;
-      try { validateWorkflowExecutionResult(invalid, data.workflow_execution_result, data.work_unit_routes, { root: planFixture.root }); } catch { rejected = true; }
-      ensure(rejected, "Workflow Execution Result 完成态变异未被拒绝");
-    }
-    let metadataRejected = false;
-    try {
-      validateInvocationMetadata(data.matt_invocation_boundary, (skill) => skill === "grill-with-docs" ? read(`.agents/skills/${skill}/SKILL.md`).replace("disable-model-invocation: true\n", "") : read(`.agents/skills/${skill}/SKILL.md`));
-    } catch { metadataRejected = true; }
-    ensure(metadataRejected, "user-invoked front matter 变异未被 baseline oracle 拒绝");
-    const mutations = [
-      (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; },
-      (item) => { item.grill_exit.user_confirmation_required = false; },
-      (item) => { delete item.git_authorization.push; },
-      (item) => { delete item.git_authorization.git_submodule; },
-      (item) => { item.git_authorization.git_submodule.forbid_commit_on_detached_head = false; },
-      (item) => { item.git_authorization.git_submodule.force_overlay_mount = "allowed"; },
-      (item) => { item.git_authorization.git_submodule.write_inside_detached_head = "allowed"; },
-      (item) => { item.git_authorization.git_submodule.empty_gitlink_writable = true },
-      (item) => { item.git_authorization.git_submodule.force_overlay_regular_dir_path = "allowed"; }
-    ];
-    for (const mutate of mutations) {
-      const candidate = structuredClone(data); mutate(candidate);
-      let rejected = false;
-      try { validateMattContract(candidate); validateInvocationBoundary(candidate); } catch { rejected = true; }
-      ensure(rejected, "Matt/YSS 契约变异未被 baseline oracle 拒绝");
-    }
-    const skill = read(".agents/skills/yss-product-lifecycle/SKILL.md");
-    validateLifecycleEntrySkill(skill);
-    for (const relative of ["SKILL.md", "references/matt-yss-adapter.md", "references/orchestration-contract.yaml"]) {
-      ensure(read(`.agents/skills/yss-product-lifecycle/${relative}`) === read(`.codex/skills/yss-product-lifecycle/${relative}`), `YSS 生命周期投影未同步: ${relative}`);
-    }
-  }
-  if (name === "yssDtoWire") {
-    const result = spawnSync("scripts/verify-yss-dto-openapi-profile", [], { cwd: root, encoding: "utf8" });
-    ensure(result.status === 0, result.stderr || result.stdout);
-  }
-  process.stdout.write(`${profile.message}\n`);
-}

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

@@ -1,140 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { isTemplateSource } from "./repository-mode.mjs";
-import { loadSkillRegistry } from "./skill-registry.mjs";
-import { treeHash, validateStrategicDesignSkillManifest, validateYssUiSkillManifest } from "./skill-supply-chain.mjs";
-
-export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
-
-function fail(message) {
-  throw new TypeError(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-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 作为无条件要求");
-  }
-  for (const marker of ["主操作必须放入 `#toolbar-right`", "只有确实需要列设置时才使用", "toolbar-config"] ) {
-    if (!globalRules.includes(marker)) fail(`全局规则缺少条件化表格工具栏规则: ${marker}`);
-  }
-  for (const marker of ["无需配置 `:toolbar-config=\"{ custom: true }\"`", "仅在业务明确需要列设置时才传入"]) {
-    if (!tableSkill.includes(marker)) fail(`YTable 专项技能缺少条件化工具栏规则: ${marker}`);
-  }
-  if (!pageSkill.includes("仅在业务明确需要列设置时才传入")) {
-    fail("业务页面 canonical 技能缺少条件化 toolbar-config 规则");
-  }
-
-  const yssUiManifest = validateYssUiSkillManifest(JSON.parse(read(".agents/skills/.yss-skills-manifest.json")));
-  const lock = JSON.parse(read("skills-lock.json"));
-  for (const skill of yssUiManifest.skills) {
-    const skillPath = `.agents/skills/${skill.canonical}/SKILL.md`;
-    if (!exists(skillPath)) fail(`yss-ui 前端清单缺少 canonical skill: ${skill.canonical}`);
-    const item = lock.skills?.shared?.[skill.canonical];
-    if (!item || item.source !== yssUiManifest.source || item.sourceRevision !== yssUiManifest.source_revision) {
-      fail(`yss-ui skill 缺少一致的来源锁定: ${skill.canonical}`);
-    }
-    if (item.skillPath !== `${yssUiManifest.source_root}/${skill.upstream}/SKILL.md` || item.upstreamHash !== skill.upstream_hash) {
-      fail(`yss-ui skill 上游路径或 hash 不一致: ${skill.canonical}`);
-    }
-    const content = read(skillPath);
-    for (const match of content.matchAll(/\.\.\/([a-z0-9-]+)\/SKILL\.md/g)) {
-      if (!exists(`.agents/skills/${match[1]}/SKILL.md`)) fail(`${skill.canonical} 引用了不存在的本地 skill: ${match[1]}`);
-    }
-  }
-  const yssUiSkill = read(".agents/skills/yss-ui/SKILL.md");
-  if (!yssUiSkill.includes("`YFormily` 是新代码 canonical name")) fail("yss-ui 必须把 YFormily 声明为新代码 canonical name");
-  if (!yssUiSkill.includes("| 新建或改造完整业务页面 | `yss-ui-business-page-generation` |")) fail("yss-ui 缺少完整业务页面生成路由");
-  if (!yssUiSkill.includes("原型阶段不得调用本技能") || yssUiSkill.includes("prototype-component-facts")) fail("yss-ui 必须保持生产实现边界，不得暴露原型模式");
-  const expectedServer = { command: "npx", args: ["-y", "@yss-ui/mcp"] };
-  for (const config of yssUiManifest.mcp.project_configs) {
-    if (!exists(config.path)) fail(`缺少 yss-ui MCP 项目配置: ${config.path}`);
-    const document = JSON.parse(read(config.path));
-    if (JSON.stringify(document?.[config.container]?.[yssUiManifest.mcp.server_name]) !== JSON.stringify(expectedServer)) {
-      fail(`yss-ui MCP 配置不一致: ${config.path}`);
-    }
-  }
-  const mcpGuide = read(yssUiManifest.mcp.global_install_guide);
-  for (const marker of ["npx -y @yss-ui/mcp install codex", "不写用户主目录", "get_codegen_rules", "list_components"]) {
-    if (!mcpGuide.includes(marker)) fail(`YSS UI MCP 指南缺少边界或自检标记: ${marker}`);
-  }
-
-  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-antdv-next-design", "yss-stage-decision"];
-  if (JSON.stringify(strategicManifest.skills.map(({ canonical }) => canonical).sort()) !== JSON.stringify(strategicIds.slice().sort())) {
-    fail("战略设计 skills 清单必须恰好覆盖六项公共技能");
-  }
-  for (const skill of strategicManifest.skills) {
-    if (isTemplateSource(ROOT)) {
-      const upstreamDirectory = path.join(ROOT, "submodules/yss-harness-design-agent", strategicManifest.source_root, skill.upstream);
-      if (!existsSync(path.join(upstreamDirectory, "SKILL.md"))) fail(`战略设计上游 skill 不存在: ${skill.upstream}`);
-      if (treeHash(upstreamDirectory) !== skill.upstream_hash) fail(`战略设计上游 hash 漂移: ${skill.upstream}`);
-    }
-    const item = lock.skills?.shared?.[skill.canonical];
-    if (!item || item.source !== strategicManifest.source || item.sourceRevision !== strategicManifest.source_revision || item.upstreamHash !== skill.upstream_hash) {
-      fail(`战略设计 skill 缺少一致的来源锁定: ${skill.canonical}`);
-    }
-    if (item.effectiveHash !== item.upstreamHash && item.adaptationRef !== strategicManifest.adaptation_ref) {
-      fail(`战略设计 skill 差异缺少薄适配引用: ${skill.canonical}`);
-    }
-  }
-
-  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", "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");
-  }
-  const prototypeStage = read(".agents/skills/yss-prototype-stage/SKILL.md");
-  const prototypeAdapter = read(".agents/skills/yss-prototype-stage/references/product-design-adapter.md");
-  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", "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", "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: 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");
-  for (const marker of ["Ant Design v6", "Ant Design Vue 4.x", "版本号不同本身不是冲突", "visual_semantic_mapping"]) {
-    if (!antdvCompatibility.includes(marker)) fail(`AntDV 兼容策略缺少双轨边界: ${marker}`);
-  }
-  for (const skill of registry.skills) {
-    if (!canonicalIds.has(skill.id)) fail(`注册表 canonical skill 无效: ${skill.id}`);
-    if (skill.maturity === "deprecated") {
-      for (const field of ["replaced_by", "migration_deadline", "cleanup_status"]) {
-        if (!skill[field] || typeof skill[field] !== "string") fail(`deprecated 技能缺少 ${field}: ${skill.id}`);
-      }
-    }
-  }
-  return { checked: true, legacy_aliases: legacy.size, yss_ui_skills: yssUiManifest.skills.length };
-}

package/template/scripts/lib/template-commit-cache.mjs

@@ -1,50 +0,0 @@
-import { runCommandSync } from "./command-runner.mjs";
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import path from "node:path";
-import { tmpdir } from "node:os";
-import { ROOT } from "./template-verification.mjs";
-
-function fail(message) { throw new TypeError(message); }
-function ensure(condition, message) { if (!condition) fail(message); }
-function git(args, cwd, timeoutMs = 0, cleanupPathsOnFailure = []) {
-  const result = args.includes("fetch") ? runCommandSync("git", args, { cwd, timeoutMs, progress: true, cleanupPathsOnFailure }) : spawnSync("git", args, { cwd, encoding: "utf8" });
-  if (result.status !== 0) fail(result.termination || result.error?.message || result.stderr.trim() || `git ${args.join(" ")} 执行失败`);
-  return result.stdout.trim();
-}
-
-export function acquireTemplateCommit({ repository, commit, cacheRoot = path.join(ROOT, ".template-source/cache/remote-templates"), allowLocal = false, timeoutMs = 0 }) {
-  ensure(Number.isFinite(timeoutMs) && timeoutMs >= 0, "timeoutMs 必须是非负毫秒数");
-  ensure(typeof repository === "string" && repository.trim(), "repository 不能为空");
-  ensure(/^[a-f0-9]{40}$/.test(commit), "模板 ref 必须是 40 位 commit");
-  if (!allowLocal) ensure(/^(?:https?:\/\/|ssh:\/\/|git@)/.test(repository), "正式模板缓存只接受远程 repository URL");
-  const key = createHash("sha256").update(repository).update("\0").update(commit).digest("hex");
-  const entry = path.join(cacheRoot, key);
-  const repositoryPath = path.join(entry, "repository.git");
-  const metadataPath = path.join(entry, "metadata.json");
-  if (existsSync(entry)) {
-    ensure(existsSync(metadataPath) && existsSync(repositoryPath), "模板缓存不完整");
-    const metadata = JSON.parse(readFileSync(metadataPath, "utf8"));
-    ensure(metadata.repository === repository && metadata.commit === commit && metadata.key === key, "模板缓存来源不一致");
-    const actual = git(["--git-dir", repositoryPath, "rev-parse", `${commit}^{commit}`], ROOT);
-    ensure(actual === commit, "模板缓存 object hash 校验失败");
-    return { cache_hit: true, key, commit, repository, repository_path: repositoryPath, metadata_path: metadataPath };
-  }
-
-  mkdirSync(cacheRoot, { recursive: true });
-  const temporary = mkdtempSync(path.join(cacheRoot, ".fetch-"));
-  try {
-    const temporaryRepository = path.join(temporary, "repository.git");
-    git(["init", "--bare", "-q", temporaryRepository], ROOT);
-    git(["--git-dir", temporaryRepository, "fetch", "--depth=1", "--no-tags", repository, commit], ROOT, timeoutMs, [temporary]);
-    const actual = git(["--git-dir", temporaryRepository, "rev-parse", "FETCH_HEAD^{commit}"], ROOT);
-    ensure(actual === commit, `远程返回 commit 与请求不一致: ${actual}`);
-    writeFileSync(path.join(temporary, "metadata.json"), `${JSON.stringify({ schema_version: 1, key, repository, commit })}\n`);
-    renameSync(temporary, entry);
-  } catch (error) {
-    rmSync(temporary, { recursive: true, force: true });
-    throw error;
-  }
-  return { cache_hit: false, key, commit, repository, repository_path: repositoryPath, metadata_path: metadataPath };
-}