create-yss-spec 3.3.1 → 3.3.4

package/template/docs/process/strategic-handoff-package.md

@@ -6,7 +6,7 @@
 
 1. 源仓必须为 `project-instance`。业务边界与规则合同保留 schema v2，正式便携导出要求 `traceability_version: 1`。`rule_catalog` 的每行包含稳定 `rule_id`、`statement`、`responsible_context`、`status: confirmed`。不得用行号、文字 hash 或导出顺序生成业务身份。
 2. 每个场景明确 `critical`、`rule_refs`、`success_results` 和既有 `failure_results`；兼容字段 `rules` 必须与引用规则正文一致。不变量使用 `rule_ref`，并通过 `scenario_refs` 指向确实覆盖该规则的场景。缺身份或关联先回战略方确认、更新并重新批准，导出器不猜测。
-3. Handoff v3 的 `package_export` 使用导出 schema。`approvals` 按 `source` 字段及 `handoff` 绑定批准记录，声明 `record_ref`、`gate_id`、`digest_kind`。沿用源角色表的现有门禁；战略、阶段、Spec 分别对应各自批准门禁，原型和视觉基线对应 `gate.user-confirmation`，业务 Ticket 集和完整交接对应源 profile 的交接批准门禁（综合模板使用阶段决策包门禁绑定本次交接）。
+3. Handoff v3 的 `package_export` 使用导出 schema。`approvals` 按 `source` 字段及 `handoff` 绑定批准记录，声明 `record_ref`、`gate_id`、`digest_kind`。沿用源角色表的现有门禁；当前综合模板的战略、阶段决策及交接资产统一绑定 `gate.plan-approved`，Spec 对应 Spec 基线批准，原型和视觉基线对应 `gate.product-design-approved`；历史包及其他源 profile 仍按包内明确登记的源批准规则验证，不自动迁移当前门禁状态。
 4. 批准记录除既有会签字段，还要在 `artifact_bindings` 中逐项绑定 `{id, version, digest}`。战略/阶段建议 `canonical-json`；普通文件使用 `sha256-bytes`；视觉基线使用 `visual-baseline`。正文中的 `approved` 和可读取批准路径不能替代当前字节的批准绑定。源角色表要求用户决定记录时，接收端必须支持并核验该策略；旧工具缺少该能力时阻断并要求升级，不能按旧规则放行。
 5. `additional_files` 明确补充依赖；`reference_map` 将 `evidence.*` 稳定证据引用解析为仓内路径。源资产、批准记录、证据引用、Markdown 本地链接和显式目录共同形成依赖闭包。HTTP 引用保留为引用，不在导出时下载网页。
 6. `prototype` 指定 `profile`、`preview_root`、`entry_ref`、`verification_ref`、`verification_digest`（验证记录的字节摘要）；H2 另须 `source_root`、`lock_ref` 和 `source_digest`（源码目录树摘要，算法同下述预览树）。源码交付目录不含 node_modules / .git；锁文件与源码一同保存。预览目录须资源闭合，可通过本地静态服务离线浏览。源码、锁文件或验证记录变化须更新交接摘要并重新批准。
@@ -54,5 +54,3 @@ node .agents/skills/yss-technical-design/scripts/validate-technical-design.mjs <
 ## 维护与同步
 
 共享脚本和包 schema 以主模板为维护源，通过 `scripts/sync-strategic-handoff-tools` 同步到设计/研发模板；源战略 schema 的离线验证副本由该脚本从 canonical `yss-stage-decision/references` 派生。三仓技能仍只编辑 `.agents/skills`，再生成各 runtime 投影与锁。CLI 快照使用各自同步工具，工作树快照用于集成验证，不代表已发布 commit。
-
-维护者可先同步三个 CLI 快照，再运行 `node .template-source/scripts/verify-strategic-handoff-distribution.mjs`，用临时合成资产验证实际生成实例之间的完整链路；结束后清理临时项目。

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

@@ -16,3 +16,7 @@ notes: 会签必须可读取；起草者不得出现在 countersigner_role_ids
 subject_ref: null
 approval_scope: []
 user_decision_ref: null
+# 聚合门禁 / 内部专业审查绑定的当前主体字节 SHA-256（64 位十六进制）。
+subject_digest: null
+# 专业检查必须与起草者为不同执行实例；不仅仅比较职称。
+drafter_principal_ref: null

package/template/docs/templates/implementation-repo-registry-template.md

@@ -92,5 +92,5 @@ Harness 内项目路径约束：`apps/backend/`、`apps/frontend/` 只能作为
 - 关联垂直切片：
 - 关联阶段 checkpoint：
 - 实现仓库准备聚合结果：
-- `gate.implementation-repositories-ready`：approved / blocked
+- `check.implementation-repositories-ready`：approved / blocked
 - fresh verification 命令：

package/template/docs/user-guide/yss-ui-mcp.md

@@ -2,7 +2,6 @@
 
 模板已为支持项目级 MCP 配置的客户端预置 `yss-ui` server：
 
-- Claude Code：`.mcp.json`
 - Antigravity：`.agents/mcp_config.json`
 - Cursor：`.cursor/mcp.json`
 - VS Code：`.vscode/mcp.json`

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

@@ -7,7 +7,8 @@ import {
   loadDigitalHumanRoles,
   collectCountersignGateIds
 } from "./digital-human-roles.mjs";
