create-yss-spec 3.0.1 → 3.1.3

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

@@ -1,68 +1,146 @@
 #!/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";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { tmpdir } from "node:os";
+import { parseDocument } from "../../../../scripts/vendor/yaml.mjs";
 
-const root = dirname(fileURLToPath(import.meta.url));
-const validator = join(root, "..", "scripts", "validate-domain-strategy.mjs");
-const packageValidator = join(root, "..", "scripts", "validate-stage-decision-package.mjs");
-const valid = join(root, "fixtures", "valid-supplier-domain.yaml");
-const invalid = join(root, "fixtures", "invalid-direction.yaml");
-const validPackage = join(root, "fixtures", "valid-stage-decision-package.yaml");
-const invalidPackage = join(root, "fixtures", "invalid-stage-decision-blocker.yaml");
-const run = (file) => spawnSync(process.execPath, [validator, file], { encoding: "utf8" });
-const pass = run(valid);
-if (pass.status !== 0) throw new Error(`valid fixture should pass: ${pass.stderr}`);
-const fail = run(invalid);
-if (fail.status === 0 || !fail.stderr.includes("direction_explanation")) throw new Error("invalid direction fixture should be blocked");
-const packagePass = spawnSync(process.execPath, [packageValidator, validPackage], { encoding: "utf8" });
-if (packagePass.status !== 0) throw new Error(`valid stage decision package should pass: ${packagePass.stderr}`);
-const packageFail = spawnSync(process.execPath, [packageValidator, invalidPackage], { encoding: "utf8" });
-if (packageFail.status === 0 || !packageFail.stderr.includes("blocker")) throw new Error("blocker package should be blocked");
-
-const temporaryRoot = await mkdtemp(join(tmpdir(), "yss-stage-decision-pressure-"));
+const testsRoot = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(testsRoot, "../../../..");
+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 validTemplate = join(testsRoot, "fixtures", "valid-supplier-domain.yaml");
+const validPackageTemplate = join(testsRoot, "fixtures", "valid-stage-decision-package.yaml");
+
+function canonical(value) {
+  if (Array.isArray(value)) return value.map(canonical);
+  if (value && typeof value === "object") return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonical(value[key])]));
+  return value;
+}
+
+function digestYaml(source) {
+  const document = parseDocument(source, { maxAliasCount: 0, uniqueKeys: true });
+  if (document.errors.length) throw new Error(document.errors[0].message);
+  return `sha256:${createHash("sha256").update(JSON.stringify(canonical(document.toJS({ maxAliasCount: 0 })))).digest("hex")}`;
+}
+
+function run(command, file, contextRoot) {
+  return spawnSync(process.execPath, [command, file, "--root", contextRoot], { cwd: projectRoot, encoding: "utf8" });
+}
+
+function expectBlocked(result, pattern, label) {
+  if (result.status === 0 || !pattern.test(`${result.stdout}\n${result.stderr}`)) throw new Error(`${label} should be blocked: ${result.stderr}`);
+}
+
+const contextSource = `---
+context_schema_version: 1
+---
+# 领域上下文
+
+## 流程术语
+
+| 术语 | 含义 | 英文标识 | 避免 / 备注 |
+|---|---|---|---|
+| Spec | 产品研发规格。 | — |  |
+
+## 业务术语
+
+| 术语 | 含义 | 英文标识 | 适用业务责任区 | 避免 / 备注 |
+|---|---|---|---|---|
+| 供应商 | 提供商品或服务的业务主体。 | Supplier | Global | 避免：\`厂商\` |
+| 准入决定 | 合规审查形成的准入结论。 | AdmissionDecision | ComplianceReview | 避免：\`审批结果\` |
+`;
+
+const temporaryRoot = await mkdtemp(join(tmpdir(), "yss-stage-decision-v2-"));
 try {
-  const validSource = await readFile(valid, "utf8");
+  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: "gate.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}`);
+
+  const legacyFile = join(temporaryRoot, "legacy-domain.yaml");
+  await writeFile(legacyFile, domainSource.replace("schema_version: 2", "schema_version: 1"));
+  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:");
+  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}`);
+  const migratedValue = JSON.parse(migrated.stdout);
+  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"));
+  const ambiguousMigration = spawnSync(process.execPath, [migrationTool, ambiguousLegacy, "--root", temporaryRoot], { cwd: projectRoot, encoding: "utf8" });
+  expectBlocked(ambiguousMigration, /migration-required.*无法唯一定位|无法唯一定位.*migration-required/, "ambiguous legacy reference");
+
+  const wrongPath = join(temporaryRoot, "wrong-context-path.yaml");
+  await writeFile(wrongPath, domainSource.replace("context_ref: CONTEXT.md", "context_ref: contexts/ComplianceReview/CONTEXT.md"));
+  expectBlocked(run(validator, wrongPath, temporaryRoot), /context_ref.*CONTEXT\.md/, "nested context path");
+
+  const staleContext = join(temporaryRoot, "stale-context.yaml");
+  await writeFile(staleContext, domainSource.replace(context.document_digest, "sha256:stale"));
+  expectBlocked(run(validator, staleContext, temporaryRoot), /document_digest/, "stale context digest");
+
+  const invalidDirection = join(temporaryRoot, "invalid-direction.yaml");
+  await writeFile(invalidDirection, domainSource.replace("direction_explanation: 申请资料由", "direction_explanation: \n    ignored: 申请资料由"));
+  expectBlocked(run(validator, invalidDirection, temporaryRoot), /direction_explanation/, "missing direction explanation");
+
   const sharedKernel = join(temporaryRoot, "shared-kernel.yaml");
-  await writeFile(sharedKernel, validSource.replace("relationship_pattern: Customer/Supplier", "relationship_pattern: Shared Kernel"));
-  const sharedKernelResult = run(sharedKernel);
-  if (sharedKernelResult.status === 0 || !sharedKernelResult.stderr.includes("shared_kernel_approval_ref")) throw new Error("unapproved Shared Kernel should be blocked");
+  await writeFile(sharedKernel, domainSource.replace("relationship_pattern: Customer/Supplier", "relationship_pattern: Shared Kernel"));
+  expectBlocked(run(validator, sharedKernel, temporaryRoot), /shared_kernel_approval_ref/, "unapproved Shared Kernel");
+
   const unknownContext = join(temporaryRoot, "unknown-context.yaml");
-  await writeFile(unknownContext, validSource.replace("to_context: ComplianceReview", "to_context: UnknownContext"));
-  const unknownContextResult = run(unknownContext);
-  if (unknownContextResult.status === 0 || !unknownContextResult.stderr.includes("未引用已声明上下文")) throw new Error("unknown context should be blocked");
-  const wrongArrayType = join(temporaryRoot, "wrong-array-type.yaml");
-  await writeFile(wrongArrayType, validSource.replace("responsibilities: [供应商申请、资料生命周期]", "responsibilities: [42]"));
-  const wrongArrayTypeResult = run(wrongArrayType);
-  if (wrongArrayTypeResult.status === 0 || !wrongArrayTypeResult.stderr.includes("responsibilities[0]")) throw new Error("non-string array item should be blocked");
-  const missingSubdomainType = join(temporaryRoot, "missing-subdomain-type.yaml");
-  await writeFile(missingSubdomainType, validSource.replace("    subdomain_type: Supporting Subdomain\n", ""));
-  const missingSubdomainTypeResult = run(missingSubdomainType);
-  if (missingSubdomainTypeResult.status === 0 || !missingSubdomainTypeResult.stderr.includes("subdomain_type 缺失")) throw new Error("missing subdomain type should be blocked");
-  const wrongReferenceType = join(temporaryRoot, "wrong-reference-type.yaml");
-  await writeFile(wrongReferenceType, validSource.replace("terminology_refs: [contexts/SupplierManagement/CONTEXT.md, contexts/ComplianceReview/CONTEXT.md]", "terminology_refs: [42]"));
-  const wrongReferenceTypeResult = run(wrongReferenceType);
-  if (wrongReferenceTypeResult.status === 0 || !wrongReferenceTypeResult.stderr.includes("terminology_refs[0]")) throw new Error("non-string terminology reference should be blocked");
-  const emptyDomainCollections = join(temporaryRoot, "empty-domain-collections.yaml");
-  await writeFile(emptyDomainCollections, validSource.replace(/contexts:\n[\s\S]*?subdomains:/, "contexts: []\nsubdomains:").replace(/subdomains:\n[\s\S]*?relationships:/, "subdomains: []\nrelationships:").replace(/scenarios:\n[\s\S]*?concept_candidates:/, "scenarios: []\nconcept_candidates:"));
-  const emptyDomainCollectionsResult = run(emptyDomainCollections);
-  if (emptyDomainCollectionsResult.status === 0 || !emptyDomainCollectionsResult.stderr.includes("contexts 必须是至少 1 项的数组")) throw new Error("empty DDD collections should be blocked");
-  const wrongDomainApproval = join(temporaryRoot, "wrong-domain-approval.yaml");
-  await writeFile(wrongDomainApproval, validSource.replace("approval_ref: .agents/skills/yss-stage-decision/tests/fixtures/domain-strategy-approval.yaml", "approval_ref: docs/.scratch/does-not-exist.yaml"));
-  const wrongDomainApprovalResult = run(wrongDomainApproval);
-  if (wrongDomainApprovalResult.status === 0 || !wrongDomainApprovalResult.stderr.includes("approval.approval_ref")) throw new Error("unreadable domain approval ref should be blocked");
-  const packageSource = await readFile(validPackage, "utf8");
-  const packageWrongArrayType = join(temporaryRoot, "package-wrong-array-type.yaml");
-  await writeFile(packageWrongArrayType, packageSource.replace("target_users: [采购专员、合规专员]", "target_users: [42]"));
-  const packageWrongArrayTypeResult = spawnSync(process.execPath, [packageValidator, packageWrongArrayType], { encoding: "utf8" });
-  if (packageWrongArrayTypeResult.status === 0 || !packageWrongArrayTypeResult.stderr.includes("target_users[0]")) throw new Error("package non-string array item should be blocked");
-  const packageWrongApproval = join(temporaryRoot, "package-wrong-approval.yaml");
-  await writeFile(packageWrongApproval, packageSource.replace("approval_ref: .agents/skills/yss-stage-decision/tests/fixtures/stage-decision-approval.yaml", "approval_ref: docs/.scratch/does-not-exist.yaml"));
-  const packageWrongApprovalResult = spawnSync(process.execPath, [packageValidator, packageWrongApproval], { encoding: "utf8" });
-  if (packageWrongApprovalResult.status === 0 || !packageWrongApprovalResult.stderr.includes("approval_ref")) throw new Error("unreadable approval ref should be blocked");
+  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: "gate.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}`);
+
+  const packageLegacy = join(temporaryRoot, "legacy-stage-decision.yaml");
+  await writeFile(packageLegacy, packageSource.replace("schema_version: 2", "schema_version: 1"));
+  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"));
+  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]"));
+  expectBlocked(run(packageValidator, packageWrongArray, temporaryRoot), /target_users\[0\]/, "package non-string array item");
 } finally {
   await rm(temporaryRoot, { recursive: true, force: true });
 }
-process.stdout.write("DDD strategic design scenarios passed\n");
+process.stdout.write("业务边界与规则设计 v2 场景验证通过\n");

package/template/.agents/skills/yss-tactical-design/SKILL.md

@@ -10,7 +10,7 @@ description: 在 YSS 技术分析阶段将批准的战略领域输入细化为
 ## 适用边界
 
 - 由 `yss-product-lifecycle` 在 `work-unit.technical-analysis` 中按领域影响条件调度。
-- 输入必须是版本当前的 Spec、功能架构、战略 DDD、状态矩阵、OpenAPI Draft / Freeze、ADR 和工程约束。
+- 输入必须是版本当前的 Spec、功能架构、战略 DDD、状态矩阵、OpenAPI Draft / Freeze、ADR 和工程约束。若输入来自 Strategic Design Handoff，必须先用 `scripts/verify-strategic-context-import` 验证 schema v3 `source_context_snapshot` / `context_delta` 已对账到目标仓根 `CONTEXT.md`，Visual Baseline Bundle 可读取且 digest 当前，并且目标侧 `context_reconciliation` 有效；未完成时不得开始战术建模。
 - 默认将结果写入系统概要设计 / 数据架构中的 Tactical DDD Check；聚合、状态机、一致性或持久化映射复杂到无法清楚表达时，才升级为独立战术设计文档。
 - 没有聚合、状态、不变量、一致性或领域边界影响时返回 `not-applicable` 及原因，不生成空设计。
 
@@ -22,7 +22,7 @@ description: 在 YSS 技术分析阶段将批准的战略领域输入细化为
 
 ## 输出与状态
 
