create-yss-spec 3.3.1 → 3.3.3

package/template/.claude/skills/yss-ddd-scaffold-generator/references/USAGE_EXAMPLES.md

@@ -1,134 +0,0 @@
-# 使用示例
-
-## 1. 准备批准合同
-
-新合同是服务级工程基线，使用 schema v3 与 `scaffold_request_id`，并把已批准的架构决策、Java 包名、Maven 坐标和 Profile 分开登记：
-
-```json
-{
-  "schema_version": 3,
-  "scaffold_request_id": "scaffold-metadata-service-1",
-  "project_name": "metadata-service",
-  "target_output_dir": "/path/to/implementation-repo",
-  "base_package": "com.yss.metadata",
-  "architecture_family": "domain-driven",
-  "generator_skill": "yss-ddd-scaffold-generator",
-  "decision_ref": "scaffold-architecture-decisions.yaml",
-  "decision_id": "architecture-metadata-service",
-  "decision_digest": "sha256:<digest>",
-  "maven_coordinates": {
-    "group_id": "com.yss.datamiddle",
-    "project_version": "1.0.0-SNAPSHOT",
-    "parent": {
-      "group_id": "com.yss.datamiddle",
-      "artifact_id": "yss-datamiddle-parent",
-      "version": "2.0.0-SNAPSHOT"
-    },
-    "yss_components_version": "2.0.0-SNAPSHOT"
-  },
-  "profiles": {
-    "architecture": "target-domain-model",
-    "persistence": "mybatis-plus",
-    "database": "mysql",
-    "platform": "spring-boot-2.7-jdk8",
-    "validation_namespace": "javax",
-    "dto_placement": "web",
-    "repository": "yss-internal"
-  },
-  "module_profile": {
-    "resolution_version": 1,
-    "requested_capabilities": [],
-    "resolved_modules": ["domain", "application", "infrastructure", "adapter", "bootstrap"]
-  },
-  "generation_policy": {
-    "mode": "initialize-only",
-    "existing_target": "unsupported",
-    "old_project_migration": "unsupported",
-    "template_upgrade": "unsupported"
-  }
-}
-```
-
-以上只是关键片段；实际合同还必须满足 `yss-implementation-contract-compiler/references/compiler-contract.yaml` 中的完整 `scaffold_contract_schema`，引用经用户确认并由生命周期批准的 `scaffold-architecture-decisions.yaml`，再持久化为当前版本。历史 schema v2 仅用于验证器只读兼容；新生成拒绝 schema v1/v2 且不自动升级。
-
-## 2. 一键生成并验证
-
-```bash
-node .agents/skills/yss-ddd-scaffold-generator/scripts/generate_and_verify_scaffold.mjs \
-  --project-name metadata-service \
-  --base-package com.yss.metadata \
-  --group-id com.yss.datamiddle \
-  --project-version 1.0.0-SNAPSHOT \
-  --parent-group-id com.yss.datamiddle \
-  --parent-artifact-id yss-datamiddle-parent \
-  --parent-version 2.0.0-SNAPSHOT \
-  --yss-components-version 2.0.0-SNAPSHOT \
-  --output-dir /path/to/implementation-repo \
-  --contract-id <approved-scaffold-contract-id> \
-  --contract-version <current-version> \
-  --approval-ref <lifecycle-approval-ref> \
-  --compiler-draft-ref <compiler-draft-ref> \
-  --persisted-ref <persisted-contract-ref> \
-  --contract-file /path/to/persisted-scaffold-contract.json \
-  --evidence-dir /path/to/evidence/scaffold
-```
-
-该入口依次生成工程并在项目根实际执行：
-
-```bash
-./mvnw validate
-./mvnw test
-./mvnw package
-```
-
-执行前必须由安全环境提供 `YSS_MAVEN_REPOSITORY_URL`、`MAVEN_REPO_USERNAME`、`MAVEN_REPO_PASSWORD`；模板不固化内部 URL 或凭据。只有三条命令全部返回 0，工作流才把 Manifest 从 `generated` 更新为 `empty-scaffold-verified`。任一步失败都返回非 0并保留证据：
-
-- `scaffold-generation.stdout.log` / `scaffold-generation.stderr.log`
-- `mvnw-validate.*.log`、`mvnw-test.*.log`、`mvnw-package.*.log`
-- `scaffold-verification.json`
-- `scaffold-workflow.json`
-
-验证报告的 `failure_category` 会区分内部仓库访问、项目模型、编译、启动入口、测试和打包失败。`preflight` 只记录凭据是否配置，不记录凭据值。
-
-## 3. 生成结果
-
-```text
-metadata-service/
-├── .mvn/
-├── .yss/scaffold-generation.json
-├── mvnw
-├── pom.xml
-├── metadata-service-domain/
-├── metadata-service-application/
-├── metadata-service-infrastructure/
-├── metadata-service-adapter/
-│   └── metadata-service-web/
-└── metadata-service-bootstrap/
-    └── src/main/java/com/yss/metadata/MetadataServiceApplication.java
-```
-
-生成器只提供工程结构、POM、项目级 Maven 配置、机械启动入口和通用测试依赖，不生成实体、表、Controller、业务 API 或示例 CRUD。
-
-## 4. 后续路由
-
-`empty-scaffold-verified` 不等于业务切片可实现。后续必须回到 `yss-implementation-contract-compiler`，消费批准且版本当前的 Slice Implementation Contract，再按影响面加载 `yss-domain`、`yss-application`、`yss-repository`、`yss-mybatis`、`yss-web-controller`、`yss-dto`、`yss-exception`、`yss-validation`、`mapstruct`、`lombok`、`alibaba-java-code-style` 等 skill，并使用 `behavior-tdd` 实现业务行为。
-
-完成 golden first slice 后，必须运行：
-
-```bash
-node .agents/skills/yss-ddd-scaffold-generator/scripts/run_first_slice_verification.mjs \
-  --project-root /path/to/implementation-repo/metadata-service \
-  --slice-contract-file /path/to/approved-slice-contract.json \
-  --evidence-dir /path/to/evidence/first-slice
-```
-
-只有该验证器确认合同、全层产物、skill tree digest 与根 Wrapper 全部通过，并更新 Manifest 后，才能标记 `first-slice-verified`。
-
-目标目录必须不存在。`--force`、旧项目迁移和当前模板升级均为 `unsupported`。旧项目继续按原工程维护；现代化改造必须单独立项、先评估再逐切片迁移。
-
-如需本地启动机械入口：
-
-```bash
-cd /path/to/implementation-repo/metadata-service
-./mvnw spring-boot:run -pl metadata-service-bootstrap
-```

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-adapter/SKILL.md