-import { ROOT } from "./lifecycle-registry.mjs";
+import { assertGateChecks } from "./lifecycle-controls.mjs";
+import { ROOT, loadRegistry } from "./lifecycle-registry.mjs";
 import { assertUserDecisionRequirement, assertWorkUnitUserDecision, assertImplementationDecision } from "./user-decision.mjs";
 
 const DECISIONS = new Set(["approved", "rejected", "vetoed"]);
@@ -65,6 +66,7 @@ export function validateApprovalRecord(record, { rolesDoc, requireApproved = fal
   if (!runtimeIds.has(record.runtime_id)) fail(`未知 runtime_id: ${record.runtime_id}`);
   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);
   if (!rule) fail(`${record.gate_id} 不是会签门禁；evidence_only / orchestrator 门禁不写 approval-record`);
 
@@ -120,10 +122,8 @@ export function assertApprovedGateHasValidApproval(gateId, gateState, { checkpoi
   if (!existsSync(resolved)) fail(`${gateId} 的 approval_ref 不可读: ${gateState.approval_ref}`);
   const record = loadApprovalRecord(resolved);
   if (record.gate_id !== gateId) fail(`${gateId} 的会签记录 gate_id 不匹配`);
-  if (rolesDoc.user_decision_policy.gates.includes(gateId) || countersignRuleForGate(rolesDoc.gate_policy, gateId)?.bucket === "biological_human") {
-    if (!gateState.subject_ref || gateState.subject_ref !== record.subject_ref || JSON.stringify([...(gateState.approval_scope || [])].sort()) !== JSON.stringify([...(record.approval_scope || [])].sort())) {
-      fail(`${gateId} user-decision-subject-mismatch: 当前门禁资产与会签范围不匹配`);
-    }
+  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: 当前门禁资产与会签范围不匹配`);
   }
   validateApprovalRecord(record, { rolesDoc, requireApproved: true });
 }
@@ -131,7 +131,10 @@ export function assertApprovedGateHasValidApproval(gateId, gateState, { checkpoi
 export function assertCheckpointApprovals(checkpoint, checkpointPath) {
   const gates = checkpoint?.gates;
   if (!gates || typeof gates !== "object") return;
+  const known = new Set(loadRegistry().gates.map(gate => gate.id));
   for (const [gateId, state] of Object.entries(gates)) {
+    if (!known.has(gateId)) fail(`未知或已退役门禁: ${gateId}；历史记录只读，不自动迁移批准`);
+    if (state.status === "approved") assertGateChecks(gateId, checkpoint);
     assertApprovedGateHasValidApproval(gateId, state, { checkpointPath });
   }
 }
@@ -149,6 +152,7 @@ export function assertCheckpointUserDecisions(checkpoint) {
   for (const requirement of review.required_decisions || []) assertUserDecisionRequirement(requirement);
   if (review.external_input) assertUserDecisionRequirement({ ...review.external_input, boundary: "external-input" });
   if (checkpoint.status === "completed") {
-    if (checkpoint.gates?.["gate.release-ready"]?.status !== "approved") throw new TypeError("user-decision-response-required: 阶段完成须发布就绪裁决");
+    if (checkpoint.blockers?.length || Object.values(checkpoint.gates || {}).some(gate => !["approved", "not-applicable"].includes(gate.status))) throw new TypeError("lifecycle-control-blocked: 仍有阻塞或未通过门禁，不可完成");
+    if (checkpoint.gates?.["gate.delivery-accepted"]?.status !== "approved") throw new TypeError("lifecycle-control-blocked: 阶段完成须交付验收，不等于发布授权");
   }
 }

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

@@ -43,7 +43,7 @@ export async function inspectBackendDelivery(root, ref) {
   const delivery=read(safe(root,ref));
   schema(delivery,'docs/process/schemas/backend-delivery.schema.json');
   ensure(boundFile(root,delivery.environment.test_data).length>0,'测试数据准备说明为空');
-  await approvedFile(root,delivery.openapi,['gate.openapi-frozen','gate.openapi-freeze-confirmed']);
+  await approvedFile(root,delivery.openapi,['gate.engineering-contract-approved','gate.openapi-frozen','gate.openapi-freeze-confirmed']);
   await approvedFile(root,delivery.slice_contract,'gate.slice-contract-approved');
   const contractDoc=read(safe(root,delivery.slice_contract.ref));
   const contract=contractDoc.slice_contract||contractDoc;

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

@@ -202,7 +202,7 @@ export function collectCountersignGateIds(policy) {
     const gates = policy?.[bucket];
     if (Array.isArray(gates)) ids.push(...gates);
   }
-  for (const rule of policy?.digital_human_review || []) {
+  for (const rule of [...(policy?.digital_human_review || []), ...(policy?.check_reviews || [])]) {
     if (rule?.gate) ids.push(rule.gate);
   }
   for (const rule of policy?.dual_digital_human || []) {
@@ -217,6 +217,8 @@ export function collectCountersignGateIds(policy) {
 }
 
 export function countersignRuleForGate(policy, gateId) {
+  const internal = (policy?.check_reviews || []).find(rule => rule.gate === gateId);
+  if (internal) return { bucket: "check_reviews", ...internal };
   const dual = (policy?.dual_digital_human || []).find((rule) => rule.gate === gateId);
   if (dual) return { bucket: "dual_digital_human", ...dual };
   const review = (policy?.digital_human_review || []).find((rule) => rule.gate === gateId);
@@ -332,7 +334,7 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
   }
   const claimed = new Set();
   for (const bucket of STRING_GATE_BUCKETS) {
-    if (bucket !== "product_digital_human_with_biological_veto" || policy[bucket]?.length !== 0) requireStringArray(policy[bucket], `gate_policy.${bucket}`);
+    if (policy[bucket]?.length !== 0) requireStringArray(policy[bucket], `gate_policy.${bucket}`);
     for (const gate of policy[bucket]) {
       if (!gateIds.has(gate)) fail(`gate_policy.${bucket} 引用了未知门禁: ${gate}`);
       if (claimed.has(gate)) fail(`门禁被多个会签桶重复占用: ${gate}`);
@@ -345,11 +347,17 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
   for (const [index, rule] of policy.digital_human_review.entries()) {
     if (typeof rule === "string") fail("digital_human_review 必须是含 gate 与 countersigners 的规则");
     validateSignRule(rule, { actors, gateIds, claimed, field: `digital_human_review[${index}]` });
-    if (rule.gate === "gate.release-ready") fail("gate.release-ready 不得放入 digital_human_review");
   }
-  if (!policy.biological_human.includes("gate.release-ready")) {
-    fail("gate.release-ready 必须属于 biological_human");
+  const checkIds = new Set(loadRegistry().checks.map(check => check.id));
+  const checkClaimed = new Set();
+  for (const id of policy.automatic_checks || []) {
+    if (!checkIds.has(id) || checkClaimed.has(id)) fail(`未知或重复自动检查: ${id}`);
+    checkClaimed.add(id);
   }
+  for (const [index, rule] of (policy.check_reviews || []).entries()) {
+    validateSignRule(rule, { actors, gateIds: checkIds, claimed: checkClaimed, field: `check_reviews[${index}]` });
+  }
+  if (checkClaimed.size !== checkIds.size) fail("内部检查职责覆盖不完整");
   if (!Array.isArray(policy.digital_human_review_work_units) || policy.digital_human_review_work_units.length === 0) {
     fail("缺少 digital_human_review_work_units");
   }
@@ -384,7 +392,7 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
   requireStringArray(decisions.gates, "user_decision_policy.gates");
   for (const gate of decisions.gates) if (!gateIds.has(gate)) fail(`用户决定引用未知门禁: ${gate}`);
   for (const unit of Object.keys(decisions.work_units || {})) if (!workUnitIds.has(unit)) fail(`用户决定引用未知工作单元: ${unit}`);
-  if (!policy.biological_human.includes("gate.user-confirmation")) fail("gate.user-confirmation 必须由真实用户裁决");
+  if (!policy.biological_human.includes("gate.product-design-approved")) fail("gate.product-design-approved 必须由真实用户裁决");
   for (const gate of [...(policy.unlisted_kept_biological || []), ...policy.biological_human]) {
     if (!decisions.gates.includes(gate)) fail(`${gate} 缺少真实回复要求`);
   }

package/template/scripts/lib/export-skills.mjs

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const sourceRoot = path.join(root, ".agents/skills");
 const managed = ["skills", "skills.sh.json", ".yss-export-manifest.json"];
-const forbidden = ["AGENTS.md", "CONTEXT.md", "docs", "skills-lock.json", ".agents", ".claude", ".codex", ".pi", ".qoder", ".trae"];
+const forbidden = ["AGENTS.md", "CONTEXT.md", "docs", "skills-lock.json", ".agents", ".codex", ".cursor", ".pi"];
 const hash = (content) => createHash("sha256").update(content).digest("hex");
 const fail = (message) => { throw new TypeError("export-yss-skills: " + message); };
 
@@ -48,8 +48,8 @@ function sanitize(text, relative) {
   const prefix = prefixPath ? prefixPath + "/" : "";
   let value = text.replace(/(YSS_SKILLS_ROOT\s*=\s*["']?)\/path\/to\/\.agents\/skills/g, "$1__YSS_SKILLS_ROOT_PATH__");
   value = value.replace(/\/path\/to\/\.agents\/skills/g, "$YSS_SKILLS_ROOT");
-  value = value.replace(/(?:\$\{base_project\}\/)?(?:\/path\/to\/)?\.(?:agents|claude|codex|pi|qoder|trae)\/skills\//g, prefix);
-  value = value.replace(/\.(?:agents|claude|codex|pi|qoder|trae)\/skills\b/g, "the canonical public skill source");
+  value = value.replace(/(?:\$\{base_project\}\/)?(?:\/path\/to\/)?\.(?:agents|codex|cursor|pi)\/skills\//g, prefix);
+  value = value.replace(/\.(?:agents|codex|cursor|pi)\/skills\b/g, "the canonical public skill source");
   value = value.replace(/\/path\/to\/skill-creator/g, "skill-creator").replace(/(?<![\w.])\/path\//g, "./path/");
   value = value.replace(/\/(?:Users|home|private)\/[^\s"'()<>\]]+/g, "<local-path-removed>").replace(/\/tmp\//g, "./tmp/");
   value = value.replace(/yss-spec-project-template/g, "the consuming project").replace(/\$\{base_project\}/g, "the consuming project");
@@ -98,7 +98,7 @@ function validate(output, skillNames) {
     const text = bytes.toString("utf8");
     if (/-----BEGIN (?:[A-Z0-9 ]+ )?PRIVATE KEY-----|(?:ghp_|github_pat_|github_token_|xox[baprs]-)[A-Za-z0-9_-]+|AKIA[0-9A-Z]{16}/.test(text)) fail("suspicious credential-like content: " + absolute);
     if (/(?:^|[^.\w])\/(?:Users|home|private|tmp)\//.test(text)) fail("absolute local path in public export: " + absolute);
-    if (/\.(?:agents|claude|codex|pi|qoder|trae)\/skills/.test(text)) fail("Agent root path in public export: " + absolute);
+    if (/\.(?:agents|codex|cursor|pi)\/skills/.test(text)) fail("Agent root path in public export: " + absolute);
   }
   validateLinks(path.join(output, "skills"));
 }

package/template/scripts/lib/lifecycle-context-query.mjs

@@ -73,6 +73,7 @@ export function queryLifecycleContext({ mode, stageId, workUnitId, include = []
   const planUnit = ['work-unit.plan-opportunity', 'work-unit.plan-requirements', 'work-unit.domain-strategy-design', 'work-unit.stage-decision', 'work-unit.spec-synthesis'].includes(workUnitId);
   const loadPlan = ['stage.plan', 'stage.spec-architecture'].includes(stageId) || planUnit;
   stageId ??= planUnit ? 'stage.plan' : undefined;
+  include = [...include, 'gate_consolidation'];
   if (loadPlan) include = [...include, 'planning', 'grill_exit'];
   const stage = selectById(lifecycle.stages, stageId, "阶段");
   const workUnit = selectById(lifecycle.work_units, workUnitId, "工作单元");
@@ -85,8 +86,9 @@ export function queryLifecycleContext({ mode, stageId, workUnitId, include = []
 
   const route = workUnitId ? orchestration.work_unit_routes?.[workUnitId] ?? null : null;
   const gates = lifecycle.gates.filter((gate) => gate.stage === stageId || (loadPlan && gate.stage === 'stage.plan'));
+  const checks = lifecycle.checks.filter(check => check.stage === stageId || gates.some(gate => gate.requires_checks?.includes(check.id)));
   const artifacts = lifecycle.artifacts.filter((artifact) => artifact.stage === stageId || (loadPlan && artifact.stage === 'stage.plan'));
-  const evidenceIds = new Set(gates.flatMap((gate) => gate.evidence ?? []));
+  const evidenceIds = new Set([...gates, ...checks].flatMap((gate) => gate.evidence ?? []));
   const selected = Object.fromEntries(normalizedIncludes.map((key) => [key, orchestration[key]]));
   const transition = workUnitId ? {
     next: orchestration.transition_graph?.routes?.[workUnitId] ?? [],
@@ -122,6 +124,7 @@ export function queryLifecycleContext({ mode, stageId, workUnitId, include = []
       artifacts,
       evidence: lifecycle.evidence.filter((item) => evidenceIds.has(item.id)),
       gates,
+      checks,
       stage,
       work_unit: workUnit,
     },

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

@@ -0,0 +1,85 @@
+import { readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { parseDocument } from '../vendor/yaml.mjs';
+import { loadRegistry, ROOT } from './lifecycle-registry.mjs';
+import { loadDigitalHumanRoles, countersignRuleForGate } from './digital-human-roles.mjs';
+import { validateApprovalRecord, loadApprovalRecord } from './approval-record.mjs';
+
+const fail = message => { throw new TypeError(`lifecycle-control-blocked: ${message}`); };
+
+// Checks retain their own evidence and independent review; only the aggregate requests a user decision.
+export function assertGateChecks(gateId, state, { root = ROOT, registry = loadRegistry(), rolesDoc = loadDigitalHumanRoles() } = {}) {
+  const gate = registry.gates.find(item => item.id === gateId);
+  if (!gate) fail(`未知或已退役门禁: ${gateId}`);
+  const controls = new Map(registry.checks.map(item => [item.id, item]));
+  const seen = new Set();
+  const evidence = item => {
+    if (!Array.isArray(item.basis) || !item.basis.length) fail('缺少当前证据摘要');
+    const refs = new Set();
+    for (const asset of item.basis) {
+      if (!asset?.ref || refs.has(asset.ref)) fail('证据引用缺失或重复');
+      refs.add(asset.ref);
+      const bytes = readFileSync(path.resolve(root, asset.ref));
+      if (createHash('sha256').update(bytes).digest('hex') !== asset.digest) fail(`证据过期: ${asset.ref}`);
+    }
+    return refs;
+  };
+  function check(id) {
+    if (seen.has(id)) return;
+    seen.add(id);
+    const definition = controls.get(id), item = state.checks?.[id];
+    if (!definition || !item) fail(`缺少检查: ${id}`);
+    const refs = evidence(item);
+    if (item.status === 'not-applicable') {
+      if (item.applicable !== false || !item.reason?.trim()) fail(`${id} 未命中须有影响面、原因和证据`);
+      return;
+    }
+    if (item.applicable !== true || !['passed', 'approved'].includes(item.status)) fail(`${id} 未通过或未评估`);
+    for (const dependency of definition.requires_checks || []) {
+      check(dependency);
+      if (state.checks[dependency].status === 'not-applicable') fail(`${id} 前置检查不适用，必须重新评估依赖`);
+    }
+    for (const kind of definition.evidence || []) {
+      if (!item.evidence?.[kind]?.length || item.evidence[kind].some(ref => !refs.has(ref))) fail(`${id} 缺少绑定证据: ${kind}`);
+    }
+    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));
+      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');
+      if (record.subject_digest !== subjectDigest) fail(`${id} 审查资产摘要不匹配`);
+      validateApprovalRecord(record, { rolesDoc, root, requireApproved: true });
+      if (!record.drafter_principal_ref || record.drafter_principal_ref === record.principal_ref) fail(`${id} 缺少独立审查身份或起草者自签`);
+    }
+  }
+  for (const id of gate.requires_checks || []) check(id);
+  const item = state.gates?.[gateId];
+  if (!item || item.status !== 'approved') fail(`${gateId} 未批准`);
+  const refs = evidence(item);
+  for (const kind of gate.evidence) {
+    if (!item.evidence?.[kind]?.length || item.evidence[kind].some(ref => !refs.has(ref))) fail(`${gateId} 缺少绑定证据: ${kind}`);
+  }
+  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));
+    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} 批准依据过期`);
+    const document = parseDocument(bytes.toString(), { uniqueKeys: true, maxAliasCount: 0 });
+    if (document.errors.length) fail(`${gateId} 审阅包不可解析`);
+    const review = document.toJS({ maxAliasCount: 0 });
+    if (review?.gate_id !== gateId || !Array.isArray(review.basis)) fail(`${gateId} 审阅包身份或依据缺失`);
+    for (const asset of item.basis.filter(asset => ![item.approval_ref, item.subject_ref].includes(asset.ref))) {
+      if (!review.basis.some(bound => bound.ref === asset.ref && bound.digest === asset.digest)) fail(`${gateId} 批准范围未覆盖证据: ${asset.ref}`);
+    }
+  }
+  // Bind the aggregate approval to the exact check evidence it covers.
+  for (const id of seen) for (const asset of state.checks[id].basis) {
+    if (!item.basis.some(bound => bound.ref === asset.ref && bound.digest === asset.digest)) fail(`${gateId} 未覆盖检查依据: ${id}/${asset.ref}`);
+  }
+  return { gate: gateId, checks: [...seen], result: 'passed' };
+}

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

@@ -7,8 +7,8 @@ import { parseDocument } from "../vendor/yaml.mjs";
 export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 export const DEFAULT_REGISTRY = path.join(ROOT, "docs/process/lifecycle-registry.yaml");
 export const DEFAULT_BASELINE = path.join(ROOT, "docs/process/lifecycle-registry-baseline.json");
-const ID_PATTERN = /^(stage|gate|artifact|work-unit|evidence)\.[a-z0-9][a-z0-9-]*$/;
-const COLLECTIONS = ["stages", "gates", "artifacts", "work_units", "evidence"];
+const ID_PATTERN = /^(stage|gate|check|artifact|work-unit|evidence)\.[a-z0-9][a-z0-9-]*$/;
+const COLLECTIONS = ["stages", "gates", "checks", "artifacts", "work_units", "evidence"];
 
 function fail(message) {
   throw new TypeError(message);
@@ -106,7 +106,7 @@ export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {})
     if (!(key in policy)) fail(`id_policy 缺少字段: ${key}`);
   }
   if (policy.published_ids_immutable !== true) fail("published_ids_immutable 必须为 true");
