create-yss-spec 2.2.10 → 3.0.1

package/template/.hermes/skills/yss-ddd-scaffold-generator/references/ARCHITECTURE.md

@@ -1,116 +0,0 @@
-# YSS DDD Target Profile
-
-本文定义 `architecture=target-domain-model` 的唯一目标结构。历史 `core/client/repository`、DTO 型 Gateway、client-in-domain 以及其他旧架构全部为 `unsupported`，不存在 legacy Profile 或回退分支。
-
-## 1. 模块职责
-
-### Domain
-
-- 聚合根、Entity、Value Object、领域行为、不变量、Domain Event。
-- 聚合持久化使用 Domain Gateway/Port，只交换 Domain Model、领域值和领域标识。
-- 不依赖 Application、Infrastructure、Repository、Web、YSS DTO/Exception、Jackson、Swagger 或 Validation。
-- Domain error 使用稳定领域错误标识和参数，不决定 HTTP status 或公开消息。
-
-推荐包：
-
-```text
-{base_package}.domain.{segment}
-├── model
-├── gateway
-├── service
-└── event
-```
-
-### Application
-
-- 定义并编排 Use Case、事务边界、Application Command/Query/Result。
-- 写用例调用 Domain Model/Domain Gateway。
-- 分页、列表和读模型通过 Application Query Port，不把 `PageQuery`、`PageResult` 或 Web VO 放入 Domain。
-- 不依赖 Infrastructure 或 Web。
-
-推荐包：
-
-```text
-{base_package}.application
-├── command
-├── query
-├── result
-├── port
-└── service
-```
-
-### Infrastructure
-
-- 实现 Domain Gateway 和 Application Query Port。
-- MyBatis-Plus Repository、PO、SQL、数据源配置和 `PO <-> Domain Model` MapStruct 转换位于本层。
-- 首个受支持 Profile 是 `persistence=mybatis-plus`；其他持久化方案必须先通过独立 fixture。
-- 事务边界由 Application 持有，不在 GatewayImpl 重复制造边界。
-
-### Adapter/Web
-
-- HTTP Request/Response、校验、Controller、WebConvertor 和异常到 HTTP/YSS Result 的映射。
-- Request 字段来自冻结 OpenAPI/批准 allowlist，不从数据库 metadata 全量推导。
-- WebConvertor 使用 `@Mapper(componentModel = "spring")` 和构造器注入。
-- DTO 物理位置固定为 Web；独立 client module 为 `unsupported`。如未来确需发布复用制品，必须另行设计并批准新的 Target Profile。
-- Web 不直接依赖 Infrastructure，不把 Domain Model 作为 Controller seam。
-
-### Bootstrap
-
-- 组合 Web 和 Infrastructure，提供机械 Spring Boot 入口与环境配置。
-- 默认配置使用 INFO；DEBUG 和 MyBatis stdout SQL 仅存在于 `application-local.yml`。
-
-## 2. 依赖方向
-
-```text
-Web -> Application -> Domain
-Infrastructure -> Application + Domain
-Bootstrap -> Web + Infrastructure
-```
-
-禁止：
-
-- Domain → Application/Infrastructure/Web
-- Application → Infrastructure/Web
-- Web → Infrastructure
-- Domain Gateway 接收 HTTP DTO、返回 Web VO/PageResult
-- Repository 把 PO 直接返回给 Application/Web
-
-上述规则由生成工程的 `ArchitectureRulesTest` 执行，不只依赖文档约定。
-
-## 3. 调用链
-
-写模型：
-
-```text
-HTTP Request -> WebConvertor -> Application Command -> Use Case
-  -> Domain Model/Domain Gateway -> GatewayImpl -> Repository/MyBatis -> PO
-```
-
-读模型：
-
-```text
-HTTP Page Request -> WebConvertor -> Application Query -> Query Port
-  -> Infrastructure Query Adapter -> Application Result -> Web Response
-```
-
-异常：
-
-```text
-Domain Error -> Application propagation/translation -> Web Exception Translator
-  -> HTTP status + stable error code + sanitized public message
-```
-
-## 4. 生成与演进
-
-- Scaffold 只生成机械模块、POM、Wrapper、配置、架构规则和 Manifest，不生成生产业务 CRUD。
-- 初始生成器为 `initialize-only`，非空目标失败。
-- Manifest v2 记录模板/合同/downstream skill digest 与 generator-owned 文件 hash。
-- 当前不支持模板升级，不得重跑初始生成器覆盖业务工程。未来如需支持同一 Target Profile 内的模板版本升级，必须另行设计、批准并验证。
-
-## 5. 完成等级
-
-- `generated`：文件已原子生成，尚未完成 Wrapper 验证。
-- `empty-scaffold-verified`：根目录 `./mvnw validate/test/package` 全部通过。
-- `first-slice-verified`：golden first slice 的 Domain、Application、Repository/MyBatis、DTO/Web、Exception、Wire 与架构负例全部通过。
-
-只有最后一级可以声明已满足下游 YSS skills 的首切片就绪条件。

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

