create-yss-spec 3.3.6 → 3.3.7

package/template/.pi/skills/yss-stage-decision/tests/run-scenarios.mjs

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { buildDecisionFixture } from "../../../../scripts/fixtures/user-decision/build-fixture.mjs";
 import { createHash } from "node:crypto";
 import { spawnSync } from "node:child_process";
 import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
@@ -14,6 +13,7 @@ const validator = join(testsRoot, "..", "scripts", "validate-domain-strategy.mjs
 const packageValidator = join(testsRoot, "..", "scripts", "validate-stage-decision-package.mjs");
 const contextValidator = join(projectRoot, "scripts", "verify-context-contract");
 const migrationTool = join(testsRoot, "..", "scripts", "migrate-context-references.mjs");
+const v3MigrationTool = join(testsRoot, "..", "scripts", "migrate-contract-v3.mjs");
 const validTemplate = join(testsRoot, "fixtures", "valid-supplier-domain.yaml");
 const validPackageTemplate = join(testsRoot, "fixtures", "valid-stage-decision-package.yaml");
 
@@ -29,6 +29,58 @@ function digestYaml(source) {
   return `sha256:${createHash("sha256").update(JSON.stringify(canonical(document.toJS({ maxAliasCount: 0 })))).digest("hex")}`;
 }
 
+function parseYaml(source) {
+  const document = parseDocument(source, { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) throw new Error(document.errors[0].message);
+  return document.toJS({ maxAliasCount: 0 });
+}
+
+function toV2Domain(source) {
+  const value = structuredClone(parseYaml(source));
+  value.schema_version = 2;
+  value.domain_version = "v2";
+  delete value.traceability_version;
+  delete value.rule_catalog;
+  for (const scenario of value.scenarios) {
+    delete scenario.rule_refs;
+    delete scenario.critical;
+    delete scenario.success_results;
+    delete scenario.evidence_refs;
+  }
+  for (const invariant of value.invariants) {
+    delete invariant.rule_ref;
+    delete invariant.evidence_refs;
+  }
+  value.downstream_mapping = [{
+    domain_change: "admission-decision-validity",
+    impacts: ["spec", "openapi", "procurement-acceptance-tests"],
+    propagation: "stale",
+    reapproval_condition: "ComplianceReview 决定和有效期重新批准"
+  }];
+  value.approval.current_version = "v2";
+  return value;
+}
+
+function toV2Stage(source, domainDigest) {
+  const value = structuredClone(parseYaml(source));
+  value.schema_version = 2;
+  value.package_version = "v2";
+  for (const field of ["success_criteria", "test_seams", "confirmed_decisions", "assumptions", "constraints"]) {
+    value[field] = value[field].map((item) => item.statement);
+  }
+  value.domain_strategy_ref.domain_version = "v2";
+  value.domain_strategy_ref.digest = domainDigest;
+  value.domain_strategy_ref.persisted_ref = "domain-strategy-v2.yaml";
+  value.downstream_mapping = [{
+    domain_change: "admission-decision-validity",
+    consumer: "spec-synthesis",
+    propagation: "direct",
+    reapproval_condition: "领域策略版本或有效性规则变化"
+  }];
+  value.approval.current_version = "v2";
+  return value;
+}
+
 function run(command, file, contextRoot) {
   return spawnSync(process.execPath, [command, file, "--root", contextRoot], { cwd: projectRoot, encoding: "utf8" });
 }
@@ -56,34 +108,59 @@ context_schema_version: 1
 | 准入决定 | 合规审查形成的准入结论。 | AdmissionDecision | ComplianceReview | 避免：\`审批结果\` |
 `;
 
-const temporaryRoot = await mkdtemp(join(tmpdir(), "yss-stage-decision-v2-"));
+const temporaryRoot = await mkdtemp(join(tmpdir(), "yss-stage-decision-v3-"));
 try {
   await writeFile(join(temporaryRoot, "CONTEXT.md"), contextSource);
   const contextResult = spawnSync(process.execPath, [contextValidator, "--root", temporaryRoot, "--allowed-context", "SupplierManagement", "--allowed-context", "ComplianceReview", "--allowed-context", "ProcurementExecution", "--term-ref", "Global/Supplier", "--term-ref", "ComplianceReview/AdmissionDecision", "--json"], { cwd: projectRoot, encoding: "utf8" });
   if (contextResult.status !== 0) throw new Error(`context fixture should pass: ${contextResult.stderr}`);
   const context = JSON.parse(contextResult.stdout);
 
-  const domainApprovalRef = join(temporaryRoot, "domain-approval.json");
   const domainSource = (await readFile(validTemplate, "utf8"))
-    .replace(".agents/skills/yss-stage-decision/tests/fixtures/domain-strategy-approval.yaml", domainApprovalRef)
     .replace("<document-digest>", context.document_digest)
     .replace("<referenced-terms-digest>", context.referenced_terms_digest);
   const domainFile = join(temporaryRoot, "domain-strategy.yaml");
   await writeFile(domainFile, domainSource);
-  const domainDecision = buildDecisionFixture(join(temporaryRoot, "domain-decision"), { boundary: "check.domain-strategy-approved", subjectRef: domainFile });
-  const domainApproval = parseDocument(await readFile(join(testsRoot, "fixtures/domain-strategy-approval.yaml"), "utf8")).toJS();
-  await writeFile(domainApprovalRef, JSON.stringify({ ...domainApproval, subject_ref: domainFile, approval_scope: domainDecision.requirement.scope, user_decision_ref: domainDecision.ref }));
   const pass = run(validator, domainFile, temporaryRoot);
-  if (pass.status !== 0) throw new Error(`valid v2 fixture should pass: ${pass.stderr}`);
+  if (pass.status !== 0) throw new Error(`valid v3 fixture should pass: ${pass.stderr}`);
+
+  const v2Domain = toV2Domain(domainSource);
+  const v2DomainSource = JSON.stringify(v2Domain, null, 2);
+  const v2DomainFile = join(temporaryRoot, "domain-strategy-v2.yaml");
+  await writeFile(v2DomainFile, v2DomainSource);
+  const v2Pass = run(validator, v2DomainFile, temporaryRoot);
+  if (v2Pass.status !== 0) throw new Error(`read-only v2 fixture should pass: ${v2Pass.stderr}`);
+
+  const migratedDomainV3 = spawnSync(process.execPath, [v3MigrationTool, v2DomainFile, "--kind", "domain-strategy", "--root", temporaryRoot], { cwd: projectRoot, encoding: "utf8" });
+  if (migratedDomainV3.status !== 0) throw new Error(`v2 domain strategy should migrate: ${migratedDomainV3.stderr}`);
+  const migratedDomainV3Value = JSON.parse(migratedDomainV3.stdout);
+  if (migratedDomainV3Value.schema_version !== 3 || migratedDomainV3Value.status !== "draft" || migratedDomainV3Value.approval.approval_ref !== "migration-required") throw new Error("domain v2 -> v3 migration must reset approval and status");
+
+  const duplicateRule = join(temporaryRoot, "duplicate-rule.yaml");
+  const duplicateRuleValue = parseYaml(domainSource);
+  duplicateRuleValue.rule_catalog.push(structuredClone(duplicateRuleValue.rule_catalog[0]));
+  await writeFile(duplicateRule, JSON.stringify(duplicateRuleValue, null, 2));
+  expectBlocked(run(validator, duplicateRule, temporaryRoot), /rule_id.*重复|重复.*rule_id/, "duplicate v3 rule id");
+
+  const danglingRule = join(temporaryRoot, "dangling-rule.yaml");
+  const danglingRuleValue = parseYaml(domainSource);
+  danglingRuleValue.scenarios[0].rule_refs = ["rule.missing"];
+  await writeFile(danglingRule, JSON.stringify(danglingRuleValue, null, 2));
+  expectBlocked(run(validator, danglingRule, temporaryRoot), /rule_refs.*未声明|悬空/, "dangling v3 rule ref");
+
+  const missingEvidence = join(temporaryRoot, "missing-rule-evidence.yaml");
+  const missingEvidenceValue = parseYaml(domainSource);
+  missingEvidenceValue.rule_catalog[0].evidence_refs = [];
+  await writeFile(missingEvidence, JSON.stringify(missingEvidenceValue, null, 2));
+  expectBlocked(run(validator, missingEvidence, temporaryRoot), /evidence_refs/, "missing v3 evidence");
 
   const legacyFile = join(temporaryRoot, "legacy-domain.yaml");
-  await writeFile(legacyFile, domainSource.replace("schema_version: 2", "schema_version: 1"));
+  await writeFile(legacyFile, JSON.stringify({ ...v2Domain, schema_version: 1 }, null, 2));
   expectBlocked(run(validator, legacyFile, temporaryRoot), /migration-required/, "legacy domain contract");
 
   const migratableLegacy = join(temporaryRoot, "migratable-legacy-domain.yaml");
-  const migratableLegacySource = domainSource
-    .replace("schema_version: 2", "schema_version: 1")
-    .replace(/context_snapshot:\n[\s\S]*?\ndownstream_mapping:/, "terminology_refs: [CONTEXT.md#Supplier, contexts/ComplianceReview/CONTEXT.md#AdmissionDecision]\ndownstream_mapping:");
+  const migratableLegacyValue = { ...structuredClone(v2Domain), schema_version: 1, terminology_refs: ["CONTEXT.md#Supplier", "contexts/ComplianceReview/CONTEXT.md#AdmissionDecision"] };
+  delete migratableLegacyValue.context_snapshot;
+  const migratableLegacySource = JSON.stringify(migratableLegacyValue, null, 2);
   await writeFile(migratableLegacy, migratableLegacySource);
   const migrated = spawnSync(process.execPath, [migrationTool, migratableLegacy, "--root", temporaryRoot], { cwd: projectRoot, encoding: "utf8" });
   if (migrated.status !== 0) throw new Error(`migratable v1 contract should migrate: ${migrated.stderr}`);
@@ -91,7 +168,7 @@ try {
   if (migratedValue.schema_version !== 2 || migratedValue.terminology_refs !== undefined || migratedValue.context_snapshot.context_ref !== "CONTEXT.md" || migratedValue.context_snapshot.term_refs.join(",") !== "ComplianceReview/AdmissionDecision,Global/Supplier") throw new Error("migrated context snapshot is incomplete");
 
   const ambiguousLegacy = join(temporaryRoot, "ambiguous-legacy-domain.yaml");
-  await writeFile(ambiguousLegacy, migratableLegacySource.replace("CONTEXT.md#Supplier, contexts/ComplianceReview/CONTEXT.md#AdmissionDecision", "contexts/ComplianceReview/CONTEXT.md"));
+  await writeFile(ambiguousLegacy, JSON.stringify({ ...migratableLegacyValue, terminology_refs: ["contexts/ComplianceReview/CONTEXT.md"] }, null, 2));
   const ambiguousMigration = spawnSync(process.execPath, [migrationTool, ambiguousLegacy, "--root", temporaryRoot], { cwd: projectRoot, encoding: "utf8" });
   expectBlocked(ambiguousMigration, /migration-required.*无法唯一定位|无法唯一定位.*migration-required/, "ambiguous legacy reference");
 
@@ -115,32 +192,48 @@ try {
   await writeFile(unknownContext, domainSource.replace("to_context: ComplianceReview", "to_context: UnknownContext"));
   expectBlocked(run(validator, unknownContext, temporaryRoot), /未引用已声明上下文|未在领域战略中登记/, "unknown context");
 
-  const packageApprovalRef = join(temporaryRoot, "package-approval.json");
   const packageSource = (await readFile(validPackageTemplate, "utf8"))
-    .replace(".agents/skills/yss-stage-decision/tests/fixtures/stage-decision-approval.yaml", packageApprovalRef)
     .replace("<document-digest>", context.document_digest)
     .replace("<referenced-terms-digest>", context.referenced_terms_digest)
     .replace("<domain-strategy-digest>", digestYaml(domainSource));
   const packageFile = join(temporaryRoot, "stage-decision.yaml");
   await writeFile(packageFile, packageSource);
-  const packageDecision = buildDecisionFixture(join(temporaryRoot, "package-decision"), { boundary: "check.stage-decision-package-approved", subjectRef: packageFile });
-  const packageApproval = parseDocument(await readFile(join(testsRoot, "fixtures/stage-decision-approval.yaml"), "utf8")).toJS();
-  await writeFile(packageApprovalRef, JSON.stringify({ ...packageApproval, subject_ref: packageFile, approval_scope: packageDecision.requirement.scope, user_decision_ref: packageDecision.ref }));
   const packagePass = run(packageValidator, packageFile, temporaryRoot);
-  if (packagePass.status !== 0) throw new Error(`valid v2 stage decision package should pass: ${packagePass.stderr}`);
+  if (packagePass.status !== 0) throw new Error(`valid v3 stage decision package should pass: ${packagePass.stderr}`);
+
+  const v2Stage = toV2Stage(packageSource, digestYaml(v2DomainSource));
+  const v2StageFile = join(temporaryRoot, "stage-decision-v2.yaml");
+  await writeFile(v2StageFile, JSON.stringify(v2Stage, null, 2));
+  const v2StagePass = run(packageValidator, v2StageFile, temporaryRoot);
+  if (v2StagePass.status !== 0) throw new Error(`read-only v2 stage decision package should pass: ${v2StagePass.stderr}`);
+
+  const migratedV3 = spawnSync(process.execPath, [v3MigrationTool, v2StageFile, "--kind", "stage-decision", "--root", temporaryRoot], { cwd: projectRoot, encoding: "utf8" });
+  if (migratedV3.status !== 0) throw new Error(`v2 stage decision should migrate: ${migratedV3.stderr}`);
+  const migratedV3Value = JSON.parse(migratedV3.stdout);
+  if (migratedV3Value.schema_version !== 3 || migratedV3Value.status !== "draft" || migratedV3Value.approval.approval_ref !== "migration-required") throw new Error("v2 -> v3 migration must reset approval and status");
+
+  const wrongSourceRef = join(temporaryRoot, "stage-decision-wrong-source-ref.yaml");
+  const wrongSourceRefValue = parseYaml(packageSource);
+  wrongSourceRefValue.success_criteria[0].source_refs = ["rule.missing"];
+  await writeFile(wrongSourceRef, JSON.stringify(wrongSourceRefValue, null, 2));
+  expectBlocked(run(packageValidator, wrongSourceRef, temporaryRoot), /source_refs.*未在领域战略中声明|悬空/, "stage decision dangling source ref");
 
   const packageLegacy = join(temporaryRoot, "legacy-stage-decision.yaml");
-  await writeFile(packageLegacy, packageSource.replace("schema_version: 2", "schema_version: 1"));
+  await writeFile(packageLegacy, JSON.stringify({ ...v2Stage, schema_version: 1 }, null, 2));
   expectBlocked(run(packageValidator, packageLegacy, temporaryRoot), /migration-required/, "legacy stage decision contract");
 
   const packageBlocker = join(temporaryRoot, "stage-decision-blocker.yaml");
-  await writeFile(packageBlocker, packageSource.replace("type: deferred", "type: blocker"));
+  const blockerValue = parseYaml(packageSource);
+  blockerValue.unresolved_items[0].type = "blocker";
+  await writeFile(packageBlocker, JSON.stringify(blockerValue, null, 2));
   expectBlocked(run(packageValidator, packageBlocker, temporaryRoot), /blocker/, "blocker package");
 
   const packageWrongArray = join(temporaryRoot, "stage-decision-wrong-array.yaml");
-  await writeFile(packageWrongArray, packageSource.replace("target_users: [采购专员、合规专员]", "target_users: [42]"));
+  const wrongArrayValue = parseYaml(packageSource);
+  wrongArrayValue.target_users = [42];
+  await writeFile(packageWrongArray, JSON.stringify(wrongArrayValue, null, 2));
   expectBlocked(run(packageValidator, packageWrongArray, temporaryRoot), /target_users\[0\]/, "package non-string array item");
 } finally {
   await rm(temporaryRoot, { recursive: true, force: true });
 }
-process.stdout.write("业务边界与规则设计 v2 场景验证通过\n");
+process.stdout.write("业务边界与规则设计 v2/v3 场景验证通过\n");

package/template/docs/process/frontend-backend-delivery.md

@@ -6,7 +6,7 @@
 
 战略方维护业务规则、Spec、页面流程和视觉基线；后端维护 API 及后端交付；前端维护工程设计、页面和验收证据；统一管理方维护基线引用、跨仓切片与业务验收汇总。
 
-前端消费需求可在上游设计时提前反馈。前端项目在战略和后端交付尚未齐备时，只能验包、诊断和回交缺口。两类输入通过接收核验后，可以准备前端工程设计、实现计划和 Slice Contract；合同获准前不得写代码。
+前端消费需求可在上游设计时提前反馈。Handoff v4 导入后的 Frontend Strategic Preflight 可在后端交付前完成战略输入、Context、视觉基线和源规则追踪核验，并允许起草前端工程设计与实现计划；它固定返回 `ready_for_agent: false`。仅当 Backend/API/Data 影响命中时，最终接收才等待后端交付；UI-only 路径使用有依据的 `backend-not-applicable`。Slice Contract 获准前均不得写代码。
 
 ## 后端导出与前端导入
 
@@ -28,11 +28,14 @@ scripts/backend-delivery import --bundle <directory-or-zip> --target-root <front
 
 ## 接收与启动
 
-导入只产生 `frontend-acceptance-draft.json`，不会批准资产。接收方完成正式词汇对账并按 `schemas/frontend-delivery-acceptance.schema.json` 准备接收记录：
+Handoff v4 先生成 `frontend-strategic-preflight-draft.json`；补齐正式 Context Reconciliation 后执行 `scripts/verify-frontend-strategic-preflight`。通过仅允许进入前端工程设计草案。
 
-- `backend_delivery` 绑定后端导入收据和包摘要。
+后端交付导入只新增匹配的 backend binding 并产生 `frontend-acceptance-draft.json`，不会覆盖已填写的前端预检/设计草案，也不会批准资产。最终接收方按当前 `schemas/frontend-delivery-acceptance.schema.json`（v2）准备记录；v1 仅服务历史 Handoff v3，继续要求真实后端交付：
+
+- `strategic_preflight` 绑定当前预检文件及字节摘要。
+- `backend_dependency.mode: required` 时，`backend_delivery` 绑定真实后端导入收据和包摘要；`not-applicable` 时必须与 Handoff v4 backend 路由的影响引用、原因和证据一致，且不得绑定后端收据。
 - `strategic_handoff` 绑定战略导入收据、包摘要、正式 `context_reconciliation_ref` 和全部源规则/关键场景的承接 rows。
-- `frontend_cases` 绑定业务规则/场景、成功或失败结果、已交付接口、Visual Baseline `case_id` 和可读取的用例说明。
+- `frontend_cases` 绑定业务规则/场景、成功或失败结果、Visual Baseline `case_id` 和可读取的用例说明；有后端依赖时绑定已交付接口，`backend-not-applicable` 时 `operation_ids` 必须为空。
 - 已规划的承接使用 `mapped`，表示已映射用例，不声称代码已实现。当前交付范围必须 mapped 到当前切片；其他范围的 pending、conflict、deferred 或 not-applicable 沿用战略逐条承接的理由、证据和依赖阻断规则。
 
 完成接收核对后记录 `status: accepted` 并执行：

package/template/docs/process/schemas/backend-delivery.schema.json

@@ -25,6 +25,10 @@
       "type": "string",
       "pattern": "^sha256:[0-9a-f]{64}$"
     },
+    "strategic_route_id": {
+      "type": "string",
+      "pattern": "^route\\.[a-z0-9][a-z0-9-]*$"
+    },
     "scope": {
       "type": "object",
       "additionalProperties": false,

package/template/docs/process/schemas/frontend-delivery-acceptance-v1.schema.json

@@ -0,0 +1,200 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "schema_version": {
+      "const": 1
+    },
+    "status": {
+      "const": "accepted"
+    },
+    "slice_id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "backend_delivery": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "import_receipt_ref": {
+          "type": "string",
+          "minLength": 1
+        },
+        "bundle_digest": {
+          "type": "string",
+          "pattern": "^sha256:[0-9a-f]{64}$"
+        }
+      },
+      "required": [
+        "import_receipt_ref",
+        "bundle_digest"
+      ]
+    },
+    "strategic_handoff": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "import_receipt_ref": {
+          "type": "string",
+          "minLength": 1
+        },
+        "bundle_digest": {
+          "type": "string",
+          "pattern": "^sha256:[0-9a-f]{64}$"
+        },
+        "context_reconciliation_ref": {
+          "type": "string",
+          "minLength": 1
+        },
+        "rows": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": [
+              "source_id",
+              "source_digest",
+              "disposition",
+              "dependency_status",
+              "dependent_slice_refs",
+              "evidence_refs"
+            ],
+            "properties": {
+              "source_id": {
+                "type": "string",
+                "minLength": 1
+              },
+              "source_digest": {
+                "type": "string",
+                "pattern": "^sha256:[0-9a-f]{64}$"
+              },
+              "disposition": {
+                "enum": [
+                  "mapped",
+                  "pending",
+                  "conflict",
+                  "deferred",
+                  "not-applicable"
+                ]
+              },
+              "dependency_status": {
+                "enum": [
+                  "known",
+                  "unknown"
+                ]
+              },
+              "dependent_slice_refs": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "minItems": 0,
+                "uniqueItems": true
+              },
+              "evidence_refs": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "minItems": 0,
+                "uniqueItems": true
+              },
+              "frontend_case_refs": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "minItems": 0,
+                "uniqueItems": true
+              }
+            }
+          },
+          "minItems": 1,
+          "uniqueItems": true
+        }
+      },
+      "required": [
+        "import_receipt_ref",
+        "bundle_digest",
+        "context_reconciliation_ref",
+        "rows"
+      ]
+    },
+    "frontend_cases": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "case_id": {
+            "type": "string",
+            "minLength": 1
+          },
+          "source_ids": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "minLength": 1
+            },
+            "minItems": 1,
+            "uniqueItems": true
+          },
+          "outcome": {
+            "enum": [
+              "success",
+              "failure"
+            ]
+          },
+          "operation_ids": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "minLength": 1
+            },
+            "minItems": 1,
+            "uniqueItems": true
+          },
+          "visual_case_ids": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "minLength": 1
+            },
+            "minItems": 1,
+            "uniqueItems": true
+          },
+          "evidence_ref": {
+            "type": "string",
+            "minLength": 1
+          },
+          "evidence_digest": {
+            "type": "string",
+            "pattern": "^sha256:[a-f0-9]{64}$"
+          }
+        },
+        "required": [
+          "case_id",
+          "source_ids",
+          "outcome",
+          "operation_ids",
+          "visual_case_ids",
+          "evidence_ref",
+          "evidence_digest"
+        ]
+      },
+      "minItems": 1,
+      "uniqueItems": true
+    }
+  },
+  "required": [
+    "schema_version",
+    "status",
+    "slice_id",
+    "backend_delivery",
+    "strategic_handoff",
+    "frontend_cases"
+  ]
+}