-  if (policy.pattern !== "^(stage|gate|artifact|work-unit|evidence)\\.[a-z0-9][a-z0-9-]*$") fail("id_policy.pattern 不符合固定命名空间");
+  if (policy.pattern !== "^(stage|gate|check|artifact|work-unit|evidence)\\.[a-z0-9][a-z0-9-]*$") fail("id_policy.pattern 不符合固定命名空间");
   if (policy.baseline !== "docs/process/lifecycle-registry-baseline.json") fail("id_policy.baseline 必须指向发布基线");
   if (!Array.isArray(policy.deprecated_ids)) fail("deprecated_ids 必须是数组");
   const ids = new Map();
@@ -126,7 +126,7 @@ export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {})
       ids.set(id, collection);
     }
   }
-  for (const gate of registry.gates) {
+  for (const gate of [...registry.gates, ...registry.checks]) {
     requireReference(ids, gate.stage, `${gate.id}.stage`);
     if (ids.get(gate.stage) !== "stages") fail(`${gate.id}.stage 必须引用 stage.*`);
     if (!Array.isArray(gate.evidence) || gate.evidence.length === 0) fail(`${gate.id}.evidence 必须是非空数组`);
@@ -134,12 +134,27 @@ export function validateRegistry(registry, { baseline = DEFAULT_BASELINE } = {})
       requireReference(ids, reference, `${gate.id}.evidence`);
       if (ids.get(reference) !== "evidence") fail(`${gate.id}.evidence 必须引用 evidence.*`);
     }
+    for (const reference of gate.requires_checks ?? []) {
+      requireReference(ids, reference, `${gate.id}.requires_checks`);
+      if (ids.get(reference) !== "checks" || reference === gate.id) fail(`${gate.id}.requires_checks 必须引用其他 check.*`);
+    }
     for (const reference of gate.requires_gates ?? []) {
       requireReference(ids, reference, `${gate.id}.requires_gates`);
       if (ids.get(reference) !== "gates") fail(`${gate.id}.requires_gates 必须引用 gate.*`);
       if (reference === gate.id) fail(`${gate.id}.requires_gates 不得引用自身`);
     }
   }