-输出结构化 tactical-design contract、验证结果、评审引用和影响标记。状态使用 `draft`、`ready-for-human`、`approved`、`blocked`、`stale`、`drift`、`new_impacts`。
+输出结构化 tactical-design contract、验证结果、评审引用和影响标记；来自 Strategic Design Handoff 时保留 `strategic_context_import_ref` 与 `context_reconciliation_ref`。状态使用 `draft`、`ready-for-human`、`approved`、`blocked`、`stale`、`drift`、`new_impacts`。
 
 当用户或当前技术分析 / 架构评审合同明确要求聚合关系、状态转换、调用链、数据流或 Before/After 图示时，追加使用 `archify`。图必须从当前 Spec、ADR、OpenAPI、Tactical Design Contract 和代码证据派生，保存成 `*.archify.json`、`*.html` 与 `*.receipt.json` 配对资产；它是审查证据，不是新的事实源或批准门禁。没有明确图示要求时，不把 `archify` 加入 `required_skills`。
 
@@ -33,3 +33,9 @@ description: 在 YSS 技术分析阶段将批准的战略领域输入细化为
 批准且版本当前的战术设计合同由 `Slice Implementation Contract` 引用，再由 `yss-domain` 使用 `behavior-tdd` 实现。`yss-domain` 不得静默重新定义聚合或不变量；发现新的 API、状态、数据或架构影响时必须返回 `new_impacts` / `drift` 并重新路由。
 
 合同、Schema、校验规则和示例见 `references/`；使用 `scripts/validate-tactical-design.mjs` 做只读验证。该 skill 不生成 Java、Repository、Controller、DTO、OpenAPI Freeze、实现 Ticket 或生产代码。
+
+## 战略交接快照包
+
+跨仓交接使用 `scripts/strategic-handoff export / verify / import`。正式导出前补齐源战略的稳定规则 ID、关键场景和当前批准绑定；源资产原字节冻结、包内路径通过清单解析。目标导入只产生快照和对账/承接草案，正式 reconciliation 通过后才能进入战术设计。流程与字段见 `docs/process/strategic-handoff-package.md`。
+
+战术合同必须绑定 `strategic_handoff` 导入收据、包摘要、正式目标对账及逐条承接 rows。来自导入包时禁止仅填 `upstream_current: true`。批准前执行 `scripts/verify-strategic-handoff-consumption --root <target> <tactical>`；存在受控延期时按切片执行 `--slice <slice-id>`，实际核验通过且合同批准后才可继续相关切片。最新源规则、关键场景或资产变化使依赖项 stale；未知依赖扩大阻断，业务冲突回交战略方。结果绑定当前包与战术摘要，不能复用旧输出宣布 ready-for-agent。

package/template/.agents/skills/yss-tactical-design/references/output-template.md

@@ -11,6 +11,9 @@ owner: ai
 |---|---|---|---|
 | Spec |  |  |  |
 | Strategic DDD |  |  |  |
+| Strategic Design Handoff v3 |  |  |  |
+| Visual Baseline Bundle v1 |  |  |  |
+| Strategic Context Import / Context Reconciliation |  |  |  |
 | 状态矩阵 |  |  |  |
 | OpenAPI / 无 API 影响记录 |  |  |  |
 

package/template/.agents/skills/yss-tactical-design/references/tactical-design-contract.md

@@ -2,7 +2,7 @@
 
 ## 输入
 
-必须引用批准且版本当前的 Spec、功能架构、战略 DDD、原型状态矩阵、OpenAPI Draft / Freeze（或无 API 影响记录）、ADR 和工程约束。所有引用都必须带版本或 digest；不可读或过期引用返回 `blocked` / `stale`。
+必须引用批准且版本当前的 Spec、功能架构、战略 DDD、原型状态矩阵、OpenAPI Draft / Freeze（或无 API 影响记录）、ADR 和工程约束。来自 Strategic Design Handoff 时，额外要求 v3 交接包、`strategic_context_import_ref` 和目标仓 `context_reconciliation_ref`；目标根 `CONTEXT.md` 未完成增量对账前返回 `blocked`。所有引用都必须带版本或 digest；不可读或过期引用返回 `blocked` / `stale`。
 
 ## 输出
 
@@ -39,3 +39,5 @@ evidence_refs: []
 5. OpenAPI schema 使用上下文公开语言，不泄漏内部聚合或持久化结构。
 6. 复杂跨聚合一致性、并发、幂等、事件补偿或持久化错位必须写明策略，必要时升级独立文档。
 7. 实现发现新影响时必须阻断并回到生命周期重新路由。
+
+跨仓快照消费另须 `strategic_handoff`；字段与实际命令以 `docs/process/strategic-handoff-package.md` 为准。

package/template/.agents/skills/yss-tactical-design/scripts/validate-tactical-design.mjs

@@ -3,6 +3,9 @@ import { readFile } from "node:fs/promises";
 import process from "node:process";
 import { parseDocument } from "../../../../scripts/vendor/yaml.mjs";
 