package/template/docs/process/schemas/frontend-delivery-acceptance.schema.json

@@ -4,7 +4,7 @@
   "additionalProperties": false,
   "properties": {
     "schema_version": {
-      "const": 1
+      "const": 2
     },
     "status": {
       "const": "accepted"
@@ -31,6 +31,27 @@
         "bundle_digest"
       ]
     },
+    "strategic_preflight": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["ref", "digest"],
+      "properties": {
+        "ref": {"type": "string", "minLength": 1},
+        "digest": {"type": "string", "pattern": "^sha256:[0-9a-f]{64}$"}
+      }
+    },
+    "backend_dependency": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["mode", "route_id"],
+      "properties": {
+        "mode": {"enum": ["required", "not-applicable"]},
+        "route_id": {"const": "route.backend"},
+        "impact_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}},
+        "reason": {"type": "string", "minLength": 1},
+        "evidence_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}}
+      }
+    },
     "strategic_handoff": {
       "type": "object",
       "additionalProperties": false,
@@ -43,6 +64,10 @@
           "type": "string",
           "pattern": "^sha256:[0-9a-f]{64}$"
         },
+        "route_id": {
+          "type": "string",
+          "pattern": "^route\\.[a-z0-9][a-z0-9-]*$"
+        },
         "context_reconciliation_ref": {
           "type": "string",
           "minLength": 1
@@ -119,6 +144,7 @@
       "required": [
         "import_receipt_ref",
         "bundle_digest",
+        "route_id",
         "context_reconciliation_ref",
         "rows"
       ]
@@ -154,7 +180,7 @@
               "type": "string",
               "minLength": 1
             },