@@ -1,31 +0,0 @@
----
-name: yss-backend-scaffold-adapter
-description: Use when the YSS DDD scaffold workflow reaches Web, scheduler, or external-adapter implementation and needs the shared target-profile skills.
----
-
-# Adapter Layer Reference
-
-本文件只负责从脚手架路由到共享权威技能，不维护第二套 Adapter 规范。
-
-## Web Adapter
-
-**REQUIRED SUB-SKILL:** 使用 `yss-web-controller` 作为 Web Adapter 的唯一实现指南，并同时消费 `yss-dto`、`yss-exception`：
-
-- HTTP Request / Response DTO 默认位于 Web module。
-- Controller 只调用 Application Service，不直连 Domain Gateway 或 Infrastructure。
-- 映射链固定为 Web DTO → Spring MapStruct WebConvertor → Application Command / Query / Result → Domain。
-- HTTP/YSS wrapper/异常脱敏在 Web 边界完成；Domain 只表达领域错误语义。
-
-## Scheduler / External Adapter
-
-- Adapter 只做协议、调度器或外部系统适配，不承载领域规则。
-- 输入先转换为 Application Command / Query，再调用 Application Service。
-- 若实现 Application 或 Domain 声明的端口，端口签名不得泄漏 HTTP DTO、PO、Mapper、第三方 SDK 类型。
-- 具体持久化端口实现继续使用 `yss-repository`；不得把 Repository 规则复制到本文件。
-
-## 禁止事项
-
-- 禁止 Web Controller 直接注入 Domain Gateway。
-- 禁止 `client.dto`、VO、`PageQuery` 进入 Domain。
-- 禁止静态 `Mappers.getMapper(...)` / `INSTANCE`；MapStruct 必须 `componentModel = "spring"` 并构造器注入。
-- 禁止把旧式 Controller 示例当成 `target-domain-model` 的方案。旧架构对新脚手架一律 `unsupported`；旧项目继续在原工程维护，现代化改造必须单独立项。

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-adapter/agents/openai.yaml

@@ -1,5 +0,0 @@
-version: 1
-interface:
-  display_name: "YSS Scaffold Adapter"
-  short_description: "YSS 后端脚手架适配器层与接口接入设计落地标准规范"
-  default_prompt: "Use $yss-backend-scaffold-adapter to implement the adapter layer for a YSS backend scaffold module."

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-application/SKILL.md

@@ -1,8 +0,0 @@
----
-name: yss-application-layer-reference
-description: Use when the YSS DDD scaffold workflow reaches Application-layer implementation and needs the shared Application skill.
----
-
-# Application Layer Reference
-
-**REQUIRED SUB-SKILL:** Use `yss-application` as the single authoritative Application-layer implementation guide (`references/application-layer-guide.md`). Do not maintain a second copy under the scaffold generator.

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-application/agents/openai.yaml

@@ -1,5 +0,0 @@
-version: 1
-interface:
-  display_name: "YSS Scaffold Application"
-  short_description: "YSS 后端脚手架应用层、用例编排与 DTO 规范"
-  default_prompt: "Use $yss-application to implement the application layer for a YSS backend scaffold module."

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-domain/SKILL.md

@@ -1,8 +0,0 @@
----
-name: yss-domain-layer-reference
-description: Use when the YSS DDD scaffold workflow reaches Domain-layer implementation and needs the shared Domain skill.
----
-
-# Domain Layer Reference
-
-**REQUIRED SUB-SKILL:** Use `yss-domain` as the single authoritative Domain-layer implementation guide (`references/domain-layer-guide.md`). Do not maintain a second copy under the scaffold generator.

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-domain/agents/openai.yaml

@@ -1,5 +0,0 @@
-version: 1
-interface:
-  display_name: "YSS Scaffold Domain"
-  short_description: "YSS 后端脚手架领域层、聚合与规则建模实践落地规范"
-  default_prompt: "Use $yss-domain to implement the domain layer for a YSS backend scaffold module."

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-infrastructure/SKILL.md

@@ -1,8 +0,0 @@
----
-name: yss-infrastructure-layer-reference
-description: Use when the YSS DDD scaffold workflow reaches Infrastructure-layer implementation and needs the shared Repository skill.
----
-
-# Infrastructure Layer Reference
-
-**REQUIRED SUB-SKILL:** Use `yss-repository` as the single authoritative Infrastructure-layer implementation guide (`references/infrastructure-layer-guide.md`). Do not maintain a second copy under the scaffold generator.

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-infrastructure/agents/openai.yaml

@@ -1,5 +0,0 @@
-version: 1
-interface:
-  display_name: "YSS Scaffold Infrastructure"
-  short_description: "YSS 后端脚手架基础设施层与持久化实现设计落地规范"
-  default_prompt: "Use $yss-repository to implement the infrastructure layer for a YSS backend scaffold module."

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-parent/SKILL.md

