create-yss-spec 2.1.8 → 2.1.10

package/template/scripts/lib/maintenance-intensity.mjs

@@ -0,0 +1,94 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseDocument } from "../vendor/yaml.mjs";
+
+const LEVELS = ["L1", "L2", "L3"];
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const INTENSITY_POLICY = path.join(root, "docs/process/maintenance-intensity.yaml");
+
+const REQUIRED_EVIDENCE = {
+  L1: ["relevant-check"],
+  L2: ["counterexample", "fresh-verification", "focused-independent-review"],
+  L3: ["red", "green", "refactor", "pressure-scenario", "fresh-verification", "formal-independent-review"]
+};
+
+const REVIEW_MODES = {
+  L1: new Set(["self-check", "human-checkpoint"]),
+  L2: new Set(["focused-independent"]),
+  L3: new Set(["formal-independent"])
+};
+
+function ensure(condition, message) {
+  if (!condition) throw new TypeError(message);
+}
+
+function loadTriggerLevels() {
+  const document = parseDocument(readFileSync(INTENSITY_POLICY, "utf8"), { uniqueKeys: true });
+  ensure(document.errors.length === 0, document.errors[0]?.message || "维护强度策略无法解析");
+  const policy = document.toJS({ maxAliasCount: 0 });
+  ensure(policy?.schema_version === 1 && LEVELS.includes(policy.default_level) && policy.levels && typeof policy.levels === "object", "维护强度策略 schema 无效");
+  const pairs = [];
+  for (const level of LEVELS) {
+    const triggers = policy.levels[level]?.triggers;
+    ensure(Array.isArray(triggers) && triggers.length > 0, `维护强度策略缺少 ${level} triggers`);
+    for (const trigger of triggers) {
+      ensure(typeof trigger === "string" && trigger.trim(), `${level} 包含无效 trigger`);
+      pairs.push([trigger, level]);
+    }
+  }
+  const map = new Map(pairs);
+  ensure(map.size === pairs.length, "维护强度策略包含重复 trigger");
+  return { defaultLevel: policy.default_level, map };
+}
+
+const triggerLevels = loadTriggerLevels();
+
+function levelRank(level) {
+  return LEVELS.indexOf(level);
+}
+
+export function minimumIntensity(triggers) {
+  ensure(Array.isArray(triggers), "triggers 必须是数组");
+  if (triggers.length === 0) return triggerLevels.defaultLevel;
+  let required = "L1";
+  for (const trigger of triggers) {
+    ensure(triggerLevels.map.has(trigger), `未知 trigger: ${trigger}`);
+    const candidate = triggerLevels.map.get(trigger);
+    if (levelRank(candidate) > levelRank(required)) required = candidate;
+  }
+  return required;
+}
+
+export function validateMaintenanceCheckpoint(data) {
+  ensure(data && typeof data === "object" && !Array.isArray(data), "checkpoint 必须是对象");
+  const exactFields = ["schema_version", "intensity", "classification_reason", "triggers", "changed_assets", "verification_evidence", "review_mode", "escalation"];
+  const unknown = Object.keys(data).filter((key) => !exactFields.includes(key));
+  ensure(unknown.length === 0, `checkpoint 包含未知字段: ${unknown.join(", ")}`);
+  ensure(data.schema_version === 1, "schema_version 必须为 1");
+  ensure(LEVELS.includes(data.intensity), "intensity 必须是 L1、L2 或 L3");
+  ensure(typeof data.classification_reason === "string" && data.classification_reason.trim(), "classification_reason 不能为空");
+  ensure(Array.isArray(data.changed_assets) && data.changed_assets.length > 0 && data.changed_assets.every((item) => typeof item === "string" && item.trim()), "changed_assets 必须包含至少一个路径或资产引用");
+  const minimum = minimumIntensity(data.triggers);
+  ensure(levelRank(data.intensity) >= levelRank(minimum), `${data.triggers.join(", ") || "默认"} 至少要求 ${minimum}，不得声明为 ${data.intensity}`);
+  ensure(typeof data.escalation === "string" && data.escalation.trim(), "escalation 必须说明 none 或升级原因");
+  ensure(Array.isArray(data.verification_evidence), "verification_evidence 必须是数组");
+  const kinds = new Set();
+  for (const evidence of data.verification_evidence) {
+    ensure(evidence && typeof evidence === "object" && !Array.isArray(evidence), "verification_evidence 条目必须是对象");
+    ensure(typeof evidence.kind === "string" && evidence.kind.trim(), "verification_evidence.kind 不能为空");
+    ensure(typeof evidence.command === "string" && evidence.command.trim(), "verification_evidence.command 不能为空");
+    ensure(evidence.result === "pass", `验证证据必须是本轮实际通过结果: ${evidence.kind ?? "unknown"}`);
+    kinds.add(evidence.kind);
+  }
+  for (const required of REQUIRED_EVIDENCE[data.intensity]) ensure(kinds.has(required), `${data.intensity} 缺少 ${required} 证据`);
+  ensure(REVIEW_MODES[data.intensity].has(data.review_mode), `${data.intensity} 不允许 review_mode=${data.review_mode}`);
+  return { intensity: data.intensity, minimum_intensity: minimum };
+}
+
+export function loadMaintenanceCheckpoint(source) {
+  const raw = source === "-" ? readFileSync(0, "utf8") : readFileSync(source, "utf8");
+  const document = parseDocument(raw, { uniqueKeys: true });
+  ensure(document.errors.length === 0, document.errors[0]?.message || "checkpoint 无法解析");
+  return document.toJS({ maxAliasCount: 0 });
+}

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