+  const visiting = new Set(), visited = new Set();
+  const controls = new Map([...registry.gates, ...registry.checks].map(record => [record.id, record]));
+  function visit(id) {
+    if (visiting.has(id)) fail(`生命周期检查依赖循环: ${id}`);
+    if (visited.has(id)) return;
+    visiting.add(id);
+    const record = controls.get(id);
+    for (const next of [...(record.requires_checks || []), ...(record.requires_gates || [])]) visit(next);
+    visiting.delete(id); visited.add(id);
+  }
+  for (const id of controls.keys()) visit(id);
   for (const artifact of registry.artifacts) {
     requireReference(ids, artifact.stage, `${artifact.id}.stage`);
     if (ids.get(artifact.stage) !== "stages") fail(`${artifact.id}.stage 必须引用 stage.*`);
@@ -152,12 +167,14 @@ export function renderLifecycleStructure(registry) {
   const display = (record, field) => record[`public_${field}`] ?? record[field];
   const lines = [
     "<!-- lifecycle-registry:structure:start -->",
-    `> 此结构区由 \`docs/process/lifecycle-registry.yaml\` 生成。当前为 \`${registry.status}\` 模式：它校验结构和派生文档，不改变运行时状态 schema 或人工批准语义。`, "",
+    `> 此结构区由 \`docs/process/lifecycle-registry.yaml\` 生成。当前为 \`${registry.status}\` 模式：正式门禁、内部检查和派生文档共同消费此事实源。`, "",
     "## 1. 主阶段", "", "| 稳定 ID | 阶段 | 目标 | 退出标准 |", "|---|---|---|---|"
   ];
   for (const stage of registry.stages) lines.push(`| \`${stage.id}\` | ${display(stage, "name")} | ${display(stage, "goal")} | ${display(stage, "exit_criteria")} |`);
-  lines.push("", "## 2. 生命周期对象", "", "门禁是需要裁决的审查点；产物、工作单元和证据不是门禁的同义词。未命中条件的门禁记录 \`not-applicable\` 及原因，不生成空文档。", "", "### 2.1 条件门禁", "", "| 稳定 ID | 门禁 | 所属阶段 | 触发条件 | 前置门禁 | 必须留下的证据 |", "|---|---|---|---|---|---|");
-  for (const gate of registry.gates) lines.push(`| \`${gate.id}\` | ${display(gate, "name")} | \`${gate.stage}\` | ${display(gate, "trigger")} | ${(gate.requires_gates ?? []).map((id) => `\`${id}\``).join("、") || "无"} | ${gate.evidence.map((id) => `\`${id}\``).join("、")} |`);
+  lines.push("", "## 2. 生命周期对象", "", "门禁是需要裁决的审查点；产物、工作单元和证据不是门禁的同义词。未命中条件的门禁记录 \`not-applicable\` 及原因，不生成空文档。", "", "### 2.1 条件门禁", "", "| 稳定 ID | 门禁 | 所属阶段 | 触发条件 | 前置门禁 / 检查 | 必须留下的证据 |", "|---|---|---|---|---|---|");
+  for (const gate of registry.gates) lines.push(`| \`${gate.id}\` | ${display(gate, "name")} | \`${gate.stage}\` | ${display(gate, "trigger")} | ${[...(gate.requires_gates ?? []), ...(gate.requires_checks ?? [])].map((id) => `\`${id}\``).join("、") || "无"} | ${gate.evidence.map((id) => `\`${id}\``).join("、")} |`);
+  lines.push("", "### 内部检查与自动前置条件", "", "检查失败仍阻断。专业审查记录作为聚合门禁证据，不单独请求用户批准；自动检查通过不授权实现或发布。", "", "| 稳定 ID | 检查 | 阶段 | 触发条件 |", "|---|---|---|---|");
+  for (const check of registry.checks) lines.push(`| \`${check.id}\` | ${display(check, "name")} | \`${check.stage}\` | ${display(check, "trigger")} |`);
   lines.push("", "### 2.2 生命周期产物", "", "| 稳定 ID | 产物 | 所属阶段 | 触发条件 |", "|---|---|---|---|");
   for (const artifact of registry.artifacts) lines.push(`| \`${artifact.id}\` | ${display(artifact, "name")} | \`${artifact.stage}\` | ${display(artifact, "trigger")} |`);
   lines.push("", "### 2.3 执行证据", "", "| 稳定 ID | 证据 | 说明 |", "|---|---|---|");

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