@@ -1,58 +0,0 @@
----
-name: yss-backend-scaffold-parent
-description: YSS DDD scaffold Engineering Baseline entry for profile, module, dependency, build, and downstream-skill routing checks.
----
-
-# YSS DDD Scaffold Engineering Baseline
-
-本文件只定义脚手架工程基线和路由，不复制 Domain、Application、Repository、Web 的实现细则。
-
-## 当前可验证 Profile
-
-- Architecture: `target-domain-model`
-- Persistence: `mybatis-plus`
-- Database: `mysql`
-- Platform: `spring-boot-2.7-jdk8`
-- Validation namespace: `javax`
-- DTO placement: `web`
-- Repository: `yss-internal`
-
-未具备独立 fixture、受控合同和真实验证证据的组合统一为 `unsupported`。旧架构不存在可选 Profile，也不能作为回退。
-
-## 模块与依赖方向
-
-```text
-domain <- application <- web
-   ^            ^
-   |            |
-infrastructure-+
-        ^
-     bootstrap
-```
-
-- `domain`：纯 Java 领域模型、领域服务、领域事件、Domain Gateway；不得依赖 YSS DTO/Exception、Web Validation、Jackson、Swagger、MyBatis。
-- `application`：用例编排、Command / Query / Result、事务边界、Application Query Port；可以依赖 Domain 和必要的 YSS result wrapper。
-- `infrastructure`：实现 Domain Gateway / Application Query Port，拥有 PO、Mapper、持久化转换器；依赖 Domain 与 Application。
-- `adapter/web`：拥有 HTTP DTO、Controller、异常翻译、WebConvertor；只依赖 Application。
-- `bootstrap`：装配与启动，不放业务逻辑。
-
-依赖方向由 Maven Reactor、Maven Enforcer 与 ArchUnit 共同约束。MapStruct 统一使用 Spring component model，父 POM 配置 annotation processor、Lombok 与 `lombok-mapstruct-binding`。
-
-## 生成与验证
-
-- 输入是批准且持久化的服务级 scaffold contract schema v3，身份为 `scaffold_request_id`，并绑定已确认的 `architecture_family=domain-driven` 架构决策；不使用 `slice_id`。历史 Manifest v2 仅供验证器只读兼容。
-- 生成器严格 initialize-only：目标工程目录必须不存在，`--force`、旧项目迁移和当前模板升级均为 `unsupported`。
-- Maven 内部仓库通过命名 profile `yss-internal` 与环境变量注入；共享模板不写内部 URL 或凭据。
-- Wrapper 必须带 checksum；DEBUG 和 MyBatis stdout SQL 只允许在 `application-local.yml`。
-- `./mvnw validate`、`./mvnw test`、`./mvnw package` 全部成功只得到 `empty-scaffold-verified`。
-- 只有批准且版本当前的 golden first slice 真实组合 Domain/Application/Infrastructure/Web、通过下游 skill tree drift 校验与根 Wrapper，才能由 `run_first_slice_verification.mjs` 写入 `first-slice-verified`。
-
-## 下游权威技能
-
-- Domain：`yss-domain`
-- Application：`yss-application`
-- Persistence：`yss-repository` + `yss-mybatis`
-- Web：`yss-web-controller` + `yss-dto` + `yss-exception`
-- 横切实现约束：`yss-validation` + `mapstruct` + `lombok` + `alibaba-java-code-style`
-
-业务代码必须回到 `yss-implementation-contract-compiler`，消费批准且版本当前的 Slice Implementation Contract，并采用 `behavior-tdd`；脚手架只生成机械工程资产。

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-parent/agents/openai.yaml

@@ -1,5 +0,0 @@
-version: 1
-interface:
-  display_name: "YSS Scaffold Parent"
-  short_description: "YSS 后端脚手架父工程、依赖与公共约定实践落地规范"
-  default_prompt: "Use $yss-backend-scaffold-parent to set up the parent project and shared conventions for a YSS backend scaffold."

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-web/SKILL.md

@@ -1,8 +0,0 @@
----
-name: yss-web-layer-reference
-description: Use when the YSS DDD scaffold workflow reaches Web Adapter implementation and needs the shared Web Controller skill.
----
-
-# Web Adapter Layer Reference
-
-**REQUIRED SUB-SKILL:** Use `yss-web-controller` as the single authoritative Web-layer implementation guide (`references/web-adapter-layer-guide.md`). Do not maintain a second copy under the scaffold generator.

package/template/.claude/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-web/agents/openai.yaml

@@ -1,5 +0,0 @@
-version: 1
-interface:
-  display_name: "YSS Scaffold Web"
-  short_description: "YSS 后端脚手架 Web 层、DTO 与控制器规范"
-  default_prompt: "Use $yss-web-controller to implement the web adapter layer for a YSS backend scaffold module."

package/template/.claude/skills/yss-ddd-scaffold-generator/scripts/first-slice-compatibility.test.mjs

@@ -1,239 +0,0 @@
-import { attachScaffoldDecisionFixture } from "../../../../scripts/fixtures/user-decision/build-fixture.mjs";
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import test from "node:test";
-import { fileURLToPath } from "node:url";
-
-import { generate as generateWeb, parseArgs as parseWebArgs } from "../../yss-web-controller/scripts/generate_controller.mjs";
-import { runFirstSliceVerification } from "./run_first_slice_verification.mjs";
-
-const scripts = path.dirname(fileURLToPath(import.meta.url));
-const generator = path.join(scripts, "generate_scaffold.mjs");
-const dtoWireProfileFile = path.resolve(scripts, "../../yss-dto/references/openapi-wire-profile.yaml");
-const execute = (file, args, options = {}) => new Promise((resolve) => execFile(file, args, { encoding: "utf8", ...options }, (error, stdout, stderr) => resolve({ code: error?.code ?? 0, stdout, stderr })));
-
-function scaffoldContract(output, decisionDigest) {
-  return {
-    schema_version: 3,
-    contract_id: "golden-scaffold-1",
-    contract_version: 1,
-    scaffold_request_id: "golden-request-1",
-    status: "approved",
-    compiler_draft_ref: "compiler-golden-1",
-    lifecycle_approval_ref: "approval-golden-1",
-    persisted_ref: "persisted-golden-1",
-    current_version: 1,
-    implementation_repository: "external",
-    backend_repository: "external",
-    scaffold_status: "required",
-    project_name: "golden-service",
-    target_output_dir: output,
-    base_package: "com.yss.golden",
-    architecture_family: "domain-driven", architecture_profile: "target-domain-model",
-    generator_skill: "yss-ddd-scaffold-generator",
-    decision_ref: "scaffold-architecture-decisions.yaml",
-    decision_id: "scaffold-decision.golden-service",
-    decision_digest: decisionDigest,
-    maven_coordinates: { group_id: "com.yss.datamiddle", project_version: "1.0.0-SNAPSHOT", parent: { group_id: "com.yss.datamiddle", artifact_id: "yss-datamiddle-parent", version: "2.0.0-SNAPSHOT" }, yss_components_version: "2.0.0-SNAPSHOT" },
-    profiles: { architecture: "target-domain-model", persistence: "mybatis-plus", verification_database: "h2", production_database: "not-bound", platform: "spring-boot-2.7-jdk8", validation_namespace: "javax", dto_placement: "web", repository: "yss-internal" },
-    module_profile: { resolution_version: 1, requested_capabilities: [], resolved_modules: ["domain", "application", "infrastructure", "adapter", "bootstrap"] },
-    allowed_write_paths: ["."],
-    expected_evidence_files: [".yss/scaffold-generation.json"],
-    verification_commands: ["./mvnw validate", "./mvnw test", "./mvnw package"],
-    approval: { approval_ref: "approval-golden-1", approver: "maintainer", persisted_ref: "persisted-golden-1", current_version: 1 },
-    work_unit: { id: "golden-unit-1", behavior: "scaffold", primary_skill: "yss-ddd-scaffold-generator", supporting_skills: ["yss-implementation-contract-compiler"], tdd_mode: "controlled-generation", allowed_write_paths: ["."], expected_evidence: ["manifest"], verification_commands: ["./mvnw validate", "./mvnw test", "./mvnw package"], controlled_generation: true },
-    generation_policy: { mode: "initialize-only", existing_target: "unsupported", old_project_migration: "unsupported", template_upgrade: "unsupported" }
-  };
-}
-
-async function writeJava(project, relative, source) {
-  const target = path.join(project, relative);
-  await mkdir(path.dirname(target), { recursive: true });
-  await writeFile(target, `${source.trim()}\n`, "utf8");
-}
-
-async function prepareGoldenProject(t) {
-  const root = await mkdtemp(path.join(os.tmpdir(), "yss-golden-slice-"));
-  t.after(() => rm(root, { recursive: true, force: true }));
-  const output = path.join(root, "implementation");
-  await mkdir(output);
-  const decisionFile = path.join(root, "scaffold-architecture-decisions.yaml");
-  let decisionText = `${JSON.stringify({ schema_version: 1, kind: "scaffold-architecture-decisions", template: false, status: "current", decisions: [{ decision_id: "scaffold-decision.golden-service", project_id: "golden-service", parent_project_id: null, status: "lifecycle-approved", recommended_architecture: "domain-driven", recommendation_reasons: ["golden first slice 需要领域边界"], confirmed_architecture: "domain-driven", override_reason: null, inheritance_mode: "root-default", inherited_from: null, platform_profile: "spring-boot-2.7-jdk8", architecture_profile: "target-domain-model", verification_database: "h2", production_database: "not-bound", requested_capabilities: [], resolved_modules: ["domain", "application", "infrastructure", "adapter", "bootstrap"], resolution_version: 1, user_confirmation: { confirmed_by: "tester", channel: "test", confirmation_ref: "test://golden-confirmation", confirmed_at: "2026-09-05T00:00:00Z", normalized_text: "确认使用 DDD" }, decision_inputs_digest: `sha256:${"1".repeat(64)}` }] }, null, 2)}\n`;
-  const decisionSet = JSON.parse(decisionText);
-  decisionSet.decisions = decisionSet.decisions.map((decision) => attachScaffoldDecisionFixture(path.join(root, "user-decision"), decision));
-  decisionText = JSON.stringify(decisionSet, null, 2) + "\n";
-  await writeFile(decisionFile, decisionText);
-  const decisionDigest = `sha256:${createHash("sha256").update(decisionText).digest("hex")}`;
-  const contractFile = path.join(root, "scaffold-contract.json");
-  await writeFile(contractFile, `${JSON.stringify(scaffoldContract(output, decisionDigest), null, 2)}\n`);
-  const args = ["--project-name", "golden-service", "--base-package", "com.yss.golden", "--output-dir", output, "--contract-id", "golden-scaffold-1", "--contract-version", "1", "--approval-ref", "approval-golden-1", "--compiler-draft-ref", "compiler-golden-1", "--persisted-ref", "persisted-golden-1", "--contract-file", contractFile, "--group-id", "com.yss.datamiddle", "--project-version", "1.0.0-SNAPSHOT", "--parent-group-id", "com.yss.datamiddle", "--parent-artifact-id", "yss-datamiddle-parent", "--parent-version", "2.0.0-SNAPSHOT", "--yss-components-version", "2.0.0-SNAPSHOT"];
-  const generated = await execute(process.execPath, [generator, ...args]);
-  assert.equal(generated.code, 0, generated.stderr);
-  const project = path.join(output, "golden-service");
-  const manifestPath = path.join(project, ".yss", "scaffold-generation.json");
-  const emptyVerificationPath = path.join(root, "empty-scaffold-verification.json");
-  await writeFile(emptyVerificationPath, JSON.stringify({ status: "passed", completion_level: "empty-scaffold-verified", commands: ["./mvnw validate", "./mvnw test", "./mvnw package"] }));
-  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
-  manifest.completion_level = "empty-scaffold-verified";
-  manifest.empty_scaffold_verification_ref = emptyVerificationPath;
-  await writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
-  const java = "src/main/java/com/yss/golden";
-  const testJava = "src/test/java/com/yss/golden";
-  await writeJava(project, `golden-service-domain/${java}/domain/quality/model/QualityRule.java`, `package com.yss.golden.domain.quality.model;
-public final class QualityRule { private final Long id; private final String name; public QualityRule(Long id, String name) { if (name == null || name.trim().isEmpty()) throw new IllegalArgumentException("quality-rule-name-required"); this.id=id; this.name=name; } public Long getId(){return id;} public String getName(){return name;} }`);
-  await writeJava(project, `golden-service-domain/${java}/domain/quality/gateway/QualityRuleGateway.java`, `package com.yss.golden.domain.quality.gateway;
-  import com.yss.golden.domain.quality.model.QualityRule; import java.util.Optional; public interface QualityRuleGateway { Optional<QualityRule> findById(Long id); void save(QualityRule rule); void delete(Long id); }`);
-  await writeJava(project, `golden-service-domain/${testJava}/domain/quality/model/QualityRuleTest.java`, `package com.yss.golden.domain.quality.model;
-import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertThrows; class QualityRuleTest { @Test void rejectsBlankName(){ assertThrows(IllegalArgumentException.class, () -> new QualityRule(1L, " ")); } }`);
-  for (const [relative, source] of Object.entries({
-    [`golden-service-application/${java}/application/command/QualityRuleCreateCommand.java`]: `package com.yss.golden.application.command; public class QualityRuleCreateCommand { private String ruleName; public String getRuleName(){return ruleName;} public void setRuleName(String value){this.ruleName=value;} }`,
-    [`golden-service-application/${java}/application/command/QualityRuleUpdateCommand.java`]: `package com.yss.golden.application.command; public class QualityRuleUpdateCommand { private Long id; private String ruleName; public Long getId(){return id;} public void setId(Long value){this.id=value;} public String getRuleName(){return ruleName;} public void setRuleName(String value){this.ruleName=value;} }`,
-    [`golden-service-application/${java}/application/query/QualityRulePageQuery.java`]: `package com.yss.golden.application.query; public class QualityRulePageQuery { private int pageIndex; private int pageSize; private String ruleName; public int getPageIndex(){return pageIndex;} public void setPageIndex(int value){this.pageIndex=value;} public int getPageSize(){return pageSize;} public void setPageSize(int value){this.pageSize=value;} public String getRuleName(){return ruleName;} public void setRuleName(String value){this.ruleName=value;} }`,
-    [`golden-service-application/${java}/application/result/QualityRuleResult.java`]: `package com.yss.golden.application.result; import java.io.Serializable; public class QualityRuleResult implements Serializable { private Long id; private String ruleName; public Long getId(){return id;} public void setId(Long value){this.id=value;} public String getRuleName(){return ruleName;} public void setRuleName(String value){this.ruleName=value;} }`,
-    [`golden-service-application/${java}/application/port/QualityRuleQueryPort.java`]: `package com.yss.golden.application.port; import com.yss.cloud.dto.result.PageResult; import com.yss.golden.application.query.QualityRulePageQuery; import com.yss.golden.application.result.QualityRuleResult; public interface QualityRuleQueryPort { PageResult<QualityRuleResult> page(QualityRulePageQuery query); }`,
-    [`golden-service-application/${java}/application/service/QualityRuleService.java`]: `package com.yss.golden.application.service; import com.yss.cloud.dto.result.PageResult; import com.yss.golden.application.command.*; import com.yss.golden.application.query.QualityRulePageQuery; import com.yss.golden.application.result.QualityRuleResult; public interface QualityRuleService { PageResult<QualityRuleResult> page(QualityRulePageQuery query); QualityRuleResult detail(Long id); Long add(QualityRuleCreateCommand command); Boolean update(QualityRuleUpdateCommand command); Boolean delete(Long id); }`,
-    [`golden-service-application/${java}/application/service/impl/QualityRuleServiceImpl.java`]: `package com.yss.golden.application.service.impl;
-import com.yss.cloud.dto.result.PageResult; import com.yss.golden.application.command.*; import com.yss.golden.application.port.QualityRuleQueryPort; import com.yss.golden.application.query.QualityRulePageQuery; import com.yss.golden.application.result.QualityRuleResult; import com.yss.golden.application.service.QualityRuleService; import com.yss.golden.domain.quality.gateway.QualityRuleGateway; import com.yss.golden.domain.quality.model.QualityRule; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional;
-@Service public class QualityRuleServiceImpl implements QualityRuleService { private final QualityRuleGateway gateway; private final QualityRuleQueryPort queryPort; public QualityRuleServiceImpl(QualityRuleGateway gateway, QualityRuleQueryPort queryPort){this.gateway=gateway;this.queryPort=queryPort;} public PageResult<QualityRuleResult> page(QualityRulePageQuery query){return queryPort.page(query);} public QualityRuleResult detail(Long id){QualityRule rule=gateway.findById(id).orElseThrow(IllegalArgumentException::new); QualityRuleResult result=new QualityRuleResult(); result.setId(rule.getId()); result.setRuleName(rule.getName()); return result;} @Transactional public Long add(QualityRuleCreateCommand command){QualityRule rule=new QualityRule(null, command.getRuleName()); gateway.save(rule); return rule.getId();} @Transactional public Boolean update(QualityRuleUpdateCommand command){gateway.save(new QualityRule(command.getId(), command.getRuleName())); return true;} @Transactional public Boolean delete(Long id){gateway.delete(id); return true;} }`,
-    [`golden-service-application/${java}/application/error/QualityRuleConflictException.java`]: `package com.yss.golden.application.error; public final class QualityRuleConflictException extends RuntimeException { public QualityRuleConflictException(String message) { super(message); } }`,
-    [`golden-service-application/${java}/application/error/QualityRuleSystemException.java`]: `package com.yss.golden.application.error; public final class QualityRuleSystemException extends RuntimeException { public QualityRuleSystemException(String message, Throwable cause) { super(message, cause); } }`,
-    [`golden-service-infrastructure/${java}/infrastructure/persistence/po/QualityRulePO.java`]: `package com.yss.golden.infrastructure.persistence.po; public class QualityRulePO { private Long id; private String name; public Long getId(){return id;} public void setId(Long value){this.id=value;} public String getName(){return name;} public void setName(String value){this.name=value;} }`,
-    [`golden-service-infrastructure/${java}/infrastructure/persistence/convertor/QualityRulePersistenceConvertor.java`]: `package com.yss.golden.infrastructure.persistence.convertor; import com.yss.golden.domain.quality.model.QualityRule; import com.yss.golden.infrastructure.persistence.po.QualityRulePO; import org.mapstruct.Mapper; @Mapper(componentModel="spring") public interface QualityRulePersistenceConvertor { QualityRule toDomain(QualityRulePO source); QualityRulePO toPO(QualityRule source); }`,
-    [`golden-service-infrastructure/${java}/infrastructure/persistence/repository/QualityRuleRepository.java`]: `package com.yss.golden.infrastructure.persistence.repository; import com.yss.golden.infrastructure.persistence.po.QualityRulePO; import java.util.List; import org.apache.ibatis.annotations.*; @Mapper public interface QualityRuleRepository { @Select("select id, rule_name as name from quality_rule where id = #{id}") QualityRulePO selectById(Long id); @Select("select id, rule_name as name from quality_rule") List<QualityRulePO> selectAll(); @Insert("insert into quality_rule(rule_name) values(#{name})") int insert(QualityRulePO po); @Delete("delete from quality_rule where id = #{id}") int deleteById(Long id); }`,
-    [`golden-service-infrastructure/${java}/infrastructure/persistence/gateway/QualityRuleGatewayImpl.java`]: `package com.yss.golden.infrastructure.persistence.gateway; import com.yss.golden.domain.quality.gateway.QualityRuleGateway; import com.yss.golden.domain.quality.model.QualityRule; import com.yss.golden.infrastructure.persistence.convertor.QualityRulePersistenceConvertor; import com.yss.golden.infrastructure.persistence.repository.QualityRuleRepository; import java.util.Optional; import org.springframework.stereotype.Repository; @Repository public class QualityRuleGatewayImpl implements QualityRuleGateway { private final QualityRuleRepository repository; private final QualityRulePersistenceConvertor convertor; public QualityRuleGatewayImpl(QualityRuleRepository repository, QualityRulePersistenceConvertor convertor){this.repository=repository;this.convertor=convertor;} public Optional<QualityRule> findById(Long id){return Optional.ofNullable(repository.selectById(id)).map(convertor::toDomain);} public void save(QualityRule rule){repository.insert(convertor.toPO(rule));} public void delete(Long id){repository.deleteById(id);} }`,
-    [`golden-service-infrastructure/${java}/infrastructure/query/adapter/QualityRuleQueryAdapter.java`]: `package com.yss.golden.infrastructure.query.adapter; import com.yss.cloud.dto.result.PageResult; import com.yss.golden.application.port.QualityRuleQueryPort; import com.yss.golden.application.query.QualityRulePageQuery; import com.yss.golden.application.result.QualityRuleResult; import java.util.Collections; import org.springframework.stereotype.Repository; @Repository public class QualityRuleQueryAdapter implements QualityRuleQueryPort { public PageResult<QualityRuleResult> page(QualityRulePageQuery query){return PageResult.of(Collections.emptyList(), 0L, query.getPageSize(), query.getPageIndex());} }`
-  })) await writeJava(project, relative, source);
-  await writeJava(project, `golden-service-application/${testJava}/application/service/QualityRuleServiceTest.java`, `package com.yss.golden.application.service; import com.yss.golden.application.command.QualityRuleCreateCommand; import com.yss.golden.application.port.QualityRuleQueryPort; import com.yss.golden.application.service.impl.QualityRuleServiceImpl; import com.yss.golden.domain.quality.gateway.QualityRuleGateway; import org.junit.jupiter.api.Test; import static org.mockito.Mockito.*; class QualityRuleServiceTest { @Test void createPersistsThroughDomainGateway(){QualityRuleGateway gateway=mock(QualityRuleGateway.class); QualityRuleCreateCommand command=new QualityRuleCreateCommand(); command.setRuleName("rule"); new QualityRuleServiceImpl(gateway, mock(QualityRuleQueryPort.class)).add(command); verify(gateway).save(any());} }`);
-  await writeJava(project, `golden-service-infrastructure/${testJava}/infrastructure/persistence/QualityRuleGatewayIntegrationTest.java`, `package com.yss.golden.infrastructure.persistence; import com.yss.golden.infrastructure.persistence.convertor.QualityRulePersistenceConvertor; import com.yss.golden.infrastructure.persistence.po.QualityRulePO; import org.junit.jupiter.api.Test; import org.mapstruct.factory.Mappers; import static org.junit.jupiter.api.Assertions.assertEquals; class QualityRuleGatewayIntegrationTest { @Test void persistenceMappingRoundTrips(){QualityRulePO po=new QualityRulePO(); po.setId(1L); po.setName("rule"); assertEquals("rule", Mappers.getMapper(QualityRulePersistenceConvertor.class).toDomain(po).getName());} }`);
-  const metadata = path.join(root, "metadata.json");
-  const webContract = path.join(root, "web-contract.json");
-  const dtoWireProfileDigest = createHash("sha256").update(await readFile(dtoWireProfileFile)).digest("hex");
-  await writeFile(metadata, JSON.stringify({ tables: [{ table_name: "quality_rule", table_comment: "质量规则", columns: [{ name: "id", sql_type: "bigint", primary: true, nullable: false }, { name: "rule_name", sql_type: "varchar(64)", nullable: false }] }] }));
-  const webProject = path.join(project, "golden-service-adapter", "golden-service-web");
-  await writeFile(webContract, JSON.stringify({ architecture_identity: manifest.architecture_identity, schema_version: 2, contract_id: "golden-slice-1", contract_version: 1, current_version: 1, slice_id: "quality-rule-first-slice", status: "approved", integration_mode: "scaffold-v2", implementation_project_root: project, scaffold_manifest_ref: manifestPath, base_package: "com.yss.golden", module_name: "golden", domain_segment: "quality", application_service_package: "com.yss.golden.application.service", architecture_profile: "target-domain-model", platform_profile: "spring-boot-2.7-jdk8", validation_namespace: "javax", dto_placement: "web", dto_wire_profile_ref: dtoWireProfileFile, dto_wire_profile_digest: dtoWireProfileDigest, openapi_freeze_ref: "openapi://quality-rule@1", allowed_write_paths: [path.join(webProject, "src/main/java/com/yss/golden/rest")], expected_evidence_files: ["first-slice-verification.json"], verification_commands: ["./mvnw test", "./mvnw package"], fields: { quality_rule: { create: ["rule_name"], update: ["id", "rule_name"], query: ["rule_name"], pagination: ["pageIndex", "pageSize"], response: ["id", "rule_name"] } } }));
-  await generateWeb(parseWebArgs(["--metadata-file", metadata, "--contract-file", webContract, "--dto-wire-profile-file", dtoWireProfileFile, "--scaffold-manifest-file", manifestPath, "--base-package", "com.yss.golden", "--module-name", "golden", "--domain-segment", "quality", "--web-project-dir", webProject, "--application-service-package", "com.yss.golden.application.service", "--validation-namespace", "javax"]), { log() {}, warn() {} });
-  await writeJava(project, `golden-service-adapter/golden-service-web/${java}/rest/advice/TargetProfileExceptionAdvice.java`, `package com.yss.golden.rest.advice;
-import com.yss.golden.application.error.QualityRuleConflictException;
-import com.yss.golden.application.error.QualityRuleSystemException;
-import org.springframework.core.Ordered;
-import org.springframework.core.annotation.Order;
-import org.springframework.http.HttpStatus;
-import org.springframework.http.ResponseEntity;
-import org.springframework.web.bind.annotation.ExceptionHandler;
-import org.springframework.web.bind.annotation.RestControllerAdvice;
-@Order(Ordered.HIGHEST_PRECEDENCE)
-@RestControllerAdvice
-public final class TargetProfileExceptionAdvice {
-  @ExceptionHandler(QualityRuleConflictException.class)
-  public ResponseEntity<ErrorResponse> handleConflict(QualityRuleConflictException ignored) { return response(HttpStatus.CONFLICT, "QUALITY_RULE_CONFLICT", "质量规则冲突", "请检查质量规则后重试"); }
-  @ExceptionHandler(QualityRuleSystemException.class)
-  public ResponseEntity<ErrorResponse> handleKnownSystem(QualityRuleSystemException ignored) { return response(HttpStatus.SERVICE_UNAVAILABLE, "QUALITY_RULE_SYSTEM", "服务暂不可用", "请稍后重试"); }
-  @ExceptionHandler(RuntimeException.class)
-  public ResponseEntity<ErrorResponse> handleUnknown(RuntimeException ignored) { return response(HttpStatus.INTERNAL_SERVER_ERROR, "SYS_ERROR", "后台服务异常，请联系技术管理员", "请联系技术管理员"); }
-  private ResponseEntity<ErrorResponse> response(HttpStatus status, String errCode, String message, String tips) { return ResponseEntity.status(status).body(new ErrorResponse(errCode, message, tips)); }
-  public static final class ErrorResponse {
-    private final String errCode;
-    private final String message;
-    private final String tips;
-    ErrorResponse(String errCode, String message, String tips) { this.errCode = errCode; this.message = message; this.tips = tips; }
-    public String getErrCode() { return errCode; }
-    public String getMessage() { return message; }
-    public String getTips() { return tips; }
-  }
-}`);
-  await writeJava(project, `golden-service-adapter/golden-service-web/${testJava}/rest/GoldenExceptionIntegrationTest.java`, `package com.yss.golden.rest;
-import com.yss.cloud.exception.advice.GlobalExceptionAdvice;
-import com.yss.golden.application.error.QualityRuleConflictException;
-import com.yss.golden.application.error.QualityRuleSystemException;
-import org.junit.jupiter.api.Test;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.boot.SpringBootConfiguration;
-import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
-import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
-import org.springframework.boot.test.context.SpringBootTest;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.annotation.Import;
-import com.yss.golden.rest.advice.TargetProfileExceptionAdvice;
-import org.springframework.http.MediaType;
-import org.springframework.test.web.servlet.MockMvc;
-import org.springframework.web.bind.annotation.GetMapping;
-import org.springframework.web.bind.annotation.RestController;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
-import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-@SpringBootTest(classes = GoldenExceptionIntegrationTest.TestApplication.class)
-@AutoConfigureMockMvc
-class GoldenExceptionIntegrationTest {
-  @Autowired MockMvc mvc;
-  @Autowired ApplicationContext context;
-  @Test void actualStarterAutoConfigurationIsLoaded() { assertThat(context.getBeansOfType(GlobalExceptionAdvice.class)).hasSize(1); }
-  @Test void businessErrorUsesStablePublicResponse() throws Exception { mvc.perform(get("/exception-probe/business")).andExpect(status().isConflict()).andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)).andExpect(jsonPath("$.errCode").value("QUALITY_RULE_CONFLICT")).andExpect(jsonPath("$.message").value("质量规则冲突")); }
-  @Test void knownSystemErrorIsSanitized() throws Exception { mvc.perform(get("/exception-probe/system")).andExpect(status().isServiceUnavailable()).andExpect(jsonPath("$.errCode").value("QUALITY_RULE_SYSTEM")).andExpect(jsonPath("$.message").value("服务暂不可用")).andExpect(content().string(org.hamcrest.Matchers.not(org.hamcrest.Matchers.containsString("database-password")))); }
-  @Test void unknownErrorIsSanitizedAndHandledBeforeComponentFallback() throws Exception { mvc.perform(get("/exception-probe/unknown")).andExpect(status().isInternalServerError()).andExpect(jsonPath("$.errCode").value("SYS_ERROR")).andExpect(jsonPath("$.message").value("后台服务异常，请联系技术管理员")).andExpect(content().string(org.hamcrest.Matchers.not(org.hamcrest.Matchers.containsString("runtime-secret")))); }
-  @SpringBootConfiguration @EnableAutoConfiguration @Import({ExceptionProbeController.class, TargetProfileExceptionAdvice.class}) static class TestApplication {}
-  @RestController static class ExceptionProbeController {
-    @GetMapping("/exception-probe/business") void business() { throw new QualityRuleConflictException("internal-business-detail"); }
-    @GetMapping("/exception-probe/system") void system() { throw new QualityRuleSystemException("database-password", new IllegalStateException("internal-cause")); }
-    @GetMapping("/exception-probe/unknown") void unknown() { throw new RuntimeException("runtime-secret"); }
-  }
-}`);
-  const sliceContract = path.join(root, "slice-contract.json");
-  const requiredSkills = ["yss-domain", "yss-application", "yss-repository", "yss-mybatis", "yss-web-controller", "yss-dto", "yss-exception", "yss-validation", "mapstruct", "lombok", "alibaba-java-code-style"];
-  await writeFile(sliceContract, JSON.stringify({ architecture_identity: manifest.architecture_identity, schema_version: 2, contract_id: "golden-slice-1", contract_version: 1, slice_id: "quality-rule-first-slice", status: "approved", readiness: { blockers: [], stale_inputs: [] }, common: { required_skills: requiredSkills }, backend: { status: "required", affected_layers: ["domain", "application", "infrastructure", "web"], required_skills: requiredSkills }, work_units: [{ architecture_identity: manifest.architecture_identity, id: "slice-backend", contract_id: "golden-slice-1", contract_version: 1, work_unit: { primary_skill: "yss-domain" } }] }));
-  return { root, project, sliceContract };
-}
-
-test("golden first slice 组合 Domain/Application/Infrastructure/Web 且不发生 DTO/PO 穿层", async (t) => {
-  const { project } = await prepareGoldenProject(t);
-  const domainPom = await readFile(path.join(project, "golden-service-domain", "pom.xml"), "utf8");
-  const applicationPom = await readFile(path.join(project, "golden-service-application", "pom.xml"), "utf8");
-  const webPom = await readFile(path.join(project, "golden-service-adapter", "golden-service-web", "pom.xml"), "utf8");
-  const controller = await readFile(path.join(project, "golden-service-adapter", "golden-service-web", "src/main/java/com/yss/golden/rest/QualityRuleController.java"), "utf8");
-  const convertor = await readFile(path.join(project, "golden-service-adapter", "golden-service-web", "src/main/java/com/yss/golden/rest/convertor/QualityRuleWebConvertor.java"), "utf8");
-  const pageRequest = await readFile(path.join(project, "golden-service-adapter", "golden-service-web", "src/main/java/com/yss/golden/rest/dto/request/QualityRulePageRequest.java"), "utf8");
-  const serviceImpl = await readFile(path.join(project, "golden-service-application", "src/main/java/com/yss/golden/application/service/impl/QualityRuleServiceImpl.java"), "utf8");
-  const repository = await readFile(path.join(project, "golden-service-infrastructure", "src/main/java/com/yss/golden/infrastructure/persistence/repository/QualityRuleRepository.java"), "utf8");
-  const gatewayImpl = await readFile(path.join(project, "golden-service-infrastructure", "src/main/java/com/yss/golden/infrastructure/persistence/gateway/QualityRuleGatewayImpl.java"), "utf8");
-  const queryAdapter = await readFile(path.join(project, "golden-service-infrastructure", "src/main/java/com/yss/golden/infrastructure/query/adapter/QualityRuleQueryAdapter.java"), "utf8");
-  assert.doesNotMatch(domainPom, /yss-component-dto|yss-component-exception|spring-web|swagger/);
-  assert.match(applicationPom, /yss-component-dto/);
-  assert.doesNotMatch(webPom, /golden-service-domain|golden-service-infrastructure/);
-  assert.doesNotMatch(`${controller}\n${convertor}`, /\.domain\.|\.infrastructure\.|\.repository\.|Mappers\.getMapper|INSTANCE/);
-  assert.match(convertor, /@Mapper\(componentModel = "spring"\)/);
-  assert.doesNotMatch(pageRequest, /offset|needTotalCount|tempTotalCount|extends PageQuery/);
-  assert.match(pageRequest, /pageIndex/);
-  assert.match(pageRequest, /pageSize/);
-  assert.doesNotMatch(pageRequest, /orderBy|orderDirection|groupBy/);
-  assert.match(serviceImpl, /implements QualityRuleService/);
-  assert.match(serviceImpl, /@Transactional/);
-  assert.match(repository, /@Mapper/);
-  assert.match(gatewayImpl, /implements QualityRuleGateway/);
-  assert.match(queryAdapter, /implements QualityRuleQueryPort/);
-});
-
-test("golden first slice 通过真实 Wrapper 后才写入 first-slice-verified", { timeout: 300_000 }, async (t) => {
-  if (!["YSS_MAVEN_REPOSITORY_URL", "MAVEN_REPO_USERNAME", "MAVEN_REPO_PASSWORD"].every((name) => process.env[name])) {
-    t.skip("缺少受控 YSS Maven 仓库环境；不得声明 first-slice-verified");
-    return;
-  }
-  const { project, sliceContract, root } = await prepareGoldenProject(t);
-  await chmod(path.join(project, "mvnw"), 0o755);
-  const result = await runFirstSliceVerification(project, path.join(root, "first-slice-evidence"), sliceContract, process.env);
-  assert.equal(result.status, "passed", JSON.stringify(result, null, 2));
-  assert.equal(JSON.parse(await readFile(path.join(project, ".yss/scaffold-generation.json"), "utf8")).completion_level, "first-slice-verified");
-});
-
-test("真实 YSS exception starter 的自动配置、优先级、三类映射和序列化均受保护", { timeout: 300_000 }, async (t) => {
-  if (!["YSS_MAVEN_REPOSITORY_URL", "MAVEN_REPO_USERNAME", "MAVEN_REPO_PASSWORD"].every((name) => process.env[name])) {
-    t.skip("缺少受控 YSS Maven 仓库环境；不得声明 exception starter 真实集成已验证");
-    return;
-  }
-  const { project } = await prepareGoldenProject(t);
-  await chmod(path.join(project, "mvnw"), 0o755);
-  const result = await execute(path.join(project, "mvnw"), ["-pl", "golden-service-adapter/golden-service-web", "-am", "test"], { cwd: project, timeout: 300_000 });
-  assert.equal(result.code, 0, `${result.stdout}\n${result.stderr}`);
-});