+import { parseArgs } from "node:util";
+import { verifyConsumption } from "../../../../scripts/lib/strategic-handoff-consumption.mjs";
+
 const required = [
   "schema_version", "tactical_design_id", "tactical_version", "status", "context_ref",
   "aggregate_catalog", "entity_catalog", "value_object_catalog", "behavior_catalog",
@@ -196,12 +199,17 @@ function validate(data) {
 }
 
 async function main() {
-  const file = process.argv[2];
+  const { values, positionals } = parseArgs({ allowPositionals: true, options: { root: { type: "string", default: process.cwd() }, slice: { type: "string" } } });
+  const file = positionals[0];
   if (!file) throw new Error("用法: validate-tactical-design.mjs <contract.yaml>");
   const source = await readFile(file, "utf8");
   const document = parseDocument(source, { maxAliasCount: 0, uniqueKeys: true });
   if (document.errors.length) throw new Error(`无法解析合同: ${document.errors[0].message}`);
-  const errors = validate(document.toJS({ maxAliasCount: 0 }));
+  const data = document.toJS({ maxAliasCount: 0 });
+  const errors = validate(data);
+  if (data.strategic_handoff || data.strategic_context_import_ref || data.upstream_impact?.source_kind === "strategic-handoff") {
+    try { const result = await verifyConsumption(data, { root: values.root, sliceRef: values.slice }); if (result.result !== "verified") errors.push(JSON.stringify(result)); } catch (error) { errors.push(error.message); }
+  }
   if (errors.length) {
     process.stderr.write(`${JSON.stringify({ result: "blocked", errors }, null, 2)}\n`);
     process.exitCode = 1;

package/template/.agents/skills/yss-ui/SKILL.md

@@ -22,6 +22,8 @@ description: Use when implementing or reviewing YSS Vue pages that combine YSS w
 
 ## 2. 执行前版本预检
 
+采用专职前端 profile 或显式 `frontend_delivery` 绑定时，先按 `docs/process/frontend-backend-delivery.md` 实际核验战略与后端联合交付。缺任一输入只能诊断和回交；输入通过后准备计划/合同，正式实现、生成和恢复仍须当前批准的 Slice Contract 冻结接收摘要。接口或部署版本漂移时重新接收，不复用旧成功输出。
+
 进入实现前从前端工程根目录执行：
 
 ```bash
@@ -30,7 +32,7 @@ pnpm why vue @yss-ui/components @yss-ui/hooks ant-design-vue vxe-table
 
 记录实际版本、lockfile、验证命令和环境阻塞。完整策略见 `references/antdv-compatibility.md`。
 
-产品设计使用的 Ant Design v6 视觉/token 语义，不等于 Vue 生产实现 API。生产代码必须使用项目安装的 Ant Design Vue 4.x API，禁止复制 React hook、props 或组件写法。`yss-antd-design` 与 `@ant-design/cli` 只用于相关 H2 React/AntD 原型；原型阶段不得调用本技能。只有进入前端实现计划、已批准切片的生产实现或实现还原验证后，才从目标 lockfile、类型、本地文档和既有用法取得真实组件事实。
+产品设计使用的 Antdv Next 或 Ant Design v6 视觉/token 语义，不等于 Vue 生产实现 API。生产代码必须使用项目安装的 Ant Design Vue 4.x API，禁止把原型 props、events、slots、hook 或组件写法当作生产合同。`yss-antdv-next-design` 只用于默认 H2 Vue 原型，`yss-antd-design` 只用于显式 React 兼容原型；原型阶段不得调用本技能。只有进入前端实现计划、已批准切片的生产实现或实现还原验证后，才从目标 lockfile、类型、本地文档和既有用法取得真实组件事实。
 
 ## 3. 组件选型门禁
 
@@ -54,7 +56,6 @@ pnpm why vue @yss-ui/components @yss-ui/hooks ant-design-vue vxe-table
 | 任务 | 必须路由 |
 |---|---|
 | 新建或改造完整业务页面 | `yss-ui-business-page-generation` |
-| 生命周期页面编排与旧触发词兼容 | `yss-page-module-development` |
 | 页面布局、组件和交互 | `yss-components` |
 | 请求、分页、参数、树数据映射 | `yss-hook` |
 | Formily schema、联动、校验、详情态 | `yss-formily` |

package/template/.agents/skills/yss-ui-business-page-generation/SKILL.md

@@ -27,7 +27,7 @@ description: 指导生成或改造 Vue3 YSS UI CRUD、列表、表单、详情
 - 编辑表格细节：`../yedit-table-usage/SKILL.md`
 - 树形细节：`../ytree-usage/SKILL.md`
 - 表单细节：`../yss-formily/SKILL.md`
-- 原型还原验收：`../prototype-page-acceptance/SKILL.md`
+- 前端还原验证：`../yss-ui/references/verification.md` 与当前 Slice 的 `frontend_implementation_plan` / `frontend_implementation_verification`
 - 主题 Token 与换肤：`../theme-token-usage/SKILL.md`
 - 文件导出下载：`../file-export-download/SKILL.md`
 - Orval 接口与错误处理：`../yss-api-integration/SKILL.md`
@@ -82,7 +82,7 @@ src/views/{module-name}/
 
 1. 读取本 skill 的三个 reference，并按上述文档检索顺序核对真实 API 与导出，禁止根据旧示例猜测。
 2. 读取 `theme-token-usage`，检查项目真实主题变量与运行时同步链路。
-3. 若有截图或旧项目路径，先按 `prototype-page-acceptance` 提取布局、按钮位置、表格高度、抽屉宽度、字段控件类型等验收项。
+3. 若有截图或旧项目路径，先读取已批准且 digest 当前的 Visual Baseline manifest 和 `frontend_implementation_plan`，按 `case_id` 提取布局、状态、交互、响应式与控件类型验收项；缺失或摘要漂移时返回 `blocked`，不得凭目录或截图猜测。
 4. 按需求类型加载细分 skill：列表读 `page-list-module` 和 `ytable-usage`；表单读 `yss-formily`；编辑表格读 `yedit-table-usage`；树读 `ytree-usage`；导出下载读 `file-export-download`。
 5. 先设计 `constant.ts`、`style.less` 和 hooks；独立类型或私有视图确有需要时再增加 `type.ts`/`components/`，最后写 `index.vue` 组合视图。
 6. 对 API 请求使用 Orval 真实生成类型和导出，在 hooks 内封装 loading、分页映射和失败后状态；错误 Toast 由 mutator 统一处理。
@@ -150,7 +150,7 @@ const openCreate = (): void => {
 - [ ] 主题色、状态色、中性色及交互态使用动态 Token；未依赖未同步变量的固定色 fallback。
 - [ ] 导出下载使用 `handleBlobResponse`，且 Blob 配置、响应头、loading 与错误链路已验证。
 - [ ] 已核对 Orval 真实导出，未使用 `if (res?.success)` 或重复错误 Toast。
-- [ ] 若有截图或旧项目参考，已逐项对照布局、按钮、表格高度、抽屉响应式和字段控件类型。
+- [ ] 若有截图或旧项目参考，已按 `case_id` 配对基准图、实现图、diff/mask 和差异解释，并记录交互、console warning、实际 `pnpm` 命令与退出码。
 
 ## 失败兜底策略
 

package/template/.agents/skills/yss-validation/SKILL.md

@@ -24,6 +24,7 @@ Read `references/source-index.md` as a path-hint index whenever the task depends
 3. For expression parsing, inspect `ExpressParserFactory` and concrete `ExpressParser` implementations before adding syntax.
 4. Register new parsers as Spring beans; `ExpressParserFactory` auto-registers available parser beans by `parserType().getType()`.
 5. Keep validation failures mapped to the service/API error contract used by the local project.
+6. 消费工程基线选择 javax/jakarta，不自行升级 Java/Boot。MVC 输入校验放在 server/client，业务不变量由 service/core 验证；不生成 DDD Domain。HTTP 失败形态由 server 的合同测试验证。
 
 ## Capability Split
 

package/template/.agents/skills/yss-web-controller/SKILL.md

@@ -5,6 +5,12 @@ description: Use when generating or refactoring YSS Web Adapter Controllers, req
 
 # yss-web-controller
 
+## 架构分流（先执行）
+
+读取当前合同的 architecture_identity 并与工程基线、仓库登记及 Manifest 核对；再且只读取 `references/profiles/<architecture_profile>.md`。支持的分支为 target-domain-model、layered-mvc-service、mvc-data-analysis-v1；成熟度以注册表为准，不能把 draft 称为受支持。MVC 不执行下文 DDD 专属规则，也不加载其旧分层 guide；组件、安全、批准合同、允许路径及执行证据规则仍共用。
+
+以下 Application / Domain Gateway / Infrastructure / Web module 叙述仅适用于 target-domain-model；MVC 的 service/core/repository/server/client 所有权由所选 Profile 引用定义。
+
 这是一个 Web 适配层生成型 skill。优先复用脚本 `scripts/generate_controller.mjs` 和模板，不手写重复 CRUD。
 
 ## 何时使用

package/template/.agents/skills/yss-web-controller/references/profiles/layered-mvc-service.md

@@ -0,0 +1,3 @@
+# layered-mvc-service
+
+先读仓库 `docs/agents/backend-architecture-profiles.md`。server 的 Controller 只调用 service；私有 DTO 在 server，已批准 published-client 的公开 DTO 在 client。server 持有 MapStruct WebConvertor、HTTP 校验与错误脱敏。不得从表结构反推 OpenAPI，不得直连 Repository。执行脚本前确认其接受当前 Profile；不接受时返回 blocked，禁止伪造 DDD Manifest 绕过。

package/template/.agents/skills/yss-web-controller/references/profiles/mvc-data-analysis-v1.md

@@ -0,0 +1,3 @@
+# mvc-data-analysis-v1
+
+遵守 `layered-mvc-service.md`，但用例接口位于 core，公开 DTO 位于 client。server 同时依赖 core 与 client 并持有转换；core 不得为了复用 HTTP DTO 而依赖 client。

package/template/.agents/skills/yss-web-controller/references/profiles/target-domain-model.md

@@ -0,0 +1,3 @@
+# target-domain-model
+
+完整执行规则见 `../web-adapter-layer-guide.md`。Web 位于 adapter/web，DTO 位于 Web；只调用稳定 Application 接口，通过 MapStruct 适配 wire 与内部模型。

package/template/.agents/skills/yss-web-controller/references/web-generation-contract.schema.json

@@ -43,10 +43,11 @@
     "module_name": { "$ref": "#/$defs/nonEmptyString" },
     "domain_segment": { "$ref": "#/$defs/nonEmptyString" },
     "application_service_package": { "$ref": "#/$defs/nonEmptyString" },
-    "architecture_profile": { "const": "target-domain-model" },
+    "architecture_profile": { "enum": ["target-domain-model", "layered-mvc-service", "mvc-data-analysis-v1"] },
+    "architecture_identity": { "type": "object", "description": "由 backend-architecture-identity.schema.json 和注册表校验，并与 Manifest 完全一致" },
     "platform_profile": { "enum": ["spring-boot-2.7-jdk8", "spring-boot-3-jdk17"] },
     "validation_namespace": { "enum": ["javax", "jakarta"] },
-    "dto_placement": { "const": "web" },
+    "dto_placement": { "enum": ["web", "server", "client"] },
     "dto_wire_profile_ref": { "$ref": "#/$defs/nonEmptyString" },
     "dto_wire_profile_digest": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
     "openapi_freeze_ref": { "$ref": "#/$defs/nonEmptyString" },

package/template/.agents/skills/yss-web-controller/scripts/generate_controller.mjs

@@ -6,6 +6,7 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { parseDocument } from "../../../../scripts/vendor/yaml.mjs";
+import { assertArchitectureAgreement, validateArchitectureIdentity } from "../../../../scripts/lib/backend-architecture.mjs";
 
 const TYPE_MAPPING = { bigint: "Long", int: "Integer", integer: "Integer", smallint: "Integer", tinyint: "Integer", number: "Long", numeric: "BigDecimal", decimal: "BigDecimal", float: "Float", double: "Double", real: "Float", varchar: "String", varchar2: "String", nvarchar2: "String", char: "String", nchar: "String", text: "String", clob: "String", nclob: "String", date: "LocalDateTime", datetime: "LocalDateTime", timestamp: "LocalDateTime", "timestamp with time zone": "LocalDateTime", boolean: "Boolean", bool: "Boolean", bit: "Boolean", json: "String", jsonb: "String", uuid: "String" };
 const PLATFORM_VALIDATION_NAMESPACES = {
@@ -131,9 +132,15 @@ async function validateContract(contract, args) {
   if (!Number.isInteger(contract.contract_version) || contract.contract_version < 1) throw new Error("web generation contract_version must be a positive integer");
   if (!["existing-project", "scaffold-v2"].includes(contract.integration_mode)) throw new Error("unsupported web generation integration_mode");
   if (!["allowed_write_paths", "expected_evidence_files", "verification_commands"].every((name) => Array.isArray(contract[name]) && contract[name].length)) throw new Error("web generation contract requires non-empty allowed_write_paths, expected_evidence_files, and verification_commands");
-  if (contract.architecture_profile !== "target-domain-model" || contract.dto_placement !== "web") throw new Error("web generation only supports target-domain-model with dto_placement=web");
+  const mvc = contract.architecture_profile !== "target-domain-model";
+  const applicationModule = { "target-domain-model": "application", "layered-mvc-service": "service", "mvc-data-analysis-v1": "core" }[contract.architecture_profile];
+  if (!applicationModule) throw new Error("unsupported architecture_profile");
+  const allowedDto = { "target-domain-model": ["web"], "layered-mvc-service": ["server", "client"], "mvc-data-analysis-v1": ["client"] }[contract.architecture_profile];
+  if (!allowedDto.includes(contract.dto_placement)) throw new Error("dto_placement does not match architecture_profile");
+  if (mvc) validateArchitectureIdentity(contract.architecture_identity);
   if (contract.base_package !== args["base-package"] || contract.module_name !== args["module-name"] || contract.domain_segment !== args["domain-segment"]) throw new Error("CLI generation identity does not match the approved web generation contract");
-  const applicationPackage = args["application-service-package"] || `${args["base-package"]}.application.service`;
+  const applicationPackage = args["application-service-package"] || `${args["base-package"]}.${applicationModule}.service`;
+  if (mvc && !applicationPackage.startsWith(`${args["base-package"]}.${applicationModule}.`)) throw new Error("MVC service interface must belong to its application module");
   if (contract.application_service_package !== applicationPackage) throw new Error("--application-service-package does not match the approved web generation contract");
   if (!(contract.platform_profile in PLATFORM_VALIDATION_NAMESPACES)) throw new Error("unsupported platform_profile in approved web generation contract");
   if (PLATFORM_VALIDATION_NAMESPACES[contract.platform_profile] !== contract.validation_namespace) throw new Error("platform_profile and validation_namespace are inconsistent");
@@ -142,7 +149,8 @@ async function validateContract(contract, args) {
   const implementationRoot = path.resolve(contract.implementation_project_root);
   if (contract.integration_mode === "existing-project") {
     if (args["scaffold-manifest-file"] || present(contract.scaffold_manifest_ref)) throw new Error("existing-project Web generation must not claim a scaffold manifest");
-    return { applicationPackage, implementationRoot };
+    if (mvc) throw new Error("existing MVC project requires explicit onboarding support; no automatic migration");
+    return { applicationPackage, implementationRoot, applicationModule };
   }
 
   if (!args["scaffold-manifest-file"] || !present(contract.scaffold_manifest_ref)) throw new Error("scaffold-v2 Web generation requires --scaffold-manifest-file and scaffold_manifest_ref");
@@ -150,18 +158,26 @@ async function validateContract(contract, args) {
   if (manifestPath !== path.resolve(contract.scaffold_manifest_ref)) throw new Error("--scaffold-manifest-file does not match the approved web generation contract");
   if (!await exists(manifestPath)) throw new Error(`scaffold manifest not found: ${manifestPath}`);
   const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-  if (manifest.schema_version !== 2) throw new Error("scaffold manifest must use schema_version=2");
+  if (![2, 3].includes(manifest.schema_version)) throw new Error("scaffold manifest must use historical schema_version=2 or current schema_version=3");
+  if (mvc && manifest.schema_version !== 3) throw new Error("MVC requires schema v3 scaffold identity");
+  if (manifest.architecture_identity || mvc) {
+    assertArchitectureAgreement(contract.architecture_identity, { manifest });
+    if (contract.architecture_identity.architecture_profile !== contract.architecture_profile) throw new Error("Web architecture profile differs from its identity");
+  } else if (manifest.schema_version === 3 && (manifest.architecture_family !== "domain-driven" || manifest.generator_skill !== "yss-ddd-scaffold-generator")) throw new Error("schema v3 scaffold manifest must bind the domain-driven generator for Web adapter generation");
   if (!["empty-scaffold-verified", "first-slice-verified"].includes(manifest.completion_level)) throw new Error("scaffold manifest must be empty-scaffold-verified before Web generation");
   const scaffoldRoot = path.dirname(path.dirname(manifestPath));
   if (implementationRoot !== scaffoldRoot) throw new Error("implementation_project_root does not match the scaffold manifest project root");
-  const expectedWebProject = path.join(scaffoldRoot, `${manifest.project_name}-adapter`, `${manifest.project_name}-web`);
+  const expectedWebProject = mvc ? path.join(scaffoldRoot, `${manifest.project_name}-server`) : path.join(scaffoldRoot, `${manifest.project_name}-adapter`, `${manifest.project_name}-web`);
   if (!args["web-project-dir"] || path.resolve(args["web-project-dir"]) !== expectedWebProject) throw new Error("--web-project-dir does not match the scaffold manifest project layout");
-  const profilePairs = [["architecture", "architecture_profile"], ["platform", "platform_profile"], ["validation_namespace", "validation_namespace"], ["dto_placement", "dto_placement"]];
+  const profilePairs = mvc ? [["platform", "platform_profile"], ["validation_namespace", "validation_namespace"]] : [["architecture", "architecture_profile"], ["platform", "platform_profile"], ["validation_namespace", "validation_namespace"], ["dto_placement", "dto_placement"]];
   for (const [manifestField, contractField] of profilePairs) {
     if (manifest.profiles?.[manifestField] !== contract[contractField]) throw new Error(`scaffold manifest ${manifestField} profile does not match the approved Web contract`);
   }
   if (manifest.base_package !== contract.base_package) throw new Error("scaffold manifest base_package does not match the approved Web contract");
-  return { applicationPackage, implementationRoot };
+  const dtoProject = contract.dto_placement === "client" ? path.join(scaffoldRoot, `${manifest.project_name}-client`) : expectedWebProject;
+  if (contract.dto_placement === "client" && !contract.architecture_identity.resolved_modules.includes("client")) throw new Error("client DTO requires approved client capability");
+  if (args["web-output-dir"] && path.resolve(args["web-output-dir"]) !== path.join(expectedWebProject, "src/main/java", packagePath(args["base-package"]))) throw new Error("web-output-dir must not override approved module ownership");
+  return { applicationPackage, implementationRoot, applicationModule, dtoProject };
 }
 
 export async function generate(args, logger = console) {
@@ -171,7 +187,7 @@ export async function generate(args, logger = console) {
   try { metadata = JSON.parse(await readFile(args["metadata-file"], "utf8")); } catch (error) { throw new Error(`Error reading metadata file: ${error.message}`); }
   let contract;
   try { contract = JSON.parse(await readFile(args["contract-file"], "utf8")); } catch (error) { throw new Error(`Error reading contract file: ${error.message}`); }
-  const { applicationPackage, implementationRoot } = await validateContract(contract, args);
+  const { applicationPackage, implementationRoot, applicationModule, dtoProject } = await validateContract(contract, args);
   const dto = await loadDtoWireProfile(contract, args);
   const tables = metadata.tables || [];
   if (!tables.length) { logger.warn("Warning: No tables found in metadata."); return []; }
@@ -183,16 +199,17 @@ export async function generate(args, logger = console) {
   const basePath = packagePath(args["base-package"]);
   const webBase = args["web-output-dir"] || (args["web-project-dir"] ? path.join(args["web-project-dir"], "src", "main", "java", basePath) : path.join(args["output-dir"], basePath));
   const webRoot = ensureSubdir(webBase, "rest");
+  const dtoRoot = dtoProject ? path.join(dtoProject, "src/main/java", basePath, "rest") : webRoot;
   const planned = [];
   const plan = (target, contents) => planned.push({ target, contents });
   for (const table of tables) {
     const domainClass = pascal(table.table_name); const domainVar = lowerCamel(table.table_name); const domainDesc = String(table.table_comment || domainClass).trim().replaceAll("\n", " ");
     const approvedFields = contract.fields[table.table_name];
     if (!approvedFields || ["create", "update", "query", "pagination", "response"].some((name) => !Array.isArray(approvedFields[name]))) throw new Error(`approved web field contract is missing create/update/query/pagination/response allowlists for table: ${table.table_name}`);
-    const context = { base_package: args["base-package"], module_name: args["module-name"], domain_class: domainClass, domain_var: domainVar, domain_desc: domainDesc, domain_url_path: kebab(table.table_name), domain_pkg_name: args["domain-segment"], author: args.author, dto_imports: [`import ${args["base-package"]}.rest.dto.request.${domainClass}CreateRequest;`, `import ${args["base-package"]}.rest.dto.request.${domainClass}UpdateRequest;`, `import ${args["base-package"]}.rest.dto.request.${domainClass}PageRequest;`, `import ${args["base-package"]}.rest.dto.response.${domainClass}Response;`].join("\n"), application_type_imports: [`import ${args["base-package"]}.application.command.${domainClass}CreateCommand;`, `import ${args["base-package"]}.application.command.${domainClass}UpdateCommand;`, `import ${args["base-package"]}.application.query.${domainClass}PageQuery;`, `import ${args["base-package"]}.application.result.${domainClass}Result;`].join("\n"), application_service_import: `import ${applicationPackage}.${domainClass}Service;`, web_convertor_import: `import ${args["base-package"]}.rest.convertor.${domainClass}WebConvertor;`, web_convertor_class: `${domainClass}WebConvertor`, application_service_field: `private final ${domainClass}Service ${domainVar}Service;`, query_call: `${domainVar}Service.page(webConvertor.toPageQuery(request))`, detail_call: `${domainVar}Service.detail(id)`, add_call: `${domainVar}Service.add(webConvertor.toCreateCommand(request))`, update_call: `${domainVar}Service.update(webConvertor.toUpdateCommand(request))`, delete_call: `${domainVar}Service.delete(id)`, response_class: `${domainClass}Response`, create_request_class: `${domainClass}CreateRequest`, update_request_class: `${domainClass}UpdateRequest`, page_request_class: `${domainClass}PageRequest`, validation_namespace: args["validation-namespace"], result_package: dto.resultPackage, page_result_type: dto.pageResultType, page_result_simple_name: simpleJavaName(dto.pageResultType), page_result_factory_method: dto.pageResultFactoryMethod, single_result_type: dto.singleResultType, single_result_simple_name: simpleJavaName(dto.singleResultType), single_result_factory_method: dto.singleResultFactoryMethod, command_dto_type: dto.commandDtoType, command_dto_simple_name: simpleJavaName(dto.commandDtoType), query_dto_type: dto.queryDtoType, query_dto_simple_name: simpleJavaName(dto.queryDtoType), page_result_factory_arguments: dto.pageResultFactoryArguments };
+    const context = { base_package: args["base-package"], module_name: args["module-name"], domain_class: domainClass, domain_var: domainVar, domain_desc: domainDesc, domain_url_path: kebab(table.table_name), domain_pkg_name: args["domain-segment"], author: args.author, dto_imports: [`import ${args["base-package"]}.rest.dto.request.${domainClass}CreateRequest;`, `import ${args["base-package"]}.rest.dto.request.${domainClass}UpdateRequest;`, `import ${args["base-package"]}.rest.dto.request.${domainClass}PageRequest;`, `import ${args["base-package"]}.rest.dto.response.${domainClass}Response;`].join("\n"), application_type_imports: [`import ${args["base-package"]}.${applicationModule}.command.${domainClass}CreateCommand;`, `import ${args["base-package"]}.${applicationModule}.command.${domainClass}UpdateCommand;`, `import ${args["base-package"]}.${applicationModule}.query.${domainClass}PageQuery;`, `import ${args["base-package"]}.${applicationModule}.result.${domainClass}Result;`].join("\n"), application_service_import: `import ${applicationPackage}.${domainClass}Service;`, web_convertor_import: `import ${args["base-package"]}.rest.convertor.${domainClass}WebConvertor;`, web_convertor_class: `${domainClass}WebConvertor`, application_service_field: `private final ${domainClass}Service ${domainVar}Service;`, query_call: `${domainVar}Service.page(webConvertor.toPageQuery(request))`, detail_call: `${domainVar}Service.detail(id)`, add_call: `${domainVar}Service.add(webConvertor.toCreateCommand(request))`, update_call: `${domainVar}Service.update(webConvertor.toUpdateCommand(request))`, delete_call: `${domainVar}Service.delete(id)`, response_class: `${domainClass}Response`, create_request_class: `${domainClass}CreateRequest`, update_request_class: `${domainClass}UpdateRequest`, page_request_class: `${domainClass}PageRequest`, validation_namespace: args["validation-namespace"], result_package: dto.resultPackage, page_result_type: dto.pageResultType, page_result_simple_name: simpleJavaName(dto.pageResultType), page_result_factory_method: dto.pageResultFactoryMethod, single_result_type: dto.singleResultType, single_result_simple_name: simpleJavaName(dto.singleResultType), single_result_factory_method: dto.singleResultFactoryMethod, command_dto_type: dto.commandDtoType, command_dto_simple_name: simpleJavaName(dto.commandDtoType), query_dto_type: dto.queryDtoType, query_dto_simple_name: simpleJavaName(dto.queryDtoType), page_result_factory_arguments: dto.pageResultFactoryArguments };
     plan(path.join(webRoot, `${domainClass}Controller.java`), render(templates["Controller.java.template"], context));
     plan(path.join(webRoot, "convertor", `${domainClass}WebConvertor.java`), render(templates["WebConvertor.java.template"], context));
-    for (const [templateName, target, declaration] of [["web/dto/Response.java.template", path.join(webRoot, "dto", "response", `${domainClass}Response.java`), fields(table.columns || [], approvedFields.response)], ["web/dto/CreateRequest.java.template", path.join(webRoot, "dto", "request", `${domainClass}CreateRequest.java`), fields(table.columns || [], approvedFields.create, { command: true })], ["web/dto/UpdateRequest.java.template", path.join(webRoot, "dto", "request", `${domainClass}UpdateRequest.java`), fields(table.columns || [], approvedFields.update, { command: true })], ["web/dto/PageRequest.java.template", path.join(webRoot, "dto", "request", `${domainClass}PageRequest.java`), fields(table.columns || [], approvedFields.query)]]) plan(target, render(templates[templateName], { ...context, field_declarations: declaration, pagination_field_declarations: paginationFields(approvedFields.pagination, dto.profile) }));
+    for (const [templateName, target, declaration] of [["web/dto/Response.java.template", path.join(dtoRoot, "dto", "response", `${domainClass}Response.java`), fields(table.columns || [], approvedFields.response)], ["web/dto/CreateRequest.java.template", path.join(dtoRoot, "dto", "request", `${domainClass}CreateRequest.java`), fields(table.columns || [], approvedFields.create, { command: true })], ["web/dto/UpdateRequest.java.template", path.join(dtoRoot, "dto", "request", `${domainClass}UpdateRequest.java`), fields(table.columns || [], approvedFields.update, { command: true })], ["web/dto/PageRequest.java.template", path.join(dtoRoot, "dto", "request", `${domainClass}PageRequest.java`), fields(table.columns || [], approvedFields.query)]]) plan(target, render(templates[templateName], { ...context, field_declarations: declaration, pagination_field_declarations: paginationFields(approvedFields.pagination, dto.profile) }));
   }
   const targets = planned.map(({ target }) => target);
   if (new Set(targets).size !== targets.length) throw new Error("approved metadata produces duplicate target files");

package/template/.agents/skills/yss-web-controller/scripts/generate_controller.test.mjs

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { createHash } from "node:crypto";
-import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, readFile, writeFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import test from "node:test";
@@ -11,6 +11,34 @@ const scripts = path.dirname(fileURLToPath(import.meta.url));
 const dtoWireProfileFile = path.resolve(scripts, "../../yss-dto/references/openapi-wire-profile.yaml");
 const dtoWireProfileDigest = createHash("sha256").update(await readFile(dtoWireProfileFile)).digest("hex");
 
+for (const [profile, module, placement, modules, generator] of [
+  ["layered-mvc-service", "service", "server", ["server", "service", "repository"], "yss-layered-mvc-scaffold-generator"],
+  ["mvc-data-analysis-v1", "core", "client", ["server", "core", "client", "repository", "adapter", "feign-client"], "yss-mvc-data-analysis-project-initializer"]
+]) test(`${profile} binds MVC service types, DTO ownership and drift checks`, async (t) => {
+  const data = await fixture({ platform_profile: "spring-boot-2.7-jdk8", validation_namespace: "javax" });
+  t.after(() => rm(data.root, { recursive: true, force: true }));
+  const identity = { architecture_family: "layered-mvc", architecture_profile: profile, generator_skill: generator, requested_capabilities: [], resolved_modules: modules, contract_digest: "a".repeat(64), verification_database: "h2", production_database: "not-bound" };
+  const project = path.join(data.root, "demo-service");
+  const manifestFile = path.join(project, ".yss/scaffold-generation.json");
+  const manifest = { schema_version: 3, project_name: "demo-service", base_package: "com.yss.demo", completion_level: "empty-scaffold-verified", architecture_identity: identity, profiles: { platform: "spring-boot-2.7-jdk8", validation_namespace: "javax" } };
+  await mkdir(path.dirname(manifestFile), { recursive: true });
+  await writeFile(manifestFile, JSON.stringify(manifest));
+  const contract = webContract(project, { architecture_profile: profile, architecture_identity: identity, dto_placement: placement, integration_mode: "scaffold-v2", scaffold_manifest_ref: manifestFile, platform_profile: "spring-boot-2.7-jdk8", validation_namespace: "javax", application_service_package: `com.yss.demo.${module}.service` });
+  await writeFile(data.contract, JSON.stringify(contract));
+  const args = parseArgs([...data.args.map((x) => x === "com.yss.demo.application.service" ? `com.yss.demo.${module}.service` : x), "--scaffold-manifest-file", manifestFile, "--web-project-dir", path.join(project, "demo-service-server")]);
+  manifest.architecture_identity = { ...identity, contract_digest: "b".repeat(64) };
+  await writeFile(manifestFile, JSON.stringify(manifest));
+  await assert.rejects(() => generate(args), /stale/);
+  manifest.architecture_identity = identity;
+  await writeFile(manifestFile, JSON.stringify(manifest));
+  const files = await generate(args, { log() {}, warn() {} });
+  assert.equal(files.length, 6);
+  const convertor = await readFile(path.join(project, "demo-service-server/src/main/java/com/yss/demo/rest/convertor/QualityRuleWebConvertor.java"), "utf8");
+  assert.match(convertor, new RegExp(`com\\.yss\\.demo\\.${module}\\.command`));
+  assert.doesNotMatch(convertor, /\.application\.|\.domain\.|Gateway/);
+  await readFile(path.join(project, `demo-service-${placement}/src/main/java/com/yss/demo/rest/dto/request/QualityRuleCreateRequest.java`));
+});
+
 const metadataValue = {
   tables: [{
     table_name: "quality_rule",

package/template/.claude/skills/alibaba-java-code-style/SKILL.md

@@ -20,6 +20,7 @@ This skill distills the provided `阿里巴巴 Java 开发手册` 1.4.0 PDF into
 
 ## Core Priorities
 
+- 先消费 architecture_identity 与工程 Java/数据库基线。MVC 分层按 `docs/agents/backend-architecture-profiles.md`；MySQL 专属方言规则仅对批准的 MySQL 存储生效，不能要求 H2 骨架引入 MySQL 驱动。YSS 包装、命名及处理器差异逐项记录基线例外，安全、权限、敏感信息与 SQL 参数绑定不得豁免。
 - Keep names readable, English, and consistent with Java layer conventions.
 - Avoid null, equality, wrapper comparison, collection, and concurrency traps that compile cleanly but fail at runtime.
 - Make logs useful without wasting CPU, disk, or alert budget.

package/template/.claude/skills/code-review/references/yss-review-standards.md

@@ -12,7 +12,7 @@
 2. Slice Implementation Contract 的 `required_skills`：对每个技能读取 `.agents/skills/<id>/SKILL.md` 及该 skill 指明的 references。
 3. 影响面专项检查输入（与合同并集，不得互相替代）：
    - 后端：`alibaba-java-code-style`、`yss-domain`、`yss-application`、`yss-repository`、`yss-web-controller`、`yss-dto`、`mapstruct`、`lombok`
-   - UI：`yss-ui`、`yss-design-system`、`yss-ui-business-page-generation`、`yss-page-module-development`
+   - UI：`yss-ui`、`yss-design-system`、`yss-ui-business-page-generation`
 4. 报告模板中的后端 / 前端门禁表。空着的适用行视为 `missing_evidence`。
 
 YSS 页面模块约定（YTable、YFormily、页面骨架等）走 Standards，不并入 UI fidelity。UI fidelity 只核原型与状态矩阵。