agentic-flow-kit 1.1.8 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-flow-kit",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "description": "AI-Native 闭环工作流 + wiki 知识层脚手架——flow-kit init 一条命令为新项目装好 .agents 工作流引擎（阶段命令/角色契约/门禁钩子/kb 检索/看板/规则面预算）+ workflow 文档闭环 + wiki 知识库，装完自包含、零运行时依赖",
   "type": "module",
   "scripts": {

package/src/doctor.mjs

@@ -5,7 +5,7 @@ import { execSync, spawnSync } from 'node:child_process';
 import net from 'node:net';
 import { createHash } from 'node:crypto';
 import { listTree, scriptTrusted } from './render.mjs';
-import { isOwned, HOSTS, pickStackVars } from './profiles.mjs';
+import { isOwned, HOSTS, pickStackVars, srcTemplatePath, templateDriftOf, TEMPLATE_DRIFT_EXCLUDE } from './profiles.mjs';
 
 // 宿主目录映射（与 src/profiles.mjs#HOSTS 同源：装副本目录名前缀带点）
 const HOST_DIR = Object.fromEntries(Object.entries(HOSTS).map(([k, v]) => [k, v.dir]));
@@ -257,6 +257,19 @@ export function doctor(args, pkgRoot) {
     }
   }
 
+  // 6.9 模板下发感知（2026-10-06 template-downstream，只读 advisory——与 sync 出账同判据
+  //     profiles.templateDriftOf 单源；doctor 不写 kit.json，两次 sync 之间持续回显，sync 后自然消隐）。
+  //     语义：源仓模板已演进且盘面未跟随 → WARN 提醒（owned 归项目所有，不自动覆盖）；首次引入 WARN。
+  //     旧装户 owned[] 无 srcSha256 → no-anchor 静默跳过（无判定依据不产出告警），下次 sync 写锚后生效。
+  const tplRes = checkTemplateDrift(target, pkgRoot);
+  if (tplRes.skipped) {
+    if (tplRes.note) add('PASS', `模板感知跳过（${tplRes.note}）`);
+  } else if (tplRes.stale.length === 0) {
+    add('PASS', `模板感知 ${tplRes.total} 份无陈旧分歧（源仓模板与上次同步锚一致或盘面已跟随）`);
+  } else {
+    add('WARN', `模板感知：源仓 ${tplRes.stale.length} 份模板自上次同步后有演进且盘面未跟随：${tplRes.stale.join('、')}——如需跟随从包源 templates/ 拷贝；有意定制可忽略（跑 flow-kit sync 刷新锚后本项静默）`);
+  }
+
   // 7. check-loop——2026-09-26 check-loop-node 起 node 实现直跑（sh 版曾需先探 sh 可用性：Windows
   //    PowerShell 常无 sh，ENOENT 曾被吞进 hard-block 分支报成空原因假警报，incident 2026-09-24-doctor-sh-enoent；
   //    迁移后无 sh 依赖，探针退役。check-loop.sh 为兼容 shim，pre-push 钩子路径照常）
@@ -351,6 +364,42 @@ export function checkOwnedDrift(target) {
   return { drift, gone, total: owned.length, skipped: false };
 }
 