@@ -12,6 +12,8 @@ export function planEntryPolicy(options = {}) {
   if (!policy?.required_checks?.length || !policy?.gate_impacts) fail('缺少 Plan 入口策略');
   const gateIds = registry.gates.filter(gate => gate.stage === 'stage.plan').map(gate => gate.id).sort();
   if (JSON.stringify(gateIds) !== JSON.stringify(Object.keys(policy.gate_impacts).sort())) fail('Plan 门禁触发策略覆盖不完整');
+  const checkIds = registry.checks.filter(check => check.stage === 'stage.plan').map(check => check.id).sort();
+  if (JSON.stringify(checkIds) !== JSON.stringify(Object.keys(policy.check_impacts || {}).sort())) fail('Plan 内部检查触发策略覆盖不完整');
   return policy;
 }
 
@@ -21,7 +23,7 @@ export function assertPlanSpecEntry(state, options = {}) {
   const io = decisionIO(options);
   const policy = planEntryPolicy(options);
   const review = io.document(state.plan_review_ref);
-  if (review.schema_version !== 1 || review.kind !== 'plan-entry-review' || review.feature_id !== state.feature_id) fail('审阅包身份或范围不匹配');
+  if (review.schema_version !== 1 || review.kind !== 'plan-entry-review' || review.gate_id !== 'gate.plan-approved' || review.feature_id !== state.feature_id) fail('审阅包身份或范围不匹配');
   if (!Array.isArray(review.basis) || !review.basis.length) fail('缺少带摘要依据');
   const basis = new Map();
   for (const asset of review.basis) {
@@ -48,30 +50,29 @@ export function assertPlanSpecEntry(state, options = {}) {
     for (const field of ['noncritical_reason', 'owner', 'resolution_point', 'downstream_recipient']) if (!text(item[field])) fail(`延期项缺少 ${field}`);
     evidence(item.evidence_refs);
   }
-  for (const [gateId, impact] of Object.entries(policy.gate_impacts)) {
+  for (const [gateId, impact] of Object.entries(policy.check_impacts)) {
     if (typeof review.impacts?.[impact] !== 'boolean') fail(`未评估影响面: ${impact}`);
-    const gate = review.gates?.[gateId];
+    const gate = review.internal_checks?.[gateId];
     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);
       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 });
-      assertUserDecisionRequirement({ boundary: gateId, subject_ref: gate.subject_ref, scope: gate.approval_scope, user_decision_ref: record.user_decision_ref }, options);
     } else if (gate.status !== 'not-applicable' || !text(gate.reason)) fail(`未命中门禁须有原因和依据: ${gateId}`);
   }
   // 门禁依赖不能通过将上游标成 N/A 来跳过。
   const registry = io.document('docs/process/lifecycle-registry.yaml');
