create-yss-spec 3.4.1 → 3.4.3

package/template/docs/templates/approval-record-template.yaml

@@ -16,6 +16,8 @@ notes: 会签必须可读取；起草者不得出现在 countersigner_role_ids
 subject_ref: null
 approval_scope: []
 user_decision_ref: null
+# 已有交付范围授权时可引用独立当前审查支持的延续证明；不能仅填写 approved。
+continuation_ref: null
 # 聚合门禁 / 内部专业审查绑定的当前主体字节 SHA-256（64 位十六进制）。
 subject_digest: null
 # 专业检查必须与起草者为不同执行实例；不仅仅比较职称。

package/template/docs/templates/vertical-slice-ticket-template.md

@@ -1,10 +1,11 @@
 ---
 status: ready-for-human
+requirement_version: v1
 ---
 
 # 垂直切片 Ticket：<标题>
 
-填写前读取[中文写作规范](../process/document-writing.md)和 [Ticket 对照](examples/lifecycle-writing-examples.md#3-ticket把交付行为与实现就绪区分清楚)。状态只在 frontmatter 维护，正文记录依据。
+填写前读取[中文写作规范](../process/document-writing.md)和 [Ticket 对照](examples/lifecycle-writing-examples.md#3-ticket把交付行为与实现就绪区分清楚)。冻结前在 frontmatter 记录状态。新 Slice 绑定本文件的需求版本与原始字节；冻结后 frontmatter 仅代表冻结时状态，当前执行状态由项目已配置的主 tracker 维护，平台不可用时使用现有任务包和待发布记录。不得回写本文件的状态、验收勾选或执行结果。需求变化另存新版本并重新编译、审查与批准，旧文件和批准不自动迁移。
 
 ## 父级
 
@@ -33,11 +34,11 @@ status: ready-for-human
 
 ## 验收标准
 
-每项写条件、操作和可观察结果，关联上游规则；保留必要例外。测试未执行前保持未勾选。
+每项写条件、操作和可观察结果，关联上游规则；保留必要例外。需求基线不记录执行结果；实际验收结论写入 tracker / 任务包。
 
-- [ ] 标准 1
-- [ ] 标准 2
-- [ ] 标准 3
+- AC-1：标准 1
+- AC-2：标准 2
+- AC-3：标准 3
 
 ## 测试 Seam
 
@@ -55,33 +56,19 @@ status: ready-for-human
 | contract_id |  |
 | contract_version |  |
 | contract_ref |  |
-| 实现合同编译器 状态 | draft / blocked / ready-for-lifecycle-review |
-| 生命周期批准状态 | pending / approved / rejected |
+| 编译与批准记录 | 在现有 checkpoint / 任务包中维护，不回写冻结 Ticket |
 | suggested_owner_role_id | `role.frontend-engineer` / `role.backend-engineer` / `role.test-engineer`（实现合同编译器 建议，编排器派活） |
 | Build Architecture Checklist |  |
 
-> 实现合同编译器 不得自行将合同批准或将本 Ticket 推进为 `ready-for-agent`。只有生命周期编排器核验并持久化当前版本合同、清除阻塞边后，才能推进状态。
+> 实现合同编译器 不得自行将合同批准或将本 Ticket 推进为 `ready-for-agent`。只有生命周期编排器核验并持久化当前版本合同、清除阻塞边后，才能在主 tracker 推进执行状态。
 
-### 工作单元
+### 工作单元与工程约束
 
-| work_unit_id | 验收行为 / 目标 | primary_skill | supporting_skills | tdd_mode | allowed_write_paths | expected_evidence | verification_commands | Execution Result 引用 | 状态 |
-|---|---|---|---|---|---|---|---|---|---|
-|  |  |  |  | behavior-tdd / controlled-generation |  |  |  |  | pending / running / blocked / completed / stale |
+新切片使用 Slice v3。Ticket 保留行为、验收、测试 seam 与合同引用；工作单元、Skill、写范围、验证命令在权威 YAML 中保存一次，不再在此复制表格。
 
-`controlled-generation` 仅允许机械脚手架、样板、冻结客户端或配置，并记录 exception reason、生成器输入和生成后行为测试；业务规则、状态机、事务、权限、错误映射、复杂查询和用户可见交互必须使用 `behavior-tdd`。只有需求明确包含权限业务行为时才把它写入工作单元，不另设安全 / 权限姿态。
+Agent 使用 `scripts/slice-contract view <合同.yaml>` 展示审阅说明，使用 `--unit <id>` 展示任务和完整工程约束。本切片新增细化、例外或缺口由 Agent 整理，独立专业审查核验；已有用户确认覆盖且无实质变化时复用。任务进度和 Execution Result 引用进入现有 tracker / 任务包。
 
-## YSS 技能与后端实现合同
-
-> 涉及后端时必须填写；不涉及时写明 `not-applicable`。不得只写“符合 YSS”。
-
-| 影响面 | 必需 skill | 需要 / 不需要的理由 | 预期证据 |
-|---|---|---|---|
-| Domain / 领域行为 | `yss-domain` |  |  |
-| Application / 用例编排 | `yss-application` |  |  |
-| Infrastructure / Repository | `yss-repository` / `yss-mybatis` |  |  |
-| Web Adapter / DTO | `yss-web-controller` / `yss-dto` |  |  |
-| POJO / 对象转换 | `lombok` / `mapstruct` |  |  |
-| Java 规范 | `alibaba-java-code-style` |  |  |
+涉及后端时，适用设计从已批准 Technical Design 绑定取得。`controlled-generation` 只适用于机械生成，并保留例外与验证；业务行为使用 `behavior-tdd`。
 
 ### 后端阻断规则
 
@@ -98,7 +85,7 @@ status: ready-for-human
 
 列出实际依赖、未决项、责任人和解除条件；尚未核验时写“待核验”。只有确认没有阻塞时才写“无”，无依赖不等于已通过实现就绪核验。
 
-## 重路由状态
+## 重路由记录位置
 
 | 字段 | 内容 |
 |---|---|
@@ -110,19 +97,21 @@ status: ready-for-human
 | return_stage | 实现合同编译器 / Architecture Re-check / 产品设计 / OpenAPI Draft-Review-Freeze / 系统或数据架构 / other |
 | recovery_conditions |  |
 
-出现 `drift`、`violation` 或非空 `new_impacts` 时暂停受影响工作单元，不得先完成代码再补合同；更新合同版本并通过生命周期审查后才能恢复。
+本表作为 tracker / 任务包的记录字段说明，冻结后不在本文件填写。出现 `drift`、`violation` 或非空 `new_impacts` 时暂停受影响工作单元，不得先完成代码再补合同；更新合同版本并通过生命周期审查后才能恢复。
 
 ## 会签
 
+冻结后会签结果保存在现有批准记录与 checkpoint，不修改以下冻结时引用。
+
 | 门禁 | 记录路径 | 会签角色 | 状态 |
 |---|---|---|---|
 |  | `docs/.scratch/<feature>/gates/<gate-id>-approval.yaml` | 见 `docs/agents/digital-human-roles.yaml` | pending / approved / blocked / not-applicable |
 
 ## 状态
 
-状态依据：<当前版本合同、批准和就绪核验记录引用，以及尚未关闭的阻塞>。
+冻结时状态依据：<当时的合同、批准和就绪核验记录引用，以及尚未关闭的阻塞>。当前状态从主 tracker / 任务包读取。
 
-> 默认 frontmatter 为 `ready-for-human`。仅在生命周期确认合同已批准且当前、阻塞已清除、全部适用门禁及就绪条件通过后更新为 `ready-for-agent`；本节不另维护第二个状态值。
+> 默认 frontmatter 为 `ready-for-human`。仅在生命周期确认合同已批准且当前、阻塞已清除、全部适用门禁及就绪条件通过后在主 tracker 更新为 `ready-for-agent`；冻结文件不更新。
 
 ## AI / 人工审查点
 
@@ -132,12 +121,14 @@ status: ready-for-human
 
 ## 完成定义
 
+以下为完成判据；检查结果和勾选进入 tracker / 任务包，不回写本文件。
+
 - [ ] 如有需要，已基于冻结 OpenAPI Spec 拆分切片
 - [ ] 实现完成
 - [ ] 已新增测试且测试通过
 - [ ] 已移除调试 / 原型代码
-- [ ] 已回勾 `Backend Slice Implementation Contract` 和 `Build Architecture Checklist`
-- [ ] 已回勾当前 `contract_id` / `contract_version`、全部工作单元和对应 `YSS Skill Execution Result`
+- [ ] 已在任务包核验 `Backend Slice Implementation Contract` 和 `Build Architecture Checklist`
+- [ ] 已在任务包核验当前 `contract_id` / `contract_version`、全部工作单元和对应 `YSS Skill Execution Result`
 - [ ] 实际 changed files 均在合同允许路径内，预期证据齐全，验证结果包含执行时间
 - [ ] `new_impacts`、`drift`、`violation` 和重路由状态均有明确结论，合同未处于 `stale`
 - [ ] 如领域或架构决策变化，已更新 `CONTEXT.md` / ADR；新增业务术语含 PascalCase `英文标识`，代码与契约字段能追溯到该词干

package/template/scripts/backend-platforms

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import { loadBackendPlatforms, platformBinding, resolveBackendPlatform } from "./lib/backend-platform.mjs";
+try {
+  const catalog = loadBackendPlatforms();
+  const rows = catalog.profiles.map(profile => {
+    const combinations = catalog.compatibility.filter(entry => entry.profile_id === profile.id && entry.spring_boot_version === profile.spring_boot_version).map(entry => {
+      try { resolveBackendPlatform(platformBinding(profile, entry)); return { id: entry.id, status: "verified", parent: entry.parent, bom: entry.bom, architectures: entry.evidence.map(item => item.architecture_family), capabilities: entry.capabilities ?? [] }; }
+      catch (error) { return { id: entry.id, status: "blocked", reason: error.message }; }
+    });
+    return { profile_id: profile.id, spring_boot_version: profile.spring_boot_version, java_version: profile.java_version, recommended_java: profile.java_version === 8 || profile.java_version === 17, selectable: combinations.some(entry => entry.status === "verified"), combinations, blockers: combinations.some(entry => entry.status === "verified") ? [] : profile.candidate_blockers };
+  });
+  process.stdout.write(`${JSON.stringify({ schema_version: 1, profiles: rows }, null, 2)}\n`);
+  if (process.argv.includes("--require-verified") && rows.some(row => !row.selectable)) process.exitCode = 1;
+} catch (error) { process.stderr.write(`${error.message}\n`); process.exitCode = 1; }

package/template/scripts/lib/approval-record.mjs

@@ -10,7 +10,7 @@ import {
 } from "./digital-human-roles.mjs";
 import { assertGateChecks } from "./lifecycle-controls.mjs";
 import { ROOT, loadRegistry } from "./lifecycle-registry.mjs";
-import { assertUserDecisionRequirement, assertWorkUnitUserDecision, assertImplementationDecision } from "./user-decision.mjs";
+import { assertUserDecisionRequirement, assertWorkUnitUserDecision, assertImplementationDecision, decisionIO, decisionDigest } from "./user-decision.mjs";
 
 const DECISIONS = new Set(["approved", "rejected", "vetoed"]);
 const ACTOR_KINDS = new Set(["digital-human", "biological-human", "orchestrator"]);
@@ -38,8 +38,16 @@ function yamlFromFile(filePath, label) {
   return value;
 }
 
-export function loadApprovalRecord(filePath) {
-  return yamlFromFile(filePath, "会签记录");
+export function loadApprovalRecord(filePath, gateId) {
+  return selectApprovalRecord(yamlFromFile(filePath, "会签记录"), gateId);
+}
+
+export function selectApprovalRecord(record, gateId) {
+  if (record.kind !== 'review-bundle') return record;
+  if (record.schema_version !== 1 || !Array.isArray(record.reviews) || !record.reviews.length || new Set(record.reviews.map(x => x.gate_id)).size !== record.reviews.length) fail('组合审查身份无效或重复');
+  const selected = record.reviews.filter(x => x.gate_id === gateId);
+  if (selected.length !== 1) fail('组合审查缺少当前检查的明确结论');
+  return selected[0];
 }
 
 export function resolveApprovalRef(approvalRef, fromFile = ROOT) {
@@ -68,7 +76,12 @@ export function validateApprovalRecord(record, { rolesDoc, requireApproved = fal
   if (record.actor_kind === "orchestrator") fail("编排器门禁不使用会签记录关闭");
 
   if (!requireApproved && loadRegistry().id_policy.deprecated_ids.includes(record.gate_id)) return { bucket: "historical", gate: record.gate_id };
-  const rule = countersignRuleForGate(registry.gate_policy, record.gate_id);
+  let rule = countersignRuleForGate(registry.gate_policy, record.gate_id);
+  const continuationReviewers = registry.gate_policy.continuation_reviews?.[record.gate_id];
+  if (record.continuation_ref && record.actor_kind === 'digital-human' && continuationReviewers) {
+    rule = { bucket: 'digital_human_review', gate: record.gate_id, countersigners: continuationReviewers };
+    if (!record.drafter_principal_ref || record.drafter_principal_ref === record.principal_ref) fail('延续批准必须由独立审查者核验');
+  }
   if (!rule) fail(`${record.gate_id} 不是会签门禁；evidence_only / orchestrator 门禁不写 approval-record`);
 
   if (requireApproved && record.decision !== "approved") {
@@ -107,7 +120,20 @@ function assertRecordUserDecision(record, registry, options) {
 }
 
 export function validateApprovalRecordFile(filePath, options = {}) {
-  return validateApprovalRecord(loadApprovalRecord(filePath), options);
+  const record = yamlFromFile(filePath, "会签记录");
+  if (record.kind === 'review-bundle') {
+    if (!Array.isArray(record.reviews) || !record.reviews.length) fail('组合审查不能为空');
+    return record.reviews.map(item => {
+      const row = loadApprovalRecord(filePath, item.gate_id);
+      if (options.requireApproved) {
+        if (!row.drafter_principal_ref || row.drafter_principal_ref === row.principal_ref) fail('组合审查必须保留独立身份');
+        const io = decisionIO(options);
+        if (!row.subject_ref || decisionDigest(io.bytes(row.subject_ref)) !== `sha256:${row.subject_digest}`) fail('组合审查主体缺失或已过期');
+      }
+      return validateApprovalRecord(row, options);
+    });
+  }
+  return validateApprovalRecord(record, options);
 }
 
 export function assertApprovedGateHasValidApproval(gateId, gateState, { checkpointPath } = {}) {
@@ -121,7 +147,7 @@ export function assertApprovedGateHasValidApproval(gateId, gateState, { checkpoi
   }
   const resolved = resolveApprovalRef(gateState.approval_ref, checkpointPath || ROOT);
   if (!existsSync(resolved)) fail(`${gateId} 的 approval_ref 不可读: ${gateState.approval_ref}`);
-  const record = loadApprovalRecord(resolved);
+  const record = loadApprovalRecord(resolved, gateId);
   if (record.gate_id !== gateId) fail(`${gateId} 的会签记录 gate_id 不匹配`);
   if (!gateState.subject_ref || gateState.subject_ref !== record.subject_ref || !gateState.approval_scope?.length || JSON.stringify([...gateState.approval_scope].sort()) !== JSON.stringify([...(record.approval_scope || [])].sort())) {
     fail(`${gateId} user-decision-subject-mismatch: 当前门禁资产与会签范围不匹配`);

package/template/scripts/lib/approved-execution-context.mjs

@@ -1,3 +1,4 @@
+import { selectSliceWorkUnit, normalizeSliceContract, sourceSliceContract, parseSliceYaml } from './slice-contract.mjs';
 import path from 'node:path';
 import { readFileSync } from 'node:fs';
 import { ROOT, read, parse, safe, hash, digest, schema } from './strategic-handoff-io.mjs';
@@ -29,11 +30,11 @@ export function verifySliceContractApproval(binding,{root=process.cwd(),contract
   check(binding?.ref&&binding?.digest&&binding?.approval_ref,'EXECUTION_APPROVAL_REQUIRED','需要当前持久化 Slice 的 ref/digest/approval_ref');
   const bytes=readFileSync(safe(root,binding.ref));
   check(hash(bytes)===binding.digest,'EXECUTION_CONTRACT_STALE','Slice 原始字节与绑定不一致');
-  const document=parse(bytes),contract=document.slice_contract||document;
-  check(contract.schema_version===2&&contract.status==='approved'&&typeof contract.contract_id==='string'&&contract.contract_id&&typeof contract.contract_version==='string'&&contract.contract_version&&typeof contract.slice_id==='string'&&contract.slice_id,'EXECUTION_CONTRACT_INVALID','需要已批准且有身份的持久化 Slice v2');
+  const document=parseSliceYaml(bytes),contract=normalizeSliceContract(document,{root});
+  check([2,3].includes(contract.schema_version)&&contract.status==='approved'&&typeof contract.contract_id==='string'&&contract.contract_id&&typeof contract.contract_version==='string'&&contract.contract_version&&typeof contract.slice_id==='string'&&contract.slice_id,'EXECUTION_CONTRACT_INVALID','需要已批准且有身份的持久化 Slice v2/v3');
   assertExistingSliceStructure(contract);
   check((!binding.id||binding.id===contract.contract_id)&&(!binding.version||binding.version===contract.contract_version),'EXECUTION_CONTRACT_CONFLICT','当前合同身份或版本不匹配');
-  if(expected)check(same(expected.slice_contract||expected,contract),'EXECUTION_CONTRACT_CONFLICT','调用方合同与持久化原字节不一致');
+  if(expected)check(same(sourceSliceContract(expected),sourceSliceContract(contract)),'EXECUTION_CONTRACT_CONFLICT','调用方合同与持久化原字节不一致');
   const roles=read(safe(root,'docs/agents/digital-human-roles.yaml'));
   const approval=read(safe(root,binding.approval_ref));
   if(!countersignRuleForGate(roles.gate_policy,gateId)&&roles.gate_policy.orchestrator?.includes(gateId)) {
@@ -51,13 +52,14 @@ export function verifySliceContractApproval(binding,{root=process.cwd(),contract
     validateApprovalRecord(approval,{...ioFor(root),rolesDoc:roles,requireApproved:true});
     check(approval.gate_id===gateId&&approval.artifact_bindings?.some(item=>item.id===contract.contract_id&&item.version===contract.contract_version&&item.digest===binding.digest),'EXECUTION_APPROVAL_SCOPE','源会签未绑定当前 Slice 的身份、版本和字节');
   }
+  if(contract.schema_version===3) verifySliceProfessionalReview(approval,{...binding,id:contract.contract_id,version:contract.contract_version},roles,root);
   return {contract,binding:structuredClone(binding),root};
 }
 
 function executionBasis(verified,{allowCompilerDrift=false}={}) {
   const {contract}=verified,resolution=contract.resolution||{};
   const compiler=read(safe(ROOT,'.agents/skills/yss-implementation-contract-compiler/references/compiler-contract.yaml'));
-  if(!allowCompilerDrift)for(const [section,fields] of Object.entries(compiler.slice_contract_required))for(const field of fields)check(Object.hasOwn(section==='root'?contract:contract[section]||{},field),'EXECUTION_CONTRACT_INVALID',`合同缺少 ${section}.${field}`);
+  if(!allowCompilerDrift&&contract.schema_version===2)for(const [section,fields] of Object.entries(compiler.slice_contract_required))for(const field of fields)check(Object.hasOwn(section==='root'?contract:contract[section]||{},field),'EXECUTION_CONTRACT_INVALID',`合同缺少 ${section}.${field}`);
   check(Array.isArray(contract.common?.allowed_write_paths)&&contract.common.allowed_write_paths.length>0&&contract.common.allowed_write_paths.every(value=>typeof value==='string'&&value.trim()),'EXECUTION_SCOPE_MISSING','合同缺少已批准写范围');
   check(Array.isArray(contract.readiness?.blockers)&&!contract.readiness.blockers.length&&Array.isArray(contract.readiness?.stale_inputs)&&!contract.readiness.stale_inputs.length,'EXECUTION_CONTRACT_STALE','合同就绪条件仍有阻断或过期输入');
   if(!allowCompilerDrift)check(resolution.registry_digest===digest(loadSkillRegistry()).slice(7)&&resolution.compiler_contract_digest===digest(compiler).slice(7),'EXECUTION_CONTRACT_STALE','编译依据已改变，应重新编译批准');
@@ -68,16 +70,18 @@ function executionBasis(verified,{allowCompilerDrift=false}={}) {
 
 export function createApprovedExecutionContext(binding,options={}) {
   const verified=executionBasis(verifySliceContractApproval(binding,options));
+  selectSliceWorkUnit(verified.contract,options.work_unit_id);
   const context=Object.freeze({kind:'approved-slice-execution-context'});
-  contexts.set(context,{binding:verified.binding,root:verified.root,allowCompilerDrift:false});
+  contexts.set(context,{binding:verified.binding,root:verified.root,work_unit_id:options.work_unit_id,allowCompilerDrift:false});
   return context;
 }
 
 /** A prior approved scope may authenticate bounded output while current compiler facts are recomputed. */
 export function createApprovedRecompilationContext(binding,options={}) {
   const verified=executionBasis(verifySliceContractApproval(binding,options),{allowCompilerDrift:true});
+  selectSliceWorkUnit(verified.contract,options.work_unit_id);
   const context=Object.freeze({kind:'approved-slice-recompilation-context'});
-  contexts.set(context,{binding:verified.binding,root:verified.root,allowCompilerDrift:true});
+  contexts.set(context,{binding:verified.binding,root:verified.root,work_unit_id:options.work_unit_id,allowCompilerDrift:true});
   return context;
 }
 
@@ -86,7 +90,7 @@ export function assertApprovedExecutionContext(context,{root=process.cwd(),contr
   const saved=contexts.get(context);
   check(saved&&saved.root===path.resolve(root),'EXECUTION_CONTEXT_UNTRUSTED','只允许从当前原始 Slice 与本地批准生成的执行上下文');
   const verified=executionBasis(verifySliceContractApproval(saved.binding,{root,contract}),{allowCompilerDrift:saved.allowCompilerDrift});
-  const current=verified.contract,resolution=current.resolution;
+  const current=selectSliceWorkUnit(verified.contract,saved.work_unit_id),resolution=current.resolution;
   if(sliceId)check(current.slice_id===sliceId,'EXECUTION_SCOPE_CONFLICT','执行上下文属于另一切片');
   if(architectureIdentity)check(same(resolution.architecture_identity,architectureIdentity),'EXECUTION_INPUT_REPLACED','执行上下文不允许替换架构身份或固定源码输入');
   if(architectureEvidence)check(same(resolution.architecture_evidence,architectureEvidence),'EXECUTION_INPUT_REPLACED','执行上下文不允许替换原始架构证据');
@@ -102,5 +106,24 @@ export function assertApprovedExecutionContext(context,{root=process.cwd(),contr
 export function approvedExecutionBinding(context) {
   const saved=contexts.get(context);
   check(saved,'EXECUTION_CONTEXT_UNTRUSTED','不能序列化未验证的执行上下文');
-  return structuredClone(saved.binding);
+  return {...structuredClone(saved.binding),...(saved.work_unit_id?{work_unit_id:saved.work_unit_id}:{})};
+}
+
+function verifySliceProfessionalReview(approval,binding,roles,root) {
+  const refs=approval.gates?.[gateId]?.evidence_refs || approval.evidence_refs || [];
+  let found=false;
+  for(const ref of refs) {
+    if(!/\.(yaml|yml|json)$/.test(ref))continue;
+    const record=read(safe(root,ref));
+    const rows=record.kind==='review-bundle'?record.reviews:[record];
+    for(const row of rows || []) {
+      if(row.gate_id!=='check.design-reviewed'||row.subject_ref!==binding.ref)continue;
+      validateApprovalRecord(row,{...ioFor(root),rolesDoc:roles,requireApproved:true});
+      check(row.drafter_principal_ref&&row.principal_ref!==row.drafter_principal_ref,'EXECUTION_REVIEW_NOT_INDEPENDENT','Slice 工程审查必须独立于起草者');
+      check(row.subject_digest===binding.digest.slice(7)&&row.artifact_bindings?.some(x=>x.id===binding.id&&x.version===binding.version&&x.digest===binding.digest),'EXECUTION_REVIEW_STALE','Slice 工程审查未绑定当前合同');
+      check(Array.isArray(row.findings)&&row.findings.every(x=>x.kind==='suggestion'?!!x.follow_up:['requirement-violation','missing-evidence','important-risk'].includes(x.kind)&&x.status==='resolved'),'EXECUTION_REVIEW_BLOCKED','Slice 工程审查有未关闭问题');
+      found=true;
+    }
+  }
+  check(found,'EXECUTION_REVIEW_REQUIRED','Slice v3 缺少当前合同的独立工程审查');
 }

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

@@ -1,3 +1,4 @@
+import { platformProfile, resolveBackendPlatform } from "./backend-platform.mjs";
 import { createHash } from "node:crypto";
 import { loadSkillRegistry } from "./skill-registry.mjs";
 import { validateExistingArchitecture, verifyExistingArchitecture } from "./existing-backend-architecture.mjs";
@@ -12,6 +13,10 @@ export function validateArchitectureIdentity(identity, registry = loadSkillRegis
   if (!identity || typeof identity !== "object") throw new TypeError("缺少 architecture_identity；请从工程基线重新编译");
   if (identity.schema_version === 2) return validateExistingArchitecture(identity, registry);
   if (identity.schema_version !== undefined || identity.source_kind !== undefined) throw new TypeError("不支持的 architecture_identity 来源或版本");
+  if (identity.platform_configuration) {
+    const selected = platformProfile(identity.platform_configuration.profile_id, undefined, identity.platform_configuration.spring_boot_version);
+    if (selected.spring_boot_version !== identity.platform_configuration.spring_boot_version || selected.java_version !== identity.platform_configuration.java_version) throw new TypeError("backend-platform: invalid architecture platform binding");
+  }
   const profile = registry.architecture_profiles?.[identity.architecture_profile];
   if (!profile || identity.architecture_family !== profile.architecture_family || identity.generator_skill !== profile.generator_skill) {
     throw new TypeError("architecture_identity 的架构族、Profile 或生成器不匹配");
@@ -51,5 +56,6 @@ export function assertArchitectureAgreement(identity, evidence, registry) {
 
 export function architectureReady(identity, registry = loadSkillRegistry()) {
   const profile = validateArchitectureIdentity(identity, registry);
+  if (identity.platform_configuration) { try { resolveBackendPlatform(identity.platform_configuration); } catch { return false; } }
   return profile.maturity === "supported";
 }

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

@@ -0,0 +1,67 @@
+/** Version qualification binds executable sources and generated bytes, not Skill prose. */
+import { createHash } from 'node:crypto';
+import { readFileSync, readdirSync, lstatSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+const digest = bytes => `sha256:${createHash('sha256').update(bytes).digest('hex')}`;
+const fail = message => { throw new TypeError(`platform-provenance: ${message}`); };
+function fileMap(root, refs) {
+  const files = {};
+  const visit = ref => {
+    const full = path.join(root, ref), info = lstatSync(full);
+    if (info.isSymbolicLink()) fail(`source symlink: ${ref}`);
+    if (info.isDirectory()) for (const name of readdirSync(full).sort()) visit(`${ref}/${name}`);
+    else files[ref] = { digest: digest(readFileSync(full)), executable: Boolean(info.mode & 0o111) };
+  };
+  refs.forEach(visit);
+  return Object.fromEntries(Object.entries(files).sort(([a], [b]) => a.localeCompare(b)));
+}
+export function platformSourceFingerprint(family, root = ROOT) {
+  const skill = family === 'domain-driven' ? 'yss-ddd-scaffold-generator' : family === 'layered-mvc' ? 'yss-layered-mvc-scaffold-generator' : null;
+  if (!skill) fail('unknown architecture');
+  const base = `.agents/skills/${skill}`;
+  const generator = fileMap(root, [`${base}/scripts/generate_scaffold.mjs`, ...(family === 'domain-driven' ? [`${base}/assets`] : ['.agents/skills/yss-ddd-scaffold-generator/assets/wrapper']), 'scripts/lib/backend-platform.mjs', 'scripts/lib/scaffold-local-database.mjs']);
+  const verifier = fileMap(root, ['scripts/lib/backend-platform-provenance.mjs', 'scripts/lib/backend-platform-verification.mjs', 'scripts/lib/command-runner.mjs', 'scripts/vendor/xml.mjs', '.agents/skills/yss-ddd-scaffold-generator/scripts/run_scaffold_verification.mjs']);
+  return { schema_version: 1, generator_digest: digest(JSON.stringify(generator)), verifier_digest: digest(JSON.stringify(verifier)) };
+}
+export function assertSourceFingerprint(value, family, root = ROOT) {
+  if (JSON.stringify(value) !== JSON.stringify(platformSourceFingerprint(family, root))) fail('generator/verifier source drift; requalify candidate');
+}
+export function generatedTreeDigest(projectRoot, manifest) {
+  const expected = manifest.ownership?.generated_files;
+  if (!Array.isArray(expected) || !expected.length) fail('missing generated file inventory');
+  const names = new Set();
+  const actual = {};
+  for (const file of expected) {
+    if (!file.path || path.isAbsolute(file.path) || file.path.split(/[\\/]/).some(p => p === '..' || p === '') || names.has(file.path)) fail('invalid generated file inventory');
+    names.add(file.path);
+    const full = path.join(projectRoot, file.path);
+    // Check every path component: file lstat alone does not detect a linked parent directory.
+    let current = projectRoot;
+    for (const part of file.path.split('/')) { current = path.join(current, part); if (lstatSync(current).isSymbolicLink()) fail(`generated symlink: ${file.path}`); }
+    const info = lstatSync(full);
+    if (!info.isFile()) fail(`generated file absent: ${file.path}`);
+    const hash = digest(readFileSync(full));
+    if (hash.replace('sha256:', '') !== file.sha256.replace('sha256:', '')) fail(`generated file drift: ${file.path}`);
+    actual[file.path] = { digest: hash, executable: Boolean(info.mode & 0o111) };
+  }
+  const visit = (directory, relative = '') => {
+    for (const item of readdirSync(directory, { withFileTypes: true })) {
+      const ref = relative ? `${relative}/${item.name}` : item.name;
+      if (item.isSymbolicLink()) fail(`unexpected symlink: ${ref}`);
+      if (item.isDirectory()) { if (!['target', '.git'].includes(item.name)) visit(path.join(directory, item.name), ref); }
+      else if (!names.has(ref) && ref !== '.yss/scaffold-generation.json' && ref !== '.yss/platform-dependencies.json' && !ref.endsWith('/.yss/platform-dependencies.json')) fail(`unexpected source file: ${ref}`);
+    }
+  };
+  visit(projectRoot);
+  return digest(JSON.stringify(Object.fromEntries(Object.entries(actual).sort(([a],[b]) => a.localeCompare(b)))));
+}
+
+export function assertResumableCandidate(projectRoot, contract, contractBytes) {
+  const manifest = JSON.parse(readFileSync(path.join(projectRoot, '.yss/scaffold-generation.json'), 'utf8'));
+  if (manifest.platform_verification !== 'candidate' || manifest.schema_version !== 4 || manifest.contract_id !== contract.contract_id || manifest.contract_version !== contract.contract_version || manifest.contract_digest.replace('sha256:', '') !== digest(contractBytes).replace('sha256:', '') || JSON.stringify(manifest.platform_configuration) !== JSON.stringify(contract.platform_configuration)) fail('resume requires the identical candidate contract/Manifest');
+  assertSourceFingerprint(manifest.source_fingerprint, contract.architecture_family);
+  if (generatedTreeDigest(projectRoot, manifest) !== manifest.generated_tree_digest) fail('resume generated tree drift');
+  return manifest;
+}

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

@@ -0,0 +1,210 @@
+import { readFile, readdir, writeFile, stat } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import path from "node:path";
+import { parseXmlDocument } from "../vendor/xml.mjs";
+import { runCommand } from "./command-runner.mjs";
+import { assertJavaPlatform, platformDigest } from "./backend-platform.mjs";
+
+const array = value => value === undefined ? [] : Array.isArray(value) ? value : [value];
+const fail = message => { throw new TypeError(`platform-dependencies: ${message}`); };
+const gav = item => `${item.groupId}:${item.artifactId}`;
+export async function platformEvidenceArtifacts(evidenceDir) {
+  const artifacts = [];
+  for (const entry of await readdir(evidenceDir, { withFileTypes: true })) {
+    if (entry.isFile() && (entry.name.endsWith('.log') || ['effective-pom.xml', 'boot-bom-effective.xml', 'dependency-trees.json', 'platform-tests.xml'].includes(entry.name))) {
+      artifacts.push({ ref: entry.name, digest: platformDigest(await readFile(path.join(evidenceDir, entry.name))) });
+    }
+  }
+  return artifacts.sort((a, b) => a.ref.localeCompare(b.ref));
+}
+export function checkPlatformTests(source, capabilities = []) {
+  const suite = parseXmlDocument(source).testsuite;
+  const cases = array(suite?.testcase);
+  const required = ['httpJsonRoundTrip', 'httpValidationRejectsBlank', 'validationAndJsonAutoConfiguration', 'mybatisCanMapVerificationQuery', ...(capabilities.includes('feign-client') ? ['feignCanDecodeJson'] : [])];
+  if (!suite || required.some(name => !cases.some(item => item['@_name'] === name && !['failure', 'error', 'skipped'].some(key => Object.hasOwn(item, key))))) fail('integration tests missing, failed or skipped');
+  return { status: 'passed', test_count: cases.length };
+}
+export async function verifyPlatformTests(projectRoot, evidenceDir, manifest, startedAt) {
+  try {
+    const module = `${manifest.project_name}-${manifest.architecture_family === 'domain-driven' ? 'bootstrap' : 'server'}`;
+    const reportPath = path.join(projectRoot, module, 'target/surefire-reports', `TEST-${manifest.base_package}.PlatformIntegrationTest.xml`);
+    if (!startedAt || (await stat(reportPath)).mtimeMs < startedAt) fail("stale integration test report");
+    const source = await readFile(reportPath, 'utf8');
+    await writeFile(path.join(evidenceDir, 'platform-tests.xml'), source);
+    return checkPlatformTests(source, manifest.module_profile?.requested_capabilities);
+  } catch (error) { return { status: 'failed', error: error.message }; }
+}
+export function checkPlatformDependencies(profile, effectivePom, dependencyTrees, { bootBom, mainArtifact, components = {} } = {}) {
+  const xml = parseXmlDocument(effectivePom);
+  const projects = array(xml.projects?.project ?? xml.project);
+  if (!projects.length || !dependencyTrees.length) fail("missing effective POM or dependency tree");
+  const main = dependencyTrees.filter(item => gav(item) === mainArtifact);
+  if (main.length !== 1) fail("missing or duplicate startup-module runtime tree");
+  const nodes = [];
+  const visit = item => { if (!["compile", "runtime"].includes(item.scope ?? "compile")) return; nodes.push(item); array(item.children).forEach(visit); };
+  array(main[0].children).forEach(visit);
+  const bom = parseXmlDocument(bootBom ?? "<missing/>").project;
+  if (bom?.groupId !== "org.springframework.boot" || bom.artifactId !== "spring-boot-dependencies" || bom.version !== profile.spring_boot_version) fail("wrong or missing independent Boot BOM");
+  const managed = new Map(array(bom.dependencyManagement?.dependencies?.dependency).map(item => [gav(item), item.version]));
+  if (!managed.size) fail("empty Boot BOM dependency management");
+  for (const item of nodes) {
+    const expected = managed.get(gav(item)) ?? components[gav(item)];
+    if (/^(com\.baomidou|org\.springdoc|org\.springframework\.cloud|com\.yss\.cloud)$/.test(item.groupId) && !expected) fail(`missing component recipe: ${gav(item)}`);
+    if (expected && String(item.version) !== String(expected)) fail(`resolved version differs from BOM/recipe: ${gav(item)}`);
+    if (/^(org\.springframework(?:\.boot)?$|org\.apache\.tomcat\.embed|jakarta\.(servlet|validation)|javax\.(servlet|validation)|(?:tools|com\.fasterxml)\.jackson|org\.slf4j|ch\.qos\.logback)/.test(item.groupId) && !expected) fail(`unmanaged platform runtime artifact: ${gav(item)}`);
+  }
+  const requireArtifact = (group, artifact, match) => {
+    const hits = nodes.filter(item => gav(item) === `${group}:${artifact}`);
+    if (!hits.length || hits.some(item => !match(String(item.version)))) fail(`${group}:${artifact} absent or incompatible`);
+  };
+  const line = (version, prefix) => version === prefix || version.startsWith(`${prefix}.`);
+  requireArtifact("org.springframework.boot", profile.web_starter, version => version === profile.spring_boot_version);
+  requireArtifact("org.springframework", "spring-webmvc", version => line(version, profile.framework_line));
+  requireArtifact("org.apache.tomcat.embed", "tomcat-embed-core", version => line(version, profile.tomcat_line));
+  requireArtifact("com.baomidou", profile.mybatis_plus_starter, version => /^3\./.test(version));
+  requireArtifact(profile.jackson_major === 3 ? "tools.jackson.core" : "com.fasterxml.jackson.core", "jackson-databind", version => version.startsWith(`${profile.jackson_major}.`));
+  for (const item of nodes) {
+    if (item.groupId === "org.springframework.boot" && String(item.version) !== profile.spring_boot_version) fail(`Boot dependency mismatch: ${gav(item)}`);
+    if (item.groupId === "org.springframework" && !line(String(item.version), profile.framework_line)) fail(`Spring dependency mismatch: ${gav(item)}`);
+    if (item.groupId === "org.apache.tomcat.embed" && !line(String(item.version), profile.tomcat_line)) fail(`Tomcat dependency mismatch: ${gav(item)}`);
+    if (item.groupId === "org.springframework.cloud" && /openfeign/.test(item.artifactId) && !line(String(item.version), profile.openfeign_line)) fail("OpenFeign line mismatch");
+    if (item.groupId === "org.springdoc" && !String(item.version).startsWith(`${profile.springdoc_major}.`)) fail("springdoc major mismatch");
+    if (profile.validation_namespace === "jakarta" && ["javax.servlet", "javax.validation"].includes(item.groupId)) fail(`legacy Java EE API: ${gav(item)}`);
+    if (profile.validation_namespace === "jakarta" && item.groupId === "jakarta.validation" && !String(item.version).startsWith("3.")) fail("Jakarta Validation version mismatch");
+    if (item.groupId === "jakarta.servlet" && !line(String(item.version), profile.servlet_version)) fail("Servlet API version mismatch");
+    if (profile.validation_namespace === "javax" && item.groupId === "jakarta.validation" && !String(item.version).startsWith("2.")) fail("Boot 2 requires javax Validation classes");
+    if (profile.validation_namespace === "javax" && item.groupId === "javax.servlet" && !String(item.version).startsWith("4.")) fail("Boot 2 Servlet mismatch");
+    if (item.groupId === "com.baomidou" && /spring-boot[34]-starter|mybatis-plus-boot-starter/.test(item.artifactId) && item.artifactId !== profile.mybatis_plus_starter) fail("mixed MyBatis-Plus starters");
+  }
+  let bootPluginFound = false;
+  for (const project of projects) {
+    const target = project.properties?.["maven.compiler.release"] ?? project.properties?.["maven.compiler.target"] ?? project.properties?.["java.version"];
+    if (![String(profile.java_version), ...(profile.java_version === 8 ? ["1.8"] : [])].includes(String(target))) fail("effective Java target mismatch");
+    for (const plugin of array(project.build?.plugins?.plugin)) if (gav(plugin) === "org.springframework.boot:spring-boot-maven-plugin") {
+      bootPluginFound = true;
+      if (plugin.version !== profile.spring_boot_version) fail("Boot plugin version mismatch");
+    }
+  }
+  if (!bootPluginFound) fail("Boot plugin absent");
+  return { status: "passed", runtime_artifacts: nodes, artifact_count: nodes.length, effective_pom_digest: platformDigest(effectivePom), dependency_tree_digest: platformDigest(dependencyTrees) };
+}
+
+export async function platformCommand(projectRoot, evidenceDir, label, args, environment, options = {}) {
+  const stdout_ref = path.join(evidenceDir, `${label}.stdout.log`);
+  const stderr_ref = path.join(evidenceDir, `${label}.stderr.log`);
+  const executed_at = new Date().toISOString();
+  const start = Date.now();
+  const result = await runCommand(path.join(projectRoot, "mvnw"), args, { cwd: projectRoot, env: environment, timeoutMs: options.timeoutMs || 180000, signal: options.signal, stdoutFile: stdout_ref, stderrFile: stderr_ref, secrets: [environment.MAVEN_REPO_USERNAME, environment.MAVEN_REPO_PASSWORD], progress: true });
+  return { command: `./mvnw ${args.join(" ")}`, exit_code: result.status, termination: result.termination, executed_at, duration_ms: Date.now() - start, stdout_ref, stderr_ref, stdout: result.stdout, stderr: result.stderr };
+}
+export async function verifyPlatformDependencies(projectRoot, evidenceDir, profile, environment, options = {}) {
+  const commands = [];
+  const run = async (label, args) => {
+    const result = await platformCommand(projectRoot, evidenceDir, label, args, environment, options);
+    const { stdout, stderr, ...record } = result;
+    commands.push(record);
+    if (result.exit_code !== 0) fail(`${label} failed; see ${record.stderr_ref}`);
+    return result;
+  };
+  try {
+    const java = await run("platform-java", ["-version"]);
+    assertJavaPlatform(`${java.stdout}\n${java.stderr}`, { java_version: profile.java_version });
+    const pom = path.join(evidenceDir, "effective-pom.xml");
+    const bootBom = path.join(evidenceDir, "boot-bom-effective.xml");
+    await run("platform-boot-bom", ["org.apache.maven.plugins:maven-help-plugin:3.5.1:effective-pom", `-Dartifact=org.springframework.boot:spring-boot-dependencies:${profile.spring_boot_version}`, `-Doutput=${bootBom}`]);
+    await run("platform-effective-pom", ["org.apache.maven.plugins:maven-help-plugin:3.5.1:effective-pom", `-Doutput=${pom}`]);
+    await run("platform-dependency-tree", ["org.apache.maven.plugins:maven-dependency-plugin:3.8.1:tree", "-DoutputType=json", "-DoutputFile=.yss/platform-dependencies.json"]);
+    const trees = [];
+    const visited = new Set();
+    for (const directory of [projectRoot, ...(await readdir(projectRoot, { withFileTypes: true })).filter(item => item.isDirectory() && item.name.startsWith(`${path.basename(projectRoot)}-`)).map(item => path.join(projectRoot, item.name))]) {
+      const candidates = [directory];
+      // DDD adapter contains the nested web module.
+      for (const entry of await readdir(directory, { withFileTypes: true })) if (entry.isDirectory() && entry.name.startsWith(`${path.basename(projectRoot)}-`)) candidates.push(path.join(directory, entry.name));
+      for (const candidate of candidates) {
+        if (visited.has(candidate)) continue;
+        visited.add(candidate);
+        try { trees.push(JSON.parse(await readFile(path.join(candidate, ".yss/platform-dependencies.json"), "utf8"))); }
+        catch (error) { if (error.code !== "ENOENT") throw error; }
+      }
+    }
+    await writeFile(path.join(evidenceDir, "dependency-trees.json"), JSON.stringify(trees, null, 2));
+    return { ...checkPlatformDependencies(profile, await readFile(pom, "utf8"), trees, { bootBom: await readFile(bootBom, "utf8"), mainArtifact: `${options.manifest.maven_coordinates.group_id}:${options.manifest.project_name}-${options.manifest.architecture_family === "domain-driven" ? "bootstrap" : "server"}`, components: options.components }), commands };
+  } catch (error) { return { status: "failed", error: error.message, commands }; }
+}
+
+async function freePort() {
+  const server = net.createServer();
+  await new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", resolve); });
+  const port = server.address().port;
+  await new Promise(resolve => server.close(resolve));
+  return port;
+}
+export function checkRuntimeArchive(entries, artifacts, { providedLombokVersion } = {}) {
+  if (!Array.isArray(artifacts) || !artifacts.length) fail("missing runtime artifact inventory");
+  const names = new Set(entries.split(/\r?\n/));
+  const expected = new Set();
+  for (const item of artifacts.filter(item => (item.type ?? "jar") === "jar")) {
+    const name = `BOOT-INF/lib/${item.artifactId}-${item.version}${item.classifier ? `-${item.classifier}` : ""}.jar`;
+    expected.add(name);
+    if (!names.has(name)) fail(`runtime jar missing ${name}`);
+  }
+  const bootVersion = artifacts.find(item => item.groupId === "org.springframework.boot")?.version;
+  // Boot's repackage goal injects its matching jarmode helper outside the dependency tree.
+  for (const name of names) if (name.startsWith("BOOT-INF/lib/") && name.endsWith(".jar") && !expected.has(name)
+    && name !== `BOOT-INF/lib/lombok-${providedLombokVersion}.jar`
+    && !["tools", "layertools"].some(kind => name === `BOOT-INF/lib/spring-boot-jarmode-${kind}-${bootVersion}.jar`)) fail(`unexpected packaged runtime jar: ${name}`);
+  return { status: "passed" };
+}
+async function inspectRuntimeJar(jar, evidenceDir, environment, options) {
+  const tool = environment.JAVA_HOME ? path.join(environment.JAVA_HOME, "bin/jar") : "jar";
+  const stdoutFile = path.join(evidenceDir, "runtime-jar-entries.log");
+  const stderrFile = path.join(evidenceDir, "runtime-jar.stderr.log");
+  const result = await runCommand(tool, ["tf", jar], { env: environment, timeoutMs: 30000, stdoutFile, stderrFile });
+  if (result.status !== 0) fail("cannot inspect packaged runtime jar");
+  return checkRuntimeArchive(result.stdout, options.runtimeArtifacts, options);
+}
+export async function verifyPlatformStartup(projectRoot, evidenceDir, manifest, environment, options = {}) {
+  const runtimeModule = `${manifest.project_name}-${manifest.architecture_family === "domain-driven" ? "bootstrap" : "server"}`;
+  const runtimeTarget = path.join(projectRoot, runtimeModule, "target");
+  try {
+    const packaged = (await readdir(runtimeTarget)).filter(name => name.endsWith(".jar") && !/-sources|-javadoc|-tests/.test(name));
+    if (packaged.length !== 1) fail("expected exactly one production runtime jar");
+    await inspectRuntimeJar(path.join(runtimeTarget, packaged[0]), evidenceDir, environment, options);
+  } catch (error) { return { status: "failed", error: error.message, commands: [] }; }
+  const packaging = await platformCommand(projectRoot, evidenceDir, "platform-local-package", ["-Pscaffold-local", "package", "-DskipTests"], environment, options);
+  const { stdout: ignoredOut, stderr: ignoredErr, ...command } = packaging;
+  if (packaging.exit_code !== 0) return { status: "failed", error: "local packaging failed", commands: [command] };
+  const module = `${manifest.project_name}-${manifest.architecture_family === "domain-driven" ? "bootstrap" : "server"}`;
+  const target = path.join(projectRoot, module, "target");
+  const jars = (await readdir(target)).filter(name => name.endsWith(".jar") && !/-sources|-javadoc|-tests/.test(name));
+  if (jars.length !== 1) return { status: "failed", error: "expected exactly one executable jar", commands: [command] };
+  const port = await freePort();
+  const java = environment.JAVA_HOME ? path.join(environment.JAVA_HOME, "bin/java") : "java";
+  const args = ["-jar", path.join(target, jars[0]), "--spring.profiles.active=scaffold-local", "--server.address=127.0.0.1", `--server.port=${port}`];
+  const processStartedAt = new Date().toISOString();
+  let output = "", errors = "", started = false, exited = false;
+  const child = spawn(java, args, { cwd: projectRoot, env: environment, stdio: ["ignore", "pipe", "pipe"] });
+  child.stdout.on("data", data => { output += data; if (/Started .* in /.test(output)) started = true; });
+  child.stderr.on("data", data => { errors += data; });
+  child.on("error", error => { errors += error.message; exited = true; });
+  const closed = new Promise(resolve => child.once("close", code => { exited = true; resolve(code); }));
+  let passed = false;
+  const deadline = Date.now() + Math.min(options.timeoutMs || 60000, 120000);
+  try {
+    while (!exited && Date.now() < deadline && !options.signal?.aborted) {
+      if (started) {
+        try { const response = await fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(1000) }); if (response.status > 0 && response.status < 500) { passed = true; break; } } catch {}
+      }
+      await new Promise(resolve => setTimeout(resolve, 250));
+    }
+  } finally {
+    if (!exited) child.kill("SIGTERM");
+    const killTimer = setTimeout(() => { if (!exited) child.kill("SIGKILL"); }, 3000);
+    await closed; clearTimeout(killTimer);
+  }
+  const redact = text => [environment.MAVEN_REPO_USERNAME, environment.MAVEN_REPO_PASSWORD].filter(Boolean).reduce((value, secret) => value.replaceAll(secret, "[REDACTED]"), text);
+  await writeFile(path.join(evidenceDir, "startup.stdout.log"), redact(output));
+  await writeFile(path.join(evidenceDir, "startup.stderr.log"), redact(errors));
+  return { status: passed ? "passed" : "failed", commands: [command], executed_at: processStartedAt, artifact_digest: platformDigest(await readFile(path.join(target, jars[0]))), stdout_ref: path.join(evidenceDir, "startup.stdout.log"), stderr_ref: path.join(evidenceDir, "startup.stderr.log") };
+}