create-yss-spec 2.1.4 → 2.1.6

package/template/scripts/verify-openapi-json-handoff-scenarios

@@ -1,270 +1,3 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "digest"
-require "json"
-require "tmpdir"
-require "yaml"
-
-# This validates the YAML-to-JSON handoff contract rather than invoking
-# Redocly or any frontend generator. These fixtures prove that a JSON
-# derivative preserves the frozen OpenAPI semantics and can be handed to an
-# implementation repository as unchanged bytes.
-module OpenapiJsonHandoff
-  module_function
-
-  def validate!(source_yaml:, source_json:, materialized_json:, handoff:, **_unused)
-    validate_source_paths!(handoff)
-    assert!(handoff.fetch("freeze_status") == "approved", "OpenAPI Freeze 未批准")
-    assert!(handoff.fetch("export_status") == "exported", "JSON 导出未完成")
-    assert!(!handoff.fetch("freeze_record").to_s.empty?, "缺少 OpenAPI Freeze 记录")
-    assert!(!handoff.fetch("export_record").to_s.empty?, "缺少 OpenAPI JSON 派生记录")
-
-    yaml_documents = YAML.load_stream(File.binread(source_yaml).force_encoding("UTF-8"))
-    assert!(yaml_documents.length == 1, "YAML 必须是单一 document")
-    assert!(yaml_documents.first.is_a?(Hash) && yaml_documents.first["openapi"] == "3.1.0", "YAML 必须是 OAS 3.1")
-
-    json_document = JSON.parse(File.binread(source_json))
-    assert!(json_document["openapi"] == "3.1.0", "JSON 必须是 OAS 3.1")
-    validate_operation_contract!(yaml_documents.first, json_document)
-    validate_json_refs!(json_document)
-    assert!(Digest::SHA256.file(source_yaml).hexdigest == handoff.fetch("yaml_sha256"), "YAML SHA-256 不匹配")
-    assert!(Digest::SHA256.file(source_json).hexdigest == handoff.fetch("json_sha256"), "JSON SHA-256 不匹配")
-    assert!(Digest::SHA256.file(materialized_json).hexdigest == handoff.fetch("json_sha256"), "前端物化 JSON 与导出记录不一致")
-
-    bundle_command = handoff.fetch("bundle_command")
-    %w[pnpm\ exec\ redocly\ bundle --ext\ json --component-renaming-conflicts-severity=error].each do |marker|
-      assert!(bundle_command.include?(marker), "bundle 命令缺少 #{marker}")
-    end
-    assert!(bundle_command.include?(handoff.fetch("source_yaml")), "bundle 命令未使用冻结 YAML")
-    assert!(bundle_command.include?(handoff.fetch("source_json")), "bundle 命令未写入记录的 JSON")
-    assert!(!bundle_command.match?(/(?:\bmvn\b|smart[ _-]?doc)/i), "bundle 命令包含已移除的 Maven OpenAPI 链路")
-
-  end
-
-  def validate_operation_contract!(yaml_document, json_document)
-    yaml_operations = operation_contracts(yaml_document)
-    json_operations = operation_contracts(json_document)
-    assert!(!yaml_operations.empty?, "YAML 缺少可生成客户端的操作")
-    assert!(yaml_operations == json_operations, "JSON 未保留 YAML 的路径、方法、operationId、请求或响应契约")
-    ids = yaml_operations.values.map { |contract| contract.fetch("operationId") }
-    assert!(ids.all? { |operation_id| operation_id.is_a?(String) && !operation_id.empty? }, "operationId 必须为非空字符串")
-    assert!(ids.uniq.length == ids.length, "operationId 必须唯一")
-  end
-
-  def operation_contracts(document)
-    methods = %w[get put post delete options head patch trace]
-    paths = document.fetch("paths", {})
-    paths.each_with_object({}) do |(path, path_item), operations|
-      next unless path_item.is_a?(Hash)
-
-      path_item.each do |method, operation|
-        next unless methods.include?(method.to_s.downcase) && operation.is_a?(Hash)
-
-        operations["#{method.to_s.upcase} #{path}"] = {
-          "operationId" => operation["operationId"],
-          "parameters" => operation.fetch("parameters", []),
-          "requestBody" => operation["requestBody"],
-          "responses" => operation.fetch("responses", {})
-        }
-      end
-    end
-  end
-
-  def validate_json_refs!(document)
-    refs = []
-    collect_refs(document, refs)
-    refs.each do |ref|
-      assert!(ref.start_with?("#/"), "JSON 不得包含外部或远程 $ref: #{ref}")
-      resolve_json_pointer!(document, ref)
-    end
-  end
-
-  def collect_refs(value, refs)
-    case value
-    when Hash
-      refs << value["$ref"] if value["$ref"].is_a?(String)
-      value.each_value { |child| collect_refs(child, refs) }
-    when Array
-      value.each { |child| collect_refs(child, refs) }
-    end
-  end
-
-  def resolve_json_pointer!(document, ref)
-    ref.delete_prefix("#/").split("/").reduce(document) do |node, segment|
-      key = segment.gsub("~1", "/").gsub("~0", "~")
-      assert!(node.is_a?(Hash) && node.key?(key), "JSON $ref 无法解析: #{ref}")
-      node.fetch(key)
-    end
-  end
-
-  def validate_source_paths!(handoff)
-    yaml_path = handoff.fetch("source_yaml")
-    json_path = handoff.fetch("source_json")
-    match = %r{\Adocs/\.scratch/([^/]+)/api/([^/]+)\.yaml\z}.match(yaml_path)
-    assert!(!match.nil? && match[1] == match[2], "冻结 YAML 路径不符合 feature 约定")
-    assert!(json_path == "docs/.scratch/#{match[1]}/api/#{match[2]}.json", "JSON 必须与冻结 YAML 同 feature 同目录")
-  end
-
-  def assert!(condition, message)
-    raise ArgumentError, message unless condition
-  end
-end
-
-def build_context(root)
-  feature = "order"
-  api_dir = File.join(root, "docs", ".scratch", feature, "api")
-  frontend_dir = File.join(root, "frontend", "openapi")
-  Dir.mkdir(File.join(root, "docs"))
-  Dir.mkdir(File.join(root, "docs", ".scratch"))
-  Dir.mkdir(File.join(root, "docs", ".scratch", feature))
-  Dir.mkdir(api_dir)
-  Dir.mkdir(File.join(root, "frontend"))
-  Dir.mkdir(frontend_dir)
-
-  source_yaml = File.join(api_dir, "#{feature}.yaml")
-  source_json = File.join(api_dir, "#{feature}.json")
-  materialized_json = File.join(frontend_dir, "openapi.json")
-  File.write(source_yaml, <<~YAML)
-    openapi: 3.1.0
-    info:
-      title: Order API
-      version: 1.0.0
-    paths:
-      /api/v1/orders/{orderId}:
-        get:
-          operationId: getOrder
-          parameters:
-            - name: orderId
-              in: path
-              required: true
-              schema:
-                type: string
-          responses:
-            '200':
-              description: success
-              content:
-                application/json:
-                  schema:
-                    $ref: '#/components/schemas/Order'
-    components:
-      schemas:
-        Order:
-          type: object
-          required: [id]
-          properties:
-            id:
-              type: string
-  YAML
-  json_document = {
-    "openapi" => "3.1.0",
-    "info" => { "title" => "Order API", "version" => "1.0.0" },
-    "paths" => {
-      "/api/v1/orders/{orderId}" => {
-        "get" => {
-          "operationId" => "getOrder",
-          "parameters" => [{ "name" => "orderId", "in" => "path", "required" => true, "schema" => { "type" => "string" } }],
-          "responses" => {
-            "200" => {
-              "description" => "success",
-              "content" => { "application/json" => { "schema" => { "$ref" => "#/components/schemas/Order" } } }
-            }
-          }
-        }
-      }
-    },
-    "components" => {
-      "schemas" => {
-        "Order" => {
-          "type" => "object",
-          "required" => ["id"],
-          "properties" => { "id" => { "type" => "string" } }
-        }
-      }
-    }
-  }
-  File.write(source_json, JSON.generate(json_document))
-  File.binwrite(materialized_json, File.binread(source_json))
-
-  source_yaml_path = "docs/.scratch/#{feature}/api/#{feature}.yaml"
-  source_json_path = "docs/.scratch/#{feature}/api/#{feature}.json"
-  handoff = {
-    "freeze_status" => "approved",
-    "export_status" => "exported",
-    "freeze_record" => "docs/.scratch/#{feature}/api/#{feature}-freeze.md",
-    "export_record" => "docs/.scratch/#{feature}/api/#{feature}-json-export.md",
-    "source_yaml" => source_yaml_path,
-    "source_json" => source_json_path,
-    "yaml_sha256" => Digest::SHA256.file(source_yaml).hexdigest,
-    "json_sha256" => Digest::SHA256.file(source_json).hexdigest,
-    "bundle_command" => "pnpm exec redocly bundle #{source_yaml_path} --output #{source_json_path} --ext json --component-renaming-conflicts-severity=error"
-  }
-  {
-    source_yaml: source_yaml,
-    source_json: source_json,
-    materialized_json: materialized_json,
-    handoff: handoff
-  }
-end
-
-def expect_rejected(label)
-  yield
-  raise "负向场景未被阻断: #{label}"
-rescue ArgumentError
-  true
-end
-
-Dir.mktmpdir("openapi-handoff-") do |root|
-  context = build_context(root)
-  OpenapiJsonHandoff.validate!(**context)
-
-  expect_rejected("Draft 不能导出") do
-    OpenapiJsonHandoff.validate!(**context.merge(handoff: context.fetch(:handoff).merge("freeze_status" => "draft")))
-  end
-
-  expect_rejected("Maven 链路不能作为导出命令") do
-    OpenapiJsonHandoff.validate!(**context.merge(handoff: context.fetch(:handoff).merge("bundle_command" => "mvn package")))
-  end
-
-  expect_rejected("运行时 URL 不能替代治理 JSON") do
-    OpenapiJsonHandoff.validate!(**context.merge(handoff: context.fetch(:handoff).merge("source_json" => "https://example.invalid/openapi.json")))
-  end
-
-  original_json = File.binread(context.fetch(:source_json))
-
-  changed_operation = JSON.parse(original_json)
-  changed_operation.fetch("paths").fetch("/api/v1/orders/{orderId}").fetch("get")["operationId"] = "getOtherOrder"
-  File.write(context.fetch(:source_json), JSON.generate(changed_operation))
-  expect_rejected("JSON 必须保留冻结 YAML 的 operationId") do
-    OpenapiJsonHandoff.validate!(**context.merge(handoff: context.fetch(:handoff).merge("json_sha256" => Digest::SHA256.file(context.fetch(:source_json)).hexdigest)))
-  end
-
-  invalid_ref = JSON.parse(original_json)
-  invalid_ref.fetch("paths").fetch("/api/v1/orders/{orderId}").fetch("get").fetch("responses").fetch("200").fetch("content").fetch("application/json").fetch("schema")["$ref"] = "#/components/schemas/Missing"
-  File.write(context.fetch(:source_json), JSON.generate(invalid_ref))
-  expect_rejected("JSON $ref 必须可解析") do
-    OpenapiJsonHandoff.validate!(**context.merge(handoff: context.fetch(:handoff).merge("json_sha256" => Digest::SHA256.file(context.fetch(:source_json)).hexdigest)))
-  end
-
-  changed_response = JSON.parse(original_json)
-  changed_response.fetch("paths").fetch("/api/v1/orders/{orderId}").fetch("get").fetch("responses").fetch("200").fetch("content").fetch("application/json").fetch("schema")["$ref"] = "#/components/schemas/ChangedOrder"
-  changed_response.fetch("components").fetch("schemas")["ChangedOrder"] = { "type" => "string" }
-  File.write(context.fetch(:source_json), JSON.generate(changed_response))
-  expect_rejected("JSON 必须保留冻结 YAML 的请求和响应契约") do
-    OpenapiJsonHandoff.validate!(**context.merge(handoff: context.fetch(:handoff).merge("json_sha256" => Digest::SHA256.file(context.fetch(:source_json)).hexdigest)))
-  end
-
-  File.binwrite(context.fetch(:source_json), original_json)
-  File.write(context.fetch(:materialized_json), "{\"openapi\":\"3.1.0\",\"paths\":{\"/tampered\":{}}}")
-  expect_rejected("前端 JSON 被手改") do
-    OpenapiJsonHandoff.validate!(**context)
-  end
-
-  File.binwrite(context.fetch(:materialized_json), original_json)
-  File.write(context.fetch(:source_json), "{\"openapi\":\"3.1.0\",\"paths\":{\"/tampered-source\":{}}}")
-  expect_rejected("治理 JSON 被手改") do
-    OpenapiJsonHandoff.validate!(**context)
-  end
-end
-
-puts "OpenAPI YAML-first JSON handoff scenarios passed"
+#!/usr/bin/env node
+import { runScenario } from "./lib/scenario-checks.mjs";
+try { runScenario("openapiJson"); } catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }

package/template/scripts/verify-openapi-yaml-first-scenarios

@@ -1,120 +1,3 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "json"
-require "pathname"
-require "yaml"
-
-ROOT = Pathname.new(__dir__).join("..").realpath
-PROJECTION_ROOTS = %w[
-  .agents/skills
-  .claude/skills
-  .codex/skills
-  .hermes/skills
-  .pi/skills
-  .qoder/skills
-  .trae/skills
-].freeze
-
-failures = []
-
-template_path = ROOT.join("docs/templates/openapi-spec-template.yaml")
-documents = YAML.load_stream(template_path.read)
-failures << "OpenAPI YAML 模板必须是单一 YAML document" unless documents.length == 1
-document = documents.first
-unless document.is_a?(Hash) && document["openapi"] == "3.1.0"
-  failures << "OpenAPI YAML 模板必须是 OAS 3.1 文档"
-end
-%w[pipeline stage status owner].each do |field|
-  failures << "OpenAPI YAML 模板不得把生命周期元数据写入根字段: #{field}" if document.is_a?(Hash) && document.key?(field)
-end
-
-PROJECTION_ROOTS.each do |root|
-  failures << "已移除的 yss-openapi 仍存在: #{root}/yss-openapi" if ROOT.join(root, "yss-openapi").exist?
-end
-
-lock = JSON.parse(ROOT.join("skills-lock.json").read)
-if lock.dig("skills", "shared", "yss-openapi")
-  failures << "skills-lock.json 仍登记 yss-openapi"
-end
-
-public_skills = JSON.parse(ROOT.join("yss-public-skills.json").read)
-if public_skills.fetch("skills").include?("yss-openapi")
-  failures << "yss-public-skills.json 仍公开 yss-openapi"
-end
-
-router = ROOT.join(".agents/skills/yss-router/references/router-contract.yaml").read
-removed_skill_pattern = /(?<![a-z0-9-])yss-openapi(?![a-z0-9-])/
-failures << "Router 仍路由到 yss-openapi" if router.match?(removed_skill_pattern)
-failures << "Router 脚手架合同仍允许旧 OpenAPI 基线" if router.include?("smart_doc_baseline")
-unless router.include?("api-integration:\n    when_regeneration: [yss-openapi-governance]")
-  failures << "Router 未将客户端重新生成路由到 yss-openapi-governance"
-end
-
-lifecycle_contract = ROOT.join(".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml").read
-failures << "Lifecycle 脚手架合同仍允许旧 OpenAPI 基线" if lifecycle_contract.include?("smart_doc_baseline")
-lifecycle_skill = ROOT.join(".agents/skills/yss-product-lifecycle/SKILL.md").read
-failures << "Lifecycle 说明仍保留旧 OpenAPI 基线" if lifecycle_skill.match?(/smart[ -]?doc/i)
-implementation_routing_template = ROOT.join("docs/templates/implementation-routing-template.md").read
-failures << "实现路由模板仍保留旧 OpenAPI 基线" if implementation_routing_template.match?(/smart[ -]?doc/i)
-
-scaffold_pom = ROOT.join(".agents/skills/yss-ddd-scaffold-generator/assets/templates/pom/bootstrap-pom.xml.template").read
-failures << "后端脚手架仍包含 smart-doc Maven 插件" if scaffold_pom.include?("smart-doc-maven-plugin")
-failures << "后端脚手架仍保留 smart-doc 配置模板" if ROOT.join(".agents/skills/yss-ddd-scaffold-generator/assets/templates/config/smart-doc.json.template").exist?
-
-scaffold_generator = ROOT.join(".agents/skills/yss-ddd-scaffold-generator/scripts/generate_scaffold.py").read
-failures << "后端脚手架生成器仍生成 smart-doc 配置" if scaffold_generator.include?("smart-doc.json") || scaffold_generator.include?("smart-doc-maven-plugin")
-
-governance = ROOT.join(".agents/skills/yss-openapi-governance/SKILL.md").read
-%w[YAML-first 唯一权威 redocly\ bundle --ext\ json operationId].each do |marker|
-  failures << "OpenAPI Governance 缺少 YAML-first JSON 派生规则: #{marker}" unless governance.include?(marker)
-end
-failures << "OpenAPI Governance 仍依赖 smart-doc" if governance.include?("smart-doc")
-%w[pnpm\ generate:api orval.config unsafeDisableValidation].each do |marker|
-  failures << "OpenAPI Governance 越界到前端代码生成或 Orval 配置: #{marker}" if governance.include?(marker)
-end
-
-api_integration = ROOT.join(".agents/skills/yss-api-integration/SKILL.md").read
-%w[冻结的\ OpenAPI\ YAML redocly\ bundle 原样物化 既有前端代码生成流程].each do |marker|
-  failures << "API Integration 缺少冻结 JSON 的下游交接规则: #{marker}" unless api_integration.include?(marker)
-end
-failures << "API Integration 仍引用 yss-openapi" if api_integration.match?(removed_skill_pattern)
-%w[docs/.scratch/<feature>/api/<feature>.json SHA-256 受控交接].each do |marker|
-  failures << "API Integration 未绑定治理 JSON 派生物: #{marker}" unless api_integration.include?(marker)
-end
-%w[orval.config unsafeDisableValidation].each do |marker|
-  failures << "API Integration 越界要求修改或核验 Orval 配置: #{marker}" if api_integration.include?(marker)
-end
-
-frontend_scaffold = ROOT.join(".agents/skills/yss-frontend-scaffold-generator/SKILL.md").read
-failures << "前端脚手架仍接受任意 openapi_source" if frontend_scaffold.include?("openapi_source")
-%w[OpenAPI\ Freeze\ 记录 OpenAPI\ JSON\ 派生记录 SHA-256 openapi/openapi.json 既有前端代码生成流程].each do |marker|
-  failures << "前端脚手架未绑定冻结 JSON 交接: #{marker}" unless frontend_scaffold.include?(marker)
-end
-%w[配置并读取实际\ `orval.config.*` unsafeDisableValidation].each do |marker|
-  failures << "前端脚手架越界修改或核验既有 Orval 配置: #{marker}" if frontend_scaffold.include?(marker)
-end
-
-export_record = ROOT.join("docs/api/templates/openapi-json-export-record-template.md")
-failures << "缺少 OpenAPI JSON 派生记录模板" unless export_record.file?
-if export_record.file?
-  export_record_text = export_record.read
-  %w[Orval\ 输入路径 orval.config unsafeDisableValidation pnpm\ generate:api].each do |marker|
-    failures << "JSON 派生记录越界记录前端 Orval 配置或执行: #{marker}" if export_record_text.include?(marker)
-  end
-end
-
-freeze_record = ROOT.join("docs/api/templates/openapi-freeze-record-template.md")
-%w[orval.config unsafeDisableValidation].each do |marker|
-  failures << "OpenAPI Freeze 记录越界规定 Orval 配置: #{marker}" if freeze_record.read.include?(marker)
-end
-
-draft_checklist = ROOT.join("docs/api/templates/openapi-draft-review-checklist.md")
-failures << "Draft 评审清单越界要求 Orval 输入路径" if draft_checklist.read.include?("Orval 输入路径")
-
-unless failures.empty?
-  warn failures.join("\n")
-  exit 1
-end
-
-puts "OpenAPI YAML-first 场景验证通过"
+#!/usr/bin/env node
+import { runScenario } from "./lib/scenario-checks.mjs";
+try { runScenario("openapiYaml"); } catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }

package/template/scripts/verify-prototype-backend-scaffold-scenarios

@@ -1,239 +1,3 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require "pathname"
-require "yaml"
-
-ROOT = Pathname.new(__dir__).join("..").realpath
-
-failures = []
-
-def require_marker(failures, path, marker)
-  body = ROOT.join(path).read
-  failures << "#{path} 缺少约束标记: #{marker}" unless body.include?(marker)
-end
-
-def route_after_prototype(facts)
-  return {"status" => "not-applicable", "steps" => []} unless facts.fetch(:backend_impact)
-
-  if facts.fetch(:ui_impact) && !facts.fetch(:prototype_confirmation)
-    return {"status" => "blocked", "reason" => "prototype-confirmation-required", "steps" => []}
-  end
-
-  steps = ["engineering-baseline"]
-  case facts.fetch(:scaffold_status)
-  when "required"
-    return {"status" => "blocked", "reason" => "scaffold-contract-required", "steps" => []} unless facts.fetch(:scaffold_contract_approved)
-    steps.concat(%w[yss-router-scaffold-contract lifecycle-approve-scaffold-contract yss-ddd-scaffold-generator yss-backend-scaffold-parent yss-router-contract-recompile])
-  when "existing", "initialized"
-    steps.concat(%w[yss-backend-scaffold-parent yss-router-contract-recompile])
-  else
-    return {"status" => "blocked", "reason" => "scaffold-status-required", "steps" => []}
-  end
-  {"status" => "ready-for-contract-review", "steps" => steps}
-end
-
-def generated_code_decision(facts)
-  return "blocked" unless facts.fetch(:contract_approved)
-  return "blocked" unless facts.fetch(:contract_persisted)
-  return "blocked" unless facts.fetch(:contract_current)
-  return "blocked" unless facts.fetch(:yss_skill_selected)
-  return "blocked" unless facts.fetch(:execution_result_bound)
-  return "blocked" if facts.fetch(:behavioral_impact) && facts.fetch(:tdd_mode) != "behavior-tdd"
-  return "blocked" if facts.fetch(:tdd_mode) == "controlled-generation" && facts.fetch(:business_behavior_in_generator)
-
-  "allowed"
-end
-
-def scaffold_generation_decision(facts)
-  return "blocked" if facts.fetch(:with_example)
-  return "blocked" if facts.fetch(:nonempty_target) && facts.fetch(:force) && !facts.fetch(:overwrite_approval)
-
-  "allowed"
-end
-
-contract_path = ROOT.join(".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml")
-contract = YAML.safe_load(contract_path.read, permitted_classes: [], aliases: false)
-router_contract = YAML.safe_load(
-  ROOT.join(".agents/skills/yss-router/references/router-contract.yaml").read,
-  permitted_classes: [], aliases: false
-)
-
-backend_scaffold = contract["backend_scaffold"]
-failures << "编排契约缺少 backend_scaffold" unless backend_scaffold.is_a?(Hash)
-if backend_scaffold.is_a?(Hash)
-  scaffold_schema = backend_scaffold.fetch("contract_schema", {})
-  failures << "脚手架合同必须声明结构化 schema" unless scaffold_schema.is_a?(Hash)
-  if scaffold_schema.is_a?(Hash)
-    failures << "生命周期脚手架合同 schema 版本不受支持" unless scaffold_schema["schema_version"] == 1
-    failures << "生命周期脚手架合同 schema 未分离 Router 与生命周期状态" unless scaffold_schema.dig("status_by_owner", "router").to_a.include?("ready-for-lifecycle-review") && scaffold_schema.dig("status_by_owner", "lifecycle").to_a.include?("approved")
-  end
-  %w[contract_id contract_version slice_id status router_draft_ref lifecycle_approval_ref persisted_ref current_version implementation_repository backend_repository scaffold_status target_git_url_or_output_dir allowed_write_paths expected_evidence_files verification_commands approval work_unit overwrite_policy].each do |required|
-    failures << "脚手架合同 schema 缺少 #{required}" unless scaffold_schema.fetch("required", []).include?(required)
-  end
-  %w[approval_ref approver persisted_ref current_version].each do |required|
-    failures << "脚手架合同审批记录缺少 #{required}" unless scaffold_schema.dig("approval", "required").to_a.include?(required)
-  end
-  failures << "backend_scaffold 必须声明 prototype_confirmation 后置顺序" unless backend_scaffold.dig("sequence", "after").include?("prototype_confirmation")
-  failures << "backend_scaffold 必须先于业务代码生成" unless backend_scaffold.dig("sequence", "before").include?("business_code_generation")
-  failures << "required 脚手架必须使用 yss-ddd-scaffold-generator" unless backend_scaffold["generator_skill"] == "yss-ddd-scaffold-generator"
-  failures << "脚手架生成必须使用 controlled-generation" unless backend_scaffold["tdd_mode"] == "controlled-generation"
-  %w[scaffold_contract_file scaffold_contract_draft scaffold_contract_approved scaffold_contract_persisted scaffold_contract_current_version].each do |required|
-    failures << "脚手架生成前缺少合同条件 #{required}" unless backend_scaffold.fetch("required_inputs", []).include?(required)
-  end
-  %w[yss-backend-scaffold-parent yss-router].each do |skill|
-    failures << "脚手架后置流程缺少 #{skill}" unless backend_scaffold.fetch("after_generation", []).include?(skill)
-  end
-  %w[business_rules state_machine permission transaction complex_query error_mapping user_visible_behavior].each do |forbidden|
-    failures << "脚手架生成禁止项缺少 #{forbidden}" unless backend_scaffold.fetch("forbidden_generation", []).include?(forbidden)
-  end
-  failures << "脚手架必须关闭 --with-example" unless backend_scaffold.dig("generation_options", "with_example") == false
-  failures << "脚手架覆盖写入必须默认阻断" unless backend_scaffold.dig("generation_options", "force") == "forbidden-by-default"
-  %w[contract_file router_draft_ref persisted_ref overwrite_scope rollback_ref].each do |required|
-    failures << "脚手架覆盖写入条件缺少 #{required}" unless backend_scaffold.dig("generation_options", "force_requires").to_a.include?(required)
-  end
-  failures << "脚手架必须留存生成元数据清单" unless backend_scaffold.fetch("required_evidence", []).include?("scaffold_generation_manifest")
-  %w[business_example_crud unapproved_force_overwrite].each do |forbidden|
-    failures << "脚手架生成禁止项缺少 #{forbidden}" unless backend_scaffold.fetch("forbidden_generation", []).include?(forbidden)
-  end
-  failures << "脚手架验证必须执行真实命令" unless backend_scaffold.dig("verification", "requires_execution") == true
-  failures << "脚手架验证必须记录命令结果" unless backend_scaffold.dig("verification", "evidence").to_a.include?("exit_code")
-  failures << "脚手架验证必须统一记录 duration_ms" unless backend_scaffold.dig("verification", "evidence").to_a.include?("duration_ms")
-  failures << "脚手架打印命令不得冒充验证证据" unless backend_scaffold.dig("verification", "printed_commands_are_not_evidence") == true
-end
-
-generated_policy = contract["post_scaffold_generated_code_policy"]
-failures << "编排契约缺少 post_scaffold_generated_code_policy" unless generated_policy.is_a?(Hash)
-if generated_policy.is_a?(Hash)
-  failures << "generated_code_policy 必须明确只约束脚手架后的代码" unless generated_policy["scope"] == "post_scaffold_generated_code"
-  %w[approved_persisted_current_slice_contract primary_yss_skill dependency_closure allowed_write_paths expected_evidence_files yss_skill_execution_result].each do |required|
-    failures << "后续代码生成缺少强制条件 #{required}" unless generated_policy.fetch("required", []).include?(required)
-  end
-  failures << "后续业务代码生成必须使用 behavior-tdd" unless generated_policy.dig("business_behavior", "tdd_mode") == "behavior-tdd"
-  failures << "未满足生成约束时必须阻断" unless generated_policy["on_violation"] == "blocked"
-  failures << "脚手架工程结构不得落入脚手架后的生成策略" if generated_policy.dig("controlled_generation", "allowed_for").to_a.include?("project_scaffold")
-end
-
-scaffold_policy = contract["scaffold_work_unit_policy"]
-failures << "编排契约缺少 scaffold_work_unit_policy" unless scaffold_policy.is_a?(Hash)
-if scaffold_policy.is_a?(Hash)
-  %w[approved_scaffold_contract primary_yss_skill allowed_write_paths expected_evidence_files verification_commands].each do |required|
-    failures << "脚手架工作单元缺少强制条件 #{required}" unless scaffold_policy.fetch("required", []).include?(required)
-  end
-  failures << "脚手架工作单元违反约束时必须阻断" unless scaffold_policy["on_violation"] == "blocked"
-end
-
-ready_requirements = contract.dig("ready_for_agent", "required") || []
-failures << "ready-for-agent 缺少 backend_scaffold_policy_satisfied" unless ready_requirements.include?("backend_scaffold_policy_satisfied")
-
-router_generator = router_contract.dig("dependency_closure", "yss-ddd-scaffold-generator") || {}
-failures << "Router 未把 yss-backend-scaffold-parent 绑定到脚手架" unless router_generator.fetch("always", []).include?("yss-backend-scaffold-parent")
-failures << "Router 未把 alibaba-java-code-style 绑定到脚手架" unless router_generator.fetch("always", []).include?("alibaba-java-code-style")
-failures << "Router 未声明脚手架完成后的完整重路由" unless router_contract.fetch("full_reroute_triggers", []).include?("scaffold-baseline-drift")
-router_scaffold_schema = router_contract.fetch("scaffold_contract_schema", {})
-failures << "Router 未声明脚手架合同 schema" unless router_scaffold_schema.is_a?(Hash)
-if router_scaffold_schema.is_a?(Hash)
-  failures << "Router 脚手架合同 schema 版本不受支持" unless router_scaffold_schema["schema_version"] == 1
-  failures << "Router 脚手架合同 schema 必须由 yss-router 编译" unless router_scaffold_schema["compiled_by"] == "yss-router"
-  failures << "Router 脚手架合同 schema 必须由生命周期批准" unless router_scaffold_schema["approved_by"] == "yss-product-lifecycle"
-  failures << "Router 脚手架合同必须按 owner 分离状态" unless router_scaffold_schema.dig("status_by_owner", "router").to_a.include?("ready-for-lifecycle-review") && router_scaffold_schema.dig("status_by_owner", "lifecycle").to_a.include?("approved")
-  failures << "Router 不得自行声明 approved 状态" if router_scaffold_schema.dig("status_by_owner", "router").to_a.include?("approved")
-  %w[contract_id contract_version slice_id status router_draft_ref lifecycle_approval_ref persisted_ref current_version allowed_write_paths expected_evidence_files verification_commands approval work_unit overwrite_policy].each do |required|
-    failures << "Router 脚手架合同 schema 缺少 #{required}" unless router_scaffold_schema.fetch("required", []).include?(required)
-  end
-  failures << "Router 脚手架合同 schema 未要求真实验证执行" unless router_scaffold_schema.dig("verification", "requires_execution") == true
-  failures << "Router 脚手架合同 schema 未统一 duration_ms" unless router_scaffold_schema.dig("verification", "evidence").to_a.include?("duration_ms")
-end
-
-complete_facts = {
-  backend_impact: true, ui_impact: true, prototype_confirmation: true, scaffold_status: "required", scaffold_contract_approved: true
-}
-complete_route = route_after_prototype(complete_facts)
-expected_steps = %w[engineering-baseline yss-router-scaffold-contract lifecycle-approve-scaffold-contract yss-ddd-scaffold-generator yss-backend-scaffold-parent yss-router-contract-recompile]
-failures << "原型完成后的后端路由顺序不完整" unless complete_route == {"status" => "ready-for-contract-review", "steps" => expected_steps}
-
-blocked_route = route_after_prototype(complete_facts.merge(prototype_confirmation: false))
-failures << "原型未确认时错误允许后端脚手架" unless blocked_route["status"] == "blocked" && blocked_route["reason"] == "prototype-confirmation-required"
-
-missing_scaffold_contract = route_after_prototype(complete_facts.merge(scaffold_contract_approved: false))
-failures << "脚手架受控生成缺少批准合同仍被允许" unless missing_scaffold_contract["status"] == "blocked" && missing_scaffold_contract["reason"] == "scaffold-contract-required"
-
-existing_route = route_after_prototype(complete_facts.merge(scaffold_status: "existing"))
-failures << "existing 工程不应重复全量脚手架" if existing_route.fetch("steps").include?("yss-ddd-scaffold-generator")
-failures << "existing 工程仍需基线校验和 Router" unless existing_route.fetch("steps") == %w[engineering-baseline yss-backend-scaffold-parent yss-router-contract-recompile]
-
-initialized_route = route_after_prototype(complete_facts.merge(scaffold_status: "initialized"))
-failures << "initialized 工程不应重复全量脚手架" if initialized_route.fetch("steps").include?("yss-ddd-scaffold-generator")
-failures << "initialized 工程仍需基线校验和 Router" unless initialized_route.fetch("steps") == %w[engineering-baseline yss-backend-scaffold-parent yss-router-contract-recompile]
-
-pressure_cases = {
-  "原型完成但无批准合同" => [
-    {contract_approved: false, contract_persisted: false, contract_current: false, yss_skill_selected: true, execution_result_bound: false, behavioral_impact: true, tdd_mode: "behavior-tdd", business_behavior_in_generator: false},
-    "blocked"
-  ],
-  "脚手架把事务和权限一起生成" => [
-    {contract_approved: true, contract_persisted: true, contract_current: true, yss_skill_selected: true, execution_result_bound: true, behavioral_impact: true, tdd_mode: "controlled-generation", business_behavior_in_generator: true},
-    "blocked"
-  ],
-  "批准合同下的业务行为切片" => [
-    {contract_approved: true, contract_persisted: true, contract_current: true, yss_skill_selected: true, execution_result_bound: true, behavioral_impact: true, tdd_mode: "behavior-tdd", business_behavior_in_generator: false},
-    "allowed"
-  ]
-}
-pressure_cases.each do |name, (facts, expected)|
-  actual = generated_code_decision(facts)
-  failures << "压力场景 #{name} 期望 #{expected}，实际 #{actual}" unless actual == expected
-end
-
-scaffold_pressure_cases = {
-  "--with-example 伪装成样板" => [{with_example: true, nonempty_target: false, force: false, overwrite_approval: false}, "blocked"],
-  "非空目录无覆盖批准" => [{with_example: false, nonempty_target: true, force: true, overwrite_approval: false}, "blocked"],
-  "空目录纯骨架" => [{with_example: false, nonempty_target: false, force: false, overwrite_approval: false}, "allowed"]
-}
-scaffold_pressure_cases.each do |name, (facts, expected)|
-  actual = scaffold_generation_decision(facts)
-  failures << "脚手架压力场景 #{name} 期望 #{expected}，实际 #{actual}" unless actual == expected
-end
-
-required_markers = {
-  ".agents/skills/yss-product-lifecycle/SKILL.md" => [
-    "原型确认 → 后端脚手架",
-    "yss-ddd-scaffold-generator",
-    "所有后续生成的后端代码",
-    "controlled-generation",
-    "behavior-tdd",
-    "--with-example",
-    "--force"
-  ],
-  ".agents/skills/yss-product-lifecycle/references/orchestration.md" => [
-    "prototype_confirmation",
-    "脚手架生成",
-    "不得把业务规则",
-    "YSS Skill Execution Result"
-  ],
-  "AGENTS.md" => [
-    "原型确认后",
-    "所有后续生成的后端代码",
-    "yss-ddd-scaffold-generator"
-  ],
-  "docs/architecture/templates/engineering-baseline-review-template.md" => [
-    "prototype_confirmation",
-    "脚手架生成结果",
-    "禁止生成业务行为"
-  ],
-  "docs/templates/implementation-routing-template.md" => [
-    "原型确认后先完成后端脚手架",
-    "所有后续生成代码",
-    "backend_scaffold_policy_satisfied"
-  ]
-}
-required_markers.each do |path, markers|
-  markers.each { |marker| require_marker(failures, path, marker) }
-end
-
-if failures.empty?
-  puts "原型到后端脚手架及后续 YSS 代码生成压力场景验证通过"
-else
-  warn failures.join("\n")
-  exit 1
-end
+#!/usr/bin/env node
+import { runScenario } from "./lib/scenario-checks.mjs";
+try { runScenario("prototype"); } catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }