create-yss-spec 3.5.6 → 3.5.8

package/template/scripts/lib/content-identity.mjs

@@ -0,0 +1,273 @@
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import path from "node:path";
+
+// Git-native content identity. A "git-sha1" / "git-sha256" identity is the blob
+// hash Git itself would record for the path (default clean filters), obtained
+// from the index only when the path is provably complete, and from
+// "git hash-object" otherwise. "sha256" is the disclosed fallback without Git.
+export const GIT_SHA1 = "git-sha1";
+export const GIT_SHA256 = "git-sha256";
+export const SHA256 = "sha256";
+export const UNRESOLVED = "unresolved";
+const HEX_LENGTH = { "git-sha1": 40, "git-sha256": 64, sha256: 64 };
+const IDENTITY_PATTERN = /^(git-sha1|git-sha256|sha256):([0-9a-f]+)$/;
+const SKIP_NAMES = new Set([".DS_Store", "__pycache__", ".git"]);
+const SKIP_FILE = /\.(iml|pyc|pyo)$/;
+
+export function parseIdentity(value) {
+  if (typeof value !== "string") return null;
+  const match = IDENTITY_PATTERN.exec(value);
+  if (!match) return null;
+  if (match[2].length !== HEX_LENGTH[match[1]]) return null;
+  return { algo: match[1], value: match[2] };
+}
+export function formatIdentity(algo, hex) {
+  const length = HEX_LENGTH[algo];
+  if (!length) throw new TypeError("未知身份算法: " + algo);
+  if (typeof hex !== "string" || !new RegExp("^[0-9a-f]{" + length + "}$").test(hex)) {
+    throw new TypeError("身份摘要非法: " + algo + ":" + hex);
+  }
+  return algo + ":" + hex;
+}
+export function identityEquals(left, right) {
+  const a = parseIdentity(left);
+  const b = parseIdentity(right);
+  if (!a || !b) return left === right;
+  return a.algo === b.algo && a.value === b.value;
+}
+export function sha256Identity(bytes) {
+  return formatIdentity(SHA256, createHash("sha256").update(bytes).digest("hex"));
+}
+export function treeDigest(entries, algo = SHA256) {
+  const digest = createHash(algo === GIT_SHA1 ? "sha1" : "sha256");
+  const sorted = [...entries].sort((left, right) => (left.path < right.path ? -1 : left.path > right.path ? 1 : 0));
+  for (const entry of sorted) {
+    digest.update(entry.path).update("\0").update(entry.kind).update("\0").update(entry.identity).update("\0");
+  }
+  return formatIdentity(algo, digest.digest("hex"));
+}
+export function treeFiles(directory, prefix = "") {
+  if (!existsSync(directory)) return [];
+  const collected = [];
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    if (SKIP_NAMES.has(entry.name)) continue;
+    const absolute = path.join(directory, entry.name);
+    const rel = prefix ? prefix + "/" + entry.name : entry.name;
+    if (SKIP_FILE.test(rel)) continue;
+    if (entry.isDirectory()) collected.push(...treeFiles(absolute, rel));
+    else if (entry.isFile() || entry.isSymbolicLink()) collected.push([rel, absolute]);
+  }
+  return collected;
+}
+
+function modeKind(mode) {
+  if (mode === "120000") return "symlink";
+  if (mode === "160000") return "gitlink";
+  if (mode === "100755") return "exec";
+  return "file";
+}
+function statKind(info) {
+  if (info.isSymbolicLink()) return "symlink";
+  return info.mode & 0o111 ? "exec" : "file";
+}
+// Mark a path and every ancestor directory. A directory may only trust the
+// index when neither it nor any descendant is dirty, untracked or ignored —
+// otherwise the index view would silently omit files the worktree has.
+function markDirectories(target, ref) {
+  target.add(ref);
+  let cursor = ref;
+  while (cursor.includes("/")) {
+    cursor = cursor.slice(0, cursor.lastIndexOf("/"));
+    if (!cursor) break;
+    target.add(cursor);
+  }
+}
+
+export function createIdentityProvider(root, { spawn = spawnSync } = {}) {
+  // Compare against the canonical root: on macOS a /tmp path is really
+  // /private/tmp, and a link inside the repository would otherwise look external.
+  const realRoot = realpathOrResolve(root);
+  const run = (args) => spawn("git", ["-C", root, ...args], { encoding: "buffer", maxBuffer: 128 * 1024 * 1024 });
+  let available = false;
+  let algo = SHA256;
+  const index = new Map();
+  const ignoredDirs = new Set();
+  let dirty = null;
+  let dirtyDirs = null;
+  const visiting = new Set();
+
+  function load() {
+    index.clear();
+    ignoredDirs.clear();
+    visiting.clear();
+    dirty = null;
+    dirtyDirs = null;
+    const probe = run(["rev-parse", "--is-inside-work-tree"]);
+    available = probe.status === 0 && probe.stdout.toString("utf8").trim() === "true";
+    algo = SHA256;
+    if (!available) return;
+    const format = run(["rev-parse", "--show-object-format"]);
+    const name = format.status === 0 ? format.stdout.toString("utf8").trim() : "sha1";
+    algo = name === "sha256" ? GIT_SHA256 : GIT_SHA1;
+    const listed = run(["ls-files", "--stage", "-z"]);
+    if (listed.status !== 0) { available = false; return; }
+    for (const record of listed.stdout.toString("utf8").split("\0")) {
+      if (!record) continue;
+      const separator = record.indexOf("\t");
+      if (separator < 0) continue;
+      const [mode, sha] = record.slice(0, separator).split(" ");
+      index.set(record.slice(separator + 1), { mode, sha });
+    }
+    const ignored = run(["ls-files", "-z", "--others", "--ignored", "--exclude-standard"]);
+    if (ignored.status === 0) {
+      for (const ref of ignored.stdout.toString("utf8").split("\0")) {
+        if (ref) markDirectories(ignoredDirs, ref);
+      }
+    }
+  }
+  load();
+
+  function dirtySet() {
+    if (dirty) return dirty;
+    dirty = new Set();
+    dirtyDirs = new Set();
+    if (available) {
+      const status = run(["status", "--porcelain=v1", "-z", "--untracked-files=all"]);
+      if (status.status === 0) {
+        const records = status.stdout.toString("utf8").split("\0");
+        for (let cursor = 0; cursor < records.length; cursor += 1) {
+          const record = records[cursor];
+          if (record.length < 4) continue;
+          const code = record.slice(0, 2);
+          const ref = record.slice(3);
+          if (code[0] === "?" || code[1] !== " ") { dirty.add(ref); markDirectories(dirtyDirs, ref); }
+          if (code[0] === "R" || code[0] === "C") {
+            cursor += 1;
+            if (records[cursor]) { dirty.add(records[cursor]); markDirectories(dirtyDirs, records[cursor]); }
+          }
+        }
+      }
+    }
+    return dirty;
+  }
+
+  function hashObject(absolute) {
+    const result = spawn("git", ["-C", root, "hash-object", "--", absolute], { encoding: "utf8" });
+    if (result.status !== 0) return null;
+    const hex = result.stdout.trim();
+    return new RegExp("^[0-9a-f]{" + HEX_LENGTH[algo] + "}$").test(hex) ? formatIdentity(algo, hex) : null;
+  }
+
+  function indexIdentity(ref) {
+    const record = ref ? index.get(ref) : null;
+    if (!record || dirtySet().has(ref)) return null;
+    return formatIdentity(algo, record.sha);
+  }
+
+  function fileFromAbsolute(absolute, ref) {
+    const fromIndex = indexIdentity(ref);
+    if (fromIndex) return fromIndex;
+    if (available) {
+      const hashed = hashObject(absolute);
+      if (hashed) return hashed;
+    }
+    try { return sha256Identity(readFileSync(absolute)); } catch { return null; }
+  }
+
+  function symlinkIdentity(absolute) {
+    let resolved;
+    try { resolved = realpathSync(absolute); } catch { return null; }
+    if (visiting.has(resolved)) return null;
+    visiting.add(resolved);
+    try {
+      const info = lstatSync(resolved);
+      const rel = path.relative(realRoot, resolved).split(path.sep).join("/");
+      // A link that leaves the repository (or points at the root itself) is never
+      // enumerated: walking it would be unbounded. A directory legitimately named
+      // like "..data" is still inside, so only the ".." path segment is rejected.
+      const inside = rel !== "" && rel !== ".." && !rel.startsWith("../") && !path.isAbsolute(rel);
+      if (!inside) return null;
+      if (info.isDirectory()) return directoryIdentity(rel, resolved).identity;
+      return fileFromAbsolute(resolved, rel);
+    } finally {
+      visiting.delete(resolved);
+    }
+  }
+
+  function unresolvedEntry(rel, info) {
+    return { path: rel, kind: info.isSymbolicLink() ? "symlink" : "file", identity: UNRESOLVED };
+  }
+
+  function directoryEntries(absolute, ref) {
+    dirtySet();
+    const complete = ref && !dirtyDirs.has(ref) && !ignoredDirs.has(ref);
+    if (complete) {
+      const candidates = [];
+      for (const [candidate, record] of index) {
+        if (candidate.startsWith(ref + "/")) candidates.push([candidate, record]);
+      }
+      if (candidates.length) {
+        const entries = candidates.map(([candidate, record]) => {
+          const rel = candidate.slice(ref.length + 1);
+          const kind = modeKind(record.mode);
+          if (kind === "symlink") {
+            const resolvedIdentity = symlinkIdentity(path.join(root, candidate));
+            return resolvedIdentity ? { path: rel, kind, identity: resolvedIdentity } : { path: rel, kind, identity: UNRESOLVED };
+          }
+          return { path: rel, kind, identity: formatIdentity(algo, record.sha) };
+        });
+        return { entries, source: "index" };
+      }
+    }
+    const entries = treeFiles(absolute).map(([rel, file]) => {
+      const info = lstatSync(file);
+      if (info.isSymbolicLink()) {
+        const identity = symlinkIdentity(file);
+        return identity ? { path: rel, kind: "symlink", identity } : unresolvedEntry(rel, info);
+      }
+      const identity = fileFromAbsolute(file, ref ? ref + "/" + rel : null);
+      return identity ? { path: rel, kind: statKind(info), identity } : unresolvedEntry(rel, info);
+    });
+    return { entries, source: available ? "worktree" : "sha256-fallback" };
+  }
+
+  function directoryIdentity(ref, absolute = path.join(root, ref)) {
+    const { entries, source } = directoryEntries(absolute, ref);
+    return { identity: treeDigest(entries, available ? algo : SHA256), kind: "dir", source };
+  }
+
+  function identityFor(ref) {
+    const absolute = path.isAbsolute(ref) ? ref : path.join(root, ref);
+    const info = lstatSafe(absolute);
+    if (!info) return { identity: null, kind: "missing", source: available ? "index" : "sha256-fallback" };
+    if (info.isSymbolicLink()) {
+      const identity = symlinkIdentity(absolute);
+      return { identity, kind: "symlink", source: identity ? (available ? "worktree" : "sha256-fallback") : "unresolved" };
+    }
+    if (info.isDirectory()) return directoryIdentity(ref, absolute);
+    const identity = fileFromAbsolute(absolute, ref);
+    return { identity, kind: statKind(info), source: indexIdentity(ref) ? "index" : (available ? "worktree" : "sha256-fallback") };
+  }
+
+  return {
+    get available() { return available; },
+    get algo() { return available ? algo : SHA256; },
+    get root() { return root; },
+    indexSize: () => index.size,
+    refresh: () => { load(); },
+    identityFor,
+    file: (ref) => identityFor(ref).identity,
+    directory: (ref) => directoryIdentity(ref).identity,
+    equals: (left, right) => identityEquals(identityFor(left).identity, identityFor(right).identity),
+  };
+}
+
+function realpathOrResolve(target) {
+  try { return realpathSync(target); } catch { return path.resolve(target); }
+}
+
+function lstatSafe(target) {
+  try { return lstatSync(target); } catch (error) { if (error.code === "ENOENT") return null; throw error; }
+}

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

@@ -1,3 +1,4 @@
+import {approvalExpectationForBoundAsset} from './approval-consumption.mjs';
 import { normalizeSliceContract, sourceSliceContract, parseSliceYaml } from './slice-contract.mjs';
 import { assertExistingSliceStructure, createApprovedExecutionContext, verifySliceContractApproval } from './approved-execution-context.mjs';
 import path from 'node:path';
@@ -122,7 +123,7 @@ async function approved(root,binding,gates) {
   ensure(binding.approval_ref&&binding.id&&binding.version,'缺少当前资产 id/version/approval_ref');
   const record=read(safe(root,binding.approval_ref));
   const roles=sourceApprovalPolicy(read(safe(root,'.template-spec/agents/digital-human-roles.yaml')));
-  validateApprovalRecord(record,{rolesDoc:roles,requireApproved:true,root,read:ref=>readFileSync(safe(root,path.relative(root,ref).split(path.sep).join('/')))});
+  validateApprovalRecord(record,{rolesDoc:roles,requireApproved:true,root,read:ref=>readFileSync(safe(root,path.relative(root,ref).split(path.sep).join('/'))),expected:approvalExpectationForBoundAsset(record.gate_id,binding,{root})});
   ensure(gates.includes(record.gate_id),'资产批准使用错误门禁');
   ensure(record.artifact_bindings?.some(x=>x.id===binding.id&&x.version===binding.version&&x.digest===binding.digest),'stale: 批准未绑定当前资产身份、版本及字节');
 }

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

@@ -1,3 +1,4 @@
+import { validateReviewCapabilityPolicy } from './review-capabilities.mjs';
 import { readFileSync } from './validation-phase.mjs';
 import path from "node:path";
 import { parseDocument } from "../vendor/yaml.mjs";
@@ -230,8 +231,11 @@ export function countersignRuleForGate(policy, gateId) {
     return { bucket: "biological_human", gate: gateId, countersigners: [BIOLOGICAL_ROLE_ID] };
   }
   if ((policy?.evidence_only || []).includes(gateId) || (policy?.orchestrator || []).includes(gateId)) return null;
-  if (policy?.default_if_unlisted === "biological-human" && loadRegistry().gates.some((gate) => gate.id === gateId)) {
-    return { bucket: "biological_human", gate: gateId, countersigners: [BIOLOGICAL_ROLE_ID] };
+  if ((policy?.automatic_checks || []).includes(gateId)) return null;
+  if (policy?.default_if_unlisted === 'reject-unlisted') {
+    const error = new TypeError(`GATE_POLICY_REQUIRED: 未分类门禁或检查 ${gateId}`);
+    error.code = 'GATE_POLICY_REQUIRED';
+    throw error;
   }
   return null;
 }
@@ -253,7 +257,7 @@ export function taskPackageDefaults(roleId, doc) {
   };
 }
 
