create-yss-spec 2.2.10 → 3.0.0

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

@@ -1,5 +1,6 @@
 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";
@@ -7,9 +8,11 @@ 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) {
@@ -57,12 +60,19 @@ async function prepareGoldenProject(t) {
   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; public interface QualityRuleGateway { void save(QualityRule rule); }`);
+  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({
@@ -72,16 +82,26 @@ import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertion
     [`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/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 }] }] }));
-  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() {} });
+  const webProject = path.join(project, "golden-service-adapter", "golden-service-web");
+  await writeFile(webContract, JSON.stringify({ 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;
@@ -147,7 +167,10 @@ class GoldenExceptionIntegrationTest {
     @GetMapping("/exception-probe/unknown") void unknown() { throw new RuntimeException("runtime-secret"); }
   }
 }`);
-  return { root, project };
+  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({ schema_version: 1, 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: [{ 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) => {
@@ -158,25 +181,36 @@ test("golden first slice 组合 Domain/Application/Infrastructure/Web 且不发
   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) => {
+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);
+  const { project, sliceContract, root } = 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}`);
-  }
+  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) => {

package/template/.codex/skills/yss-ddd-scaffold-generator/scripts/first-slice-verification.test.mjs

@@ -0,0 +1,164 @@
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { chmod, mkdir, mkdtemp, readFile, readdir, 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 { runFirstSliceVerification } from "./run_first_slice_verification.mjs";
+
+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"];
+const scripts = path.dirname(fileURLToPath(import.meta.url));
+const repositoryRoot = path.resolve(scripts, "../../../..");
+
+async function treeDigest(root) {
+  const relativeFiles = [];
+  async function visit(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const absolute = path.join(directory, entry.name);
+      if (entry.isDirectory()) await visit(absolute);
+      else if (entry.isFile()) relativeFiles.push(path.relative(root, absolute).split(path.sep).join("/"));
+    }
+  }
+  await visit(root);
+  const hash = createHash("sha256");
+  for (const relative of relativeFiles.sort()) hash.update(relative).update("\0").update(await readFile(path.join(root, relative))).update("\0");
+  return hash.digest("hex");
+}
+
+async function readiness() {
+  const downstreamSkills = {};
+  for (const skill of requiredSkills) downstreamSkills[skill] = await treeDigest(path.join(repositoryRoot, ".agents", "skills", skill));
+  const digest = async (relative) => createHash("sha256").update(await readFile(path.join(repositoryRoot, relative))).digest("hex");
+  return {
+    downstream_skills: downstreamSkills,
+    contracts: {
+      scaffold_parent: await digest(".agents/skills/yss-ddd-scaffold-generator/references/yss-backend-scaffold-parent/SKILL.md"),
+      router_contract: await digest(".agents/skills/yss-router/references/router-contract.yaml")
+    },
+    architecture_ruleset: "b".repeat(64)
+  };
+}
+
+async function write(project, relative, content = "fixture\n") {
+  const target = path.join(project, relative);
+  await mkdir(path.dirname(target), { recursive: true });
+  await writeFile(target, content);
+}
+
+async function fixture({ omitGatewayImpl = false, omitReadiness = false } = {}) {
+  const root = await mkdtemp(path.join(os.tmpdir(), "yss-first-slice-verification-"));
+  const project = path.join(root, "demo-service");
+  const evidence = path.join(root, "evidence");
+  const manifestPath = path.join(project, ".yss", "scaffold-generation.json");
+  const contractPath = path.join(root, "slice-contract.json");
+  await mkdir(path.dirname(manifestPath), { recursive: true });
+  await writeFile(manifestPath, JSON.stringify({
+    schema_version: 2,
+    contract_id: "scaffold-1",
+    contract_version: 1,
+    scaffold_request_id: "scaffold-request-1",
+    contract_digest: "a".repeat(64),
+    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" },
+    ownership: { generated_files: [] },
+    readiness: omitReadiness ? { downstream_skills: {}, contracts: {}, architecture_ruleset: "b".repeat(64) } : await readiness(),
+    generation_policy: { mode: "initialize-only", existing_target: "unsupported", old_project_migration: "unsupported", template_upgrade: "unsupported" },
+    completion_level: "empty-scaffold-verified",
+    approval_ref: "approval-1",
+    approver: "maintainer",
+    lifecycle_approval_ref: "approval-1",
+    router_draft_ref: "router-1",
+    persisted_ref: "persisted-1",
+    contract_file_ref: contractPath,
+    current_version: 1,
+    allowed_write_paths: ["."],
+    expected_evidence_files: [".yss/scaffold-generation.json"],
+    verification_commands: ["./mvnw validate", "./mvnw test", "./mvnw package"],
+    generation_mode: "controlled-generation",
+    maven_coordinates_source: "approved-contract"
+  }));
+  await writeFile(contractPath, JSON.stringify({
+    schema_version: 1,
+    contract_id: "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: [{ id: "slice-backend", contract_id: "slice-1", contract_version: 1, work_unit: { primary_skill: "yss-domain" } }]
+  }));
+  await write(project, "mvnw", "#!/bin/sh\nexit 0\n");
+  await chmod(path.join(project, "mvnw"), 0o755);
+  await write(project, ".mvn/settings.xml", "<settings/>\n");
+  await write(project, ".mvn/maven.config", "-s .mvn/settings.xml -P yss-internal\n");
+  const files = [
+    "demo-service-domain/src/main/java/com/yss/demo/domain/quality/model/QualityRule.java",
+    "demo-service-domain/src/main/java/com/yss/demo/domain/quality/gateway/QualityRuleGateway.java",
+    "demo-service-domain/src/test/java/com/yss/demo/domain/quality/model/QualityRuleTest.java",
+    "demo-service-application/src/main/java/com/yss/demo/application/command/QualityRuleCreateCommand.java",
+    "demo-service-application/src/main/java/com/yss/demo/application/query/QualityRulePageQuery.java",
+    "demo-service-application/src/main/java/com/yss/demo/application/result/QualityRuleResult.java",
+    "demo-service-application/src/main/java/com/yss/demo/application/service/QualityRuleService.java",
+    "demo-service-application/src/main/java/com/yss/demo/application/service/impl/QualityRuleServiceImpl.java",
+    "demo-service-application/src/test/java/com/yss/demo/application/service/QualityRuleServiceTest.java",
+    "demo-service-infrastructure/src/main/java/com/yss/demo/infrastructure/persistence/po/QualityRulePO.java",
+    "demo-service-infrastructure/src/main/java/com/yss/demo/infrastructure/persistence/repository/QualityRuleRepository.java",
+    "demo-service-infrastructure/src/main/java/com/yss/demo/infrastructure/persistence/convertor/QualityRulePersistenceConvertor.java",
+    "demo-service-infrastructure/src/main/java/com/yss/demo/infrastructure/query/adapter/QualityRuleQueryAdapter.java",
+    "demo-service-infrastructure/src/test/java/com/yss/demo/infrastructure/persistence/QualityRuleGatewayIntegrationTest.java",
+    "demo-service-adapter/demo-service-web/src/main/java/com/yss/demo/rest/QualityRuleController.java",
+    "demo-service-adapter/demo-service-web/src/main/java/com/yss/demo/rest/convertor/QualityRuleWebConvertor.java",
+    "demo-service-adapter/demo-service-web/src/main/java/com/yss/demo/rest/dto/request/QualityRuleCreateRequest.java",
+    "demo-service-adapter/demo-service-web/src/main/java/com/yss/demo/rest/dto/response/QualityRuleResponse.java",
+    "demo-service-adapter/demo-service-web/src/test/java/com/yss/demo/rest/QualityRuleContractTest.java"
+  ];
+  if (!omitGatewayImpl) files.push("demo-service-infrastructure/src/main/java/com/yss/demo/infrastructure/persistence/gateway/QualityRuleGatewayImpl.java");
+  for (const relative of files) await write(project, relative);
+  return { root, project, evidence, manifestPath, contractPath };
+}
+
+const environment = { ...process.env, JAVA_HOME: "/fixture/java", YSS_MAVEN_REPOSITORY_URL: "https://repo.example.invalid", MAVEN_REPO_USERNAME: "user", MAVEN_REPO_PASSWORD: "secret" };
+
+test("refuses first-slice promotion when a required persistence seam is absent", async () => {
+  const data = await fixture({ omitGatewayImpl: true });
+  const report = await runFirstSliceVerification(data.project, data.evidence, data.contractPath, environment);
+  assert.equal(report.status, "failed");
+  assert.ok(report.missing_artifacts.includes("infrastructure-gateway-implementation"));
+  const manifest = JSON.parse(await readFile(data.manifestPath, "utf8"));
+  assert.equal(manifest.completion_level, "empty-scaffold-verified");
+});
+
+test("refuses first-slice promotion when downstream skill or contract digests are absent", async () => {
+  const data = await fixture({ omitReadiness: true });
+  const report = await runFirstSliceVerification(data.project, data.evidence, data.contractPath, environment);
+  assert.equal(report.status, "failed");
+  assert.ok(report.downstream_skill_drift.includes("yss-domain:digest-missing"));
+  assert.ok(report.downstream_skill_drift.includes("router_contract:digest-missing"));
+  const manifest = JSON.parse(await readFile(data.manifestPath, "utf8"));
+  assert.equal(manifest.completion_level, "empty-scaffold-verified");
+});
+
+test("refuses first-slice promotion when a work unit references a stale contract version", async () => {
+  const data = await fixture();
+  const contract = JSON.parse(await readFile(data.contractPath, "utf8"));
+  contract.work_units[0].contract_version = 0;
+  await writeFile(data.contractPath, JSON.stringify(contract));
+  const report = await runFirstSliceVerification(data.project, data.evidence, data.contractPath, environment);
+  assert.equal(report.status, "failed");
+  assert.ok(report.contract_failures.includes("work-unit-contract-version-mismatch:slice-backend"));
+});
+
+test("promotes a complete approved slice only after all root wrapper commands pass", async () => {
+  const data = await fixture();
+  const report = await runFirstSliceVerification(data.project, data.evidence, data.contractPath, environment);
+  assert.equal(report.status, "passed");
+  assert.equal(report.completion_level, "first-slice-verified");
+  assert.deepEqual(report.commands.map((item) => item.exit_code), [0, 0, 0]);
+  const manifest = JSON.parse(await readFile(data.manifestPath, "utf8"));
+  assert.equal(manifest.completion_level, "first-slice-verified");
+  assert.equal(manifest.first_slice_contract.contract_id, "slice-1");
+  assert.equal(manifest.first_slice_contract.slice_id, "quality-rule-first-slice");
+  assert.equal(JSON.parse(await readFile(path.join(data.evidence, "first-slice-verification.json"), "utf8")).status, "passed");
+});

package/template/.codex/skills/yss-ddd-scaffold-generator/scripts/generate_scaffold.mjs

@@ -25,7 +25,19 @@ const SUPPORTED_PROFILES = Object.freeze({
   dto_placement: "web",
   repository: "yss-internal"
 });
-const DOWNSTREAM_SKILLS = ["yss-domain", "yss-application", "yss-repository", "yss-mybatis", "yss-dto", "yss-exception", "yss-web-controller"];
+const DOWNSTREAM_SKILLS = [
+  "yss-domain",
+  "yss-application",
+  "yss-repository",
+  "yss-mybatis",
+  "yss-web-controller",
+  "yss-dto",
+  "yss-exception",
+  "yss-validation",
+  "mapstruct",
+  "lombok",
+  "alibaba-java-code-style"
+];
 function fail(message) { throw new Error(message); }
 function isoNow() { return new Date().toISOString(); }
 function localDate() { return new Date().toISOString().slice(0, 10); }
@@ -324,10 +336,12 @@ class ScaffoldGenerator {
     }
     const downstream = {};
     for (const skill of DOWNSTREAM_SKILLS) {
-      const skillFile = path.join(REPOSITORY_ROOT, ".agents", "skills", skill, "SKILL.md");
-      downstream[skill] = await isFile(skillFile) ? sha256(await readFile(skillFile)) : "unavailable";
+      const skillRoot = path.join(REPOSITORY_ROOT, ".agents", "skills", skill);
+      downstream[skill] = await isFile(path.join(skillRoot, "SKILL.md")) ? await treeDigest(skillRoot) : "unavailable";
     }
-    const manifest = { schema_version: 2, contract_id: this.options.contractId, contract_version: this.options.contractVersion, scaffold_request_id: contract.scaffold_request_id, approval_ref: this.options.approvalRef, router_draft_ref: this.options.routerDraftRef, persisted_ref: this.options.persistedRef, contract_file_ref: this.contractFile, contract_digest: this.contractDigest, lifecycle_approval_ref: contract.lifecycle_approval_ref, current_version: contract.current_version, approver: contract.approval.approver, allowed_write_paths: contract.allowed_write_paths, expected_evidence_files: contract.expected_evidence_files, project_name: this.projectName, base_package: this.basePackage, bootstrap_main_class: `${this.basePackage}.${this.applicationClassName}`, bootstrap_main_source: this.bootstrapMainSource, maven_coordinates: this.mavenCoordinates, maven_coordinates_source: this.mavenCoordinatesSource, profiles: this.profiles, database: this.options.database, generation_mode: "controlled-generation", completion_level: "generated", generator: { id: "yss-ddd-scaffold-generator", template_digest: await treeDigest(path.join(SKILL_ROOT, "assets")) }, ownership: { generated_files: generatedFiles, user_owned_globs: ["**/src/main/java/**", "**/src/test/java/**", "db/**"] }, readiness: { downstream_skills: downstream, architecture_ruleset: sha256(await readFile(path.join(this.javaTemplateDir, "architecture-rules-test.java.template"))) }, generation_policy: { mode: "initialize-only", existing_target: "unsupported", old_project_migration: "unsupported", template_upgrade: "unsupported" }, verification_commands: COMMANDS, generated_at: isoNow() };
+    const scaffoldParent = path.join(SKILL_ROOT, "references", "yss-backend-scaffold-parent", "SKILL.md");
+    const routerContract = path.join(REPOSITORY_ROOT, ".agents", "skills", "yss-router", "references", "router-contract.yaml");
+    const manifest = { schema_version: 2, contract_id: this.options.contractId, contract_version: this.options.contractVersion, scaffold_request_id: contract.scaffold_request_id, approval_ref: this.options.approvalRef, router_draft_ref: this.options.routerDraftRef, persisted_ref: this.options.persistedRef, contract_file_ref: this.contractFile, contract_digest: this.contractDigest, lifecycle_approval_ref: contract.lifecycle_approval_ref, current_version: contract.current_version, approver: contract.approval.approver, allowed_write_paths: contract.allowed_write_paths, expected_evidence_files: contract.expected_evidence_files, project_name: this.projectName, base_package: this.basePackage, bootstrap_main_class: `${this.basePackage}.${this.applicationClassName}`, bootstrap_main_source: this.bootstrapMainSource, maven_coordinates: this.mavenCoordinates, maven_coordinates_source: this.mavenCoordinatesSource, profiles: this.profiles, database: this.options.database, generation_mode: "controlled-generation", completion_level: "generated", generator: { id: "yss-ddd-scaffold-generator", template_digest: await treeDigest(path.join(SKILL_ROOT, "assets")) }, ownership: { generated_files: generatedFiles, user_owned_globs: ["**/src/main/java/**", "**/src/test/java/**", "db/**"] }, readiness: { downstream_skills: downstream, contracts: { scaffold_parent: sha256(await readFile(scaffoldParent)), router_contract: sha256(await readFile(routerContract)) }, architecture_ruleset: sha256(await readFile(path.join(this.javaTemplateDir, "architecture-rules-test.java.template"))) }, generation_policy: { mode: "initialize-only", existing_target: "unsupported", old_project_migration: "unsupported", template_upgrade: "unsupported" }, verification_commands: COMMANDS, generated_at: isoNow() };
     await writeText(path.join(this.projectRoot, ".yss", "scaffold-generation.json"), `${JSON.stringify(manifest, null, 2)}\n`); console.log("  ✓ .yss/scaffold-generation.json");
   }
   async copyWrapperFiles() {

package/template/.codex/skills/yss-ddd-scaffold-generator/scripts/run_first_slice_verification.mjs

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/** Promote a generated backend only after a complete, approved first vertical slice passes real Wrapper verification. */
+import { createHash } from "node:crypto";
+import { mkdir, readFile, readdir, rename, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+import { run as runScaffoldVerification } from "./run_scaffold_verification.mjs";
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const REPOSITORY_ROOT = path.resolve(SCRIPT_DIR, "../../../..");
+const REQUIRED_SKILLS = ["yss-domain", "yss-application", "yss-repository", "yss-mybatis", "yss-web-controller", "yss-dto", "yss-exception", "yss-validation", "mapstruct", "lombok", "alibaba-java-code-style"];
+const REQUIRED_LAYERS = ["domain", "application", "infrastructure", "web"];
+const ARTIFACT_CHECKS = [
+  ["domain-model", /-domain\/src\/main\/java\/.+\/domain\/.+\/model\/.+\.java$/],
+  ["domain-gateway", /-domain\/src\/main\/java\/.+\/domain\/.+\/gateway\/.+Gateway\.java$/],
+  ["domain-behavior-test", /-domain\/src\/test\/java\/.+(?:Test|Tests)\.java$/],
+  ["application-command-or-query", /-application\/src\/main\/java\/.+\/application\/(?:command|query)\/.+\.java$/],
+  ["application-result", /-application\/src\/main\/java\/.+\/application\/result\/.+Result\.java$/],
+  ["application-service", /-application\/src\/main\/java\/.+\/application\/service\/.+Service\.java$/],
+  ["application-service-implementation", /-application\/src\/main\/java\/.+\/application\/service\/impl\/.+ServiceImpl\.java$/],
+  ["application-behavior-test", /-application\/src\/test\/java\/.+(?:Test|Tests)\.java$/],
+  ["infrastructure-po", /-infrastructure\/src\/main\/java\/.+\/infrastructure\/persistence\/po\/.+PO\.java$/],
+  ["infrastructure-repository", /-infrastructure\/src\/main\/java\/.+\/infrastructure\/persistence\/repository\/.+Repository\.java$/],
+  ["infrastructure-convertor", /-infrastructure\/src\/main\/java\/.+\/infrastructure\/persistence\/convertor\/.+Convertor\.java$/],
+  ["infrastructure-gateway-implementation", /-infrastructure\/src\/main\/java\/.+\/infrastructure\/persistence\/gateway\/.+GatewayImpl\.java$/],
+  ["infrastructure-query-adapter", /-infrastructure\/src\/main\/java\/.+\/infrastructure\/query\/adapter\/.+QueryAdapter\.java$/],
+  ["infrastructure-integration-test", /-infrastructure\/src\/test\/java\/.+(?:Test|Tests)\.java$/],
+  ["web-controller", /-adapter\/.+-web\/src\/main\/java\/.+\/rest\/.+Controller\.java$/],
+  ["web-convertor", /-adapter\/.+-web\/src\/main\/java\/.+\/rest\/convertor\/.+WebConvertor\.java$/],
+  ["web-request", /-adapter\/.+-web\/src\/main\/java\/.+\/rest\/dto\/request\/.+Request\.java$/],
+  ["web-response", /-adapter\/.+-web\/src\/main\/java\/.+\/rest\/dto\/response\/.+Response\.java$/],
+  ["web-contract-test", /-adapter\/.+-web\/src\/test\/java\/.+(?:Test|Tests)\.java$/]
+];
+
+const isoNow = () => new Date().toISOString();
+const sha256 = (content) => createHash("sha256").update(content).digest("hex");
+async function isFile(target) { try { return (await stat(target)).isFile(); } catch (error) { if (error.code === "ENOENT") return false; throw error; } }
+async function files(root) {
+  const output = [];
+  async function visit(directory) {
+    for (const entry of await readdir(directory, { withFileTypes: true })) {
+      const absolute = path.join(directory, entry.name);
+      if (entry.isDirectory()) await visit(absolute);
+      else if (entry.isFile()) output.push(path.relative(root, absolute).split(path.sep).join("/"));
+    }
+  }
+  await visit(root);
+  return output.sort();
+}
+async function treeDigest(root) {
+  const hash = createHash("sha256");
+  for (const relative of await files(root)) hash.update(relative).update("\0").update(await readFile(path.join(root, relative))).update("\0");
+  return hash.digest("hex");
+}
+async function writeJsonAtomic(target, value) {
+  await mkdir(path.dirname(target), { recursive: true });
+  const temporary = `${target}.${process.pid}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  await rename(temporary, target);
+}
+function invalidContractReasons(contract) {
+  const reasons = [];
+  if (contract.schema_version !== 1) reasons.push("slice-contract-schema");
+  if (contract.status !== "approved") reasons.push("slice-contract-not-approved");
+  for (const field of ["contract_id", "contract_version", "slice_id"]) if (contract[field] === undefined || contract[field] === null || contract[field] === "") reasons.push(`slice-contract-${field}-missing`);
+  if (contract.readiness?.blockers?.length) reasons.push("slice-contract-has-blockers");
+  if (contract.readiness?.stale_inputs?.length) reasons.push("slice-contract-has-stale-inputs");
+  const actualSkills = new Set([...(contract.common?.required_skills ?? []), ...(contract.backend?.required_skills ?? [])]);
+  for (const skill of REQUIRED_SKILLS) if (!actualSkills.has(skill)) reasons.push(`required-skill-missing:${skill}`);
+  const actualLayers = new Set(contract.backend?.affected_layers ?? []);
+  for (const layer of REQUIRED_LAYERS) if (!actualLayers.has(layer)) reasons.push(`required-layer-missing:${layer}`);
+  if (!Array.isArray(contract.work_units) || !contract.work_units.length) reasons.push("slice-contract-work-units-missing");
+  else for (const [index, unit] of contract.work_units.entries()) {
+    const id = unit.id || `index-${index}`;
+    if (unit.contract_id !== contract.contract_id) reasons.push(`work-unit-contract-id-mismatch:${id}`);
+    if (unit.contract_version !== contract.contract_version) reasons.push(`work-unit-contract-version-mismatch:${id}`);
+    if (!unit.work_unit?.primary_skill) reasons.push(`work-unit-primary-skill-missing:${id}`);
+  }
+  return reasons;
+}
+async function downstreamDrift(manifest) {
+  const drift = [];
+  const recordedSkills = manifest.readiness?.downstream_skills ?? {};
+  for (const skill of REQUIRED_SKILLS) {
+    const expected = recordedSkills[skill];
+    if (typeof expected !== "string" || !/^[a-f0-9]{64}$/.test(expected)) {
+      drift.push(`${skill}:digest-missing`);
+      continue;
+    }
+    const root = path.join(REPOSITORY_ROOT, ".agents", "skills", skill);
+    if (!await isFile(path.join(root, "SKILL.md"))) drift.push(`${skill}:unavailable`);
+    else if (await treeDigest(root) !== expected) drift.push(`${skill}:digest-mismatch`);
+  }
+  const contracts = manifest.readiness?.contracts ?? {};
+  const contractFiles = {
+    scaffold_parent: path.join(REPOSITORY_ROOT, ".agents", "skills", "yss-ddd-scaffold-generator", "references", "yss-backend-scaffold-parent", "SKILL.md"),
+    router_contract: path.join(REPOSITORY_ROOT, ".agents", "skills", "yss-router", "references", "router-contract.yaml")
+  };
+  for (const [name, target] of Object.entries(contractFiles)) {
+    const expected = contracts[name];
+    if (typeof expected !== "string" || !/^[a-f0-9]{64}$/.test(expected)) {
+      drift.push(`${name}:digest-missing`);
+      continue;
+    }
+    if (!await isFile(target)) drift.push(`${name}:unavailable`);
+    else if (sha256(await readFile(target)) !== expected) drift.push(`${name}:digest-mismatch`);
+  }
+  return drift;
+}
+
+export async function runFirstSliceVerification(projectRoot, evidenceDir, sliceContractFile, environment = process.env) {
+  projectRoot = path.resolve(projectRoot);
+  evidenceDir = path.resolve(evidenceDir);
+  sliceContractFile = path.resolve(sliceContractFile);
+  const manifestPath = path.join(projectRoot, ".yss", "scaffold-generation.json");
+  const reportPath = path.join(evidenceDir, "first-slice-verification.json");
+  if (!await isFile(manifestPath)) throw new Error(`missing scaffold manifest: ${manifestPath}`);
+  if (!await isFile(sliceContractFile)) throw new Error(`missing Slice Implementation Contract: ${sliceContractFile}`);
+  const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+  const contract = JSON.parse(await readFile(sliceContractFile, "utf8"));
+  const contractFailures = invalidContractReasons(contract);
+  if (manifest.schema_version !== 2 || manifest.completion_level !== "empty-scaffold-verified") contractFailures.push("scaffold-not-empty-scaffold-verified");
+  const projectFiles = await files(projectRoot);
+  const missingArtifacts = ARTIFACT_CHECKS.filter(([, pattern]) => !projectFiles.some((file) => pattern.test(file))).map(([name]) => name);
+  const skillDrift = await downstreamDrift(manifest);
+  if (contractFailures.length || missingArtifacts.length || skillDrift.length) {
+    const report = { verification_mode: "first-slice", project_root: projectRoot, slice_contract_ref: sliceContractFile, scaffold_manifest_ref: manifestPath, generated_at: isoNow(), status: "failed", completion_level: manifest.completion_level, contract_failures: contractFailures, missing_artifacts: missingArtifacts, downstream_skill_drift: skillDrift, commands: [] };
+    await writeJsonAtomic(reportPath, report);
+    return report;
+  }
+
+  const mavenEvidence = path.join(evidenceDir, "maven");
+  const wrapper = await runScaffoldVerification(projectRoot, mavenEvidence, environment);
+  const passed = wrapper.status === "passed";
+  const report = { verification_mode: "first-slice", project_root: projectRoot, slice_contract_ref: sliceContractFile, scaffold_manifest_ref: manifestPath, generated_at: isoNow(), status: passed ? "passed" : "failed", failure_category: wrapper.failure_category, completion_level: passed ? "first-slice-verified" : manifest.completion_level, contract_failures: [], missing_artifacts: [], downstream_skill_drift: [], commands: wrapper.commands };
+  await writeJsonAtomic(reportPath, report);
+  if (passed) {
+    manifest.completion_level = "first-slice-verified";
+    manifest.first_slice_verification_ref = reportPath;
+    manifest.first_slice_verified_at = isoNow();
+    manifest.first_slice_contract = { contract_id: contract.contract_id, contract_version: contract.contract_version, slice_id: contract.slice_id, sha256: sha256(await readFile(sliceContractFile)) };
+    await writeJsonAtomic(manifestPath, manifest);
+  }
+  return report;
+}
+
+function parseArgs(argv) {
+  const result = {};
+  for (let index = 0; index < argv.length; index += 2) {
+    const flag = argv[index], value = argv[index + 1];
+    if (!["--project-root", "--evidence-dir", "--slice-contract-file"].includes(flag) || !value) throw new Error("usage: run_first_slice_verification.mjs --project-root DIR --evidence-dir DIR --slice-contract-file FILE");
+    result[flag.slice(2).replaceAll(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = value;
+  }
+  if (!result.projectRoot || !result.evidenceDir || !result.sliceContractFile) throw new Error("project root, evidence dir, and slice contract file are required");
+  return result;
+}
+
+async function main() {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const report = await runFirstSliceVerification(args.projectRoot, args.evidenceDir, args.sliceContractFile);
+    process.stdout.write(`${report.status}: ${path.join(path.resolve(args.evidenceDir), "first-slice-verification.json")}\n`);
+    return report.status === "passed" ? 0 : 1;
+  } catch (error) {
+    process.stderr.write(`first-slice verification failed: ${error.message}\n`);
+    return 1;
+  }
+}
+
+if (process.argv[1] && import.meta.url === new URL(`file://${process.argv[1]}`).href) process.exitCode = await main();

package/template/.codex/skills/yss-ddd-scaffold-generator/scripts/scaffold-generator.test.mjs

@@ -1,5 +1,6 @@
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
 import { chmod, mkdtemp, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { existsSync } from "node:fs";
 import os from "node:os";
@@ -15,6 +16,18 @@ const generator = path.join(scripts, "generate_scaffold.mjs");
 const workflow = path.join(scripts, "generate_and_verify_scaffold.mjs");
 const command = (args, options = {}) => new Promise((resolve) => execFile(process.execPath, [generator, ...args], { encoding: "utf8", ...options }, (error, stdout, stderr) => resolve({ code: error?.code ?? 0, stdout, stderr })));
 const workflowCommand = (args, options = {}) => new Promise((resolve) => execFile(process.execPath, [workflow, ...args], { encoding: "utf8", ...options }, (error, stdout, stderr) => resolve({ code: error?.code ?? 0, stdout, stderr })));
+async function treeDigest(root) {
+  const hash = createHash("sha256");
+  async function visit(directory) {
+    for (const entry of (await readdir(directory, { withFileTypes: true })).sort((left, right) => left.name.localeCompare(right.name))) {
+      const absolute = path.join(directory, entry.name);
+      if (entry.isDirectory()) await visit(absolute);
+      else if (entry.isFile()) hash.update(path.relative(root, absolute).split(path.sep).join("/")).update("\0").update(await readFile(absolute)).update("\0");
+    }
+  }
+  await visit(root);
+  return hash.digest("hex");
+}
 function contract(outputDir, overrides = {}) {
   return {
     schema_version: 2,
@@ -99,7 +112,7 @@ async function prepareVerifierProject(project, manifest = targetManifest()) {
   await writeFile(path.join(project, ".yss", "scaffold-generation.json"), `${JSON.stringify(manifest)}\n`);
 }
 
-test("生成批准的服务级 target profile 骨架，并写入可追溯 Manifest v2", async (t) => { const data = await fixture(); t.after(() => rm(data.root, { recursive: true, force: true })); const result = await command(data.args); assert.equal(result.code, 0, result.stderr); const project = path.join(data.output, "demo-service"); const manifest = JSON.parse(await readFile(path.join(project, ".yss/scaffold-generation.json"), "utf8")); assert.equal(manifest.schema_version, 2); assert.equal(manifest.scaffold_request_id, "scaffold-request-1"); assert.equal(manifest.slice_id, undefined); assert.equal(manifest.completion_level, "generated"); assert.equal(manifest.profiles.architecture, "target-domain-model"); assert.deepEqual(manifest.generation_policy, { mode: "initialize-only", existing_target: "unsupported", old_project_migration: "unsupported", template_upgrade: "unsupported" }); assert.match(manifest.generator.template_digest, /^[a-f0-9]{64}$/); assert.match(manifest.contract_digest, /^[a-f0-9]{64}$/); assert.ok(manifest.ownership.generated_files.length > 8); assert.ok(manifest.ownership.generated_files.every((item) => item.owner === "generator" && /^[a-f0-9]{64}$/.test(item.sha256))); assert.equal(manifest.generation_mode, "controlled-generation"); assert.deepEqual(manifest.verification_commands, ["./mvnw validate", "./mvnw test", "./mvnw package"]); assert.equal(manifest.bootstrap_main_class, "com.yss.demo.DemoServiceApplication"); assert.equal(manifest.bootstrap_main_source, "demo-service-bootstrap/src/main/java/com/yss/demo/DemoServiceApplication.java"); assert.match(await readFile(path.join(project, manifest.bootstrap_main_source), "utf8"), /class DemoServiceApplication/); assert.match(await readFile(path.join(project, "pom.xml"), "utf8"), /demo-service/); });
+test("生成批准的服务级 target profile 骨架，并写入可追溯 Manifest v2", async (t) => { const data = await fixture(); t.after(() => rm(data.root, { recursive: true, force: true })); const result = await command(data.args); assert.equal(result.code, 0, result.stderr); const project = path.join(data.output, "demo-service"); const manifest = JSON.parse(await readFile(path.join(project, ".yss/scaffold-generation.json"), "utf8")); assert.equal(manifest.schema_version, 2); assert.equal(manifest.scaffold_request_id, "scaffold-request-1"); assert.equal(manifest.slice_id, undefined); assert.equal(manifest.completion_level, "generated"); assert.equal(manifest.profiles.architecture, "target-domain-model"); assert.deepEqual(manifest.generation_policy, { mode: "initialize-only", existing_target: "unsupported", old_project_migration: "unsupported", template_upgrade: "unsupported" }); assert.match(manifest.generator.template_digest, /^[a-f0-9]{64}$/); assert.match(manifest.contract_digest, /^[a-f0-9]{64}$/); assert.ok(manifest.ownership.generated_files.length > 8); assert.ok(manifest.ownership.generated_files.every((item) => item.owner === "generator" && /^[a-f0-9]{64}$/.test(item.sha256))); assert.equal(manifest.generation_mode, "controlled-generation"); assert.deepEqual(manifest.verification_commands, ["./mvnw validate", "./mvnw test", "./mvnw package"]); assert.equal(manifest.bootstrap_main_class, "com.yss.demo.DemoServiceApplication"); assert.equal(manifest.bootstrap_main_source, "demo-service-bootstrap/src/main/java/com/yss/demo/DemoServiceApplication.java"); assert.match(await readFile(path.join(project, manifest.bootstrap_main_source), "utf8"), /class DemoServiceApplication/); assert.match(await readFile(path.join(project, "pom.xml"), "utf8"), /demo-service/); assert.equal(manifest.readiness.downstream_skills["yss-domain"], await treeDigest(path.resolve(scripts, "../../yss-domain"))); assert.match(manifest.readiness.contracts.scaffold_parent, /^[a-f0-9]{64}$/); assert.match(manifest.readiness.contracts.router_contract, /^[a-f0-9]{64}$/); });
 
 test("schema v1 scaffold contract is unsupported and is never upgraded", async (t) => {
   const data = await fixture({ schema_version: 1 });

package/template/.codex/skills/yss-domain/SKILL.md

@@ -47,7 +47,8 @@ description: 用于构建或重构 YSS 领域层代码。当用户要求设计
 
 - 命名体现业务语义，不照抄表名缩写。
 - 生成代码应可编译，且没有跨层依赖泄漏。
-- 对不确定规则写出假设或 TODO，不要伪装成已确认事实。
+- Domain Gateway interface 由本 skill 唯一拥有；Infrastructure 只能实现，不得由 `yss-repository` 反向创建或改写其签名。
+- 对不确定规则返回 `new_impacts` / `drift` 并暂停；不要把未批准假设或 TODO 写进实现冒充已确认事实。
 
 ## 协同顺序
 

package/template/.codex/skills/yss-domain/agents/openai.yaml

@@ -1,5 +1,5 @@
 version: 1
 interface:
   display_name: "YSS Domain"
-  short_description: "领域建模、聚合根、规则与网关设计实践落地标准化规范"
-  default_prompt: "Use $yss-domain to design aggregates, entities, domain gateways, and business rules for a YSS domain model."
+  short_description: "按批准战术模型实现聚合、规则与 Domain Gateway 接口"
+  default_prompt: "Use $yss-domain to implement approved aggregates, entities, business rules, domain tests, and the sole Domain Gateway interfaces; reroute instead of inventing unresolved rules."

package/template/.codex/skills/yss-domain/references/domain-layer-guide.md

@@ -41,6 +41,8 @@ DTO/VO 位于 `{base_package}.rest.dto`。独立 client Maven module 对当前 T
 
 Gateway 描述领域能力，只交换 Domain Model、领域值和领域标识。例如：
 
+Gateway interface 的签名由批准战术模型决定，并由 `yss-domain` 唯一创建和维护；Infrastructure / `yss-repository` 只能实现该接口。若实现所需能力超出既有签名，返回 `new_impacts` 并重路由，不得从 DDL 反向扩写 Domain 合同。
+
 ```java
 package com.yss.quality.domain.template.gateway;