-  for (const gate of registry.gates.filter(gate => gate.stage === 'stage.plan')) {
-    if (review.gates[gate.id]?.status === 'approved') {
-      for (const dependency of gate.requires_gates || []) if (review.gates[dependency]?.status !== 'approved') fail(`门禁依赖未批准: ${dependency}`);
+  for (const gate of registry.checks.filter(gate => gate.stage === 'stage.plan')) {
+    if (review.internal_checks[gate.id]?.status === 'approved') {
+      for (const dependency of gate.requires_checks || []) if (review.internal_checks[dependency]?.status !== 'approved') fail(`门禁依赖未批准: ${dependency}`);
     }
   }
   const reconciliation = io.document(review.context_reconciliation_ref);
   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: 'plan-conclusion', 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 }, options);
   return { result: 'allowed', blocking_signals: [], missing_requirements: [], evidence_refs: [state.plan_review_ref, ...basis.keys()], next_work_unit: null };
 }
 

package/template/scripts/lib/skill-registry.mjs

@@ -236,12 +236,9 @@ export function validateSkillRegistry(registry, { lock, compilerContract, lifecy
   const roots = registry.agent_runtime_roots;
   if (!roots || typeof roots !== "object" || Array.isArray(roots)) fail("缺少 agent_runtime_roots");
   const expected = {
-    claude: ".claude/skills",
     codex: ".codex/skills",
     cursor: ".cursor/skills",
-    pi: ".pi/skills",
-    qoder: ".qoder/skills",
-    trae: ".trae/skills"
+    pi: ".pi/skills"
   };
   for (const [agent, root] of Object.entries(expected)) {
     if (roots[agent] !== root) fail(`agent_runtime_roots.${agent} 必须为 ${root}`);

package/template/scripts/lib/skill-supply-chain.mjs

@@ -9,7 +9,7 @@ const SOURCE_ROOT = path.join(ROOT, ".agents/skills");
 const LOCK_PATH = path.join(ROOT, "skills-lock.json");
 const YSS_UI_MANIFEST_PATH = path.join(SOURCE_ROOT, ".yss-skills-manifest.json");
 const STRATEGIC_DESIGN_MANIFEST_PATH = path.join(SOURCE_ROOT, ".strategic-design-skills-manifest.json");
-export const PROJECTION_ROOTS = [".claude/skills", ".codex/skills", ".cursor/skills", ".pi/skills", ".qoder/skills", ".trae/skills"];
+export const PROJECTION_ROOTS = [".codex/skills", ".cursor/skills", ".pi/skills"];
 export const OBSOLETE = new Set(["to-" + "prd", "to-" + "issues", "design-an-interface", "qa", "request-refactor-plan", "ubiquitous-language", "edit-article", "obsidian-vault", "writing-great-skills", "code-review-process", "yss-domain-modeling", "yss-dir", "yss-duckdb", "yss-file", "yss-filerunner", "yss-db2mybatis", "yss-mail", "yss-mapper-dynamic", "yss-quality", "yss-sql-condition", "yss-sql-tpl", "yss-valuation", "yss-variable", "yss-openapi", "web-design-engineer", "web-video-presentation", "wireframe-prototype", "wizard", "git-guardrails-claude-code", "claude-handoff", "batch-grill-me", "product-design-prototype", "research", "ask-matt", "dispatching-parallel-agents", "loop-me", "migrate-to-shoehorn", "prototype-page-acceptance", "scaffold-exercises", "setup-pre-commit", "setup-ts-deep-modules", "teach", "writing-beats", "writing-fragments", "writing-shape", "yss-microapp-commit", "yss-page-module-development", "yss-dictionary", "yss-jdbc", "yss-log", "yss-taskflow", "yss-backend-scaffold-application", "yss-backend-scaffold-domain", "yss-backend-scaffold-infrastructure", "yss-backend-scaffold-web", "yss-router", "yss-source-index"]);
 export function obsoleteCanonicalResidues(names, obsolete = OBSOLETE) {
   return names.filter((name) => obsolete.has(name)).sort();
@@ -222,7 +222,7 @@ function sourceRevisionMap(oldLock, arguments_) {
 function metadata(name, skillPath, directory, previous, canonical = false, sources = {}, upstreamRoot = null) {
   const old = previous[name] ?? {};
   let recordedPath = old.skillPath ?? skillPath;
-  if (canonical && /^\.(claude|codex|cursor|pi|qoder|trae)\/skills\//.test(recordedPath)) recordedPath = skillPath;
+  if (canonical && /^\.(codex|cursor|pi)\/skills\//.test(recordedPath)) recordedPath = skillPath;
   const result = { source: old.source ?? "project", sourceType: old.sourceType ?? "local", skillPath: recordedPath, effectiveHash: treeHash(directory) };
   const sourceInfo = sources[result.source];
   if (sourceInfo?.revision) result.sourceRevision = sourceInfo.revision;

package/template/scripts/lib/strategic-handoff.mjs

@@ -104,8 +104,10 @@ export async function inspectSource(root, handoffRef) {
   for (const [artifact, version] of [[strategy,strategy.domain_version],[stage,stage.package_version]]) {
     if(artifact.approval) { const record=read(safe(root,artifact.approval.approval_ref));await sourceApproval(record,roles,root);ensure(artifact.approval.current_version===version,'资产内置批准版本过期'); }
   }
-  const terminalGate=countersignRuleForGate(roles.gate_policy,'gate.strategic-design-handoff-approved')?'gate.strategic-design-handoff-approved':'gate.stage-decision-package-approved';
-  const expectedGates={domain_strategy_ref:'gate.domain-strategy-approved',stage_decision_package_ref:'gate.stage-decision-package-approved',spec_ref:'gate.spec-baseline-approved',prototype_ref:'gate.user-confirmation',visual_baseline_ref:'gate.user-confirmation',business_ticket_set_ref:terminalGate,handoff:terminalGate};
+  // Source packages retain their published approval vocabulary. Never promote old approvals into current checkpoint gates.
+  const currentPlan = (roles.gate_policy.dual_digital_human || []).some(rule => rule.gate === 'gate.plan-approved');
+  const terminalGate=currentPlan?'gate.plan-approved':countersignRuleForGate(roles.gate_policy,'gate.strategic-design-handoff-approved')?'gate.strategic-design-handoff-approved':'gate.stage-decision-package-approved';
+  const expectedGates={domain_strategy_ref:currentPlan?'gate.plan-approved':'gate.domain-strategy-approved',stage_decision_package_ref:currentPlan?'gate.plan-approved':'gate.stage-decision-package-approved',spec_ref:'gate.spec-baseline-approved',prototype_ref:currentPlan?'gate.product-design-approved':'gate.user-confirmation',visual_baseline_ref:currentPlan?'gate.product-design-approved':'gate.user-confirmation',business_ticket_set_ref:terminalGate,handoff:terminalGate};
   const bindings={...handoff.source,handoff:{id:handoff.handoff_id,version:handoff.handoff_version,persisted_ref:handoffRef,status:'approved'}};
   for(const [key,ref] of Object.entries(bindings)) {
     const approval=config.approvals[key];

package/template/scripts/lib/task-package.mjs

@@ -3,7 +3,7 @@ import path from "node:path";
 import { parseDocument } from "../vendor/yaml.mjs";
 import { loadDigitalHumanRoles, taskPackageDefaults } from "./digital-human-roles.mjs";
 import { loadRegistry, ROOT } from "./lifecycle-registry.mjs";
-import { loadMaintenanceCheckpoint, validateMaintenanceCheckpoint } from "./maintenance-intensity.mjs";
+import { readRepositoryMode } from "./repository-mode.mjs";
 import { assertImplementationDecision } from "./user-decision.mjs";
 import { validateNextRoute } from "./lifecycle-transition.mjs";
 import { assertPlanSpecEntry } from "./plan-spec-entry.mjs";
@@ -17,6 +17,11 @@ export const CONTRACT_KINDS = new Set(["lifecycle-work-unit", "slice-implementat
 export const EXECUTION_STATES = new Set(["Explorer", "Drafter", "Worker", "Reviewer", "Verifier"]);
 export const WORKFLOW_STATUSES = new Set(["not-started", "active", "paused", "resolved", "failed"]);
 
+const repositoryMode = readRepositoryMode(ROOT);
+const maintenanceValidators = repositoryMode === "template-source"
+  ? await import("./maintenance-intensity.mjs")
+  : null;
+
 function fail(message) { throw new TypeError(message); }
 function requireString(value, field) { if (typeof value !== "string" || !value.trim()) fail(`${field} 不能为空`); }
 function equalArrays(actual, expected) { return Array.isArray(actual) && actual.length === expected.length && actual.every((value, index) => value === expected[index]); }
@@ -143,11 +148,12 @@ function validateContract(value, registry, lifecycle) {
     return;
   }
   if (contract.kind === "template-maintenance") {
+    if (!maintenanceValidators) fail("project-instance 不支持 template-maintenance 任务包");
     if (contract.slice_contract_ref || contract.lifecycle_ref) fail("template-maintenance 不得携带其他合同引用");
     const checkpointPath = assertSafeRelativePath(contract.maintenance_ref, "contract.maintenance_ref");
     if (!existsSync(checkpointPath)) fail(`维护 checkpoint 不存在: ${contract.maintenance_ref}`);
-    const checkpoint = loadMaintenanceCheckpoint(contract.maintenance_ref);
-    validateMaintenanceCheckpoint(checkpoint, {
+    const checkpoint = maintenanceValidators.loadMaintenanceCheckpoint(contract.maintenance_ref);
+    maintenanceValidators.validateMaintenanceCheckpoint(checkpoint, {
       allowPendingReview: value.execution_state === "Reviewer" && value.workflow_status !== "resolved"
     });
     if (checkpoint.schema_version === 2 && value.execution_state === "Reviewer") {