+// 模板下发感知（2026-10-06 template-downstream）：只读判据——owned 模板条目三方 sha 比对，
+// 判定单源 profiles.templateDriftOf（与 sync 出账同源，防两处字面量漂移）。恒不写 kit.json。
+// 返回 { skipped, note?, total, stale[] }：skipped=true 时 note 说明原因（无 kit / 无 owned /
+// 无锚——旧装户静默不追溯）；total＝参与比对的条目数；stale＝stale-drift 的 rel 清单。
+export function checkTemplateDrift(target, pkgRoot) {
+  const kitPath = path.join(target, '.agents', 'kit.json');
+  if (!fs.existsSync(kitPath)) return { skipped: true, note: 'kit.json 不存在', total: 0, stale: [] };
+  let kit;
+  try {
+    kit = JSON.parse(fs.readFileSync(kitPath, 'utf8'));
+  } catch (e) {
+    return { skipped: true, note: `kit.json 解析失败：${e.message}`, total: 0, stale: [] };
+  }
+  if (!pkgRoot) return { skipped: true, note: '无包源根', total: 0, stale: [] };
+  const owned = Array.isArray(kit.owned) ? kit.owned : [];
+  if (owned.length === 0) return { skipped: true, note: 'kit.json 无 owned 条目', total: 0, stale: [] };
+  const shaText = (p) => createHash('sha256').update(fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n'), 'utf8').digest('hex');
+  const stale = [];
+  let total = 0;
+  let anchored = 0;
+  for (const f of owned) {
+    if (TEMPLATE_DRIFT_EXCLUDE.has(f.rel)) continue;
+    const src = srcTemplatePath(pkgRoot, f.rel);
+    if (!src) continue;
+    total++;
+    if (typeof f.srcSha256 !== 'string' || !f.srcSha256) continue; // no-anchor：旧装户静默跳过
+    anchored++;
+    const srcCur = shaText(src);
+    const diskPath = path.join(target, f.rel);
+    const disk = fs.existsSync(diskPath) ? shaText(diskPath) : null;
+    if (templateDriftOf({ disk, srcRecord: f.srcSha256, srcCur }) === 'stale-drift') stale.push(f.rel);
+  }
+  if (anchored === 0) return { skipped: true, note: 'owned 模板条目均无 srcSha256 锚（旧装户，下次 sync 写锚后生效）', total: 0, stale: [] };
+  return { skipped: false, total, stale };
+}
+
 // 跨宿主薄适配正文段漂移校验（独立 export 供 doctor 主流程 + 单元测试共用；2026-09-25 cross-host-sync）
 // 装户侧视角：.agents/{commands,roles}/*.md 是权威源；4 宿主目录（zcode→.zcode、omp→.omp、
 // opencode→.opencode、trae→.trae）下 {agents,commands}/*.md 是薄适配。按正文段 sha 比对

package/src/fresh-init.test.mjs

@@ -25,6 +25,24 @@ const out = `${r.stdout || ''}${r.stderr || ''}`;
 check('fresh init exit 0', r.status === 0, `exit=${r.status}\n${out.split('\n').slice(-30).join('\n')}`);
 const kit = JSON.parse(fs.readFileSync(path.join(dir, '.agents', 'kit.json'), 'utf8'));
 check('新装 audit 为 false 且 policyVersion 为 2', kit.audit === false && kit.policyVersion === 2, JSON.stringify({ audit: kit.audit, policyVersion: kit.policyVersion }));
+// 模板下发感知初始锚（2026-10-06 template-downstream）：有包源模板对应的 owned 条目带 srcSha256＝
+// 包源模板原文 LF 归一 sha；生成器目标（INDEX.md 类）排除出感知面无该键
+{
+  const { createHash } = await import('node:crypto');
+  const tplAnchor = (rel) => kit.owned.find((f) => f.rel === rel);
+  const shaOf = (buf) => createHash('sha256').update(buf).digest('hex');
+  const agents = tplAnchor('AGENTS.md');
+  const srcRaw = fs.readFileSync(path.join(ROOT, 'templates', 'AGENTS.md'), 'utf8').replace(/\r\n/g, '\n');
+  check('新装 owned 模板条目带 srcSha256 且等于包源原文 sha（AGENTS.md）',
+    agents && typeof agents.srcSha256 === 'string' && agents.srcSha256 === shaOf(Buffer.from(srcRaw, 'utf8')),
+    JSON.stringify(agents || null));
+  check('新装生成器目标无锚（wiki/INDEX.md 排除出感知面）',
+    tplAnchor('wiki/INDEX.md') !== undefined && tplAnchor('wiki/INDEX.md').srcSha256 === undefined);
+  const cfg = tplAnchor('.agents/hooks/commit-check.config.json');
+  check('新装无包源模板对应条目无锚（生成类配置不参与感知）', cfg !== undefined && cfg.srcSha256 === undefined);
+  const rb = tplAnchor('.agents/rule-budgets.txt');
+  check('新装 _agents 前缀翻译参与感知（rule-budgets 带锚）', rb !== undefined && typeof rb.srcSha256 === 'string');
+}
 check('claude 命令与角色薄适配落盘',
   fs.existsSync(path.join(dir, '.claude', 'commands', 'wf-plan.md'))
   && fs.existsSync(path.join(dir, '.claude', 'agents', 'implementer.md')));

package/src/init.mjs

@@ -5,7 +5,7 @@ import path from 'node:path';
 import readline from 'node:readline';
 import { execSync, spawnSync } from 'node:child_process';
 import { renderTree, renderContent, sha256, scriptTrusted, listTree } from './render.mjs';
-import { HOSTS, STACKS, STACK_ALIASES, settingsJson, commitCheckConfig, pickStackVars, isOwned } from './profiles.mjs';
+import { HOSTS, STACKS, STACK_ALIASES, settingsJson, commitCheckConfig, pickStackVars, isOwned, srcTemplatePath, TEMPLATE_DRIFT_EXCLUDE } from './profiles.mjs';
 import { doctor } from './doctor.mjs';
 
 function fail(msg) {
@@ -292,7 +292,7 @@ export async function init(args, pkgRoot) {
   //    owned 的生成器目标按生成后盘面重记（P1-2）；记账一律 LF 归一 sha（P1-4——render 写盘已归一，
   //    生成器重写目标与用户合并文件两侧同口径，跨 checkout 字节稳定）
   const shaText = (p) => sha256(Buffer.from(fs.readFileSync(p, 'utf8').replace(/\r\n/g, '\n'), 'utf8'));
-  const GEN_TARGETS = new Set(['workflow/INDEX.md', 'wiki/INDEX.md', 'wiki/知识沉淀总览.html']); // 新增生成器目标须同步本清单
+  const GEN_TARGETS = TEMPLATE_DRIFT_EXCLUDE; // 单源挪 profiles（2026-10-06 template-downstream）：模板感知排除面与生成器重记面同集
   const managed = [
     ...t.written.filter((f) => !isOwned(f.rel)),
     // 宿主文件渲染时相对宿主根，入台账须还原为项目根相对路径
@@ -311,6 +311,14 @@ export async function init(args, pkgRoot) {
     owned.push({ rel, sha256: shaText(path.join(target, rel)) });
   }
   if (agentsMergedSha) owned.push({ rel: 'AGENTS.md', sha256: agentsMergedSha });
+  // 模板下发感知初始锚（2026-10-06 template-downstream）：有包源模板对应的 owned 条目记
+  // srcSha256＝包源模板原始文件 LF 归一 sha——锚记「见过的源」而非「期望盘面」（装户渲染/定制与锚正交）；
+  // GEN_TARGETS 是生成器重写目标，不期望被跟随，排除出感知面（防「拉取了也被重写」的单周期无谓出账）
+  const ownedFinal = owned.map((f) => {
+    if (GEN_TARGETS.has(f.rel)) return f;
+    const src = srcTemplatePath(pkgRoot, f.rel);
+    return src ? { ...f, srcSha256: shaText(src) } : f;
+  });
   const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, 'package.json'), 'utf8'));
   fs.mkdirSync(path.dirname(kitPath), { recursive: true });
   fs.writeFileSync(kitPath, `${JSON.stringify({
@@ -322,9 +330,9 @@ export async function init(args, pkgRoot) {
     createdAt: new Date().toISOString(),
     options: { hosts, stack: opt.stack, boardPort: String(opt.boardPort) },
     managed,
-    owned,
+    owned: ownedFinal,
   }, null, 2)}\n`);
-  console.log(`  kit.json 台账：managed ${managed.length} 份 ｜ owned ${owned.length} 份（版本 ${pkg.version}）`);
+  console.log(`  kit.json 台账：managed ${managed.length} 份 ｜ owned ${ownedFinal.length} 份（版本 ${pkg.version}）`);
 
   // 8) 自检（kit.json 已按生成后盘面记账——doctor §6.6 应全绿，fresh init 以 exit 0 收场）
   // 输出语义（p2-batch1 P2-4）：doctor 打印在异步端口回调里、晚于本横幅——脚本化消费方按退出码判定

package/src/profiles.mjs

@@ -1,4 +1,7 @@
 // 宿主注册表 + 技术栈 profile + init 生成的 owned 基线配置
+// fs/path 仅供 srcTemplatePath（模板下发感知）——显式 import，不依赖 Node 22+ 的全局 fs（engines >=18）
+import fs from 'node:fs';
+import path from 'node:path';
 // stack 决定门禁配置三处：commit-check 的条件构建（builds）与质量检测（checks，秒级确定性
 // 检查——lint/类型/vet；测试不放提交门，关单在 test.md 阶段门）、settings.json 的自检验
 // 命令权限（allow）、AGENTS.md「项目适配区」命令预填；不改工作流流程本身。
@@ -112,6 +115,37 @@ export function isOwned(rel) {
     || rel === '.agents/hooks/local-pre-commit';
 }
 
+// ---- 模板下发感知（2026-10-06 template-downstream）----
+// 装户 owned 模板无下发通道（init 一次性复制），源仓演进静默陈旧——S18/S20 装户事故根因。
+// 感知层 = 三方 sha 比对（一律 LF 归一，与 ownedSha 自愈同口径）：
+//   disk＝装户盘面 / srcRecord＝kit.json owned[].srcSha256（上次 sync/init 见过的包源 sha）/ srcCur＝本次包源。
+
+// 生成器目标（init「按生成后盘面重记」的清单，原 init 内 GEN_TARGETS 挪此单源）：生成器拥有该文件，
+// 装户不期望跟随包源模板——模板感知排除出比对面（防「拉取了也被生成器重写」的无谓出账）。新增生成器目标须同步本清单。
+export const TEMPLATE_DRIFT_EXCLUDE = new Set(['workflow/INDEX.md', 'wiki/INDEX.md', 'wiki/知识沉淀总览.html']);
+
+// 映射规则单源：renderTree 的「srcRoot/templates ↔ targetRoot/项目根」关系 + 点目录前缀翻译
+// （render.mjs：`_agents` → `.agents`）——装户 rel 以 .agents/ 开头时探 templates/_agents/<余径>。
+// 复核 P2-1（2026-10-06 template-downstream 独立复核）：漏翻译会让 rule-budgets.txt /
+// metric-claims.txt / local-pre-commit 等 5 条有包源起步模板的 owned 件永不参与感知。
+export function srcTemplatePath(pkgRoot, rel) {
+  const tplRel = rel.startsWith('.agents/') ? `_agents/${rel.slice('.agents/'.length)}` : rel;
+  const p = path.join(pkgRoot, 'templates', tplRel);
+  return fs.existsSync(p) ? p : null;
+}
+
+// 三态判定纯函数（sync 出账与 doctor 回显共用——防两处字面量漂移，N3 教训）：
+//   'stale-drift'   源已演进且盘面未跟随 → 唯一出账形态（advisory）
+//   'custom-synced' 盘面 ≠ 源但源 == 上次锚 → 装户定制跟源，owned 语义正常态，永不告警
+//   'synced'        盘面 == 当前源 → 静默（手工拉取后天然落此态）
+//   'no-anchor'     台账缺 srcSha256（旧装户）→ 静默跳过，下次 sync 写锚后生效，不追溯
+export function templateDriftOf({ disk, srcRecord, srcCur }) {
+  if (typeof srcRecord !== 'string' || !srcRecord) return 'no-anchor';
+  if (disk === srcCur) return 'synced';
+  if (srcCur !== srcRecord) return 'stale-drift';
+  return 'custom-synced';
+}
+
 export function settingsJson(stackKey) {
   const allow = [...new Set([
     'node', 'git status', 'git diff', 'git add', 'git commit', 'git log', 'git push',

package/src/sync.mjs

@@ -12,7 +12,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { spawnSync } from 'node:child_process';
 import { renderTree, sha256, scriptTrusted } from './render.mjs';
-import { HOSTS, pickStackVars, isOwned } from './profiles.mjs';
+import { HOSTS, pickStackVars, isOwned, srcTemplatePath, templateDriftOf, TEMPLATE_DRIFT_EXCLUDE } from './profiles.mjs';
 import { doctor } from './doctor.mjs';
 
 function fail(msg) {
@@ -166,6 +166,28 @@ export function sync(args, pkgRoot) {
     }
     if (ownedRefreshed) console.log(`  owned 台账哈希按盘面刷新 ${ownedRefreshed} 份（owned 归项目所有，仅记账不约束）`);
 
+    // 模板下发感知（2026-10-06 template-downstream，advisory 恒不 hard-block）：owned 模板无下发通道，
+    // 源仓演进静默陈旧（S18/S20 装户事故根因）——三方 sha 判定见 profiles.templateDriftOf 单源。
+    // 锚「见过即刷新」：本次 sync 见到的包源 sha 记入 srcSha256（含旧账无锚首跑写锚——写锚不出账，
+    // 不追溯）；唯一出账形态 = 源已演进且盘面未跟随。GEN_TARGETS 生成器目标不期望被跟随，排除。
+    const driftList = [];
+    if (Array.isArray(kit.owned)) {
+      kit.owned = kit.owned.map((f) => {
+        if (TEMPLATE_DRIFT_EXCLUDE.has(f.rel)) return f;
+        const src = srcTemplatePath(pkgRoot, f.rel);
+        if (!src) return f; // 无包源模板对应（项目配置类）不参与
+        const srcCur = ownedSha(src);
+        const diskPath = path.join(target, f.rel);
+        const disk = fs.existsSync(diskPath) ? ownedSha(diskPath) : null;
+        if (templateDriftOf({ disk, srcRecord: f.srcSha256, srcCur }) === 'stale-drift') driftList.push(f.rel);
+        return srcCur === f.srcSha256 ? f : { ...f, srcSha256: srcCur };
+      });
+    }
+    if (driftList.length) {
+      console.log(`  ⚠️ 模板感知（advisory）：源仓 ${driftList.length} 份模板自上次同步后有演进且盘面未跟随：${driftList.join('、')}`);
+      console.log('    owned 归项目所有，不自动覆盖；如需跟随：从包源 templates/ 拷贝对应文件；有意定制可忽略（下次 sync 起静默）');
+    }
+
     // 台账重写：版本对齐当前包；removed 出册；skipped 保持包侧基线持续报告
     kit.managed = managedNew.sort((a, b) => a.rel.localeCompare(b.rel));
     kit.version = pkg.version;

package/src/sync.test.mjs

@@ -296,5 +296,75 @@ else if (cmd === 'add-gate') addGate(rest, root);
   check('S14③ 盘上无 → 新增安装（既有行为不回归）', (r3.stdout + r3.stderr).includes('新增安装') && R(path.join(t3, '.agents/commands/new.txt')) === 'new in v2\n');
 }
 
+// ============ 场景 15：模板下发感知三态（2026-10-06 template-downstream）============
+// fixture 包源 templates/AGENTS.md = 'owned skeleton v2\n'；盘面定制 'owned CUSTOM\n'（≠ 包源）
+{
+  const sha = (s) => sha256(Buffer.from(s, 'utf8'));
+  const SRC_TPL = 'owned skeleton v2\n';
+  const kitOf = (t) => JSON.parse(R(path.join(t, '.agents', 'kit.json')));
+  const mkStale = (fx, t, owned) => W(path.join(t, '.agents', 'kit.json'), `${JSON.stringify({
+    kit: 'agentic-flow-kit', version: '1.0.0', createdAt: '2026-09-23T00:00:00Z',
+    options: { hosts: ['zcode'], stack: 'none', boardPort: '777' },
+    managed: [{ rel: '.agents/scripts/keep.txt', sha256: sha('keep v2\n') }], owned,
+  }, null, 2)}\n`);
+
+  // ① 源演进未拉取 → advisory 出账（唯一出账形态）+ 锚刷新 + 再跑静默（单周期出账）
+  const fx1 = mkFixture(), t1 = mkTarget(fx1);
+  W(path.join(t1, 'AGENTS.md'), 'owned CUSTOM\n');
+  mkStale(fx1, t1, [{ rel: 'AGENTS.md', sha256: sha('owned CUSTOM\n'), srcSha256: sha('owned skeleton v1\n') }]);
+  let r1 = runCmd('sync', fx1, t1);
+  const out1 = r1.stdout + r1.stderr;
+  // 断言锚定出账特征串「有演进且盘面未跟随」——doctor §6.9 的 PASS 回显也含「模板感知」四字，不可作判据
+  check('S15① 源演进未拉取 → 出账「模板感知」含文件名', out1.includes('有演进且盘面未跟随') && out1.includes('AGENTS.md'), out1.slice(0, 300));
+  check('S15① 锚刷新为当前包源 sha', kitOf(t1).owned[0].srcSha256 === sha(SRC_TPL));
+  r1 = runCmd('sync', fx1, t1);
+  check('S15① 锚已刷 → 再跑静默（单周期出账）', !(r1.stdout + r1.stderr).includes('有演进且盘面未跟随'));
+
+  // ② 定制跟源（srcSha256 == 当前包源）→ custom-synced 静默
+  const fx2 = mkFixture(), t2 = mkTarget(fx2);
+  W(path.join(t2, 'AGENTS.md'), 'owned CUSTOM\n');
+  mkStale(fx2, t2, [{ rel: 'AGENTS.md', sha256: sha('owned CUSTOM\n'), srcSha256: sha(SRC_TPL) }]);
+  const r2 = runCmd('sync', fx2, t2);
+  check('S15② 定制跟源 → 静默（owned 语义正常态永不告警）', !(r2.stdout + r2.stderr).includes('有演进且盘面未跟随'));
+
+  // ③ 旧 schema 无锚（mkTarget 原生）→ 静默写锚不追溯
+  const fx3b = mkFixture(), t3b = mkTarget(fx3b);
+  const r3b = runCmd('sync', fx3b, t3b);
+  check('S15③ 旧 schema 无锚 → 静默（写锚不出账，不追溯）', !(r3b.stdout + r3b.stderr).includes('有演进且盘面未跟随'));
+  check('S15③ 无锚首跑写入锚（下次 sync 起生效）', kitOf(t3b).owned.find((f) => f.rel === 'AGENTS.md').srcSha256 === sha(SRC_TPL));
+
+  // ④ 手工拉取（盘面 == 包源）→ synced 静默（可消退出账的路径）
+  const fx4 = mkFixture(), t4 = mkTarget(fx4);
+  mkStale(fx4, t4, [{ rel: 'AGENTS.md', sha256: sha(SRC_TPL), srcSha256: sha('owned skeleton v1\n') }]);
+  const r4 = runCmd('sync', fx4, t4);
+  check('S15④ 盘面已跟随（手工拉取）→ 静默', !(r4.stdout + r4.stderr).includes('有演进且盘面未跟随'));
+
+  // ⑤ doctor 只读回显：同判据出 stale 清单、且运行后 kit.json 字节不变；旧账无锚 skipped
+  //    （no-anchor 须用未跑过 sync 的独立 fixture——sync 会写锚）
+  const { checkTemplateDrift } = await import(pathToFileURL(path.join(SRC_ROOT, 'doctor.mjs')).href);
+  const fx5 = mkFixture(), t5 = mkTarget(fx5);
+  W(path.join(t5, 'AGENTS.md'), 'owned CUSTOM\n');
+  mkStale(fx5, t5, [{ rel: 'AGENTS.md', sha256: sha('owned CUSTOM\n'), srcSha256: sha('owned skeleton v1\n') }]);
+  const before = R(path.join(t5, '.agents', 'kit.json'));
+  const resStale = checkTemplateDrift(t5, fx5);
+  check('S15⑤ doctor 判据同源：stale 出清单', resStale.skipped === false && resStale.stale.includes('AGENTS.md'), JSON.stringify(resStale));
+  check('S15⑤ doctor 只读：kit.json 字节不变', R(path.join(t5, '.agents', 'kit.json')) === before);
+  const fx6 = mkFixture(), t6 = mkTarget(fx6);
+  const resNoAnchor = checkTemplateDrift(t6, fx6);
+  check('S15⑤ doctor 旧账无锚 → skipped 静默', resNoAnchor.skipped === true, JSON.stringify(resNoAnchor));
+
+  // ⑥ 点目录前缀翻译（复核 P2-1）：owned rel `.agents/x` ↔ 包源 `templates/_agents/x`——
+  //    有包源起步模板的 .agents/ owned 件同样参与感知（rule-budgets.txt 等 5 类）
+  const fx7 = mkFixture(), t7 = mkTarget(fx7);
+  W(path.join(fx7, 'templates/_agents/rule-budgets.txt'), 'budgets v2\n');
+  W(path.join(t7, '.agents/rule-budgets.txt'), 'budgets CUSTOM\n');
+  mkStale(fx7, t7, [
+    { rel: 'AGENTS.md', sha256: sha('owned skeleton v2\n'), srcSha256: sha(SRC_TPL) },
+    { rel: '.agents/rule-budgets.txt', sha256: sha('budgets CUSTOM\n'), srcSha256: sha('budgets v1\n') },
+  ]);
+  const r7 = runCmd('sync', fx7, t7);
+  check('S15⑥ .agents/ 前缀翻译 → _agents 模板参与感知出账', (r7.stdout + r7.stderr).includes('有演进且盘面未跟随') && (r7.stdout + r7.stderr).includes('.agents/rule-budgets.txt'));
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${failCount}`);
 process.exit(failCount ? 1 : 0);

package/templates/_agents/scripts/check-loop.mjs

@@ -111,7 +111,7 @@ import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { loadEnums } from './workflow-enums.mjs';
 import { runCheck16 } from './check-metric-claims.mjs';
-import { auditEnabled, loadKitPolicy } from './policy.mjs';
+import { auditEnabled, loadKitPolicy, hasFreshVerifyLine } from './policy.mjs';
 import { laneOfEntry } from './stage-gates.mjs';
 // MARK_RE：incident 留痕形态的单源（第七轮复核 N3——此前 check-loop 内联复制一份同口径字面量，
 // 两处靠注释与人工同步；改为复用 stage-gates.mjs 的导出，从结构上消除漂移可能）
@@ -629,9 +629,22 @@ function warnEvidenceExempt(type, base) {
 }
 
 // 证据真相校验：检查证据字符串是否包含合法的 commit SHA，且该 commit 触及了 plan 声明的文件
-function verifyEvidenceTruth(evidenceStr, planBase, root) {
+// 测试绿声明对账（2026-10-07 verify-evidence）：ctx = { verifyRelevant, hasFresh } 时，无 SHA 且命中
+// 关键词的证据走凭证对账——有 24h 绿行 → verify 型豁免出账；无 → verify-missing（聚合段出 warning，
+// 灰度第一档非 blocker）。ctx 由调用方按「intent 加入 git ≥ verifySince（v5 锚）」组装；锚不可判定
+// → ctx null → 维持 text 豁免（无判定依据不产出告警）。关键词表最小集起步（check2-datetime 先例：
+// 只豁免实证形态，变体实证再扩）。
+const VERIFY_GREEN_RE = /测试通过|测试全绿|测试绿|全绿/;
+function verifyEvidenceTruth(evidenceStr, planBase, root, ctx) {
   const shaMatch = evidenceStr.match(/\b([a-f0-9]{7,40})\b/i);
   if (!shaMatch) {
+    if (ctx && ctx.verifyRelevant && VERIFY_GREEN_RE.test(evidenceStr)) {
+      if (ctx.hasFresh) {
+        warnEvidenceExempt('verify', planBase);
+        return { ok: true, type: 'verify' };
+      }
+      return { ok: true, type: 'verify-missing' };
+    }
     warnEvidenceExempt('text', planBase);
     return { ok: true, type: 'text' };
   }
@@ -711,6 +724,15 @@ function verifyEvidenceTruth(evidenceStr, planBase, root) {
 {
   const accCutoff = '2026-09-12';
   let legacyUnaccounted = 0;
+  // 测试绿凭证状态（2026-10-07 verify-evidence）：台账读一次循环外缓存；policy 缺 verifySince
+  //（v1-v4）→ ctxBase null → 对账整体跳过（向后兼容）
+  const verifySinceOf = kitPolicy.verifySince;
+  const verifyFresh = (() => {
+    try {
+      const vp = path.join(ROOT, '.agents', 'verifications.jsonl');
+      return fs.existsSync(vp) ? hasFreshVerifyLine(fs.readFileSync(vp, 'utf8').split(/\r?\n/)) : false;
+    } catch { return false; }
+  })();
   for (const intent of docFiles('intents')) {
     if (fmGet(intent, '状态') !== 'done') continue;
     const base = path.basename(intent);
@@ -761,9 +783,17 @@ function verifyEvidenceTruth(evidenceStr, planBase, root) {
     //（豁免通道不得独立成立，防「只引 docs 提交洗白代码改动」）。
     if (evidenceItems.length) {
       const planBase = base.replace(/.md$/, '');
-      const results = evidenceItems.map((ev) => ({ t: verifyEvidenceTruth(ev, planBase, ROOT) }));
+      // verify 对账 ctx：intent 首次加入 git ≥ verifySince（v5 锚）才参与；不可判定 → null 走 text 豁免
+      const iadd = addedDateOf(intent);
+      const vctx = typeof verifySinceOf === 'string' && iadd !== '' && iadd >= verifySinceOf
+        ? { verifyRelevant: true, hasFresh: verifyFresh } : null;
+      const results = evidenceItems.map((ev) => ({ t: verifyEvidenceTruth(ev, planBase, ROOT, vctx) }));
       const hasImplEvidence = results.some((r) => r.t.ok && (r.t.type === 'sha' || r.t.type === 'process'));
       for (const r of results) {
+        if (r.t.ok && r.t.type === 'verify-missing') {
+          warnings.push(`- [WARN 测试绿缺凭证] ${base} 验收证据声明「测试绿」但 24h 内无 verify 凭证（verifications.jsonl）——跑 node .agents/scripts/verify.mjs 后重跑（advisory，灰度第一档）`);
+          continue;
+        }
         if (r.t.ok) continue;
         if (r.t.type === 'irrelevant' && r.t.recordCommit && hasImplEvidence) {
           warnEvidenceExempt('record', planBase);

package/templates/_agents/scripts/check-loop.test.mjs

@@ -2662,5 +2662,46 @@ w(T, 'workflow/intents/2026-09-12-deep.md', INTENT('deep', '状态: draft\n级
   rmfix(T2);
 }
 
+// ---- 场景:检查 8 测试绿声明对账（2026-10-07 verify-evidence）——v5 锚后无 SHA「测试绿」声明须有凭证 ----
+{
+  // 配对构造（检查 15 须过）：approved 态全文算指纹 → done 态落盘 + 台账 done 行（prev=approved，
+  // ts=今天 ≥ bindingTs）——与 bindingSha256 复原口径对称
+  const mkVe = (withLedger) => {
+    const T = mkfix();
+    gitInit(T);
+    w(T, '.agents/kit.json', JSON.stringify({ policyVersion: 5 }));
+    if (withLedger) {
+      w(T, '.agents/verifications.jsonl', `${JSON.stringify({ ts: new Date().toISOString(), exitCode: 0, suite: 'npm test' })}\n`);
+    }
+    const iBody = '# INTENT — ve\n\n## 验收标准（可测试）\n- [x] 用例通过（证据:测试全绿）\n';
+    const pBody = '# PLAN — ve\n';
+    const fpI = computeFingerprint(`---\n状态: approved\n级别: L1\n日期: 2026-10-07\n---\n${iBody}`);
+    const fpP = computeFingerprint(`---\n状态: approved\n级别: L1\n---\n${pBody}`);
+    w(T, 'workflow/intents/2026-10-07-ve.md', `---\n状态: done\n级别: L1\n日期: 2026-10-07\n确认指纹: ${fpI.slice(0, 16)}\n---\n${iBody}`);
+    w(T, 'workflow/plans/2026-10-07-ve.md', `---\n状态: done\n级别: L1\n确认指纹: ${fpP.slice(0, 16)}\n---\n${pBody}`);
+    const now = new Date().toISOString();
+    writeLedger(T, [
+      { ts: now, doc: 'workflow/intents/2026-10-07-ve.md', stage: 'done', fingerprint: fpI, prev: 'approved' },
+      { ts: now, doc: 'workflow/plans/2026-10-07-ve.md', stage: 'done', fingerprint: fpP, prev: 'approved' },
+    ]);
+    gitCommitAll(T, 'feat: ve fixture');
+    return T;
+  };
+  // ① 无凭证 → warning（advisory，不拦 exit）
+  const T1 = mkVe(false);
+  let r = run(T1);
+  check('检查 8 凭证对账:锚后「测试绿」声明无凭证 → warning 且不 hard',
+    r.status === 0 && outOf(r).includes('测试绿缺凭证') && !outOf(r).includes('证据伪造') && !outOf(r).includes('证据无关'),
+    `exit=${r.status}\n${outOf(r)}`);
+  rmfix(T1);
+  // ② 有近期绿行 → verify 型豁免出账、零 warning
+  const T2 = mkVe(true);
+  r = run(T2);
+  check('检查 8 凭证对账:24h 内有绿行 → verify 豁免出账且无 warning',
+    r.status === 0 && outOf(r).includes('证据豁免 verify') && !outOf(r).includes('测试绿缺凭证'),
+    `exit=${r.status}\n${outOf(r)}`);
+  rmfix(T2);
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/confirm-doc.mjs

@@ -40,7 +40,19 @@ import readline from 'node:readline';
 import { createHash, randomBytes } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { confirmGateFor, doneGateFor, laneOfEntry, laneOfDoc } from './stage-gates.mjs';
-import { loadKitPolicy } from './policy.mjs';
+import { loadKitPolicy, hasFreshVerifyLine } from './policy.mjs';
+
+// hasFreshVerify(root)：读 <root>/.agents/verifications.jsonl 判 24h 窗口绿行（判定单源
+// policy.hasFreshVerifyLine）。只读，台账缺失/不可读一律 false（=无凭证，advisory 层 fail-open）。
+function hasFreshVerify(root) {
+  try {
+    const p = path.join(root, '.agents', 'verifications.jsonl');
+    if (!fs.existsSync(p)) return false;
+    return hasFreshVerifyLine(fs.readFileSync(p, 'utf8').split(/\r?\n/));
+  } catch {
+    return false;
+  }
+}
 
 // computeFingerprint(text)：CRLF 归一 → 剔指纹行 → sha256 hex（64 位）
 export function computeFingerprint(text) {
@@ -304,6 +316,14 @@ if (isMain) {
         continue;
       }
     }
+    // 测试绿凭证前置（2026-10-07 verify-evidence，advisory 不拦）：→done 且文档含「验收标准」节且
+    // policy v5（verifySince）→ 24h 窗口内须有 verifications.jsonl 绿行。只读判定，任何读取异常降级
+    // 静默（fail-open——advisory 层不因台账缺失/坏行阻断关单）；升 hard 走后续 policyVersion 演进。
+    if (target === 'done' && typeof loadKitPolicy(root).verifySince === 'string'
+      && /^##\s*[^#]*验收标准/m.test(text) && !hasFreshVerify(root)) {
+      console.error(`⚠️ ${doc} 置 done：24h 内无测试绿凭证（verifications.jsonl）——关单勾验的「测试绿」声明缺机器事实`);
+      console.error('   跑 node .agents/scripts/verify.mjs（全绿自动落账）后重新关单；本次不拦截（advisory，灰度第一档）');
+    }
     const fp = computeFingerprint(text);
     // AI 自治放行分支（2026-09-30 ai-autonomy-trust）：
     // ① 仅 L0/L1（读 frontmatter「级别」，缺级别按不可自治处理——fail-closed）；

package/templates/_agents/scripts/confirm-doc.test.mjs

@@ -700,5 +700,41 @@ const writeTrust = (root, cfg) => {
   fs.rmSync(root, { recursive: true, force: true });
 }
 
+// ---- S38 测试绿凭证前置（2026-10-07 verify-evidence）：v5 + 验收节 + 无凭证 → ⚠️ advisory 且仍落账 ----
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-verify1-'));
+  const docP = path.join(root, 'workflow', 'intents');
+  fs.mkdirSync(docP, { recursive: true });
+  fs.mkdirSync(path.join(root, '.agents'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.agents', 'kit.json'), JSON.stringify({ policyVersion: 5 }), 'utf8');
+  fs.writeFileSync(path.join(docP, '2026-10-07-v.md'),
+    '---\n状态: approved\n级别: L1\n确认指纹: aaaa1111aaaa1111\n---\n# I\n\n## 验收标准（可测试）\n- [x] 用例通过（证据:测试全绿）\n', 'utf8');
+  const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-10-07-v.md', '--delegated', '可以'], { cwd: root, encoding: 'utf8' });
+  const after = fs.readFileSync(path.join(docP, '2026-10-07-v.md'), 'utf8');
+  check('S38 凭证前置：v5 + 验收节 + 无凭证 → ⚠️ 出账且 done 仍落态（advisory 不拦）',
+    r.status === 0 && /无测试绿凭证/.test(r.stderr) && /verify\.mjs/.test(r.stderr) && after.includes('状态: done'),
+    JSON.stringify({ status: r.status, stderr: String(r.stderr).slice(0, 200) }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- S39 测试绿凭证前置：近期绿凭证在场 → 静默（无 ⚠️）----
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'confirm-verify2-'));
+  const docP = path.join(root, 'workflow', 'intents');
+  fs.mkdirSync(docP, { recursive: true });
+  fs.mkdirSync(path.join(root, '.agents'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.agents', 'kit.json'), JSON.stringify({ policyVersion: 5 }), 'utf8');
+  fs.writeFileSync(path.join(root, '.agents', 'verifications.jsonl'),
+    `${JSON.stringify({ ts: new Date().toISOString(), exitCode: 0, suite: 'npm test', passed: 1, failed: 0 })}\n`, 'utf8');
+  fs.writeFileSync(path.join(docP, '2026-10-07-w.md'),
+    '---\n状态: approved\n级别: L1\n确认指纹: bbbb2222bbbb2222\n---\n# I\n\n## 验收标准（可测试）\n- [x] 用例通过（证据:测试全绿）\n', 'utf8');
+  const r = spawnSync(process.execPath, [CLI, 'workflow/intents/2026-10-07-w.md', '--delegated', '可以'], { cwd: root, encoding: 'utf8' });
+  const after = fs.readFileSync(path.join(docP, '2026-10-07-w.md'), 'utf8');
+  check('S39 凭证前置：24h 内有绿行 → 静默（无 ⚠️）且 done 落态',
+    r.status === 0 && !/无测试绿凭证/.test(r.stderr) && after.includes('状态: done'),
+    JSON.stringify({ status: r.status, stderr: String(r.stderr).slice(0, 200) }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/gate-checklist.mjs

@@ -65,6 +65,7 @@ const PAIRS = [
   { doctor: '6.6', cl: null, note: 'owned 漂移——装户体检独有' },
   { doctor: '6.7', cl: null, note: '跨宿主薄适配——装户体检独有' },
   { doctor: '6.8', cl: null, note: 'workflows 编排脚本 lint——装户体检独有' },
+  { doctor: '6.9', cl: null, note: '模板下发感知（2026-10-06 template-downstream）——装户体检独有（只读回显 sync 出账同源判据）' },
   { doctor: '8', cl: null, note: '看板端口——信息级独有' },
   // 经 §7 覆盖：doctor §7 整体运行 check-loop（#2/#11 已直接配对，不重复登记）
   { doctor: '7', cl: '1', note: '经 §7 整体运行覆盖' },

package/templates/_agents/scripts/pipeline-run.mjs

@@ -90,7 +90,9 @@ function runNode(ctx, run, script, args) {
   const scriptPath = path.join(ctx.bin, script);
   const cmd = `node .agents/scripts/${script} ${args.join(' ')}`;
   const t0 = Date.now();
-  const p = spawnSync(process.execPath, [scriptPath, ...args], { cwd: ctx.root, encoding: 'utf8', windowsHide: true });
+  // PIPELINE_RUN_ID 注入（2026-10-07 verify-evidence 复核 P2-1）：verify.mjs 绿行据此绑定 runId
+  //（对质链与 run 事件流同源，docsCommit 格式已含同一 runId）——spec「pipeline-run 路径自动绑定」落点
+  const p = spawnSync(process.execPath, [scriptPath, ...args], { cwd: ctx.root, encoding: 'utf8', windowsHide: true, env: { ...process.env, PIPELINE_RUN_ID: run.runId } });
   const ms = Date.now() - t0;
   const exit = p.status ?? 1;
   emit(run, { type: 'gate', cmd, exit, ms });

package/templates/_agents/scripts/policy.mjs

@@ -52,6 +52,23 @@ export const POLICIES = {
     bindingTs: '2026-09-28',
     delegationSince: '2026-10-06', // 检查 18 委派台账对账生效日（2026-10-06 loop-audit-remediation）；v1-v3 无此键 → 原全量对账行为
   },
+  // 版本 5 = 版本 2 的全部日期 + verifySince（测试绿机器凭证生效日，2026-10-07 verify-evidence）。
+  // 基准：Anthropic AI-Native SDLC「make test before done」。三处消费：verify.mjs 绿行落账（无开关，
+  // 纯事实记录）+ confirm-doc 置 done 门前置 advisory（24h 窗口）+ 检查 8 无 SHA 测试绿声明对账
+  // （intent 首次加入 git ≥ verifySince 才判）。缺键（v1-v4）→ 两处判定整体跳过，存量零新增告警。
+  // 注意本版本以 v2 为基线（本仓自用版本），不含 v3/v4 的装户后移锚——装户升 v5 视同同时接受
+  // v2 基线的早期锚（装户已选 v3/v4 的，升 v5 前 doctor 会提示锚变化，逐键核对后再升）。
+  5: {
+    moduleSince: '2026-09-22',
+    check14Since: '2026-09-26',
+    confirmDocsEffective: '2026-09-27',
+    confirmIncidentsEffective: '2026-09-28',
+    bindingTs: '2026-09-28',
+    check17UnclosedAfter: '0.8.0',
+    stageGateSince: '2026-09-29',
+    riskLevelSince: '2026-10-01',
+    verifySince: '2026-10-07', // 测试绿机器凭证生效日（2026-10-07 verify-evidence）；v1-v4 无此键 → 前置与对账整体跳过
+  },
 };
 
 export function loadKitPolicy(root) {
@@ -72,3 +89,22 @@ export function loadKitPolicy(root) {
 export function auditEnabled(policy) {
   return policy.audit !== false;
 }
+
+// ---- 测试绿凭证判定（2026-10-07 verify-evidence）----
+// 单源（confirm-doc done 前置与 check-loop 检查 8 对账共用——防两处窗口字面量漂移，N3 教训）：
+// hasFreshVerifyLine(lines, now)：verifications.jsonl 的行数组里是否存在「ts 距 now ≤ 24h 且
+// exitCode === 0」的绿行。坏行（非 JSON / 缺 ts）跳过不抛；窗口 24h = 覆盖「跑 verify → 跨会话/
+// 隔夜 → 次日关单」节奏（spec 2026-10-07-verify-evidence 论证）。
+export function hasFreshVerifyLine(lines, now = Date.now()) {
+  for (const line of lines || []) {
+    if (!line || !line.trim()) continue;
+    try {
+      const e = JSON.parse(line);
+      if (e && e.exitCode === 0 && typeof e.ts === 'string') {
+        const t = Date.parse(e.ts);
+        if (Number.isFinite(t) && now - t <= 24 * 60 * 60 * 1000) return true;
+      }
+    } catch { /* 坏行容忍跳过（confirmations.jsonl 同口径） */ }
+  }
+  return false;
+}

package/templates/_agents/scripts/verify.mjs

@@ -1,12 +1,18 @@
 #!/usr/bin/env node
 // verify.mjs — 关单固定编排（2026-09-24 intent closeout-verify-script；2026-09-26 check-loop-node 第 2 步直连 node）
 // 用途：关单前一键过门——按写死顺序执行 npm test → check-loop，逐项输出 pass/fail。
-// 语义：只编排不裁决——两条命令都是既有门禁原样跑，本脚本不新增校验、不读配置、无状态；
-//   任一步非零即 fail-fast 退出 1，失败原因经 stdio inherit 原样透传不吞。
+// 语义：只编排不裁决——两条命令都是既有门禁原样跑，本脚本不读配置、不判窗口、不改退出码；
+//   任一步非零即 fail-fast 退出 1，失败原因原样透传不吞。
 //   check-loop 为 node 实现（经 check-loop.mjs 直跑——node 即本脚本运行时必然可用，
 //   旧「缺 sh 环境 fail-closed」分支随 sh 依赖消失退役）。
+// 凭证落账（2026-10-07 verify-evidence）：两步全绿后向 <root>/.agents/verifications.jsonl append
+//   一行机器事实 {ts, exitCode:0, suite, passed?, failed?, runId?}——append-only 事实记录，不属裁决
+//   （窗口判定/门禁在消费方 confirm-doc 与 check-loop 检查 8）；消费语义 = 「按门跑了 verify 且全绿」，
+//   裸跑 npm test 不落账（对齐引导）。npm test 步骤输出从 inherit 改 pipe 捕获后回放（延迟显示，
+//   关单场景可接受）——仅为 best-effort 抓「合计: PASS n / FAIL n」计数行，抓不到则省略计数键。
 // 测试：node templates/_agents/scripts/verify.test.mjs（--test-cmd 注入假命令 + CHECK_LOOP_ROOT 注入夹具，不触真实 npm test 与 workflow）
 // 用法：node .agents/scripts/verify.mjs [--test-cmd "<shell 命令>"]（--test-cmd 仅供测试注入）
+import fs from 'node:fs';
 import { spawnSync } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -15,9 +21,12 @@ const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const args = process.argv.slice(2);
 const testCmd = args.includes('--test-cmd') ? args[args.indexOf('--test-cmd') + 1] : 'npm test';
 const checkLoop = path.join(SCRIPT_DIR, 'check-loop.mjs');
+const ROOT = process.env.CHECK_LOOP_ROOT || path.resolve(SCRIPT_DIR, '..', '..');
 
 console.log(`[verify] ▶ 1/2 ${testCmd}`);
-const t = spawnSync(testCmd, { shell: true, stdio: 'inherit' });
+const t = spawnSync(testCmd, { shell: true, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+if (t.stdout) process.stdout.write(t.stdout);
+if (t.stderr) process.stderr.write(t.stderr);
 if (t.status !== 0) {
   console.error(`[verify] ❌ 1/2 ${testCmd} 未通过（exit ${t.status ?? t.error?.code}）——修复后重跑，非绿不关单`);
   process.exit(1);
@@ -31,4 +40,17 @@ if (c.status !== 0) {
   process.exit(1);
 }
 console.log('[verify] ✅ 2/2 闭环校验通过');
+
+// 凭证落账：两步全绿才落（check-loop 红不产生凭证——凭证语义 = verify 全绿）；IO 失败出账不阻断
+try {
+  const m = [...String(t.stdout || '').matchAll(/合计: PASS (\d+) \/ FAIL (\d+)/g)].pop();
+  const entry = { ts: new Date().toISOString(), exitCode: 0, suite: 'npm test' };
+  if (m) { entry.passed = Number(m[1]); entry.failed = Number(m[2]); }
+  if (process.env.PIPELINE_RUN_ID) entry.runId = process.env.PIPELINE_RUN_ID;
+  fs.mkdirSync(path.join(ROOT, '.agents'), { recursive: true });
+  fs.appendFileSync(path.join(ROOT, '.agents', 'verifications.jsonl'), `${JSON.stringify(entry)}\n`);
+  console.log(`[verify] 🧾 测试绿凭证已落账 verifications.jsonl${entry.passed !== undefined ? `（PASS ${entry.passed} / FAIL ${entry.failed}）` : ''}`);
+} catch (e) {
+  console.error(`[verify] ⚠️ 凭证落账失败（${e.code || e.message}）——不阻断，关单门前置将按无凭证告警`);
+}
 console.log('[verify] ✅ 全绿——可以关单（逐条勾验验收标准补证据后 intent/plan → done）');

package/templates/_agents/scripts/verify.test.mjs

@@ -46,10 +46,10 @@ const mkBroken = () => {
   ].join('\n'), 'utf8');
   return d;
 };
-// 假命令（绝对路径直调，不依赖 PATH，跨平台无引号问题）
-const mkCmd = (code) => {
+// 假命令（绝对路径直调，不依赖 PATH，跨平台无引号问题）；out 可选输出汇总行
+const mkCmd = (code, out = '') => {
   const f = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'verify-cmd-')), `exit${code}.mjs`);
-  fs.writeFileSync(f, `process.exit(${code});`, 'utf8');
+  fs.writeFileSync(f, `process.stdout.write(${JSON.stringify(out)});process.exit(${code});`, 'utf8');
   return f;
 };
 const run = (argv, opts = {}) => spawnSync(process.execPath, [VERIFY, ...argv], { encoding: 'utf8', ...opts });
@@ -81,6 +81,41 @@ const run = (argv, opts = {}) => spawnSync(process.execPath, [VERIFY, ...argv],
   fs.rmSync(root, { recursive: true, force: true });
 }
 
+// ---- 场景 4：绿路径凭证落账（2026-10-07 verify-evidence）——全绿后 fixture 台账出合法绿行 ----
+{
+  const root = mkfix();
+  const r = run(['--test-cmd', `node ${mkCmd(0, '合计: PASS 3 / FAIL 0\n')}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
+  const vp = path.join(root, '.agents', 'verifications.jsonl');
+  const line = fs.existsSync(vp) ? JSON.parse(fs.readFileSync(vp, 'utf8').trim()) : null;
+  check('场景 4：全绿 → verifications.jsonl 落绿行（exitCode 0 + 计数捕获）',
+    r.status === 0 && line !== null && line.exitCode === 0 && line.passed === 3 && line.failed === 0
+      && typeof line.ts === 'string' && r.stdout.includes('凭证已落账'),
+    `exit=${r.status} line=${JSON.stringify(line)}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- 场景 5：红路径不落账（check-loop 红 → fail-fast 在落账前退出）----
+{
+  const root = mkBroken();
+  const r = run(['--test-cmd', `node ${mkCmd(0)}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
+  check('场景 5：npm test 绿但 check-loop 红 → 无凭证行（凭证语义 = verify 全绿）',
+    r.status === 1 && !fs.existsSync(path.join(root, '.agents', 'verifications.jsonl')),
+    `exit=${r.status}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+// ---- 场景 6：输出无汇总行 → 计数键省略（exitCode 才是硬事实）----
+{
+  const root = mkfix();
+  const r = run(['--test-cmd', `node ${mkCmd(0, 'ok\n')}`], { env: { ...process.env, CHECK_LOOP_ROOT: root } });
+  const vp = path.join(root, '.agents', 'verifications.jsonl');
+  const line = fs.existsSync(vp) ? JSON.parse(fs.readFileSync(vp, 'utf8').trim()) : null;
+  check('场景 6：无汇总输出 → 绿行落盘但计数键省略',
+    r.status === 0 && line !== null && line.exitCode === 0 && !('passed' in line) && !('failed' in line),
+    `line=${JSON.stringify(line)}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 if (fail) {
   console.log('\n用法：node templates/_agents/scripts/verify.test.mjs');