@@ -1,114 +0,0 @@
-# 使用示例
-
-## 1. 准备批准合同
-
-新合同是服务级工程基线，使用 schema v2 与 `scaffold_request_id`，并把 Java 包名、Maven 坐标和 Profile 分开登记：
-
-```json
-{
-  "schema_version": 2,
-  "scaffold_request_id": "scaffold-metadata-service-1",
-  "project_name": "metadata-service",
-  "target_output_dir": "/path/to/implementation-repo",
-  "base_package": "com.yss.metadata",
-  "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"
-  },
-  "generation_policy": {
-    "mode": "initialize-only",
-    "existing_target": "unsupported",
-    "old_project_migration": "unsupported",
-    "template_upgrade": "unsupported"
-  }
-}
-```
-
-以上只是关键片段；实际合同还必须满足 `yss-router/references/router-contract.yaml` 中的完整 `scaffold_contract_schema`，由生命周期批准并持久化为当前版本。schema v1 合同为 `unsupported`，直接拒绝且不自动升级。
-
-## 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 \
-  --database mysql \
-  --contract-id <approved-scaffold-contract-id> \
-  --contract-version <current-version> \
-  --approval-ref <lifecycle-approval-ref> \
-  --router-draft-ref <router-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-router`，消费批准且版本当前的 Slice Implementation Contract，再按影响面加载 `yss-domain`、`yss-application`、`yss-repository`、`yss-mybatis`、`yss-dto`、`yss-exception`、`yss-web-controller` 等 skill，并使用 `behavior-tdd` 实现业务行为。只有 golden first slice 全部通过才能标记 `first-slice-verified`。
-
-目标目录必须不存在。`--force`、旧项目迁移和当前模板升级均为 `unsupported`。旧项目继续按原工程维护；现代化改造必须单独立项、先评估再逐切片迁移。
-
-如需本地启动机械入口：
-
-```bash
-cd /path/to/implementation-repo/metadata-service
-./mvnw spring-boot:run -pl metadata-service-bootstrap
-```

package/template/.hermes/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/.hermes/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/.hermes/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/.hermes/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/.hermes/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/.hermes/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/.hermes/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/.hermes/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/.hermes/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-parent/SKILL.md

@@ -1,57 +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 v2，身份为 `scaffold_request_id`，不使用 `slice_id`。
-- 生成器严格 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 并通过根 Wrapper，才能得到 `first-slice-verified`。
-
-## 下游权威技能
-
-- Domain：`yss-domain`
-- Application：`yss-application`
-- Persistence：`yss-repository` + `yss-mybatis`
-- Web：`yss-web-controller` + `yss-dto` + `yss-exception`
-
-业务代码必须回到 `yss-router`，消费批准且版本当前的 Slice Implementation Contract，并采用 `behavior-tdd`；脚手架只生成机械工程资产。

package/template/.hermes/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/.hermes/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/.hermes/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/.hermes/skills/yss-ddd-scaffold-generator/scripts/first-slice-compatibility.test.mjs

@@ -1,191 +0,0 @@
-import assert from "node:assert/strict";
-import { execFile } from "node:child_process";
-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";
-
-const scripts = path.dirname(fileURLToPath(import.meta.url));
-const generator = path.join(scripts, "generate_scaffold.mjs");
-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) {
-  return {
-    schema_version: 2,
-    contract_id: "golden-scaffold-1",
-    contract_version: 1,
-    scaffold_request_id: "golden-request-1",
-    status: "approved",
-    router_draft_ref: "router-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",
-    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" },
-    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-router"], 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 contractFile = path.join(root, "scaffold-contract.json");
-  await writeFile(contractFile, `${JSON.stringify(scaffoldContract(output), null, 2)}\n`);
-  const args = ["--project-name", "golden-service", "--base-package", "com.yss.golden", "--output-dir", output, "--database", "mysql", "--contract-id", "golden-scaffold-1", "--contract-version", "1", "--approval-ref", "approval-golden-1", "--router-draft-ref", "router-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 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; public interface QualityRuleGateway { void save(QualityRule rule); }`);
-  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/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); }`
-  })) await writeJava(project, relative, source);
-  const metadata = path.join(root, "metadata.json");
-  const webContract = path.join(root, "web-contract.json");
-  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 }] }] }));
-  await writeFile(webContract, JSON.stringify({ schema_version: 1, status: "approved", base_package: "com.yss.golden", module_name: "golden", domain_segment: "quality", architecture_profile: "target-domain-model", platform_profile: "spring-boot-2.7-jdk8", validation_namespace: "javax", dto_placement: "web", openapi_freeze_ref: "openapi://quality-rule@1", fields: { quality_rule: { create: ["rule_name"], update: ["id", "rule_name"], query: ["rule_name"], response: ["id", "rule_name"] } } }));
-  await generateWeb(parseWebArgs(["--metadata-file", metadata, "--contract-file", webContract, "--base-package", "com.yss.golden", "--module-name", "golden", "--domain-segment", "quality", "--web-project-dir", path.join(project, "golden-service-adapter", "golden-service-web"), "--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"); }
-  }
-}`);
-  return { root, project };
-}
-
-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");
-  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/);
-});
-
-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 } = await prepareGoldenProject(t);
-  await chmod(path.join(project, "mvnw"), 0o755);
-  for (const phase of ["validate", "test", "package"]) {
-    const result = await execute(path.join(project, "mvnw"), [phase], { cwd: project, timeout: 300_000 });
-    assert.equal(result.code, 0, `${phase}\n${result.stdout}\n${result.stderr}`);
-  }
-});
-
-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}`);
-});