-export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, artifactIds, evidenceIds, workUnitIds, skillRegistry } = {}) {
+export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, artifactIds, evidenceIds, workUnitIds, skillRegistry, checkIds: suppliedCheckIds } = {}) {
   if (!doc || typeof doc !== "object" || Array.isArray(doc)) fail("数字人角色注册表必须是对象");
   if (doc.schema_version !== 1) fail("schema_version 必须为 1");
   if (doc.registry_id !== "yss.digital-human-roles") fail("registry_id 必须为 yss.digital-human-roles");
@@ -323,7 +327,7 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
 
   const policy = doc.gate_policy;
   if (!policy || typeof policy !== "object") fail("缺少 gate_policy");
-  if (policy.default_if_unlisted !== "biological-human") fail("default_if_unlisted 必须为 biological-human");
+  if (policy.default_if_unlisted !== "reject-unlisted") fail("GATE_POLICY_REQUIRED: default_if_unlisted 必须为 reject-unlisted");
   if (policy.runtime_side_effect_approval !== "biological-human") fail("runtime_side_effect_approval 必须为 biological-human");
   if (policy.commercial_contract !== "biological-human") fail("commercial_contract 必须为 biological-human");
   if (policy.unlisted_kept_biological) {
@@ -348,7 +352,7 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
     if (typeof rule === "string") fail("digital_human_review 必须是含 gate 与 countersigners 的规则");
     validateSignRule(rule, { actors, gateIds, claimed, field: `digital_human_review[${index}]` });
   }
-  const checkIds = new Set(loadRegistry().checks.map(check => check.id));
+  const checkIds = suppliedCheckIds || 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}`);
@@ -387,6 +391,8 @@ export function validateDigitalHumanRoles(doc, { skillIds, stageIds, gateIds, ar
     if (claimed.has(gate)) fail(`unlisted_kept_biological 与会签桶重复: ${gate}`);
   }
 
+  validateReviewCapabilityPolicy(doc, { skillIds, gateIds, checkIds });
+
   const decisions = doc.user_decision_policy;
   if (decisions?.continuation) {
     const continuation = decisions.continuation;
@@ -425,6 +431,7 @@ export function validateDefaultDigitalHumanRoles() {
     skillIds: skillIdsFromRegistry(skills),
     stageIds: idsFromCollection(lifecycle.stages, "stages"),
     gateIds: idsFromCollection(lifecycle.gates, "gates"),
+    checkIds: idsFromCollection(lifecycle.checks, "checks"),
     artifactIds: idsFromCollection(lifecycle.artifacts, "artifacts"),
     evidenceIds: idsFromCollection(lifecycle.evidence, "evidence"),
     workUnitIds: idsFromCollection(lifecycle.work_units, "work_units"),

package/template/scripts/lib/drift-report.mjs

@@ -0,0 +1,110 @@
+import { existsSync, lstatSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { SHA256, createIdentityProvider, identityEquals, parseIdentity, sha256Identity } from "./content-identity.mjs";
+
+// Records written by create-yss-spec historically store a bare sha256 hex in
+// contentHash. Normalize bare digests to their algorithm-tagged identity so the
+// comparison is by algorithm and value, never by string shape alone.
+export function normalizeRecordedIdentity(value) {
+  if (typeof value !== "string") return null;
+  if (parseIdentity(value)) return value;
+  if (/^[0-9a-f]{64}$/.test(value)) return "sha256:" + value;
+  if (/^[0-9a-f]{40}$/.test(value)) return "git-sha1:" + value;
+  return value;
+}
+
+export const DRIFT_EXIT = { clean: 0, drift: 1, usage: 2, environment: 3 };
+
+// Classify every recorded managed asset. "not-installed" means nothing was ever
+// recorded for an expected asset, "missing" means it was recorded and is now
+// gone, "drifted" means it was recorded and its content changed.
+export function classifyManagedFiles({ root, managedFiles = {}, expected = [], provider = null, allowCustomizations = false } = {}) {
+  const identity = provider || createIdentityProvider(root);
+  const entries = [];
+  const recorded = new Set(Object.keys(managedFiles));
+  for (const [ref, record] of Object.entries(managedFiles).sort(([left], [right]) => (left < right ? -1 : 1))) {
+    const info = lstatSafe(path.join(root, ref));
+    const customizable = allowCustomizations && record.ownership === "managed-customizable";
+    const expectedIdentity = customizable ? null : normalizeRecordedIdentity(record.identity ?? record.contentHash ?? null);
+    if (!info) { entries.push({ ref, kind: "missing", expected: expectedIdentity, actual: null }); continue; }
+    // Customization permits different file content, not missing, unreadable or
+    // replaced paths. Generated assets continue to require their recorded hash.
+    if (customizable && !info.isFile()) {
+      entries.push({ ref, kind: "drifted", expected: null, actual: null, error: "customizable-asset-must-be-file" });
+      continue;
+    }
+    // Compare like with like: a recorded sha256 digest must be matched against a
+    // freshly computed sha256, never against a differently-versioned Git identity.
+    const parsed = parseIdentity(expectedIdentity);
+    // A directory, a broken symlink or an unreadable path must surface as drift,
+    // never as an uncaught exception.
+    let actual = null;
+    let error = null;
+    try {
+      // A cached Git identity cannot prove that a permitted custom file is
+      // currently readable. Read its actual bytes before accepting it.
+      actual = customizable || (parsed && parsed.algo === SHA256) ? sha256Identity(readFileSync(path.join(root, ref))) : identity.identityFor(ref).identity;
+    } catch (cause) { actual = null; error = cause.message; }
+    if (!expectedIdentity) { entries.push({ ref, kind: error || (customizable && actual === null) ? "drifted" : "ok", expected: null, actual, ...(error ? { error } : {}) }); continue; }
+    const kind = identityEquals(expectedIdentity, actual) ? "ok" : "drifted";
+    const diagnosis = error ?? (actual === null ? "unreadable-or-unresolved" : null);
+    entries.push({ ref, kind, expected: expectedIdentity, actual, ...(diagnosis ? { error: diagnosis } : {}) });
+  }
+  for (const ref of [...expected].sort()) {
+    if (recorded.has(ref) || existsSync(path.join(root, ref))) continue;
+    entries.push({ ref, kind: "not-installed", expected: null, actual: null });
+  }
+  const summary = { ok: 0, not_installed: 0, missing: 0, drifted: 0, obsolete: 0 };
+  for (const entry of entries) {
+    const key = entry.kind === "not-installed" ? "not_installed" : entry.kind;
+    summary[key] += 1;
+  }
+  return { entries, summary };
+}
+
+export function buildDriftReport({ scope, root, provider = null, managedFiles = {}, expected = [], asOf = new Date().toISOString(), allowCustomizations = false } = {}) {
+  if (!["template-source", "project-instance"].includes(scope)) throw new TypeError("未知 drift-report scope: " + scope);
+  const identity = provider || createIdentityProvider(root);
+  const { entries, summary } = classifyManagedFiles({ root, managedFiles, expected, provider: identity, allowCustomizations: scope === "project-instance" && allowCustomizations });
+  return {
+    schema_version: 1,
+    kind: "drift-report",
+    as_of: asOf,
+    scope,
+    identity: { algo: identity.algo, source: identity.available ? "index" : "sha256-fallback" },
+    entries,
+    summary,
+  };
+}
+
+export function driftReportExit(report) {
+  return report.summary.missing || report.summary.drifted || report.summary.obsolete || report.summary.not_installed
+    ? DRIFT_EXIT.drift
+    : DRIFT_EXIT.clean;
+}
+
+function short(value) {
+  return typeof value === "string" ? value.slice(0, 18) : String(value);
+}
+
+export function formatDriftReport(report) {
+  const lines = ["drift-report [" + report.scope + "] identity=" + report.identity.algo + "/" + report.identity.source];
+  for (const entry of report.entries) {
+    if (entry.kind === "ok") continue;
+    const detail = entry.expected ? " (expected " + short(entry.expected) + ", actual " + short(entry.actual) + ")" : "";
+    lines.push("  " + entry.kind + ": " + entry.ref + detail);
+  }
+  lines.push("  summary: ok=" + report.summary.ok + " not-installed=" + report.summary.not_installed + " missing=" + report.summary.missing + " drifted=" + report.summary.drifted + " obsolete=" + report.summary.obsolete);
+  return lines.join("\n");
+}
+
+// Expected assets the distribution says should exist but that were never recorded.
+export function expectedFromDistribution(metadata = {}) {
+  const expected = [];
+  for (const skill of metadata.distribution?.installedSkills ?? []) expected.push(".agents/skills/" + skill);
+  return expected;
+}
+
+function lstatSafe(target) {
+  try { return lstatSync(target); } catch (error) { if (error.code === "ENOENT") return null; throw error; }
+}

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

@@ -1,3 +1,5 @@
+import {countersignRuleForGate} from './digital-human-roles.mjs';
+import {approvalExpectationForBoundAsset} from './approval-consumption.mjs';
 import {assertApprovedExecutionContext} from './approved-execution-context.mjs';
 import {createHash} from 'node:crypto';
 import { realpathSync } from 'node:fs';
@@ -113,7 +115,8 @@ export function verifyExistingArchitecture(identity,bindings,{root,registry,exec
  const review=bound(root,baseline.boundary_review);
  const rolesFile=path.join(root,'.template-spec/agents/digital-human-roles.yaml');
  const roles=parse(readFileSync(rolesFile));
- validateApprovalRecord(review,{rolesDoc:roles,requireApproved:true,root});
+ const reviewBoundary=['check.architecture-reviewed','gate.technical-design-approved'].find(boundary=>countersignRuleForGate(roles.gate_policy,boundary));
+ validateApprovalRecord(review,{rolesDoc:roles,requireApproved:true,root,expected:approvalExpectationForBoundAsset(reviewBoundary,bindings.manifest,{root})});
  requireThat(['check.architecture-reviewed','gate.technical-design-approved'].includes(review.gate_id)&&text(baseline.id)&&text(baseline.version),'ARCH_REVIEW_MISSING','需要架构边界审查');
  const basis=existingArchitectureDigest(Object.fromEntries(Object.entries(baseline).filter(([k])=>k!=='boundary_review')));
  requireThat(review.artifact_bindings?.some(x=>x.id===baseline.id&&x.version===baseline.version&&x.digest===basis),'ARCH_REVIEW_STALE','架构审查未绑定当前基线');