-            "minItems": 1,
+            "minItems": 0,
             "uniqueItems": true
           },
           "visual_case_ids": {
@@ -193,8 +219,16 @@
     "schema_version",
     "status",
     "slice_id",
-    "backend_delivery",
+    "strategic_preflight",
+    "backend_dependency",
     "strategic_handoff",
     "frontend_cases"
+  ],
+  "allOf": [
+    {
+      "if": {"properties": {"backend_dependency": {"properties": {"mode": {"const": "required"}}}}, "required": ["backend_dependency"]},
+      "then": {"required": ["backend_delivery"]},
+      "else": {"properties": {"backend_dependency": {"required": ["reason", "impact_refs", "evidence_refs"]}}}
+    }
   ]
 }

package/template/docs/process/schemas/frontend-strategic-preflight.schema.json

@@ -0,0 +1,32 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://yss.local/schemas/frontend-strategic-preflight-v1.json",
+  "title": "YSS Frontend Strategic Preflight v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "status", "route_id", "capability", "import_receipt_ref", "bundle_digest", "context_reconciliation_ref", "visual_baseline_ref", "source_rule_refs", "backend_dependency", "ready_for_agent"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "status": {"enum": ["draft", "verified", "blocked", "stale"]},
+    "route_id": {"type": "string", "pattern": "^route\\.[a-z0-9][a-z0-9-]*$"},
+    "capability": {"const": "frontend-engineering-design"},
+    "import_receipt_ref": {"type": "string", "minLength": 1},
+    "bundle_digest": {"type": "string", "pattern": "^sha256:[a-f0-9]{64}$"},
+    "context_reconciliation_ref": {"type": "string"},
+    "visual_baseline_ref": {"type": "string", "minLength": 1},
+    "source_rule_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "pattern": "^(rule|scenario|invariant)\\.[a-z0-9][a-z0-9-]*$"}},
+    "backend_dependency": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["mode", "route_id"],
+      "properties": {
+        "mode": {"enum": ["required", "not-applicable"]},
+        "route_id": {"const": "route.backend"},
+        "reason": {"type": "string", "minLength": 1},
+        "impact_refs": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}},
+        "evidence_refs": {"type": "array", "uniqueItems": true, "items": {"type": "string", "minLength": 1}}
+      }
+    },
+    "ready_for_agent": {"const": false}
+  }
+}