@@ -2,11 +2,103 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { spawnSync } from "node:child_process";
+import { parseDocument } from "../vendor/yaml.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 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 导航入口");
+  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 === "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} 授权必填字段不完整`);
+  }
+}
+
+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", "research", "resolving-merge-conflicts", "scaffold-exercises", "setup-pre-commit", "tdd", "writing-for-agents"];
+  const expectedLifecycleModelInvoked = ["code-review", "codebase-design", "diagnosing-bugs", "domain-modeling", "grilling", "prototype", "research", "tdd"];
+  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"]) && 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", "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 契约不完整");
+  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"]), "生命周期人工门禁集合已漂移");
+  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 === "research", "机会调研事实路由不准确");
+  ensure(routes?.["work-unit.slice-implementation"]?.skills?.includes("tdd") && routes?.["work-unit.slice-implementation"]?.skills?.includes("yss-ui"), "原生实现工作单元缺少 TDD 或 UI 路由");
+  ensure(routes?.["work-unit.frontend-implementation-verification"]?.skills?.includes("code-review") && routes?.["work-unit.frontend-implementation-verification"]?.applies_when === "ui_impact", "前端还原验证未绑定 UI fidelity 审查轴");
+  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) {
+  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 无效");
+  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}`);
+  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 不匹配");
+  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), `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 validateMattProse(skill, adapter) {
+  ensure(skill.includes("不得写生命周期资产或改变门禁/Ticket 状态") && skill.includes("任何写入前回交本编排器"), "主技能缺少 direct Matt 只导航并回交的说明");
+  ensure(adapter.includes("仅发现旧路径资产") && adapter.includes("不得调用 `setup-matt-pocock-skills`"), "适配器缺少 setup 旧资产迁移或显式用户入口条件");
+  ensure(adapter.includes("frontier 为空") && adapter.includes("双方共同理解已确认"), "适配器缺少 grill_exit 的 frontier 或共同理解条件");
+  ensure(skill.includes("自然语言意向不构成上述结构化 Git 授权") && adapter.includes("本身不是结构化授权"), "主技能或适配器缺少自然语言 Git 意向不是授权的说明");
+}
+
+function validateInvocationProse(skill, adapter, orchestration) {
+  ensure(skill.includes("不得自动调用它们或代替其创建正式资产") && skill.includes("Workflow Execution Result"), "主技能未限制 user-invoked 调用或未采用新结果协议");
+  ensure(adapter.includes("workflow reference 不表示调用") && adapter.includes("正式 Spec、Ticket 或实现资产仍只能由对应显式用户入口创建"), "适配器未限制 workflow reference 的正式资产所有权");
+  ensure(orchestration.includes("只实际调用允许的 model-invoked skill") && orchestration.includes("用户显式启动"), "编排协议未区分 model-invoked 原语和显式用户入口");
+}
 
 const profiles = {
   lifecycle: {
@@ -16,8 +108,8 @@ const profiles = {
   },
   matt: {
     message: "Matt/YSS 集成压力场景验证通过",
-    files: [".agents/skills/yss-product-lifecycle/references/matt-yss-adapter.md", ".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml"],
-    markers: [[".agents/skills/yss-product-lifecycle/SKILL.md", "Matt Skill Result"]]
+    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 代码生成压力场景验证通过",
@@ -66,6 +158,84 @@ export function runScenario(name) {
   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.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 validResult = {
+      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",
+      evidence_refs: ["docs/process/lifecycle-registry.yaml"],
+      changed_artifacts: [],
+      new_impacts: [],
+      stale_candidates: [],
+      next_route: "work-unit.ticket-decomposition",
+      blocking_signals: []
+    };
+    validateWorkflowExecutionResult(validResult, data.workflow_execution_result, data.work_unit_routes);
+    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);
+    for (const mutate of [
+      (item) => { delete item.workflow_reference; },
+      (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"; }
+    ]) {
+      const invalid = structuredClone(validResult); mutate(invalid);
+      let rejected = false;
+      try { validateWorkflowExecutionResult(invalid, data.workflow_execution_result, data.work_unit_routes); } 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.direct_matt_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; }
+    ];
+    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");
+    const adapter = read(".agents/skills/yss-product-lifecycle/references/matt-yss-adapter.md");
+    const orchestration = read(".agents/skills/yss-product-lifecycle/references/orchestration.md");
+    validateMattProse(skill, adapter);
+    validateInvocationProse(skill, adapter, orchestration);
+    let proseRejected = false;
+    try { validateMattProse(skill.replace("任何写入前回交本编排器", "允许直接写入"), adapter); } catch { proseRejected = true; }
+    ensure(proseRejected, "Matt/YSS prose 变异未被 baseline oracle 拒绝");
+    let invocationProseRejected = false;
+    try { validateInvocationProse(skill.replace("不得自动调用它们或代替其创建正式资产", "可以自动调用并创建正式资产"), adapter, orchestration); } catch { invocationProseRejected = true; }
+    ensure(invocationProseRejected, "调用边界 prose 变异未被 baseline oracle 拒绝");
+    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" });

package/template/scripts/lib/skill-supply-chain.mjs

@@ -8,7 +8,7 @@ export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "
 const SOURCE_ROOT = path.join(ROOT, ".agents/skills");
 const LOCK_PATH = path.join(ROOT, "skills-lock.json");
 const PROJECTION_ROOTS = [".claude/skills", ".codex/skills", ".hermes/skills", ".pi/skills", ".qoder/skills", ".trae/skills"];
-const OBSOLETE = new Set(["to-" + "prd", "to-" + "issues", "design-an-interface", "qa", "request-refactor-plan", "ubiquitous-language", "edit-article", "obsidian-vault", "writing-great-skills", "code-review-process", "yss-domain-modeling", "yss-dir", "yss-duckdb", "yss-file", "yss-filerunner", "yss-db2mybatis", "yss-mail", "yss-mapper-dynamic", "yss-quality", "yss-sql-condition", "yss-sql-tpl", "yss-valuation", "yss-variable", "yss-openapi"]);
+const OBSOLETE = new Set(["to-" + "prd", "to-" + "issues", "design-an-interface", "qa", "request-refactor-plan", "ubiquitous-language", "edit-article", "obsidian-vault", "writing-great-skills", "code-review-process", "yss-domain-modeling", "yss-dir", "yss-duckdb", "yss-file", "yss-filerunner", "yss-db2mybatis", "yss-mail", "yss-mapper-dynamic", "yss-quality", "yss-sql-condition", "yss-sql-tpl", "yss-valuation", "yss-variable", "yss-openapi", "web-design-engineer", "web-video-presentation", "wireframe-prototype", "wizard", "git-guardrails-claude-code", "claude-handoff", "batch-grill-me"]);
 
 function relative(target) { return path.relative(ROOT, target).replaceAll(path.sep, "/"); }
 function entries(directory) { return existsSync(directory) ? readdirSync(directory, { withFileTypes: true }) : []; }
@@ -42,8 +42,13 @@ function ensureSafeProjection(target) {
   const resolved = path.resolve(target);
   if (!resolved.startsWith(`${ROOT}${path.sep}`) || path.basename(resolved) !== "skills") throw new TypeError(`refusing unsafe projection target: ${target}`);
 }
+export function unlockedProjectionEntries(candidates, allowedNames, isTracked) {
+  const allowed = new Set(allowedNames);
+  return candidates.filter((candidate) => candidate.isDirectory() || candidate.isSymbolicLink()).filter((candidate) => !allowed.has(candidate.name) && isTracked(candidate.name));
+}
 export function syncSkills({ check = false } = {}) {
-  const shared = sharedFromLock(parseLock());
+  const lock = parseLock();
+  const shared = sharedFromLock(lock);
   const absent = shared.filter((name) => !lstatSafe(path.join(SOURCE_ROOT, name))?.isDirectory());
   if (absent.length) throw new TypeError(`锁文件声明的共享 skills 缺少权威内容: ${absent.join(", ")}`);
   const obsolete = shared.filter((name) => OBSOLETE.has(name));
@@ -53,6 +58,12 @@ export function syncSkills({ check = false } = {}) {
     const projection = path.join(ROOT, root);
     ensureSafeProjection(projection);
     if (!check) mkdirSync(projection, { recursive: true });
+    const allowed = [...shared, ...Object.keys(lock.skills?.platform?.[root] ?? {})];
+    for (const entry of unlockedProjectionEntries(entries(projection), allowed, (name) => tracked(relative(path.join(projection, name)))).filter((entry) => !OBSOLETE.has(entry.name))) {
+      const target = path.join(projection, entry.name);
+      if (!check && entry.isSymbolicLink() && !existsSync(target)) rmSync(target, { force: true });
+      else drift.push(`unlocked projection: ${relative(target)}`);
+    }
     for (const name of shared) {
       const source = path.join(SOURCE_ROOT, name);
       const target = path.join(projection, name);
@@ -85,16 +96,41 @@ function priorMetadata(lock) {
   if (!["shared", "platform"].some((key) => key in skills)) return skills;
   return { ...skills.shared, ...Object.values(skills.platform ?? {}).reduce((all, group) => ({ ...all, ...group }), {}), ...Object.fromEntries(Object.entries(skills).filter(([key]) => !["shared", "platform"].includes(key))) };
 }
-function metadata(name, skillPath, directory, previous, canonical = false) {
+function option(arguments_, name) {
+  const prefix = `--${name}=`;
+  const value = arguments_.find((argument) => argument.startsWith(prefix));
+  return value?.slice(prefix.length) || null;
+}
+function sourceRevisionMap(oldLock, arguments_) {
+  const sources = structuredClone(oldLock?.sources ?? {});
+  const revision = option(arguments_, "source-revision");
+  if (revision) {
+    const separator = revision.lastIndexOf(":");
+    if (separator <= 0 || separator === revision.length - 1) throw new TypeError("--source-revision 必须使用 source:revision 格式");
+    const source = revision.slice(0, separator);
+    sources[source] = { ...(sources[source] ?? {}), revision: revision.slice(separator + 1) };
+  }
+  return sources;
+}
+function metadata(name, skillPath, directory, previous, canonical = false, sources = {}, upstreamRoot = null) {
   const old = previous[name] ?? {};
   let recordedPath = old.skillPath ?? skillPath;
   if (canonical && /^\.(claude|codex|hermes|pi|qoder|trae)\/skills\//.test(recordedPath)) recordedPath = skillPath;
   const result = { source: old.source ?? "project", sourceType: old.sourceType ?? "local", skillPath: recordedPath, effectiveHash: treeHash(directory) };
-  if (old.upstreamHash ?? old.computedHash) result.upstreamHash = old.upstreamHash ?? old.computedHash;
+  const sourceInfo = sources[result.source];
+  if (sourceInfo?.revision) result.sourceRevision = sourceInfo.revision;
+  let upstreamDirectory = null;
+  if (upstreamRoot && result.source === "mattpocock/skills") {
+    upstreamDirectory = path.join(upstreamRoot, recordedPath).replace(/\/SKILL\.md$/, "");
+    if (!existsSync(upstreamDirectory)) throw new TypeError(`${name} 的上游路径不存在: ${recordedPath}`);
+    result.upstreamHash = treeHash(upstreamDirectory);
+  } else if (old.upstreamHash ?? old.computedHash) result.upstreamHash = old.upstreamHash ?? old.computedHash;
+  if (result.source === "mattpocock/skills" && result.upstreamHash && result.effectiveHash !== result.upstreamHash) result.adaptationRef = "docs/process/MATT-POCOCK-ENGINEERING-SKILLS.md";
   return result;
 }
 export function updateSkillLock(arguments_ = process.argv.slice(2)) {
-  const oldLock = parseLock(); const previous = priorMetadata(oldLock);
+  const oldLock = parseLock(); const previous = priorMetadata(oldLock); const sources = sourceRevisionMap(oldLock, arguments_); const upstreamRoot = option(arguments_, "upstream-root");
+  if (upstreamRoot && !existsSync(upstreamRoot)) throw new TypeError(`--upstream-root 不存在: ${upstreamRoot}`);
   const additions = arguments_.filter((arg) => arg.startsWith("--add=")).map((arg) => arg.slice(6));
   const removals = new Set(arguments_.filter((arg) => arg.startsWith("--remove=")).map((arg) => arg.slice(9)));
   const platformAdds = arguments_.filter((arg) => arg.startsWith("--add-platform=")).map((arg) => arg.slice(15).split(":", 2));
@@ -106,7 +142,7 @@ export function updateSkillLock(arguments_ = process.argv.slice(2)) {
   if (unlocked.length) throw new TypeError(`发现未登记到 skills-lock.json 的已跟踪共享 skills: ${unlocked.join(", ")}\n确认新增后运行 scripts/update-skill-lock --add=<skill-name>`);
   const targets = [".agents/skills", ...PROJECTION_ROOTS];
   const shared = Object.fromEntries(sharedNames.map((name) => {
-    const item = metadata(name, `.agents/skills/${name}/SKILL.md`, path.join(SOURCE_ROOT, name), previous, true); item.targets = targets; return [name, item];
+    const item = metadata(name, `.agents/skills/${name}/SKILL.md`, path.join(SOURCE_ROOT, name), previous, true, sources, upstreamRoot); item.targets = targets; return [name, item];
   }));
   const platform = {};
   for (const root of PROJECTION_ROOTS) {
@@ -115,9 +151,9 @@ export function updateSkillLock(arguments_ = process.argv.slice(2)) {
     if (!names.length) continue;
     const absentPlatform = names.filter((name) => !lstatSafe(path.join(location, name))?.isDirectory());
     if (absentPlatform.length) throw new TypeError(`锁文件声明的平台 skills 缺少内容 (${root}): ${absentPlatform.join(", ")}`);
-    platform[root] = Object.fromEntries(names.map((name) => { const item = metadata(name, `${root}/${name}/SKILL.md`, path.join(location, name), previous); item.targets = [root]; return [name, item]; }));
+    platform[root] = Object.fromEntries(names.map((name) => { const item = metadata(name, `${root}/${name}/SKILL.md`, path.join(location, name), previous, false, sources, upstreamRoot); item.targets = [root]; return [name, item]; }));
   }
-  const manifest = { version: 3, generatedBy: "scripts/update-skill-lock", canonicalRoot: ".agents/skills", projectionRoots: PROJECTION_ROOTS, skills: { shared, platform } };
+  const manifest = { version: 3, generatedBy: "scripts/update-skill-lock", canonicalRoot: ".agents/skills", projectionRoots: PROJECTION_ROOTS, sources, skills: { shared, platform } };
   const rendered = `${JSON.stringify(manifest, null, 2)}\n`;
   if (arguments_.includes("--check")) { if (!existsSync(LOCK_PATH) || readFileSync(LOCK_PATH, "utf8") !== rendered) throw new TypeError("skills-lock.json is stale; run scripts/update-skill-lock"); return "skills-lock.json matches distributed skills"; }
   writeFileSync(LOCK_PATH, rendered); return `updated skills-lock.json with ${sharedNames.length} shared skills and ${Object.values(platform).reduce((sum, group) => sum + Object.keys(group).length, 0)} platform skills`;

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

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { fileURLToPath } from "node:url";
+import { parseDocument } from "./vendor/yaml.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const schemaPath = path.join(root, "docs/process/schemas/frontend-implementation-evidence.schema.json");
+const validator = String.raw`
+import json
+import sys
+from jsonschema import Draft202012Validator
+schema = json.load(open(sys.argv[1], encoding="utf-8"))
+value = json.load(sys.stdin)
+errors = sorted(Draft202012Validator(schema).iter_errors(value), key=lambda error: list(error.absolute_path))
+for error in errors:
+    location = ".".join(str(part) for part in error.absolute_path) or "<root>"
+    print(f"{location}: {error.message}", file=sys.stderr)
+sys.exit(1 if errors else 0)
+`;
+
+try {
+  const { values, positionals } = parseArgs({ options: { "allow-template": { type: "boolean" } }, allowPositionals: true, strict: true });
+  if (positionals.length !== 1) throw new TypeError("用法: scripts/verify-frontend-implementation-evidence [--allow-template] <file.yaml>");
+  const document = parseDocument(readFileSync(path.resolve(positionals[0]), "utf8"), { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) throw new TypeError(document.errors[0].message);
+  const value = document.toJS({ maxAliasCount: 0 });
+  const result = spawnSync("python3", ["-c", validator, schemaPath], { cwd: root, encoding: "utf8", input: JSON.stringify(value) });
+  if (result.status !== 0) throw new TypeError(`${result.stdout}${result.stderr}`.trim());
+  if (!values["allow-template"] && value.template !== false) throw new TypeError("正式证据必须设置 template: false");
+  if (!values["allow-template"] && value.status !== "approved") throw new TypeError("正式证据必须达到 status: approved");
+  const serialized = JSON.stringify(value);
+  if (!values["allow-template"] && /REPLACE_ME|<[^>]+>|docs\/\.scratch\/example/.test(serialized)) throw new TypeError("正式证据不得保留模板占位值");
+  if (!values["allow-template"]) {
+    for (const field of ["prototype_ref", "spec_ref"]) {
+      const reference = value[field];
+      if (!/^https?:\/\//.test(reference) && !existsSync(path.resolve(root, reference))) throw new TypeError(`${field} 不可读取: ${reference}`);
+    }
+  }
+  if (!values["allow-template"] && value.kind === "verification") {
+    if (value.console_warning_check !== "pass") throw new TypeError("前端验证必须通过 console warning 检查");
+    if (value.uncovered_differences.length > 0 && !value.difference_owner) throw new TypeError("存在未覆盖差异时必须填写 difference_owner");
+    if (value.independent_review?.status !== "approved") throw new TypeError("前端验证必须通过独立 UI fidelity review");
+  }
+  process.stdout.write(`前端实现还原 ${value.kind} 验证通过\n`);
+} catch (error) {
+  process.stderr.write(`前端实现还原证据验证失败: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/verify-lifecycle-checkpoint

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { fileURLToPath } from "node:url";
+import { parseDocument } from "./vendor/yaml.mjs";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const schemaPath = path.join(root, "docs/process/schemas/lifecycle-checkpoint.schema.json");
+const validator = String.raw`
+import json
+import sys
+from jsonschema import Draft202012Validator
+schema = json.load(open(sys.argv[1], encoding="utf-8"))
+value = json.load(sys.stdin)
+errors = sorted(Draft202012Validator(schema).iter_errors(value), key=lambda error: list(error.absolute_path))
+for error in errors:
+    location = ".".join(str(part) for part in error.absolute_path) or "<root>"
+    print(f"{location}: {error.message}", file=sys.stderr)
+sys.exit(1 if errors else 0)
+`;
+
+try {
+  const { positionals } = parseArgs({ allowPositionals: true, strict: true });
+  if (positionals.length !== 1) throw new TypeError("用法: scripts/verify-lifecycle-checkpoint <checkpoint.yaml|checkpoint.json>");
+  const sourcePath = path.resolve(positionals[0]);
+  const document = parseDocument(readFileSync(sourcePath, "utf8"), { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) throw new TypeError(document.errors[0].message);
+  const value = document.toJS({ maxAliasCount: 0 });
+  const result = spawnSync("python3", ["-c", validator, schemaPath], { cwd: root, encoding: "utf8", input: JSON.stringify(value) });
+  if (result.status !== 0) throw new TypeError(`${result.stdout}${result.stderr}`.trim());
+  process.stdout.write("生命周期 checkpoint 验证通过\n");
+} catch (error) {
+  process.stderr.write(`生命周期 checkpoint 验证失败: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/verify-maintenance-checkpoint

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { loadMaintenanceCheckpoint, validateMaintenanceCheckpoint } from "./lib/maintenance-intensity.mjs";
+
+try {
+  const { positionals } = parseArgs({ allowPositionals: true, strict: true });
+  if (positionals.length > 1) throw new TypeError("用法: scripts/verify-maintenance-checkpoint [checkpoint.yaml|checkpoint.json|-]");
+  const result = validateMaintenanceCheckpoint(loadMaintenanceCheckpoint(positionals[0] ?? "-"));
+  process.stdout.write(`模板维护 checkpoint 验证通过（${result.intensity}，最低 ${result.minimum_intensity}）\n`);
+} catch (error) {
+  process.stderr.write(`模板维护 checkpoint 验证失败: ${error.message}\n`);
+  process.exitCode = 1;
+}

package/template/scripts/verify-maintenance-intensity-scenarios

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { validateMaintenanceCheckpoint } from "./lib/maintenance-intensity.mjs";
+
+const checkerSource = readFileSync(new URL("./lib/maintenance-intensity.mjs", import.meta.url), "utf8");
+if (checkerSource.includes("LEVEL_BY_TRIGGER = new Map")) {
+  throw new TypeError("触发项映射必须由 docs/process/maintenance-intensity.yaml 唯一维护");
+}
+if (!checkerSource.includes("maintenance-intensity.yaml")) {
+  throw new TypeError("维护强度校验器必须加载权威触发项映射");
+}
+
+const evidence = (...kinds) => kinds.map((kind) => ({ kind, command: `verify ${kind}`, result: "pass" }));
+const base = {
+  schema_version: 1,
+  classification_reason: "场景验证",
+  changed_assets: ["docs/example.md"],
+  escalation: "none"
+};
+
+const accepted = [
+  { ...base, intensity: "L1", triggers: ["textual-only"], verification_evidence: evidence("relevant-check"), review_mode: "self-check" },
+  { ...base, intensity: "L2", triggers: ["local-rule"], verification_evidence: evidence("counterexample", "fresh-verification", "focused-independent-review"), review_mode: "focused-independent" },
+  { ...base, intensity: "L2", triggers: [], verification_evidence: evidence("counterexample", "fresh-verification", "focused-independent-review"), review_mode: "focused-independent" },
+  { ...base, intensity: "L3", triggers: ["lifecycle-gate"], verification_evidence: evidence("red", "green", "refactor", "pressure-scenario", "fresh-verification", "formal-independent-review"), review_mode: "formal-independent" }
+];
+
+for (const checkpoint of accepted) validateMaintenanceCheckpoint(checkpoint);
+
+const rejected = [
+  { ...accepted[1], verification_evidence: evidence("fresh-verification") },
+  { ...accepted[1], verification_evidence: evidence("counterexample", "fresh-verification") },
+  { ...accepted[0], triggers: ["release-semantics"] },
+  { ...accepted[0], triggers: ["aggregate-behavior-change"] },
+  { ...accepted[2], verification_evidence: evidence("red", "green", "refactor", "pressure-scenario") },
+  { ...accepted[2], verification_evidence: evidence("red", "green", "refactor", "pressure-scenario", "fresh-verification") },
+  { ...accepted[1], escalation: "发现发布语义影响但仍维持 L2", triggers: ["release-semantics"] },
+  { ...accepted[2], intensity: "L1" }
+];
+
+for (const checkpoint of rejected) {
+  let failed = false;
+  try { validateMaintenanceCheckpoint(checkpoint); } catch { failed = true; }
+  if (!failed) throw new TypeError(`错误 checkpoint 未被拒绝: ${JSON.stringify(checkpoint)}`);
+}
+
+process.stdout.write("模板维护 L1/L2/L3 强度场景验证通过\n");

package/template/scripts/verify-template

@@ -5,7 +5,7 @@ ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 cd "$ROOT_DIR"
 node -e 'const [major]=process.versions.node.split(".").map(Number); if (major < 22 || major >= 27) { console.error("模板工具需要 Node >=22 <27"); process.exit(1); }'
 
-required_files=(yss-project.yaml AGENTS.md CONTEXT.md skills-lock.json docs/process/lifecycle-registry.yaml docs/process/lifecycle-registry-baseline.json scripts/repository-mode scripts/implementation-path-policy scripts/sync-skills scripts/update-skill-lock scripts/generate-lifecycle-artifacts scripts/verify-lifecycle-registry scripts/verify-yss-dto-openapi-profile scripts/verify-yss-dto-openapi-scenarios scripts/export-yss-skills)
+required_files=(yss-project.yaml AGENTS.md CONTEXT.md skills-lock.json docs/process/lifecycle-registry.yaml docs/process/lifecycle-registry-baseline.json docs/process/maintenance-intensity.yaml docs/process/schemas/lifecycle-checkpoint.schema.json docs/process/schemas/frontend-implementation-evidence.schema.json docs/process/templates/lifecycle-checkpoint-template.yaml docs/process/templates/frontend-implementation-plan-template.yaml docs/process/templates/frontend-implementation-verification-template.yaml scripts/repository-mode scripts/implementation-path-policy scripts/sync-skills scripts/update-skill-lock scripts/generate-lifecycle-artifacts scripts/verify-lifecycle-registry scripts/verify-lifecycle-checkpoint scripts/verify-frontend-implementation-evidence scripts/verify-maintenance-checkpoint scripts/verify-maintenance-intensity-scenarios scripts/verify-yss-dto-openapi-profile scripts/verify-yss-dto-openapi-scenarios scripts/export-yss-skills)
 for required in "${required_files[@]}"; do test -f "$required" || { echo "缺少模板必需文件: $required" >&2; exit 1; }; done
 
 repository_mode="$(scripts/repository-mode)"
@@ -21,7 +21,11 @@ scripts/update-skill-lock --check
 scripts/verify-yss-dto-openapi-profile
 scripts/verify-yss-dto-openapi-scenarios
 scripts/verify-lifecycle-registry
+scripts/verify-lifecycle-checkpoint docs/process/templates/lifecycle-checkpoint-template.yaml
+scripts/verify-frontend-implementation-evidence --allow-template docs/process/templates/frontend-implementation-plan-template.yaml
+scripts/verify-frontend-implementation-evidence --allow-template docs/process/templates/frontend-implementation-verification-template.yaml
 scripts/verify-lifecycle-scenarios
+scripts/verify-maintenance-intensity-scenarios
 scripts/verify-governance-release
 scripts/verify-implementation-path-scenarios
 scripts/verify-scaffold-generator-scenarios
@@ -32,7 +36,7 @@ scripts/verify-yss-ui-scenarios
 scripts/verify-openapi-yaml-first-scenarios
 scripts/verify-openapi-json-handoff-scenarios
 
-for entry in scripts/sync-skills scripts/update-skill-lock scripts/generate-lifecycle-artifacts scripts/verify-lifecycle-registry scripts/verify-yss-dto-openapi-profile scripts/verify-yss-dto-openapi-scenarios scripts/verify-lifecycle-scenarios scripts/verify-matt-yss-integration-scenarios scripts/verify-prototype-backend-scaffold-scenarios scripts/verify-yss-router-scenarios scripts/verify-openapi-yaml-first-scenarios scripts/verify-openapi-json-handoff-scenarios scripts/export-yss-skills; do node --check "$entry"; done
+for entry in scripts/sync-skills scripts/update-skill-lock scripts/generate-lifecycle-artifacts scripts/verify-lifecycle-registry scripts/verify-lifecycle-checkpoint scripts/verify-frontend-implementation-evidence scripts/verify-maintenance-checkpoint scripts/verify-maintenance-intensity-scenarios scripts/verify-yss-dto-openapi-profile scripts/verify-yss-dto-openapi-scenarios scripts/verify-lifecycle-scenarios scripts/verify-matt-yss-integration-scenarios scripts/verify-prototype-backend-scaffold-scenarios scripts/verify-yss-router-scenarios scripts/verify-openapi-yaml-first-scenarios scripts/verify-openapi-json-handoff-scenarios scripts/export-yss-skills; do node --check "$entry"; done
 
 legacy_runtime="ru""by"
 script_roots=(scripts)