create-yss-spec 3.4.1 → 3.4.3

package/template/scripts/lib/backend-platform.mjs

@@ -0,0 +1,175 @@
+import { assertSourceFingerprint } from "./backend-platform-provenance.mjs";
+/** Shared, exact backend platform selection. Catalog entries are maintenance-owned. */
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const PLATFORM_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+export const PLATFORM_CATALOG_REF = "docs/engineering/backend-platforms.json";
+export const PLATFORM_SKILLS = ["yss-ddd-scaffold-generator", "yss-layered-mvc-scaffold-generator"];
+const fail = (message) => { throw new TypeError(`backend-platform: ${message}`); };
+const stable = (value) => Array.isArray(value) ? value.map(stable) : value && typeof value === "object" ? Object.fromEntries(Object.keys(value).sort().map(key => [key, stable(value[key])])) : value;
+export const platformDigest = value => `sha256:${createHash("sha256").update(typeof value === "string" || Buffer.isBuffer(value) ? value : JSON.stringify(stable(value ?? null))).digest("hex")}`;
+export function loadBackendPlatforms(root = PLATFORM_ROOT) {
+  const value = JSON.parse(readFileSync(path.join(root, PLATFORM_CATALOG_REF), "utf8"));
+  if (value.schema_version !== 1 || value.kind !== "backend-platform-catalog" || !Array.isArray(value.profiles) || !Array.isArray(value.compatibility)) fail("invalid catalog");
+  if (new Set(value.profiles.map(item => `${item.id}:${item.spring_boot_version}:${item.java_version}`)).size !== value.profiles.length || new Set(value.compatibility.map(item => item.id)).size !== value.compatibility.length) fail("duplicate catalog release/id");
+  for (const profile of value.profiles) if (!/^\d+\.\d+\.\d+$/.test(profile.spring_boot_version)) fail("catalog requires exact patch versions");
+  return value;
+}
+export function platformProfile(id, catalog = loadBackendPlatforms(), version) {
+  const matches = catalog.profiles.filter(item => item.id === id && (!version || item.spring_boot_version === version));
+  if (matches.length > 1) fail("multiple patches: select an exact spring_boot_version");
+  const result = matches[0];
+  if (!result) fail(`unsupported platform_profile: ${id}`);
+  return result;
+}
+export function platformRecipeDigest(profile, entry) {
+  const { candidate_blockers, recommended, ...recipe } = profile;
+  return platformDigest({ profile: recipe, entry: { id: entry.id, profile_id: entry.profile_id, spring_boot_version: entry.spring_boot_version, parent: entry.parent, bom: entry.bom, components: entry.components ?? {} } });
+}
+export function platformBinding(profile, entry) {
+  return { schema_version: 2, profile_id: profile.id, spring_boot_version: profile.spring_boot_version, java_version: profile.java_version, parent: entry.parent, bom: entry.bom, compatibility_id: entry.id, compatibility_digest: platformRecipeDigest(profile, entry) };
+}
+export function resolveBackendPlatform(binding, { catalog = loadBackendPlatforms(), requireVerified = true, root = PLATFORM_ROOT } = {}) {
+  if (!binding || binding.schema_version !== 2) fail("missing platform_configuration v2 (v1 is historical read-only); 生命周期须展示 Boot/Java/YSS 组合并取得用户确认");
+  const profile = platformProfile(binding.profile_id, catalog, binding.spring_boot_version);
+  if (binding.spring_boot_version !== profile.spring_boot_version || binding.java_version !== profile.java_version) fail("unsupported exact Boot/Java combination (x/latest and Java 8/11 for Boot 3.5/4.1 are rejected)");
+  const entry = catalog.compatibility.find(item => item.id === binding.compatibility_id);
+  const evidenceReports = [];
+  if (!entry || entry.profile_id !== profile.id || entry.spring_boot_version !== profile.spring_boot_version) fail("YSS compatibility entry missing; parent/BOM/starter verification required");
+  if (platformDigest(binding) !== platformDigest(platformBinding(profile, entry))) fail("stale compatibility digest or YSS coordinates");
+  if (requireVerified) {
+    if (entry.status !== "verified") fail(`YSS combination ${entry.id} is not verified`);
+    if (!Array.isArray(entry.evidence) || !entry.evidence.length) fail("verified combination lacks evidence");
+    for (const item of entry.evidence) {
+      if (!item.ref || !item.digest || path.isAbsolute(item.ref) || item.ref.split(/[\\/]/).includes("..")) fail("invalid portable evidence reference");
+      const bytes = readFileSync(path.join(root, item.ref));
+      if (platformDigest(bytes) !== item.digest) fail("compatibility evidence drift");
+      const report = JSON.parse(bytes);
+      if (report.verification_scope !== "empty-scaffold") fail("qualification requires empty-scaffold evidence");
+      if (report.recipe_digest !== platformRecipeDigest(profile, entry)) fail("evidence recipe drift");
+      assertSourceFingerprint(report.source_fingerprint, report.architecture_family);
+      if (!/^sha256:[a-f0-9]{64}$/.test(report.generated_tree_digest ?? "")) fail("missing generated tree digest");
+      evidenceReports.push(report);
+      if (report.status !== "passed" || report.spring_boot_version !== profile.spring_boot_version || report.java_version !== profile.java_version || report.architecture_family !== item.architecture_family || platformDigest(report.parent) !== platformDigest(entry.parent) || platformDigest(report.bom) !== platformDigest(entry.bom)) fail("compatibility evidence identity mismatch");
+      for (const phase of ["validate", "test", "package"]) if (!report.commands?.some(cmd => cmd.command === `./mvnw ${phase}` && cmd.exit_code === 0 && cmd.stdout_ref && cmd.stderr_ref && cmd.executed_at)) fail("missing real Maven evidence");
+      if (report.dependency_check !== "passed" || report.startup_check !== "passed" || report.integration_tests?.status !== "passed") fail("missing dependency/startup/integration-test evidence");
+      const required = ["effective-pom.xml", "dependency-trees.json", "platform-tests.xml", "boot-bom-effective.xml", "runtime-jar-entries.log", "startup.stdout.log", "startup.stderr.log", ...["validate", "test", "package"].flatMap(phase => [`mvnw-${phase}.stdout.log`, `mvnw-${phase}.stderr.log`])];
+      if (!Array.isArray(report.evidence_artifacts) || required.some(ref => !report.evidence_artifacts.some(artifact => artifact.ref === ref))) fail("missing portable evidence artifacts");
+      for (const artifact of report.evidence_artifacts) {
+        if (!artifact.ref || path.isAbsolute(artifact.ref) || artifact.ref.split(/[\\/]/).includes("..")) fail("invalid evidence artifact path");
+        if (platformDigest(readFileSync(path.join(root, path.dirname(item.ref), artifact.ref))) !== artifact.digest) fail("evidence artifact drift");
+      }
+    }
+  }
+  return { profile, entry, evidenceReports };
+}
+export function assertContractPlatform(contract, decision, options = {}) {
+  const binding = contract.platform_configuration;
+  const resolved = resolveBackendPlatform(binding, options);
+  if (contract.profiles?.platform !== resolved.profile.id || contract.profiles?.validation_namespace !== resolved.profile.validation_namespace) fail("platform and validation_namespace are inconsistent");
+  if (platformDigest(contract.maven_coordinates?.parent) !== platformDigest(binding.parent) || contract.maven_coordinates?.yss_components_version !== binding.bom.version || binding.bom.group_id !== "com.yss.cloud" || binding.bom.artifact_id !== "yss-components-bom") fail("YSS Maven coordinates mismatch");
+  if (decision && platformDigest(decision.platform_configuration) !== platformDigest(binding)) fail("decision/contract platform_configuration mismatch");
+  if (options.requireVerified !== false && !resolved.entry.evidence?.some(item => item.architecture_family === contract.architecture_family)) fail("architecture has no compatibility evidence");
+  for (const capability of contract.module_profile?.requested_capabilities ?? []) if (!resolved.entry.capabilities?.includes(capability)) fail(`unverified capability: ${capability}`);
+  if (options.requireVerified !== false && !resolved.evidenceReports.some(report => report.architecture_family === contract.architecture_family && (contract.module_profile?.requested_capabilities ?? []).every(capability => report.verified_capabilities?.includes(capability)))) fail("architecture/capability combination lacks evidence");
+  return resolved;
+}
+export function assertPlatformAgreement(left, right) {
+  if (platformDigest(left) !== platformDigest(right)) fail("platform_configuration drift between contract and Manifest");
+}
+export function javaMajor(output) {
+  const value = output.match(/(?:java|openjdk) version "(?:1\.)?(\d+)|Java version:\s*(?:1\.)?(\d+)/i);
+  return value ? Number(value[1] ?? value[2]) : null;
+}
+export function assertJavaPlatform(output, binding) {
+  if (javaMajor(output) !== binding.java_version) fail(`JDK mismatch: expected Java ${binding.java_version}`);
+}
+export function platformTemplateVars(profile) {
+  return { boot_version: profile.spring_boot_version, java_version: profile.java_version === 8 ? "1.8" : String(profile.java_version), java_range: profile.java_version === 8 ? "[1.8,1.9)" : `[${profile.java_version},${profile.java_version + 1})`, web_starter: profile.web_starter, web_test_starter: profile.web_test_starter, aop_starter: profile.aop_starter, swagger_artifact: profile.swagger_artifact, ...Object.fromEntries(Object.entries(profile.versions).map(([key, value]) => [`${key}_version`, value])) };
+}
+
+export function platformSmokeTest(basePackage, profile, capabilities = []) {
+  const mapper = profile.jackson_major === 3 ? "tools.jackson.databind.json.JsonMapper" : "com.fasterxml.jackson.databind.ObjectMapper";
+  return `package ${basePackage};
+
+import ${profile.validation_namespace}.validation.Validator;
+import ${profile.validation_namespace}.validation.Valid;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Import;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import ${profile.validation_namespace}.validation.constraints.NotBlank;
+import ${mapper};
+import org.apache.ibatis.annotations.Select;
+import org.apache.ibatis.session.SqlSession;
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import static org.junit.jupiter.api.Assertions.*;
+
+/** Mechanical integration only: no business endpoint or production storage. */
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+@Import(PlatformIntegrationTest.ProbeController.class)
+@ActiveProfiles("scaffold-test")
+class PlatformIntegrationTest {
+    @Value("\${local.server.port}") int port;
+    @Autowired Validator validator;
+    public static class ProbePayload {
+        @NotBlank private String value;
+        public String getValue() { return value; }
+        public void setValue(String value) { this.value = value; }
+    }
+    @RestController
+    public static class ProbeController {
+        @PostMapping(value = "/__scaffold_probe", consumes = "application/json", produces = "application/json")
+        public ProbePayload echo(@Valid @RequestBody ProbePayload body) { return body; }
+    }
+    @Test void httpJsonRoundTrip() throws Exception { httpProbe("probe", 200); }
+    @Test void httpValidationRejectsBlank() throws Exception { httpProbe("", 400); }
+    private void httpProbe(String value, int expectedStatus) throws Exception {
+        java.net.HttpURLConnection connection = (java.net.HttpURLConnection) new java.net.URL("http://127.0.0.1:" + port + "/__scaffold_probe").openConnection();
+        connection.setConnectTimeout(5000); connection.setReadTimeout(5000);
+        connection.setRequestMethod("POST"); connection.setRequestProperty("Content-Type", "application/json"); connection.setDoOutput(true);
+        ProbePayload request = new ProbePayload(); request.setValue(value);
+        try {
+            try (java.io.OutputStream stream = connection.getOutputStream()) { stream.write(mapper.writeValueAsBytes(request)); }
+            assertEquals(expectedStatus, connection.getResponseCode());
+            if (expectedStatus == 200) {
+                assertTrue(connection.getContentType().startsWith("application/json"));
+                try (java.io.InputStream stream = connection.getInputStream()) { assertEquals(value, mapper.readValue(stream, ProbePayload.class).getValue()); }
+            }
+        } finally { connection.disconnect(); }
+    }
+    @Autowired ${mapper.split(".").at(-1)} mapper;
+    @Autowired SqlSessionFactory sqlSessionFactory;
+    static final class ValidationProbe { @NotBlank String value = ""; }
+    @Test void validationAndJsonAutoConfiguration() throws Exception {
+        assertFalse(validator.validate(new ValidationProbe()).isEmpty());
+        assertEquals("\\\"probe\\\"", mapper.writeValueAsString("probe"));
+    }
+    interface ProbeMapper { @Select("SELECT 1") int probe(); }
+    @Test void mybatisCanMapVerificationQuery() throws Exception {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            if (!session.getConfiguration().hasMapper(ProbeMapper.class)) session.getConfiguration().addMapper(ProbeMapper.class);
+            assertEquals(1, session.getMapper(ProbeMapper.class).probe());
+        }
+    }
+${capabilities.includes("feign-client") ? `    @Autowired org.springframework.cloud.openfeign.${profile.java_version === 8 ? "FeignContext" : "FeignClientFactory"} feignFactory;
+    @Test void feignCanDecodeJson() throws Exception {
+        feign.codec.Decoder decoder = feignFactory.getInstance("platform-probe", feign.codec.Decoder.class);
+        assertNotNull(decoder);
+        feign.Request request = feign.Request.create(feign.Request.HttpMethod.GET, "http://localhost/probe", java.util.Collections.emptyMap(), (byte[]) null, java.nio.charset.StandardCharsets.UTF_8, null);
+        feign.Response response = feign.Response.builder().request(request).status(200).reason("OK")
+            .headers(java.util.Collections.singletonMap("Content-Type", java.util.Collections.singletonList("application/json")))
+            .body("{}", java.nio.charset.StandardCharsets.UTF_8).build();
+        assertTrue(decoder.decode(response, java.util.Map.class) instanceof java.util.Map);
+    }
+` : ""}}
+`;
+}

package/template/scripts/lib/backend-scaffold-prerequisites.mjs

@@ -102,7 +102,7 @@ export async function validateBackendScaffoldPrerequisites(contract, { contractF
   const approvalRef = prerequisites.engineering_contract_approval_ref;
   if (approvalRef !== contract.lifecycle_approval_ref || approvalRef !== contract.approval?.approval_ref) fail("工程合同批准引用与脚手架合同不一致");
   const approvalFile = resolveLocalRef(root, approvalRef, "工程合同批准记录");
-  const approval = loadApprovalRecord(approvalFile);
+  const approval = loadApprovalRecord(approvalFile, 'gate.engineering-contract-approved');
   validateApprovalRecord(approval, { requireApproved: true, root });
   if (approval.gate_id !== "gate.engineering-contract-approved") fail("工程合同批准记录 gate_id 必须为 gate.engineering-contract-approved");
   if (!Array.isArray(approval.approval_scope) || !approval.approval_scope.includes(contract.contract_id) || !approval.approval_scope.includes(contract.project_name)) fail("工程合同批准范围未覆盖当前合同和项目");

package/template/scripts/lib/decision-continuation.mjs

@@ -0,0 +1,79 @@
+import { decisionIO, decisionDigest, decisionError, assertUserDecisionRequirement } from './user-decision.mjs';
+
+export const CONTINUATION_CAPABILITY = 'approved-scope-continuation-v1';
+const fail = message => decisionError('user-decision-continuation-invalid', message);
+const strings = value => Array.isArray(value) && value.length > 0 && value.every(x => typeof x === 'string' && x.trim()) && new Set(value).size === value.length;
+const sameSet = (a, b) => strings(a) && strings(b) && a.length === b.length && a.every(x => b.includes(x));
+const basisFields = ['business_scope', 'acceptance', 'contract_commitments', 'authorization', 'risk_acceptance', 'quality', 'external_commitments'];
+
+// A continuation validates an explicit human mandate and an independent current
+// review. It never infers semantic equivalence from whitespace or a boolean flag.
+export function assertDecisionContinuation(requirement, roles, options = {}) {
+  const io = decisionIO(options);
+  const policy = roles.user_decision_policy.continuation;
+  if (policy?.capability !== CONTINUATION_CAPABILITY || !policy.boundaries.includes(requirement.boundary)) fail('未授权的延续边界');
+  const proof = io.document(requirement.continuation_ref);
+  if (proof.schema_version !== 1 || proof.kind !== CONTINUATION_CAPABILITY || proof.boundary !== requirement.boundary || proof.subject?.ref !== requirement.subject_ref || !sameSet(proof.scope, requirement.scope)) fail('当前边界、资产或范围不匹配');
+  const current = (asset, parse = true) => {
+    if (!asset?.ref || !asset.version || !asset.digest || decisionDigest(io.bytes(asset.ref)) !== asset.digest) fail(`当前证据缺失或过期: ${asset?.ref}`);
+    return parse ? io.document(asset.ref) : null;
+  };
+  if (!proof.source || proof.source.continuation_ref || proof.source.boundary !== 'delivery-scope') fail('必须引用原始交付范围批准，不能链式扩权');
+  const sourceResult = assertUserDecisionRequirement(proof.source, { ...options, rolesDoc: roles });
+  const mandate = io.document(proof.source.subject_ref);
+  if (mandate.schema_version !== 1 || mandate.kind !== 'delivery-authorization' || !Array.isArray(mandate.targets)) fail('缺少已展示并批准的交付授权清单');
+  if (!requirement.scope.every(x => proof.source.scope.includes(x))) fail('超出原始批准范围');
+  const matches = mandate.targets.filter(x => x.boundary === requirement.boundary && x.subject_ref === requirement.subject_ref && requirement.scope.every(s => x.scope?.includes(s)));
+  if (matches.length !== 1) fail('原授权未唯一覆盖当前边界、资产和范围');
+  const target = matches[0];
+  if (!basisFields.every(key => strings(target.decision_basis?.[key]))) fail('原授权缺少业务、验收、契约、授权、风险、质量或对外承诺依据');
+  if (!Array.isArray(mandate.basis) || !mandate.basis.length) fail('原授权缺少可读取的决定依据');
+  for (const asset of mandate.basis) {
+    if (!asset.ref || !asset.version || decisionDigest(io.bytes(asset.ref)) !== asset.digest) fail('原授权决定依据变化，须重新决定');
+  }
+  const external = current(mandate.external_policy);
+  if (external.status !== 'confirmed' || !Array.isArray(external.requirements)) fail('项目外部审批要求尚未确认，不能自动延续');
+  current(proof.subject, false);
+  if (requirement.boundary === 'implementation-scope') {
+    const manifest = io.document(proof.subject.ref);
+    if (manifest.kind !== 'implementation-scope' || !Array.isArray(manifest.slices)) fail('实施范围清单无效');
+    for (const ticket of requirement.scope) {
+      const slices = manifest.slices.filter(x => x.ticket_ref === ticket);
+      const limit = target.implementation_limits?.[ticket];
+      if (slices.length !== 1 || !limit || !sameSet(slices[0].repositories, limit.repositories) || !sameSet(slices[0].allowed_write_paths, limit.allowed_write_paths)) fail('实施仓库或写路径超出原授权边界');
+    }
+  }
+  if (!Array.isArray(proof.basis) || !proof.basis.length) fail('缺少本次实际验证证据');
+  for (const asset of proof.basis) {
+    if (!asset.ref || !asset.version || decisionDigest(io.bytes(asset.ref)) !== asset.digest) fail('本次验证证据过期');
+  }
+  const review = current(proof.review);
+  const actor = roles.roles.find(x => x.id === review.role_id);
+  if (!actor || !roles.runtimes.some(x => x.id === review.runtime_id) || !review.principal_ref || !review.drafter_principal_ref || review.principal_ref === review.drafter_principal_ref) fail('缺少独立专业审查身份');
+  const eligible = roles.gate_policy.continuation_reviews?.[requirement.boundary] || roles.gate_policy.dual_digital_human?.find(x => x.gate === requirement.boundary)?.countersigners;
+  if (!eligible?.includes(review.role_id)) fail('审查能力不覆盖当前边界');
+  if (review.decision !== 'approved' || !['within-approved-scope', 'presentation-only', 'implementation-detail'].includes(review.classification)) fail('未知或实质变化须重新决定');
+  if (!Array.isArray(review.material_changes) || review.material_changes.length || !Array.isArray(review.findings)) fail('存在实质变化或未完成影响分析');
+  for (const finding of review.findings) {
+    if (!finding.id || !finding.reason || !['requirement-violation', 'missing-evidence', 'important-risk', 'suggestion'].includes(finding.kind)) fail('审查发现未分类');
+    if (finding.kind === 'suggestion' && !finding.follow_up) fail('非阻断建议缺少待办去向');
+    if (finding.kind !== 'suggestion' && finding.status !== 'resolved') fail('未解决的缺陷、证据缺口或重要风险');
+  }
+  if (review.boundary !== requirement.boundary || !sameSet(review.scope, requirement.scope) || decisionDigest(review.subject) !== decisionDigest(proof.subject) || decisionDigest(review.basis) !== decisionDigest(proof.basis)) fail('审查未绑定当前资产、范围和验证证据');
+  if (decisionDigest(review.decision_basis) !== decisionDigest(target.decision_basis)) fail('决定依据有实质变化');
+  if (!review.reason?.trim() || !review.comparison?.before || !review.comparison?.after) fail('缺少可审阅的前后差异和等价性说明');
+  // Before is an immutable, originally approved snapshot; after is the current candidate.
+  const before = review.comparison.before;
+  if (!mandate.basis.some(x => decisionDigest(x) === decisionDigest(before)) || decisionDigest(review.comparison.after) !== decisionDigest(proof.subject)) fail('前后差异未绑定原授权快照和当前资产');
+  for (const obligation of external.requirements) {
+    if (!obligation.id || !strings(obligation.boundaries) || !strings(obligation.principals)) fail('外部审批制度记录不完整');
+    if (!obligation.boundaries.includes(requirement.boundary)) continue;
+    for (const principal of obligation.principals) {
+      const reply = proof.external_decisions?.find(x => x.obligation_id === obligation.id && x.principal_ref === principal);
+      if (!reply || reply.requirement?.continuation_ref || reply.requirement?.boundary !== requirement.boundary || reply.requirement?.subject_ref !== requirement.subject_ref || !sameSet(reply.requirement?.scope, requirement.scope)) fail('外部强制审批缺失或范围不符');
+      const result = assertUserDecisionRequirement(reply.requirement, { ...options, rolesDoc: roles });
+      if (!result.validated.length || result.validated.some(x => x.principal_ref !== principal)) fail('外部审批人与制度要求不符');
+    }
+  }
+  return { ...sourceResult, continued: true, review_ref: proof.review.ref };
+}

package/template/scripts/lib/delivery-preflight.mjs

@@ -1,3 +1,4 @@
+import { normalizeSliceContract, sourceSliceContract, parseSliceYaml } from './slice-contract.mjs';
 import { assertExistingSliceStructure, createApprovedExecutionContext, verifySliceContractApproval } from './approved-execution-context.mjs';
 import path from 'node:path';
 import { readFileSync, existsSync } from 'node:fs';
@@ -46,7 +47,7 @@ function requireBackendCapability(key) {
 }
 
 /** Read-only: never executes input commands, starts services, unpacks archives or writes receipts. */
-export async function preflightDelivery(input,{stage,root=process.cwd()}={}) {
+export async function preflightDelivery(input,{stage,root=process.cwd(),work_unit_id}={}) {
   try { ensure(STAGES.includes(stage),'未知阶段；必须是 prepare|build|export|accept');schema(input,'docs/process/schemas/delivery-preflight-input.schema.json'); }
   catch(error) { return invalidPreflightInput(error.message); }
   root=path.resolve(root,input.governance_root||'.');
@@ -78,7 +79,7 @@ export async function preflightDelivery(input,{stage,root=process.cwd()}={}) {
     if(input.architecture_identity.source_kind==='existing-registration')ensure(input.architecture_identity.repository_id===input.scope.repository_id&&input.architecture_identity.project_id===input.scope.project_id,'架构身份与预检目标仓库/项目不一致');
   },{source:'architecture_identity'});
   if(valid.has('architecture.identity'))await run('architecture.profile',()=>{ensure(architecture.validateArchitectureIdentity(input.architecture_identity).maturity==='supported','不支持未达到 supported 的 architecture_profile');},{source:'architecture_profile'});
-  if(['build','export','accept'].includes(stage)&&assets.slice_contract)await run('slice_contract.execution',()=>{requireBackendCapability('slice_contract');execution=createApprovedExecutionContext(assets.slice_contract,{root});},{from:'build',source:assets.slice_contract.approval_ref||'slice_contract',evidence:[assets.slice_contract.ref,...(assets.slice_contract.approval_ref?[assets.slice_contract.approval_ref]:[])]});
+  if(['build','export','accept'].includes(stage)&&assets.slice_contract)await run('slice_contract.execution',()=>{requireBackendCapability('slice_contract');execution=createApprovedExecutionContext(assets.slice_contract,{root,work_unit_id});},{from:'build',source:assets.slice_contract.approval_ref||'slice_contract',evidence:[assets.slice_contract.ref,...(assets.slice_contract.approval_ref?[assets.slice_contract.approval_ref]:[])]});
   const archDeps=['architecture.identity',...['repository_registration','engineering_baseline','manifest'].map(x=>`architecture.${x}`)];
   if(archDeps.every(x=>valid.has(x)))await run('architecture',()=>{
     ensure(typeof architecture.verifyArchitectureEvidence==='function','不支持既有工程原始证据验证，请同步支持该身份版本的模板运行时');
@@ -143,12 +144,12 @@ async function verifyAsset(key,data,binding,{root,input,documents,assets,executi
     await validateTechnicalDesign(data,{root,sliceRef:input.scope.slice_id,readOnly:true,execution});
     await approved(root,binding,['gate.engineering-contract-approved','gate.technical-design-approved']);
   } else if(key==='slice_contract') {
-    const contract=data.slice_contract||data;
+    const contract=normalizeSliceContract(data,{root});
     assertExistingSliceStructure(contract);
-    ensure(contract.schema_version===2&&contract.status==='approved'&&contract.slice_id===input.scope.slice_id,'Slice 合同版本、批准状态或切片不匹配');
+    ensure([2,3].includes(contract.schema_version)&&contract.status==='approved'&&contract.slice_id===input.scope.slice_id,'Slice 合同版本、批准状态或切片不匹配');
     ensure(binding.id===contract.contract_id&&binding.version===contract.contract_version,'Slice 合同身份与引用不一致');
     const compiler=read(safe(ROOT,'.agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml'));
-    for(const [section,fields]of Object.entries(compiler.slice_contract_required))for(const field of fields)ensure(Object.hasOwn(section==='root'?contract:contract[section]||{},field),`合同缺少 ${section}.${field}`);
+    if(contract.schema_version===2)for(const [section,fields]of Object.entries(compiler.slice_contract_required))for(const field of fields)ensure(Object.hasOwn(section==='root'?contract:contract[section]||{},field),`合同缺少 ${section}.${field}`);
     ensure(contract.readiness.blockers.length===0&&contract.readiness.stale_inputs.length===0,'Slice 合同仍有 blocker 或 stale input');
     const resolution=contract.resolution;
     ensure(resolution.freshness==='current','Slice resolution 非 current');

package/template/scripts/lib/digital-human-roles.mjs

@@ -388,6 +388,16 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
   }
 
   const decisions = doc.user_decision_policy;
+  if (decisions?.continuation) {
+    const continuation = decisions.continuation;
+    if (continuation.capability !== 'approved-scope-continuation-v1' || continuation.source_boundary !== 'delivery-scope' || continuation.unknown_change !== 'blocked' || continuation.external_policy_unconfirmed !== 'no-automatic-continuation') fail('授权延续策略不能省略未知变化或外部制度保护');
+    requireStringArray(continuation.boundaries, 'continuation.boundaries');
+    for (const boundary of continuation.boundaries) {
+      if (!gateIds.has(boundary) && boundary !== 'implementation-scope') fail(`未支持的延续边界: ${boundary}`);
+      requireStringArray(policy.continuation_reviews?.[boundary], `${boundary}.continuation_reviews`);
+      for (const role of policy.continuation_reviews[boundary]) if (!actors.has(role)) fail(`未知延续审查角色: ${role}`);
+    }
+  }
   if (decisions?.schema_version !== 1 || decisions.default_responder !== "requester" || decisions.delegate_requires_requester_evidence !== true) fail("缺少统一用户决定策略");
   requireStringArray(decisions.gates, "user_decision_policy.gates");
   for (const gate of decisions.gates) if (!gateIds.has(gate)) fail(`用户决定引用未知门禁: ${gate}`);

package/template/scripts/lib/frontend-delivery-boundary.mjs

@@ -1,3 +1,4 @@
+import { normalizeSliceContract, sourceSliceContract, parseSliceYaml } from './slice-contract.mjs';
 import { loadDeliveryProfile } from './harness-execution-scope.mjs';
 import { existsSync } from 'node:fs';
 import path from 'node:path';
@@ -8,6 +9,7 @@ import { ROOT, read, safe, ensure, digest } from './strategic-handoff-io.mjs';
 // Always re-executes the verifier; a caller-supplied "verified" flag is never evidence.
 export function enforceFrontendDelivery(state={}, {root=ROOT,phase='inputs'}={}) {
   ensure(['preflight','design','contract','inputs','implementation','verification'].includes(phase),`未知前端交付阶段: ${phase}`);
+  if(state.schema_version===3)state=normalizeSliceContract(state,{root});
   const profile=loadDeliveryProfile(root);
   let contract;
   const contractRef=state.slice_contract_ref||state.contract?.slice_contract_ref;
@@ -35,6 +37,7 @@ export function enforceFrontendDelivery(state={}, {root=ROOT,phase='inputs'}={})
     const file=path.resolve(root,contractRef);
     if(existsSync(file)) {
       const document=read(file);contract=document.slice_contract||document;
+      if(contract.schema_version===3)contract=normalizeSliceContract(contract,{root});
       const direct=contract.frontend?.delivery, resolved=contract.resolution?.frontend_delivery;
       ensure(!direct||!resolved||digest(direct)===digest(resolved),'Slice Contract 前端交付绑定冲突');
       binding=direct||resolved||binding;

package/template/scripts/lib/implementation-contract-compiler.mjs

@@ -1,3 +1,6 @@
+import { resolveBackendPlatform } from "./backend-platform.mjs";
+import { safe } from './strategic-handoff-io.mjs';
+import { selectSliceWorkUnit, normalizeSliceContract, withinSlicePath } from './slice-contract.mjs';
 import { createApprovedExecutionContext, createApprovedRecompilationContext, assertApprovedExecutionContext } from './approved-execution-context.mjs';
 import { enforceTechnicalDesign } from './technical-design-boundary.mjs';
 import { enforceHarnessSkillScope } from "./harness-execution-scope.mjs";
@@ -67,13 +70,15 @@ export function compileImplementationContract({
   architecture_identity,
   architecture_evidence,
   approved_slice,
+  work_unit_id,
   root = ROOT,
   slice_id,
   frontend_delivery,
-  technical_design
+  technical_design,
+  readOnly = false
 }) {
   assertV2(registry, compilerContract);
-  const recompilationExecution=approved_slice?createApprovedRecompilationContext(approved_slice,{root}):undefined;
+  const recompilationExecution=approved_slice?createApprovedRecompilationContext(approved_slice,{root,work_unit_id}):undefined;
   const deliveryInput = enforceFrontendDelivery({ slice_id, frontend_delivery }, { root });
   if (!Array.isArray(recipeIds) || !Array.isArray(requiredCapabilities) || !Array.isArray(conditions)) {
     fail("recipeIds、requiredCapabilities 与 conditions 必须是数组");
@@ -96,7 +101,8 @@ export function compileImplementationContract({
     for (const recipe of orderedRecipes) if (recipe.architecture_family && recipe.architecture_family !== architecture_identity.architecture_family) fail(`Recipe ${recipe.id} 与架构族不匹配`);
   }
 
-  enforceTechnicalDesign({ technical_design, conditions, architecture_identity, slice_id }, { root, execution:recompilationExecution });
+  if (architecture_identity?.platform_configuration) resolveBackendPlatform(architecture_identity.platform_configuration);
+  enforceTechnicalDesign({ technical_design, conditions, architecture_identity, slice_id }, { root, execution:recompilationExecution, readOnly });
 
   const capabilitySources = new Map();
   const orderedCapabilities = [];
@@ -206,14 +212,17 @@ export function compileDefaultImplementationContract(input = {}) {
   });
 }
 
-export function evaluateContractFreshness(contract, { registry, compilerContract, root = ROOT, approved_slice, readOnly = false }, execution) {
+export function evaluateContractFreshness(contract, { registry, compilerContract, root = ROOT, approved_slice, readOnly = false, work_unit_id }, execution) {
   assertV2(registry, compilerContract);
-  if (contract?.schema_version !== 2) fail("Slice Implementation Contract schema v1 已停止支持；必须重新编译 v2 合同");
+  try { contract=normalizeSliceContract(contract,{root}); } catch(error) { return {freshness:'stale',reasons:[error.message]}; }
+  if (![2,3].includes(contract?.schema_version)) fail("Slice Implementation Contract schema v1 已停止支持；必须重新编译 v2 合同");
+  const all=contract;
+  try {contract=selectSliceWorkUnit(contract,work_unit_id);} catch(error){return {freshness:'stale',reasons:[error.message]};}
   const resolution = contract.resolution ?? contract;
   const reasons = [];
   let trustedExecution;
   try {
-    trustedExecution=approved_slice?createApprovedExecutionContext(approved_slice,{root,contract}):execution;
+    trustedExecution=approved_slice?createApprovedExecutionContext(approved_slice,{root,contract:all,work_unit_id}):execution;
     if(trustedExecution)assertApprovedExecutionContext(trustedExecution,{root,contract});
   } catch(error) { reasons.push(error.code||'EXECUTION_APPROVAL_INVALID');trustedExecution=undefined; }
   try { enforceTechnicalDesign({ ...resolution, slice_id: contract.slice_id ?? resolution.slice_id }, { root,execution:trustedExecution,readOnly }); }
@@ -236,11 +245,13 @@ export function evaluateContractFreshness(contract, { registry, compilerContract
 
 export function validateExecutionResult(result, contract, current) {
   if (result?.schema_version !== 2) fail("YSS Skill Execution Result schema v1 已停止支持；请迁移到 v2");
-  if (contract?.schema_version !== 2) fail("Slice Implementation Contract schema v1 已停止支持；必须重新编译 v2 合同");
+  contract=normalizeSliceContract(contract,{root:current?.root || ROOT});
+  if (![2,3].includes(contract?.schema_version)) fail("Slice Implementation Contract schema v1 已停止支持；必须重新编译 v2 合同");
   if (!EXECUTION_STATUSES.has(result.status)) fail(`未知 execution result status: ${result.status}`);
-  if(contract.resolution?.architecture_identity?.schema_version===2&&!current?.approved_slice)return {status:'stale',blockers:['EXECUTION_APPROVAL_REQUIRED']};
-  const freshness = evaluateContractFreshness(contract, current);
+  if((contract.schema_version===3||contract.resolution?.architecture_identity?.schema_version===2)&&!current?.approved_slice)return {status:'stale',blockers:['EXECUTION_APPROVAL_REQUIRED']};
+  const freshness = evaluateContractFreshness(contract, {...current,work_unit_id:result.work_unit_id});
   if (freshness.freshness === "stale") return { status: "stale", blockers: freshness.reasons };
+  contract=selectSliceWorkUnit(contract,result.work_unit_id);
   const consumed = result.consumed_contract ?? {};
   const resolution = contract.resolution ?? contract;
   const blockers = [];
@@ -253,6 +264,28 @@ export function validateExecutionResult(result, contract, current) {
     if (!item?.command || item.exit_code === undefined || !item.executed_at) blockers.push("verification-result-incomplete");
     else if (item.exit_code !== 0) blockers.push("verification-failed");
   }
+  if(contract.schema_version===3) {
+    const unit=contract.work_units.find(item=>item.id===result.work_unit_id);
+    if(!unit)blockers.push('work-unit-mismatch');
+    else {
+      const checks=unit.work_unit.verification;
+      for(const check of checks)if(!result.verification_results?.some(item=>item.command===check.command&&item.exit_code===0&&item.cwd===check.cwd&&(!check.dependency_roots||JSON.stringify(item.dependency_roots)===JSON.stringify(check.dependency_roots))))blockers.push('verification-coverage-or-cwd-missing');
+      if(!Array.isArray(result.changed_files))blockers.push('changed-files-missing');
+      else for(const item of result.changed_files) {
+        const changed=typeof item==='string'?item:item.path;
+        if(contract.repositories&&(typeof item==='string'||item.project_root!==unit.project_root))blockers.push('changed-file-repository-mismatch');
+        if(!unit.allowed_write_paths.some(parent=>withinSlicePath(changed,parent)))blockers.push('write-scope-violation');
+      }
+      const evidence=result.evidence_files||[];
+      for(const ref of unit.work_unit.expected_evidence) {
+        if(!evidence.some(item=>(typeof item==='string'?item:item.path)===ref&&(!contract.repositories||item.project_root===unit.project_root)))blockers.push('expected-evidence-missing');
+        else {try {readFileSync(safe(contract.repositories?unit.project_root:(current.root||ROOT),ref));}catch {blockers.push('expected-evidence-unreadable');}}
+      }
+    }
+    if(['drift','violation'].includes(result.status))blockers.push(result.status);
+    if(result.status==='not-applicable'&&!result.not_applicable_reason?.trim())blockers.push('not-applicable-reason-missing');
+    if(result.status==='seam-deferred'&&(!result.seam_deferred?.length||result.seam_deferred.some(item=>['risk','owner','follow_up_ticket','verification_plan','target_version_or_release_date'].some(key=>!item[key]))))blockers.push('seam-deferred-incomplete');
+  }
   if (Array.isArray(result.new_impacts) && result.new_impacts.length) blockers.push("new-impacts");
   return { status: blockers.length ? "blocked" : "accepted", blockers: [...new Set(blockers)] };
 }

package/template/scripts/lib/lifecycle-controls.mjs

@@ -46,7 +46,7 @@ export function assertGateChecks(gateId, state, { root = ROOT, registry = loadRe
     const rule = countersignRuleForGate(rolesDoc.gate_policy, id);
     if (rule) {
       if (!refs.has(item.approval_ref) || !refs.has(item.subject_ref)) fail(`${id} 未绑定审查与资产`);
-      const record = loadApprovalRecord(path.resolve(root, item.approval_ref));
+      const record = loadApprovalRecord(path.resolve(root, item.approval_ref), id);
       if (record.gate_id !== id || record.subject_ref !== item.subject_ref) fail(`${id} 审查对象不匹配`);
       if (!item.approval_scope?.length || JSON.stringify([...item.approval_scope].sort()) !== JSON.stringify([...(record.approval_scope || [])].sort())) fail(`${id} 审查范围不匹配`);
       const subjectDigest = createHash('sha256').update(readFileSync(path.resolve(root, item.subject_ref))).digest('hex');
@@ -65,7 +65,7 @@ export function assertGateChecks(gateId, state, { root = ROOT, registry = loadRe
   const approvalRequired = countersignRuleForGate(rolesDoc.gate_policy, gateId);
   if (approvalRequired) {
     if (!refs.has(item.approval_ref) || !refs.has(item.subject_ref)) fail(`${gateId} 缺少已绑定批准记录和审阅包`);
-    const record = loadApprovalRecord(path.resolve(root, item.approval_ref));
+    const record = loadApprovalRecord(path.resolve(root, item.approval_ref), gateId);
     if (!record.drafter_principal_ref || record.drafter_principal_ref === record.principal_ref) fail(`${gateId} 缺少独立审查身份或起草者自签`);
     const bytes = readFileSync(path.resolve(root, item.subject_ref));
     if (record.subject_ref !== item.subject_ref || record.subject_digest !== createHash('sha256').update(bytes).digest('hex')) fail(`${gateId} 批准依据过期`);

package/template/scripts/lib/lifecycle-transition.mjs

@@ -1,3 +1,5 @@
+// Wire capability marker: profile-local readiness rules are not interchangeable.
+export const SLICE_REPOSITORY_PREPARATION_PROTOCOL = 1;
 import { createHash } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { parseDocument } from "../vendor/yaml.mjs";
@@ -168,7 +170,7 @@ function backendDesignPrerequisitesReady(prerequisites, exists, root, projectId)
     const approvalFile = path.isAbsolute(prerequisites.engineering_contract_approval_ref)
       ? prerequisites.engineering_contract_approval_ref
       : path.resolve(root, prerequisites.engineering_contract_approval_ref);
-    const approval = loadApprovalRecord(approvalFile);
+    const approval = loadApprovalRecord(approvalFile, 'gate.engineering-contract-approved');
     validateApprovalRecord(approval, { requireApproved: true, root });
     if (approval.gate_id !== "gate.engineering-contract-approved" || !approval.approval_scope?.includes(projectId)) return false;
     if (!approvalHasBinding(approval, technical.expected) || !approvalHasBinding(approval, data.expected)) return false;

package/template/scripts/lib/plan-spec-entry.mjs

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { verifyContextReconciliation } from './context-reconciliation.mjs';
 import { decisionIO, decisionDigest, assertUserDecisionRequirement } from './user-decision.mjs';
-import { validateApprovalRecord } from './approval-record.mjs';
+import { validateApprovalRecord, selectApprovalRecord } from './approval-record.mjs';
 
 const fail = message => { throw new TypeError(`plan-spec-entry-blocked: ${message}`); };
 const text = value => typeof value === 'string' && value.trim().length > 0;
@@ -56,7 +56,7 @@ export function assertPlanSpecEntry(state, options = {}) {
     evidence(gate?.evidence_refs);
     if (review.impacts[impact]) {
       if (gate.status !== 'approved' || !basis.has(gate.approval_ref) || !basis.has(gate.subject_ref)) fail(`命中门禁未批准或未绑定依据: ${gateId}`);
-      const record = io.document(gate.approval_ref);
+      const record = selectApprovalRecord(io.document(gate.approval_ref), gateId);
       if (record.gate_id !== gateId || record.subject_ref !== gate.subject_ref || !gate.approval_scope?.includes(state.feature_id) || JSON.stringify([...(gate.approval_scope || [])].sort()) !== JSON.stringify([...(record.approval_scope || [])].sort())) fail(`会签资产或范围不匹配: ${gateId}`);
       validateApprovalRecord(record, { ...options, requireApproved: true });
     } else if (gate.status !== 'not-applicable' || !text(gate.reason)) fail(`未命中门禁须有原因和依据: ${gateId}`);
@@ -72,7 +72,7 @@ export function assertPlanSpecEntry(state, options = {}) {
   if (reconciliation.status !== 'reconciled' || reconciliation.repository_mode !== 'project-instance') fail('Context 未调和');
   try { verifyContextReconciliation(path.resolve(io.root, review.context_reconciliation_ref), { root: io.root }); }
   catch (error) { fail(`Context reconciliation 验证失败: ${error.message}\n`); }
-  assertUserDecisionRequirement({ boundary: 'gate.plan-approved', subject_ref: state.plan_review_ref, scope: [state.feature_id], user_decision_ref: state.plan_user_decision_ref }, options);
+  assertUserDecisionRequirement({ boundary: 'gate.plan-approved', subject_ref: state.plan_review_ref, scope: [state.feature_id], user_decision_ref: state.plan_user_decision_ref, continuation_ref: state.plan_continuation_ref }, options);
   return { result: 'allowed', blocking_signals: [], missing_requirements: [], evidence_refs: [state.plan_review_ref, ...basis.keys()], next_work_unit: null };
 }
 

package/template/scripts/lib/scaffold-local-database.mjs

@@ -14,6 +14,7 @@ export function localDatabaseConfiguration(name) {
 
 export function scaffoldArchitectureIdentity(contract, contractDigest) {
   return {
+    ...(contract.platform_configuration ? { platform_configuration: contract.platform_configuration } : {}),
     architecture_family: contract.architecture_family,
     architecture_profile: contract.architecture_profile,
     generator_skill: contract.generator_skill,

package/template/scripts/lib/slice-applicability.mjs

@@ -0,0 +1,10 @@
+// Interpret the published lifecycle check, without creating a second gate registry.
+export function sliceCheckApplicability(scope,registry) {
+ if(!['low','medium','high'].includes(scope.risk_level))throw new TypeError('缺少明确风险等级，不能裁剪材料');
+ if(scope.impacted_areas.some(impact=>!['ui','frontend','backend','api','data','persistence','domain','architecture','cross-repo','cross-boundary','high-risk'].includes(impact)))throw new TypeError('未知影响不能裁剪材料，先补影响分析');
+ const check=registry.checks?.find(check=>check.id==='check.architecture-reviewed');
+ // Unknown source rule revisions need an adapter update, never a local default.
+ if(check?.trigger!=='高风险或跨边界变化。')throw new TypeError('不支持当前生命周期架构审查规则');
+ const required=scope.risk_level==='high'||scope.impacted_areas.includes('high-risk')||scope.impacted_areas.some(impact=>['architecture','cross-repo','cross-boundary'].includes(impact))||scope.project_roots.length>1;
+ return {[check.id]:{status:required?'required':'not-applicable',reason:`${check.trigger} 本切片风险 ${scope.risk_level}，影响 ${scope.impacted_areas.join(', ')||'无'}，工程数 ${scope.project_roots.length}。`}};
+}