package/template/docs/process/schemas/lifecycle-checkpoint.schema.json

@@ -221,7 +221,8 @@
       "type": "object"
     },
     "ticket_sync": {
-      "type": "object"
+      "type": "object",
+      "description": "Ticket 仅保存追踪同步状态；refs 关联消费者 Import Receipt、Consumer Feedback、Feedback Adjudication 与 Delivery Acceptance 等权威资产，不复制其机器状态。"
     },
     "verification": {
       "type": "object"

package/template/docs/process/schemas/strategic-consumer-feedback.schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://yss.local/schemas/strategic-consumer-feedback-v1.json",
+  "title": "YSS Strategic Consumer Feedback v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "feedback_id", "status", "import_receipt_ref", "bundle", "route_id", "source", "issue_type", "severity", "suggestion", "raised_by", "evidence_refs", "created_at"],
+  "properties": {
+    "schema_version": {"const": 1},
+    "feedback_id": {"type": "string", "pattern": "^consumer-feedback\\.[a-z0-9][a-z0-9-]*$"},
+    "status": {"const": "submitted"},
+    "import_receipt_ref": {"type": "string", "minLength": 1},
+    "bundle": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "version", "digest"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^strategic-design-handoff\\.[a-z0-9][a-z0-9-]*$"},
+        "version": {"type": "string", "pattern": "^v[1-9][0-9]*$"},
+        "digest": {"type": "string", "pattern": "^sha256:[a-f0-9]{64}$"}
+      }
+    },
+    "route_id": {"type": "string", "pattern": "^route\\.[a-z0-9][a-z0-9-]*$"},
+    "source": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "digest"],
+      "properties": {
+        "id": {"type": "string", "pattern": "^(rule|scenario|invariant)\\.[a-z0-9][a-z0-9-]*$"},
+        "digest": {"type": "string", "pattern": "^sha256:[a-f0-9]{64}$"}
+      }
+    },
+    "issue_type": {"enum": ["rule-conflict", "scenario-gap", "impact-mismatch", "context-conflict", "design-baseline", "other"]},
+    "severity": {"enum": ["blocking", "non-blocking"]},
+    "suggestion": {"type": "string", "minLength": 1},
+    "raised_by": {"type": "string", "minLength": 1},
+    "evidence_refs": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "minLength": 1}},
+    "created_at": {"type": "string", "format": "date-time"}
+  }
+}