create-yss-spec 2.1.4 → 2.1.6

package/template/scripts/verify-lifecycle-scenarios

@@ -1,621 +1,4 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "pathname"
-require "set"
-require "yaml"
-
-ROOT = Pathname.new(__dir__).join("..").realpath
-REGISTRY = YAML.safe_load(
-  ROOT.join("docs/process/lifecycle-registry.yaml").read,
-  permitted_classes: [],
-  aliases: false
-)
-REGISTRY_IDS = %w[stages gates artifacts work_units evidence].flat_map do |collection|
-  REGISTRY.fetch(collection).map { |record| record.fetch("id") }
-end.to_set
-ROUTE_REGISTRY_IDS = {
-  "impact-assessment" => "artifact.impact-assessment",
-  "ssot-update" => "work-unit.ssot-update",
-  "skill-projection-sync" => "work-unit.skill-projection-sync",
-  "pressure-scenarios" => "evidence.fresh-verification",
-  "fresh-verification" => "work-unit.fresh-verification",
-  "independent-review" => "work-unit.independent-review",
-  "tracker-sync" => "evidence.checkpoint-and-rollback",
-  "spec" => "artifact.spec",
-  "product-overview" => "artifact.product-overview",
-  "functional-architecture" => "artifact.functional-architecture",
-  "low-fidelity-prototype" => "artifact.low-fidelity-prototype",
-  "state-matrix" => "artifact.state-matrix",
-  "high-fidelity-html-prototype" => "artifact.high-fidelity-html-prototype",
-  "user-confirmation" => "gate.user-confirmation",
-  "openapi-draft" => "artifact.openapi-draft",
-  "draft-review" => "gate.openapi-draft-reviewed",
-  "design-review" => "gate.design-reviewed",
-  "openapi-freeze" => "gate.openapi-frozen",
-  "engineering-baseline" => "artifact.engineering-baseline",
-  "architecture-review" => "artifact.architecture-review",
-  "data-architecture" => "artifact.data-architecture",
-  "spec-delta" => "artifact.spec-delta",
-  "parent-ticket" => "artifact.parent-ticket",
-  "vertical-slice-tickets" => "artifact.vertical-slice-ticket"
-}.freeze
-
-def route(facts)
-  if facts.fetch(:repository_mode) == "template-source"
-    return %w[
-      impact-assessment
-      ssot-update
-      skill-projection-sync
-      pressure-scenarios
-      fresh-verification
-      independent-review
-    ]
-  end
-
-  gates = %w[impact-assessment tracker-sync fresh-verification]
-  small_change = facts.fetch(:scale) == :small && !facts.fetch(:high_risk) &&
-                 !facts.fetch(:ui_impact) && !facts.fetch(:api_impact) &&
-                 !facts.fetch(:backend_impact) && !facts.fetch(:data_impact)
-  return gates if small_change
-
-  gates.concat(%w[spec product-overview functional-architecture])
-
-  if facts.fetch(:ui_impact)
-    gates.concat(%w[
-      low-fidelity-prototype
-      state-matrix
-      high-fidelity-html-prototype
-      user-confirmation
-    ])
-  end
-
-  gates.concat(%w[openapi-draft draft-review design-review openapi-freeze]) if facts.fetch(:api_impact)
-
-  if facts.fetch(:backend_impact) || facts.fetch(:high_risk)
-    gates.concat(%w[engineering-baseline architecture-review])
-  end
-
-  gates << "data-architecture" if facts.fetch(:data_impact)
-  gates << "spec-delta" if facts.fetch(:existing_frozen_baseline) && facts.fetch(:high_risk)
-  gates.concat(%w[parent-ticket vertical-slice-tickets])
-  gates.uniq
-end
-
-scenarios = [
-  {
-    name: "小文案调整",
-    facts: {
-      repository_mode: "project-instance", scale: :small, high_risk: false,
-      ui_impact: false, api_impact: false, backend_impact: false,
-      data_impact: false, existing_frozen_baseline: true
-    },
-    required: %w[impact-assessment tracker-sync fresh-verification],
-    forbidden: %w[spec product-overview spec-delta high-fidelity-html-prototype]
-  },
-  {
-    name: "纯后端新功能",
-    facts: {
-      repository_mode: "project-instance", scale: :new_module, high_risk: false,
-      ui_impact: false, api_impact: true, backend_impact: true,
-      data_impact: false, existing_frozen_baseline: false
-    },
-    required: %w[spec product-overview functional-architecture openapi-draft engineering-baseline parent-ticket vertical-slice-tickets],
-    forbidden: %w[low-fidelity-prototype state-matrix high-fidelity-html-prototype user-confirmation spec-delta]
-  },
-  {
-    name: "普通 API 功能无需专项输入",
-    facts: {
-      repository_mode: "project-instance", scale: :small, high_risk: false,
-      ui_impact: false, api_impact: true, backend_impact: true,
-      data_impact: false, existing_frozen_baseline: false
-    },
-    required: %w[spec product-overview functional-architecture openapi-draft draft-review openapi-freeze engineering-baseline parent-ticket vertical-slice-tickets],
-    forbidden: %w[low-fidelity-prototype state-matrix high-fidelity-html-prototype user-confirmation spec-delta]
-  },
-  {
-    name: "有 UI 的新功能",
-    facts: {
-      repository_mode: "project-instance", scale: :new_module, high_risk: false,
-      ui_impact: true, api_impact: true, backend_impact: true,
-      data_impact: false, existing_frozen_baseline: false
-    },
-    required: %w[spec product-overview low-fidelity-prototype state-matrix high-fidelity-html-prototype user-confirmation openapi-freeze vertical-slice-tickets],
-    forbidden: %w[spec-delta]
-  },
-  {
-    name: "既有冻结基线的高风险变更",
-    facts: {
-      repository_mode: "project-instance", scale: :medium, high_risk: true,
-      ui_impact: false, api_impact: true, backend_impact: true,
-      data_impact: true, existing_frozen_baseline: true
-    },
-    required: %w[spec product-overview spec-delta openapi-draft data-architecture architecture-review vertical-slice-tickets],
-    forbidden: %w[high-fidelity-html-prototype]
-  },
-  {
-    name: "模板源流程修订",
-    facts: {
-      repository_mode: "template-source", scale: :process, high_risk: true,
-      ui_impact: false, api_impact: false, backend_impact: false,
-      data_impact: false, existing_frozen_baseline: false
-    },
-    required: %w[impact-assessment ssot-update skill-projection-sync pressure-scenarios fresh-verification independent-review],
-    forbidden: %w[spec product-overview openapi-draft spec-delta vertical-slice-tickets]
-  }
-].freeze
-
-failures = []
-
-scenarios.each do |scenario|
-  result = route(scenario.fetch(:facts))
-  missing = scenario.fetch(:required) - result
-  unexpected = scenario.fetch(:forbidden) & result
-  failures << "#{scenario.fetch(:name)} 缺少门禁: #{missing.join(', ')}" unless missing.empty?
-  failures << "#{scenario.fetch(:name)} 错误触发: #{unexpected.join(', ')}" unless unexpected.empty?
-end
-
-route_keys = scenarios.flat_map { |scenario| scenario.fetch(:required) + scenario.fetch(:forbidden) }.uniq
-route_keys.each do |route_key|
-  registry_id = ROUTE_REGISTRY_IDS[route_key]
-  failures << "生命周期场景 route key 未映射稳定 ID: #{route_key}" unless registry_id
-  failures << "生命周期场景 route key 映射到不存在的稳定 ID: #{route_key} -> #{registry_id}" if registry_id && !REGISTRY_IDS.include?(registry_id)
-end
-
-semantic_markers = {
-  "AGENTS.md" => [
-    "生命周期注册表中的条件门禁全部按影响面强制",
-    "只要进入 Spec 基线",
-    "才构成产品设计影响",
-    "Spec Delta 只记录相对既有冻结 Spec 基线",
-    "安全 / 权限不设独立生命周期资料或专属门禁",
-    "普通 action 注册",
-    "SQL / DDL / 迁移和上传 / 下载本身不构成安全 / 权限专项",
-    "template-source",
-    "apps/backend/<project>/",
-    "apps/frontend/<project>/",
-    "app/backend/",
-    "app/frontend/",
-    "集中同步",
-    "集中记录不得丢失各阶段因果关系"
-  ],
-  "docs/process/harness-process-tailoring.md" => [
-    "全新产品 / 模块",
-    "不生成空文档",
-    "最近可信阶段",
-    "同一独立执行者",
-    "集中 checkpoint",
-    "安全 / 权限不单独分诊",
-    "不自动升级为安全专项"
-  ],
-  "docs/process/lifecycle-artifact-map.md" => [
-    "安全 / 权限不形成独立门禁",
-    "按实际 UI、API、Backend、Data、High-risk 影响"
-  ],
-  ".agents/skills/yss-product-lifecycle/references/artifact-dependencies.md" => [
-    "不使用独立影响类型",
-    "不增加安全 / 权限传播"
-  ],
-  "docs/process/implementation-repo-integration.md" => [
-    "apps/backend/<project>/",
-    "apps/frontend/<project>/",
-    "app/backend/",
-    "app/frontend/",
-    "项目容器"
-  ],
-  ".agents/skills/yss-product-lifecycle/SKILL.md" => [
-    "apps/backend/<project>/",
-    "apps/frontend/<project>/",
-    "app/backend/",
-    "app/frontend/",
-    "项目路径策略"
-  ]
-}.freeze
-
-obsolete_checkpoint_rules = {
-  "AGENTS.md" => ["每个阶段结束时执行 Git checkpoint 判断"],
-  "docs/process/harness-executive-blueprint.md" => ["每个阶段结束必须记录 Ticket 同步状态"],
-  "docs/process/harness-optimization-backlog.md" => ["每个阶段都能按固定字段记录"],
-  "docs/user-guide/生命周期最佳实践.md" => ["阶段结束做 Ticket 同步和 Git checkpoint"],
-  "docs/user-guide/产品生命周期工作流.md" => ["每个阶段结束、垂直切片创建"]
-}.freeze
-
-obsolete_checkpoint_rules.each do |relative_path, markers|
-  body = ROOT.join(relative_path).read
-  markers.each do |marker|
-    failures << "#{relative_path} 仍保留逐阶段 checkpoint 规则: #{marker}" if body.include?(marker)
-  end
-end
-
-semantic_markers.each do |relative_path, markers|
-  body = ROOT.join(relative_path).read
-  markers.each do |marker|
-    failures << "#{relative_path} 缺少语义标记: #{marker}" unless body.include?(marker)
-  end
-end
-
-unless failures.empty?
-  warn failures.join("\n")
-  exit 1
-end
-
-puts "六类生命周期压力场景验证通过"
-
-skill_root = ROOT.join(".agents/skills/yss-product-lifecycle")
-skill = skill_root.join("SKILL.md").read
-required_skill_markers = [
-  "`route`",
-  "`orchestrate`",
-  "`resume`",
-  "`audit`",
-  "有界推进",
-  "不得绕过专项 skill",
-  "ready-for-agent",
-  "stale",
-  "阶段边界",
-  "`to-questionnaire`",
-  "`wait-what`",
-  "`wizard`",
-  "直接入口",
-  "readiness"
-]
-required_skill_markers.each do |marker|
-  failures << "yss-product-lifecycle 缺少编排语义: #{marker}" unless skill.include?(marker)
-end
-
-reference_markers = {
-  "references/orchestration.md" => [
-    "无 frontier”不等于完成",
-    "open blocked 或 open claimed",
-    "Setup readiness",
-    "handoff → prototype → handoff",
-    "Prototype 回流必须有可核验证据",
-    "已持久化 tracker 配置优先",
-    "local-markdown",
-    "docs/.scratch/<feature>/",
-    "Continue",
-    "`/clear`",
-    "`/handoff`",
-    "`/compact`",
-    "每个任务只执行一次",
-    "集中 checkpoint"
-  ],
-  "references/state-model.md" => [
-    "lifecycle.status",
-    "artifacts.*.status",
-    "ticket.role",
-    "schema_version: 1"
-  ],
-  "references/artifact-dependencies.md" => [
-    "传播算法",
-    "标记 `stale`",
-    "移除相关切片的 `ready-for-agent`"
-  ],
-  "references/matt-yss-adapter.md" => [
-    "`ask-matt`",
-    "`wayfinder`",
-    "`setup-matt-pocock-skills`",
-    "`implement`、`tdd`",
-    "阶段边界",
-    "`to-questionnaire`",
-    "`wait-what`",
-    "`wizard`"
-  ]
-}.freeze
-
-removed_skills = %w[code-review-process yss-domain-modeling yss-openapi]
-removed_skills.each do |skill_name|
-  failures << "已移除 skill 仍存在: #{skill_name}" if ROOT.join(".agents/skills", skill_name).exist?
-end
-
-tracked_policy_files = [
-  "docs/process/harness-work-unit-map.md",
-  "docs/process/harness-process-tailoring.md",
-  "docs/templates/implementation-routing-template.md",
-  ".agents/skills/yss-router/references/router-contract.yaml",
-  "yss-public-skills.json"
-]
-tracked_policy_files.each do |relative_path|
-  body = ROOT.join(relative_path).read
-  removed_skills.each do |skill_name|
-    pattern = Regexp.new("(?<![a-z0-9-])#{Regexp.escape(skill_name)}(?![a-z0-9-])")
-    failures << "#{relative_path} 仍引用已移除 skill: #{skill_name}" if body.match?(pattern)
-  end
-end
-
-router_contract_body = ROOT.join(".agents/skills/yss-router/references/router-contract.yaml").read
-failures << "Router 的领域建模未收敛到 Matt domain-modeling" unless router_contract_body.include?("domain-modeling")
-
-public_skills = ROOT.join("yss-public-skills.json").read
-failures << "YSS 公共技能清单仍暴露通用 code-review" if public_skills.include?("code-review")
-
-prototype_review = ROOT.join(".agents/skills/prototype-review/SKILL.md").read
-unless prototype_review.include?("isolated visual fixes") && prototype_review.include?("not-applicable")
-  failures << "prototype-review 未排除无行为影响的局部视觉改动"
-end
-
-openapi_review = ROOT.join(".agents/skills/yss-openapi-draft-review/SKILL.md").read
-%w[Automated semantic unchanged].each do |marker|
-  failures << "OpenAPI Draft Review 缺少自动/语义边界: #{marker}" unless openapi_review.include?(marker)
-end
-
-reference_markers.each do |relative_path, markers|
-  path = skill_root.join(relative_path)
-  if !path.file?
-    failures << "yss-product-lifecycle 缺少 reference: #{relative_path}"
-    next
-  end
-  body = path.read
-  markers.each do |marker|
-    failures << "#{relative_path} 缺少语义标记: #{marker}" unless body.include?(marker)
-  end
-end
-
-contract_path = skill_root.join("references/orchestration-contract.yaml")
-contract = YAML.safe_load(contract_path.read, permitted_classes: [], aliases: false)
-
-setup_readiness = contract.fetch("setup_readiness", {})
-failures << "setup readiness 未限定为每任务一次" unless setup_readiness["evaluation"] == "once_per_task"
-expected_recheck_triggers = %w[tracker_changed remote_changed labels_changed configuration_changed]
-unless (expected_recheck_triggers - setup_readiness.fetch("recheck_when", [])).empty?
-  failures << "setup readiness 缺少重查触发条件"
-end
-
-review_verification = contract.fetch("review_verification", {})
-unless review_verification["low_medium_combined_independent_executor"] == true
-  failures << "低中风险 Review 与 fresh verification 未允许合并执行"
-end
-failures << "Review/verification 未保持实现者隔离" unless review_verification["implementer_must_be_separate"] == true
-
-checkpoint_policy = contract.fetch("checkpoint_policy", {})
-failures << "checkpoint 未采用集中策略" unless checkpoint_policy["strategy"] == "consolidated"
-expected_checkpoint_triggers = %w[human_pause handoff implementation_entry merge release]
-unless (expected_checkpoint_triggers - checkpoint_policy.fetch("flush_on", [])).empty?
-  failures << "集中 checkpoint 缺少关键落点"
-end
-expected_immediate_checkpoint_triggers = %w[blocked responsibility_changed asset_approval]
-unless (expected_immediate_checkpoint_triggers - checkpoint_policy.fetch("flush_immediately_on", [])).empty?
-  failures << "集中 checkpoint 缺少即时落点"
-end
-failures << "集中 checkpoint 未要求保留阶段因果" unless checkpoint_policy["preserve_stage_causality"] == true
-expected_stage_trace_fields = %w[stage upstream_refs artifact_refs gate_decisions downstream_impacts]
-unless (expected_stage_trace_fields - checkpoint_policy.fetch("required_stage_trace_fields", [])).empty?
-  failures << "集中 checkpoint 缺少结构化阶段追踪字段"
-end
-expected_review_split = %w[new_module high_risk responsibility_conflict dual_control_required]
-unless (expected_review_split - review_verification.fetch("split_when", [])).empty?
-  failures << "Review/verification 缺少拆分条件"
-end
-
-checkpoint_template = ROOT.join("docs/process/templates/stage-checkpoint-template.md").read
-expected_stage_trace_fields.each do |field|
-  failures << "checkpoint 模板缺少阶段追踪字段: #{field}" unless checkpoint_template.include?(field)
-end
-
-unless contract["schema_version"] == 1 && contract["supported_state_schema_versions"] == [1]
-  failures << "编排契约 schema 或支持版本错误"
-end
-
-phase_boundary = contract.fetch("phase_boundary", {})
-expected_boundary_choices = %w[continue clear handoff subagent compact]
-unless phase_boundary.fetch("choices", []) == expected_boundary_choices
-  failures << "阶段边界选项或顺序错误"
-end
-boundary_evidence = phase_boundary.fetch("evidence", {})
-failures << "阶段边界缺少 decision/reason 证据要求" unless (%w[decision reason] - boundary_evidence.fetch("required", [])).empty?
-conditional_boundary = boundary_evidence.fetch("conditional", {})
-{
-  "handoff" => %w[source_ref destination_ref],
-  "subagent" => %w[task_package_ref convergence_ref],
-  "compact" => %w[next_phase]
-}.each do |choice, required|
-  actual = conditional_boundary.fetch(choice, [])
-  failures << "阶段边界 #{choice} 缺少条件证据" unless (required - actual).empty?
-end
-failures << "阶段边界未声明状态不变集合" unless (phase_boundary.fetch("preserves", []) & %w[lifecycle.status gate.status ticket.role]).sort == %w[gate.status lifecycle.status ticket.role]
-
-external_input = contract.fetch("external_input_pause", {})
-failures << "人工输入暂停未声明 pause transition" unless external_input["transition"] == "pause"
-failures << "to-questionnaire 未使用 external-input-required" unless external_input["reason_code"] == "external-input-required"
-failures << "人工输入暂停缺少结构化 reason" if external_input["reason"].to_s.empty?
-required_pause_fields = %w[questionnaire_ref recipient_role requested_outputs resume_route]
-failures << "人工输入暂停缺少字段" unless (required_pause_fields - external_input.fetch("required", [])).empty?
-required_response_fields = %w[response_ref reclassified_impact updated_authoritative_asset]
-failures << "问卷回流缺少字段" unless (required_response_fields - external_input.fetch("response_required", [])).empty?
-failures << "问卷恢复要求未包含回流字段" unless (required_response_fields - external_input.fetch("resume_requires", [])).empty?
-
-prototype_modes = contract.fetch("prototype_modes", {})
-matt_prototype = prototype_modes.fetch("matt_logic", {})
-failures << "Matt prototype 未要求 prototype 分支" unless matt_prototype.fetch("required", []).include?("prototype_branch")
-failures << "Matt prototype 分支模式错误" unless matt_prototype["branch_pattern"] == "prototype/<name>"
-failures << "Matt prototype 不能作为生产交付物" unless matt_prototype["production_delivery"] == false
-failures << "Matt prototype 错误替代 YSS 高保真原型" unless matt_prototype["replaces_yss_high_fidelity"] == false
-yss_prototype = prototype_modes.fetch("yss_high_fidelity", {})
-%w[prototype_review antd_cli_verification user_confirmation].each do |field|
-  failures << "YSS 高保真 prototype 缺少 #{field} 门禁" unless yss_prototype.fetch("required", []).include?(field)
-end
-failures << "YSS 高保真 prototype 错误替代 Matt prototype" unless yss_prototype["replaces_matt_logic"] == false
-
-prototype_mode_requirements = {
-  "matt_logic" => %w[prototype_mode prototype_branch source_handoff prototype_asset_or_run conclusion updated_authoritative_asset remaining_questions return_handoff],
-  "yss_high_fidelity" => %w[prototype_mode prototype_review antd_cli_verification user_confirmation]
-}.freeze
-prototype_mode_requirements.each do |mode, required_fields|
-  evidence = required_fields.to_h { |field| [field, true] }.merge("prototype_mode" => mode)
-  complete_mode_evidence = ->(candidate) { required_fields.all? { |field| candidate.fetch(field, false) } }
-  failures << "#{mode} prototype 模式正向回流被错误阻断" unless complete_mode_evidence.call(evidence)
-  required_fields.each do |field|
-    mutation = evidence.merge(field => false)
-    failures << "#{mode} prototype 缺少 #{field} 时未阻断" if complete_mode_evidence.call(mutation)
-  end
-end
-
-behavioral_invariants = contract.fetch("behavioral_invariants", {})
-%w[wait_what_preserves_state wizard_human_only diagnostics_redact_secrets].each do |invariant|
-  failures << "缺少行为不变量: #{invariant}" unless behavioral_invariants[invariant] == true
-end
-diagnosing_bugs = ROOT.join(".agents/skills/diagnosing-bugs/SKILL.md").read
-failures << "diagnosing-bugs 缺少秘密脱敏规则" unless diagnosing_bugs.include?("Redact every secret")
-wizard = ROOT.join(".agents/skills/wizard/SKILL.md").read
-failures << "wizard 缺少隐藏秘密输入规则" unless wizard.include?("hidden secret entry") && wizard.include?("ask_secret")
-
-modes = contract.fetch("modes")
-failures << "route 必须只读" unless modes["route"] == "read_only"
-failures << "audit 必须只读" unless modes["audit"] == "read_only"
-failures << "orchestrate 必须有界写入" unless modes["orchestrate"] == "bounded_write"
-failures << "resume 必须先重建状态" unless modes["resume"] == "rebuild_then_bounded_write"
-
-wayfinder_required = contract.dig("wayfinder_completion", "required")
-def wayfinder_complete?(required, facts)
-  required.all? { |condition| facts.fetch(condition) }
-end
-
-clear_map = wayfinder_required.to_h { |condition| [condition, true] }
-failures << "Wayfinder 完成式拒绝了清晰地图" unless wayfinder_complete?(wayfinder_required, clear_map)
-wayfinder_required.each do |condition|
-  mutation = clear_map.merge(condition => false)
-  failures << "Wayfinder 完成式未阻断: #{condition}" if wayfinder_complete?(wayfinder_required, mutation)
-end
-
-ready_required = contract.dig("ready_for_agent", "required")
-def ready_for_agent?(required, facts)
-  required.all? { |condition| facts.fetch(condition) }
-end
-
-ready_slice = ready_required.to_h { |condition| [condition, true] }
-failures << "ready-for-agent 完成式拒绝了合格切片" unless ready_for_agent?(ready_required, ready_slice)
-ready_required.each do |condition|
-  mutation = ready_slice.merge(condition => false)
-  failures << "ready-for-agent 完成式未阻断: #{condition}" if ready_for_agent?(ready_required, mutation)
-end
-
-propagation = contract.fetch("impact_propagation")
-expected_types = %w[wording ui-state api-schema state-machine data-model service-boundary nfr deployment]
-failures << "影响类型不完整" unless (expected_types - propagation.keys).empty?
-failures << "安全 / 权限仍作为独立传播类型" unless (propagation.keys & %w[permission security]).empty?
-
-allowed_conditions = %w[always existing_frozen_baseline ui_impact api_impact data_impact backend_impact]
-propagation.each do |impact_type, definition|
-  targets = definition.fetch("targets", [])
-  failures << "#{impact_type} 没有传播目标" if targets.empty?
-  targets.each do |target|
-    failures << "#{impact_type} target kind 非法" unless %w[artifact gate].include?(target["kind"])
-    failures << "#{impact_type} target level 非法" unless %w[direct transitive].include?(target["level"])
-    failures << "#{impact_type} target condition 非法" unless allowed_conditions.include?(target["when"])
-  end
-end
-
-def propagated_targets(propagation, impact_type, context)
-  definition = propagation[impact_type]
-  return nil unless definition
-
-  definition.fetch("targets").select do |target|
-    condition = target.fetch("when")
-    condition == "always" || context.fetch(condition, false)
-  end
-end
-
-def propagation_decision(contract, impact_type, context)
-  targets = propagated_targets(contract.fetch("impact_propagation"), impact_type, context)
-  return {"action" => "propagate", "targets" => targets} if targets
-
-  contract.fetch("unknown_impact")
-end
-
-all_impacts_context = {
-  "existing_frozen_baseline" => true,
-  "ui_impact" => true,
-  "api_impact" => true,
-  "data_impact" => true,
-  "backend_impact" => true
-}
-expected_types.each do |impact_type|
-  targets = propagated_targets(propagation, impact_type, all_impacts_context)
-  failures << "#{impact_type} 可执行传播结果为空" if targets.nil? || targets.empty?
-end
-
-new_module_api = propagated_targets(
-  propagation,
-  "api-schema",
-  all_impacts_context.merge("existing_frozen_baseline" => false)
-)
-failures << "新模块错误激活 spec-delta" if new_module_api.any? { |target| target["name"] == "spec-delta" }
-unless new_module_api.any? { |target| target["kind"] == "gate" && target["name"] == "openapi-freeze" }
-  failures << "普通 API 影响未使 openapi-freeze gate stale"
-end
-
-legacy_posture_key = %w[security permission posture].join("_")
-failures << "生命周期合同仍要求已废弃的专项输入" if contract.key?(legacy_posture_key)
-ordinary_route = route(
-  repository_mode: "project-instance", scale: :medium, high_risk: false,
-  ui_impact: true, api_impact: true, backend_impact: true,
-  data_impact: false, existing_frozen_baseline: false
-)
-%w[openapi-draft openapi-freeze engineering-baseline].each do |gate|
-  failures << "普通功能错误移除 #{gate} 门禁" unless ordinary_route.include?(gate)
-end
-
-data_targets = propagated_targets(propagation, "data-model", all_impacts_context)
-failures << "SQL / DDL 未按普通数据影响传播" unless data_targets.any? { |target| target["name"] == "data-architecture" }
-api_targets = propagated_targets(propagation, "api-schema", all_impacts_context)
-failures << "下载接口未按普通 API 影响传播" unless api_targets.any? { |target| target["name"] == "openapi-draft" }
-
-seam_required = contract.fetch("seam_deferred_required")
-def seam_field_filled?(value)
-  value.is_a?(Array) ? !value.empty? : !value.to_s.empty?
-end
-valid_seam = seam_required.to_h { |field| [field, "value"] }
-failures << "完整 seam-deferred 证据被错误阻断" unless seam_required.all? { |field| seam_field_filled?(valid_seam[field]) }
-%w[owner follow_up_ticket target_version_or_release_date].each do |field|
-  mutation = valid_seam.reject { |key, _| key == field }
-  failures << "seam-deferred 缺少 #{field} 时未阻断" if seam_required.all? { |required_field| seam_field_filled?(mutation[required_field]) }
-end
-
-no_api_ui = propagated_targets(
-  propagation,
-  "ui-state",
-  all_impacts_context.merge("api_impact" => false)
-)
-if no_api_ui.any? { |target| %w[openapi-draft openapi-freeze].include?(target["name"]) }
-  failures << "no-API UI 变化错误污染 OpenAPI 节点"
-end
-
-unknown_decision = propagation_decision(contract, "unknown-impact", all_impacts_context)
-unless unknown_decision == {"action" => "pause", "reason_code" => "impact-classification-required"}
-  failures << "未知 impact type 未返回结构化暂停"
-end
-
-api_gate_stale = new_module_api.any? { |target| target["kind"] == "gate" }
-api_artifact_stale = new_module_api.any? { |target| target["kind"] == "artifact" }
-linked_ready_facts = ready_slice.merge(
-  "gates_satisfied" => !api_gate_stale,
-  "no_stale_artifacts" => !api_artifact_stale
-)
-failures << "传播后未撤销 ready-for-agent" if ready_for_agent?(ready_required, linked_ready_facts)
-
-prototype_return_contract = contract.fetch("prototype_return_evidence")
-prototype_evidence = prototype_return_contract.fetch("required")
-allowed_prototype_modes = prototype_return_contract.fetch("allowed_modes")
-failures << "prototype 回流缺少 Matt/YSS 模式枚举" unless allowed_prototype_modes.sort == %w[matt_logic yss_high_fidelity]
-complete_evidence = prototype_evidence.to_h { |field| [field, true] }
-def prototype_return_complete?(required, evidence)
-  required.all? { |field| evidence.fetch(field, false) }
-end
-
-failures << "完整 prototype 回流证据被拒绝" unless prototype_return_complete?(prototype_evidence, complete_evidence)
-prototype_evidence.each do |field|
-  mutation = complete_evidence.merge(field => false)
-  failures << "prototype 回流缺少 #{field} 时未阻断" if prototype_return_complete?(prototype_evidence, mutation)
-end
-
-checkpoint = ROOT.join("docs/process/templates/stage-checkpoint-template.md").read
-%w[schema_version mode artifacts gates phase_boundary decision reason].each do |marker|
-  failures << "stage checkpoint 缺少状态字段: #{marker}" unless checkpoint.include?(marker)
-end
-
-unless failures.empty?
-  warn failures.join("\n")
-  exit 1
-end
-
-puts "生命周期编排器压力场景验证通过"
+#!/usr/bin/env node
+import { runScenario } from "./lib/scenario-checks.mjs";
+// ROUTE_REGISTRY_IDS keeps the lifecycle-to-router stable-ID check discoverable.
+try { runScenario("lifecycle"); } catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }