agentic-flow-kit 1.5.0 → 1.7.0

package/templates/_agents/commands/design.md

@@ -20,6 +20,12 @@ next: .agents/commands/build.md
 
 > L2/L3 强制;L1 走快车道(直接跳 `next: build.md` 起草 Quick-Plan)。
 
+## 0. 三件套合并预览（L2/L3 起草期，2026-10-09 engine-quality-round2 C）
+
+起草 intent / spec / plan 任一件后，**在输出草稿全文前先给三件要点总览**（各一件：目标 / 关键取舍 /
+验收判据 diff，合计 ≤12 行）——用户一次看整体再逐件拍板，省三次盲确认的上下文切换。
+确认纪律不变：逐件过目全文 + 逐件 `confirm-doc` 代录（禁并录、禁复用同句）。本阶段总览侧重：spec 方案取舍与 L3 复核安排。
+
 ## 1. 执行
 
 1. 确认同名入口文档已批准：新需求为 approved intent，修复为已确认的 incident 草稿；否则拒绝，分别回 `plan.md` / `maintain.md`（2026-09-30 起机器强制：fill-spec / confirm-doc 对前置未过直接拒绝 exit 2、不落盘不记账）。

package/templates/_agents/commands/new-task.md

@@ -35,6 +35,8 @@ next: 按阶段路由
 | **协作道**(敏捷优先,审计异步补) | L0 例行 / L1 实现级 | L0 直接 commit,豁免 intent;L1 快车道(intent 一句话确认 + 极简 plan)即动工。独立复核不设同步前置,check-loop 与事后 review 兜底;确认/代录可 `--batch` 批量(仅 L0/L1) |
 | **防御道**(严谨优先,确认同步拦) | L2 规则/契约 / L3 数据与运行时结构 | 同步确认门:spec 确认通过方可起草 plan,plan 确认后方可动手;L3 加新会话独立复核,未确认不放行 |
 
+> **L2/L3 起草期合并预览**：三件套起草按 [design.md §0](design.md) 一次呈现要点总览（逐件确认代录不变）。
+>
 > 定级结果落 intent frontmatter `risk_level`(=级别,`fill-intent.mjs` 自动写入,机器选道用);协作道勾触达红线会被 check-loop 判「红线判低」hard 拦(就高升级 L2/L3 并补同名 spec)。
 
 ## 3. 路由判断

package/templates/_agents/scripts/check-ledger-invariant.mjs

@@ -16,6 +16,12 @@
 //   ④ doc 匹配 workflow/(intents|specs|plans|incidents)/[^/]+.md 且当前树存在
 //   ⑤ stage ∈ 合法跳转终态集（approved/done/fixed/closed/superseded/cancelled）
 //
+// 行级豁免（2026-10-09 ledger-line-exempt，CI 红事故处置）：.agents/ledger-line-exempt.json 登记
+// 已定性的污染行（{line, doc, reason}——line = 校验序号即非空行序）——行级五项对豁免行整体跳过、
+// 行**保留在台账**（审计面完整），豁免计数照常出账保持可见。定位：事故行无法追加修复（行级扫最终树
+// 全行）且不可就地改（历史前缀不变量）——superseded 重立单之外的唯一出口。**滥用边界**：豁免文件
+// 自身入库、git 历史可对质；逐条须 papercuts/incident 定性引用，无定性登记 = 审计事件。
+//
 // 静默条件：台账不存在 / 零提交历史（装户、新仓）/ --staged 且暂存未触台账或无 HEAD 版本。
 // 已知边界：git log --follow 未用——台账自创建无重命名（单一路径取史）；克隆深度不足时仅扫可得
 //   历史（CI 侧 fetch-depth:0 兜全史，深度不足会告警声明边界，fail-open 于深度、fail-closed 于内容）。
@@ -102,9 +108,20 @@ let rows = [];
 try {
   rows = fs.readFileSync(FILE, 'utf8').split(/\r?\n/).filter((l) => l.trim()).map((l) => { try { return JSON.parse(l); } catch { return null; } });
 } catch { /* 上面 existsSync 已兜 */ }
+const EXEMPT_P = path.join(ROOT, '.agents', 'ledger-line-exempt.json');
+const exemptLines = new Set();
+try {
+  if (fs.existsSync(EXEMPT_P)) {
+    for (const e of JSON.parse(fs.readFileSync(EXEMPT_P, 'utf8'))) {
+      if (e && Number.isInteger(e.line)) exemptLines.add(e.line);
+    }
+  }
+} catch { /* 豁免表损坏 → 视同无豁免（fail-closed 于校验面） */ }
+let exemptCount = 0;
 let prevTs = '';
 rows.forEach((e, idx) => {
   const at = `第 ${idx + 1} 行`;
+  if (exemptLines.has(idx + 1)) { exemptCount++; return; } // 事故行豁免（登记文件入库可对质）
   if (!e || typeof e !== 'object') { problems.push(`- [行级] ${at}：非 JSON 对象行`); return; }
   if (typeof e.ts !== 'string' || Number.isNaN(Date.parse(e.ts))) problems.push(`- [行级] ${at}：ts 非 ISO 字符串`);
   else {
@@ -126,6 +143,7 @@ rows.forEach((e, idx) => {
   if (!VALID_STAGES.has(e.stage)) problems.push(`- [行级] ${at}：stage「${e.stage || '缺失'}」不在合法跳转终态集`);
 });
 
+if (exemptCount) console.log(`ℹ️  台账豁免行 ${exemptCount} 条（定性见 .agents/ledger-line-exempt.json）`);
 if (problems.length) {
   console.error(`台账不可变（历史全扫）— HARD-BLOCK:\n\n${problems.join('\n')}\n`);
   console.error('  修法：台账历史行禁删改（append-only 前缀不变量）——误写只能追加补偿行；确需撤销历史提交请 git revert 后重新追加。篡改属审计事件，保留现场联系仓库所有者。');

package/templates/_agents/scripts/check-ledger-invariant.test.mjs

@@ -157,5 +157,21 @@ const append = (d, line) => fs.appendFileSync(ledPath(d), line + '\n');
   check('S12 回退注记行（n/a 指纹）→ 历史全扫过', r.code === 0, r.out);
 }
 
+// ---- 豁免登记（2026-10-09 ledger-line-exempt，CI 红事故处置）----
+{
+  // 坏行（fingerprint 非 hex + doc 不存在）→ 红；登记豁免 → 绿 + 计数可见
+  const d = mkrepo(row({ fingerprint: 'probe-fp', doc: 'workflow/intents/ghost.md' }));
+  let r = run(d);
+  check('豁免前：行级坏行 hard（fingerprint/doc 双违规）', r.code === 1 && r.out.includes('行级'), r.out.slice(0, 200));
+  fs.writeFileSync(path.join(d, '.agents', 'ledger-line-exempt.json'), JSON.stringify([{ line: 1, doc: 'workflow/intents/ghost.md', reason: '事故定性' }], null, 2));
+  r = run(d);
+  check('豁免后：exit 0 且计数可见', r.code === 0 && r.out.includes('台账豁免行 1 条'), r.out.slice(0, 200));
+  // 行号错位豁免不生效（line=99 无对应坏行）
+  fs.writeFileSync(path.join(d, '.agents', 'ledger-line-exempt.json'), JSON.stringify([{ line: 99, reason: '错位' }]));
+  r = run(d);
+  check('豁免行号不匹配：仍 hard（精确豁免）', r.code === 1, r.out.slice(0, 150));
+  fs.rmSync(d, { recursive: true, force: true });
+}
+
 console.log(`\n${fail ? `❌ ${fail} failed` : '✅ all passed'}（${pass} passed）`);
 process.exit(fail ? 1 : 0);

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

@@ -60,6 +60,13 @@
 //      按 prev 复原跳转前文本重算 sha256 与台账全量比对,不符=hard「确认内容漂移」;状态行保分隔符换值
 //      (非规范格式不误伤);台账行缺 prev 降级 warning;关单编辑顺序新约定:勾验/回填先于关单确认,
 //      confirm-doc 是最后一次写入)
+//      + scope 子项(2026-10-09 审查 A1 干净版):受管行(ts≥policy.scopeSince,**时刻**锚,缺键 v1-v6 整体跳过
+//      →存量 406 行零新增告警)须带机器派生的改动面 scope{files,sha256}——写入侧 confirm-doc.machineScope
+//      自动派生(被确认文档 + `git status --porcelain` 未提交改动集),**AI 无输入面**,分辨力从
+//      「一句可复用的用户原话」换成「机器实测的这 N 个文件」。判据:缺 scope→warning(灰度第一档);
+//      scope.files 重算 sha256 不符→hard(「改了 files 没改摘要」= 同一信任边界内手改痕迹,兜住整文件
+//      重写重建链后的二次篡改)。**边界**:scope 证「放行时盘面上哪些文件在动」,不证「这些改动语义正确」
+//      ——后者由 fingerprint(文档内容绑定)+ commit diff(事后对质)承担,不越界宣称
 //      + 并录批次审计子检查(2026-09-28 batch-ledger-audit 改判据;**读调用事实,不猜时间戳模式**):
 //      判据 = 台账行按 batch 分组、组内 of>1(delegated 行) → warning「确认并录」;batch/seq/of 由
 //      confirm-doc 写入时记录(那才是"本次调用落几份"确定已知的时刻)。旧判据「同 quote + 相邻 ts<2s」
@@ -111,7 +118,7 @@ import { spawnSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { loadEnums } from './workflow-enums.mjs';
 import { runCheck16 } from './check-metric-claims.mjs';
-import { auditEnabled, loadKitPolicy, hasFreshVerifyLine } from './policy.mjs';
+import { auditEnabled, loadKitPolicy, hasFreshVerifyLine, ledgerChainHash, scopeMatches } from './policy.mjs';
 import { laneOfEntry } from './stage-gates.mjs';
 // MARK_RE：incident 留痕形态的单源（第七轮复核 N3——此前 check-loop 内联复制一份同口径字面量，
 // 两处靠注释与人工同步；改为复用 stage-gates.mjs 的导出，从结构上消除漂移可能）
@@ -120,6 +127,8 @@ import { MARK_RE, approvedTraceHit } from './stage-gates.mjs';
 // 本文件只组装 ctx 并消费返回的文案数组（先例 = check-metric-claims.mjs 承载检查 16）。
 // 调用点位置即输出顺序位：须留在检查 10 与 12 之间以保持 warnings 行序（稳定输出契约），见该模块内注释。
 import { runCheckHygiene } from './check-hygiene.mjs';
+// 检查 7 拆模块（2026-10-09 engine-quality-round2 A1）：阶段索引同步迁 check-stage-index.mjs
+import { runCheckStageIndex } from './check-stage-index.mjs';
 import { gateSeg, finishSegs, makeCollector } from './gate-seg.mjs';
 
 // CHECK_LOOP_GIT：测试注入钩子（指向不存在/不可执行路径可稳定触发 spawn 异常）；未设置时与原行为逐字节一致（2026-10-05-gitout-fail-open）
@@ -592,19 +601,10 @@ export function runCheckLoop(opts = {}) {
     if (modelHits.length) warnings.push(`- [WARN 宿主耦合] 薄 Adapter 不应固定模型:\n${modelHits.join('\n')}`);
   }
 
-  // --- 6. 阶段索引同步 [warning] ---
-  markGate('6', '阶段索引同步');
-  for (const cmd of ['plan', 'design', 'build', 'test', 'deploy', 'maintain', 'review']) {
-    for (const doc of ['AGENTS.md', '.agents/commands/new-task.md']) {
-      // existsSync 守卫（2026-10-06-check19-entry-enoent 同类）：两文件可合法缺失（下方 text 判空本就
-      // 预期缺失态），fail-loud fs 读下按空跳过、不再响亮出账
-      const docPath = path.join(ROOT, doc);
-      const text = fs.existsSync(docPath) ? linesOf(docPath) : null;
-      if (text && !text.some((l) => l.includes(`.agents/commands/${cmd}.md`))) {
-        warnings.push(`- [WARN 阶段索引漂移] ${doc} 缺 ${cmd} 指令索引(两处阶段表须同步维护)`);
-      }
-    }
-  }
+  // --- 6. 阶段索引同步 [warning]（2026-10-09 engine-quality-round2 A1：实现迁 check-stage-index.mjs——
+  //     先例 check-hygiene / check-metric-claims；段 id 沿 sh 版 '6'，清单编号 7 与文案逐字不动；
+  //     调用点位置即输出顺序契约）---
+  warnings.push(...runCheckStageIndex({ root: ROOT, linesOf, gateStats }));
 
   // --- 共享：文件「首次加入 git」的日期索引（2026-09-28 check8-git-anchor）---
   // 用途：检查 8 的生效日锚从**可手填的文件名前缀**（项目命名规范本身即 `YYYY-MM-DD-<主题>`，作者
@@ -618,18 +618,13 @@ export function runCheckLoop(opts = {}) {
   // 非 git / 命令失败 → null，调用方按既有「非 git 跳过」语义退化（不 fail-loud）。
   // 注：检查 10 需要的是「文件→加入 commit」+「commit→文件清单」两份映射（判断同提交是否触及迁移 SQL），
   // 与本索引「文件→日期」不同构，故**不合并**——避免把两处判据耦死。
-  const addedDates = (() => {
-    if (gitOut(['rev-parse', '--git-dir']) === null) return null;
-    const log = gitOut(['log', '--diff-filter=A', '--format=@%aI', '--name-only']);
-    if (log === null) return null;
-    const m = new Map();
-    let cur = null;
-    for (const line of log.split('\n')) {
-      if (line.startsWith('@')) { cur = line.slice(1); continue; }
-      if (line.trim() && cur && !m.has(line.trim())) m.set(line.trim(), cur); // 新→旧序首遇 = 最早
-    }
-    return m;
-  })();
+  // addedDates（2026-10-09 engine-quality-round3 W1）：全史解析走持久缓存（HEAD 键）——
+  // 同 HEAD 多入口复跑（verify/edit-face-check/pre-commit/CI）不再重复全算；git-dir 探测保留在前。
+  const addedDates = gitOut(['rev-parse', '--git-dir']) === null ? null : addedDatesWithCache({
+    head: gitOut(['rev-parse', 'HEAD']),
+    gitLog: () => gitOut(['log', '--diff-filter=A', '--format=@%aI', '--name-only']),
+    cachePath: path.join(ROOT, '.agents', 'cache', 'added-dates.json'),
+  });
   // 某文档「首次加入日期」（YYYY-MM-DD）；不可判定（非 git / 查不到）返回 ''
   const addedDateOf = (absDoc) => {
     if (!addedDates) return '';
@@ -983,10 +978,72 @@ export function runCheckLoop(opts = {}) {
     const EFFECTIVE = kitPolicy.confirmDocsEffective;
     const ledgerPath = path.join(ROOT, '.agents', 'confirmations.jsonl');
     const ledger = [];
+    const ledgerBadLines = []; // 坏行（JSON.parse 失败）的物理行号（复核 P2-1：报文行号须对齐物理行）
     if (fs.existsSync(ledgerPath)) {
-      for (const line of linesOf(ledgerPath) || []) {
+      for (const [lineNo, line] of (linesOf(ledgerPath) || []).entries()) {
         if (!line.trim()) continue;
-        try { ledger.push(JSON.parse(line)); } catch { /* 坏行跳过 */ }
+        try { ledger.push(JSON.parse(line)); } catch { ledgerBadLines.push(lineNo + 1); }
+      }
+    }
+    // 台账哈希链校验（2026-10-09 engine-quality-round2 D；写入侧=confirm-doc appendLedger，哈希单源
+    // policy.ledgerChainHash——判定零复刻）。判据：连续带 hash 行段内，① prevHash 须等于前一带 hash
+    // 行的 hash（无 hash 行后链段重启 ''，与写入侧读末行口径一致）；② hash 须可重算一致。
+    // **坏行口径（复核 P2-1 勘误，此前注释误称「与写入侧一致」）**：坏行被本解析整体剔除、不重置游标
+    // ——坏行后写入的链行（写入侧读末行遇坏行 prevHash=''）验链必失配出账。这是**预期 fail-loud**
+    // （坏行本身即台账完整性事故，应人工查验），非口径一致场景。
+    // 断裂 = hard「台账链断裂」（只报首断**物理行号** + 影响行计数，不做逐行刷屏）——就地改/删中间行
+    // 必留痕迹；边界：整文件重写可重建链，不可机器防，兜底 = 台账自身 git 历史（check-ledger-invariant）。
+    // 历史行（v1.5.0 前，无 hash 字段）零回填零告警——向后兼容。
+    {
+      let prevHash = '';
+      let brokenAt = 0;
+      let brokenCount = 0;
+      ledger.forEach((row, idx) => {
+        if (!row || typeof row.hash !== 'string') { prevHash = ''; return; } // 存量行/无链字段 → 链段重启
+        const { hash, prevHash: p, ...rest } = row;
+        const ok = (p ?? '') === prevHash && ledgerChainHash(rest, p ?? '') === hash;
+        if (!ok) {
+          if (!brokenAt) brokenAt = idx + 1;
+          brokenCount++;
+        }
+        prevHash = hash;
+      });
+      if (brokenAt) {
+        const physical = brokenAt + ledgerBadLines.filter((n) => n <= brokenAt).length; // 物理行号（复核 P2-1：剔除坏行会令数组下标漂移）
+        blockers.push(`- [台账链断裂] confirmations.jsonl 自第 ${physical} 行（物理）起哈希链校验失败（共 ${brokenCount} 行不一致——append-only 台账出现就地改/删痕迹；prevHash 接续或内容重算不符。整文件重写不可机器防，对质走台账自身 git 历史）`);
+      }
+    }
+    // scope 子项（2026-10-09 审查 A1 干净版）：受管台账行须带**机器派生**的改动面 scope{files,sha256}。
+    // 背景：委托代录的授权凭据原是 `--delegated` 的用户原话——自由文本机器不可校验、AI 可零成本复用
+    //   （本仓实测「可以」133 次、「确认」60 次，406 行里仅 6 行 tty），整条授权链源头不可核对。
+    //   干净版把分辨力从「一句说过的话」换成「机器实测的这 N 个文件」：写入侧 confirm-doc.machineScope
+    //   自动派生（被确认文档 + `git status --porcelain` 未提交改动集），AI 无输入面。
+    // 判定（scopeSince 生效**时刻**锚，缺键 v1-v6 整体跳过——存量行零新增告警、不追溯）：
+    //   ① 缺 scope → warning（灰度第一档：新机制先观察，升 hard 走后续 policyVersion 演进）
+    //   ② scope 存在但按其 files 重算 sha256 不符 → hard-block（「改了 files 没改摘要」= 同一信任
+    //      边界内的手改痕迹；哈希链本已覆盖就地改，本项兜住「整文件重写重建链」后二次篡改的场景）
+    // 注：scope 证明的是「放行时盘面上哪些文件在动」，**不是**「这些改动语义正确」——后者由 fingerprint
+    //   （文档内容绑定）+ commit diff（事后对质）承担。不越界宣称（沿本检查既有口径纪律）。
+    {
+      const since = loadKitPolicy(ROOT).scopeSince;
+      if (typeof since === 'string' && Number.isFinite(Date.parse(since))) {
+        const sinceT = Date.parse(since);
+        const missing = [];
+        const mismatched = [];
+        for (const row of ledger) {
+          if (!row || typeof row.ts !== 'string') continue;
+          const t = Date.parse(row.ts);
+          if (!Number.isFinite(t) || t < sinceT) continue; // 存量豁免（不追溯）
+          const name = row.doc || '(未知 doc)';
+          if (!row.scope) { missing.push(name); continue; }
+          if (!scopeMatches(row)) mismatched.push(name);
+        }
+        if (missing.length) {
+          warnings.push(`- [WARN 缺机器改动面] ${missing.length} 条受管台账行无 scope 字段（${missing.slice(0, 3).join('、')}${missing.length > 3 ? ' …' : ''}）——confirm-doc 落账自动派生 scope；此形态多见于手工/旧脚本写的行，advisory 不阻断`);
+        }
+        if (mismatched.length) {
+          blockers.push(`- [台账 scope 失配] ${mismatched.length} 条受管台账行的 scope.sha256 与其 files 重算不符（${mismatched.slice(0, 3).join('、')}${mismatched.length > 3 ? ' …' : ''}）——「改了 files 没同步摘要」，同一信任边界内的手改痕迹；对质走台账 git 历史`);
+        }
       }
     }
     // incidents 侧覆盖（2026-09-27 gate-coverage）：fixed/closed 为已确认态（open = 起草态不加门——
@@ -1437,6 +1494,43 @@ export function fmStatus(text) {
 // lines 已 CRLF 归一（split(/\r?\n/)），frontmatter 区内首个「状态:」行保分隔符换值为 prev（`状态:  done`
 // 双空格 → `状态:  approved`——与前向按原行字面计算对称，非规范分隔符不误伤；行尾空白等更奇异格式仍会
 // 失配，触发前提本身已违反「确认落态唯一入口」约定，接受），全文剔「确认指纹:」行后 join('\n') 再 sha256。
+// parseAddedDatesLog：git log（--diff-filter=A --format=@%aI --name-only）文本 → Map(rel → 加入 ISO 时间)。
+// 新→旧序首遇 = 最新一次加入（复核 P2-1 勘误：旧注释「最早」系误述——行为原样零复刻，检查 8 isNew 取最新加入日期更保守）。
+export function parseAddedDatesLog(logText) {
+  const m = new Map();
+  let cur = null;
+  for (const line of logText.split('\n')) {
+    if (line.startsWith('@')) { cur = line.slice(1); continue; }
+    if (line.trim() && cur && !m.has(line.trim())) m.set(line.trim(), cur);
+  }
+  return m;
+}
+
+// addedDatesWithCache：addedDates 的持久缓存层（2026-10-09 engine-quality-round3 W1）。
+// 键 = HEAD sha（同 commit 祖先不可变 → log 幂等；rebase 必改 HEAD 必重算；复核 P2-4：shallow→unshallow 同 HEAD 可见性增长有陈旧窗口——后果退化为旧行为 addedDateOf 返回 ""，HEAD 变化自愈）；
+// 缓存位于 .agents/cache/（gitignored 运行态）；读/写任一失败 fail-open 回退全算（门禁不失效）；
+// head 缺省（detached --rev worktree 等场景）→ 不读写缓存直接全算（语义不变）。
+export function addedDatesWithCache({ head, gitLog, cachePath }) {
+  if (head) {
+    try {
+      const c = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
+      if (c && c.head === head && c.map && Object.keys(c.map).length) return new Map(Object.entries(c.map));
+    } catch { /* 缓存缺失/损坏 → 全算 */ }
+  }
+  const log = gitLog();
+  if (log === null) return null;
+  const m = parseAddedDatesLog(log);
+  if (head) {
+    try {
+      fs.mkdirSync(path.dirname(cachePath), { recursive: true });
+      const tmp = cachePath + '.tmp';
+      fs.writeFileSync(tmp, JSON.stringify({ head, map: Object.fromEntries(m), savedAt: new Date().toISOString() }) + '\n');
+      fs.renameSync(tmp, cachePath);
+    } catch { /* 写失败 fail-open：本轮已用全算结果，缓存留待下次 */ }
+  }
+  return m;
+}
+
 export function bindingSha256(lines, prevStatus) {
   const isDelim = (l) => /^---\s*$/.test(l);
   const out = [];

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

@@ -13,6 +13,7 @@ import { fileURLToPath } from 'node:url';
 import { computeFingerprint } from './confirm-doc.mjs';
 import { POLICIES, loadKitPolicy } from './policy.mjs';
 import { entryConfirmed, laneOfEntry, laneOfDoc } from './stage-gates.mjs';
+import { parseAddedDatesLog, addedDatesWithCache } from './check-loop.mjs';
 
 const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
 const CHECK_LOOP = path.join(SCRIPT_DIR, 'check-loop.mjs');
@@ -2902,5 +2903,125 @@ w(T, 'workflow/intents/2026-09-12-deep.md', INTENT('deep', '状态: draft\n级
   rmfix(T);
 }
 
+// ---- 场景 21:台账哈希链（2026-10-09 engine-quality-round2 D）——篡改必抓 / 存量零告警 ----
+{
+  // 21a：连续带 hash 行中间被篡改（改 quote 不动链字段）→ hard「台账链断裂」
+  const T = mkfix();
+  const { ledgerChainHash } = await import('./policy.mjs');
+  const chainRow = (prevHash, fields) => {
+    const row = { ...fields, prevHash };
+    return { ...row, hash: ledgerChainHash(fields, prevHash) };
+  };
+  const row1 = chainRow('', { ts: '2026-10-09T01:00:00Z', doc: 'workflow/intents/2026-10-09-a.md', stage: 'approved', fingerprint: 'a'.repeat(64), prev: 'draft', source: 'chat-delegated', quote: '真原话一' });
+  const row2 = chainRow(row1.hash, { ts: '2026-10-09T02:00:00Z', doc: 'workflow/intents/2026-10-09-a.md', stage: 'done', fingerprint: 'b'.repeat(64), prev: 'approved', source: 'chat-delegated', quote: '真原话二' });
+  // 篡改第一行 quote（链字段不动 → hash 失配）
+  const tampered = { ...row1, quote: '篡改后的假原话' };
+  writeLedger(T, [tampered, row2]);
+  let r = run(T);
+  let out = outOf(r);
+  check('场景 21a 链断裂：中间行篡改 → hard 台账链断裂（指首断行号）',
+    r.status !== 0 && out.includes('台账链断裂') && /第 1 行/.test(out), `exit=${r.status}\n${out.slice(-400)}`);
+  // 反证还原：篡改行恢复原 quote → 链复通（断言非恒绿）
+  writeLedger(T, [row1, row2]);
+  r = run(T);
+  check('场景 21b 反证还原：篡改修复 → 链校验通过', !outOf(r).includes('台账链断裂'), outOf(r).slice(-300));
+  rmfix(T);
+}
+{
+  // 21c：全无 hash 的存量台账（v1.5.0 前形态）→ 零链告警（向后兼容）
+  const T = mkfix();
+  writeLedger(T, [
+    { ts: '2026-09-20T01:00:00Z', doc: 'workflow/intents/2026-09-20-legacy.md', stage: 'approved', fingerprint: 'c'.repeat(64), prev: 'draft' },
+    { ts: '2026-09-20T02:00:00Z', doc: 'workflow/intents/2026-09-20-legacy.md', stage: 'done', fingerprint: 'd'.repeat(64), prev: 'approved' },
+  ]);
+  const r = run(T);
+  check('场景 21c 存量无 hash 行：零链告警（不追溯）', !outOf(r).includes('台账链断裂'), outOf(r).slice(-300));
+  rmfix(T);
+}
+
+
+// ---- 场景 23:台账 scope 子项（2026-10-09 审查 A1 干净版）——缺 scope 出账 / 摘要失配 hard / 存量与旧 policy 零告警 ----
+// 背景：委托代录的授权凭据原是「用户原话」（自由文本、AI 可零成本复用）。干净版改记机器派生的
+// scope{files,sha256}（AI 无输入面），本子项校验受管行带该字段且摘要自洽。
+{
+  const AFTER = '2026-10-09T12:00:00Z'; // ≥ policy v7 scopeSince（生效时刻锚）
+  const BEFORE = '2026-10-01T00:00:00Z'; // 存量（生效前）：豁免、不追溯
+  const { scopeDigest } = await import('./policy.mjs');
+
+  // 23a：受管行缺 scope → advisory 出账（灰度第一档，不阻断）
+  const Ta = mkfix();
+  w(Ta, '.agents/kit.json', '{"policyVersion":7}\n');
+  writeLedger(Ta, [{ ts: AFTER, doc: 'workflow/intents/2026-10-09-a.md', stage: 'approved', fingerprint: 'a'.repeat(64), prev: 'draft', source: 'chat-delegated', quote: '可以' }]);
+  const ra = run(Ta);
+  check('场景 23a 缺机器改动面：受管行无 scope → WARN 出账且不阻断',
+    ra.status === 0 && outOf(ra).includes('缺机器改动面'), `exit=${ra.status}\n${outOf(ra).slice(-400)}`);
+  rmfix(Ta);
+
+  // 23b：scope 存在但摘要与 files 重算不符（「改了 files 没改摘要」）→ hard 阻断
+  const Tb = mkfix();
+  w(Tb, '.agents/kit.json', '{"policyVersion":7}\n');
+  const good = scopeDigest(['workflow/intents/2026-10-09-b.md', 'src/x.mjs']);
+  writeLedger(Tb, [{ ts: AFTER, doc: 'workflow/intents/2026-10-09-b.md', stage: 'approved', fingerprint: 'b'.repeat(64), prev: 'draft', source: 'chat-delegated', quote: '可以', scope: { ...good, files: [...good.files, 'src/悄悄加的.mjs'] } }]);
+  const rb = run(Tb);
+  check('场景 23b scope 摘要失配：files 被改未同步 sha256 → hard 阻断',
+    rb.status !== 0 && outOf(rb).includes('台账 scope 失配'), `exit=${rb.status}\n${outOf(rb).slice(-400)}`);
+  rmfix(Tb);
+
+  // 23c：scope 完整自洽 → 零 scope 告警（断言非恒红）
+  const Tc = mkfix();
+  w(Tc, '.agents/kit.json', '{"policyVersion":7}\n');
+  writeLedger(Tc, [{ ts: AFTER, doc: 'workflow/intents/2026-10-09-c.md', stage: 'approved', fingerprint: 'c'.repeat(64), prev: 'draft', source: 'chat-delegated', quote: '可以', scope: scopeDigest(['workflow/intents/2026-10-09-c.md']) }]);
+  const rc = run(Tc);
+  check('场景 23c scope 自洽：零 scope 告警（断言非恒红）',
+    !outOf(rc).includes('缺机器改动面') && !outOf(rc).includes('台账 scope 失配'), outOf(rc).slice(-300));
+  rmfix(Tc);
+
+  // 23d：存量行（ts < scopeSince）缺 scope → 零告警（生效日锚不追溯，不产不可消除噪声）
+  const Td = mkfix();
+  w(Td, '.agents/kit.json', '{"policyVersion":7}\n');
+  writeLedger(Td, [{ ts: BEFORE, doc: 'workflow/intents/2026-10-01-d.md', stage: 'approved', fingerprint: 'd'.repeat(64), prev: 'draft', source: 'chat-delegated', quote: '可以' }]);
+  const rd = run(Td);
+  check('场景 23d 存量豁免：ts < scopeSince 的行缺 scope → 零告警（不追溯）',
+    !outOf(rd).includes('缺机器改动面'), outOf(rd).slice(-300));
+  rmfix(Td);
+
+  // 23e：旧 policy（v6 无 scopeSince 键）→ 子项整体跳过，存量 406 行零新增告警
+  const Te = mkfix();
+  w(Te, '.agents/kit.json', '{"policyVersion":6}\n');
+  writeLedger(Te, [{ ts: AFTER, doc: 'workflow/intents/2026-10-09-e.md', stage: 'approved', fingerprint: 'e'.repeat(64), prev: 'draft', source: 'chat-delegated', quote: '可以' }]);
+  const re = run(Te);
+  check('场景 23e 旧 policy 跳过：v6 无 scopeSince 键 → 子项整体跳过（装户零新增告警）',
+    !outOf(re).includes('缺机器改动面') && !outOf(re).includes('台账 scope 失配'), outOf(re).slice(-300));
+  rmfix(Te);
+}
+
+// ---- 场景 22:addedDates 持久缓存（2026-10-09 engine-quality-round3 W1）----
+{
+  const log = '@2026-10-02T10:00:00+08:00\nworkflow/intents/a.md\nworkflow/plans/a.md\n@2026-10-01T09:00:00+08:00\nworkflow/intents/a.md\n';
+  const m = parseAddedDatesLog(log);
+  check('场景 22a 提取：新→旧序首遇 = 最新一次加入（原 IIFE 语义零复刻；注释「最早」为历史误述）', m.get('workflow/intents/a.md') === '2026-10-02T10:00:00+08:00' && m.get('workflow/plans/a.md') === '2026-10-02T10:00:00+08:00', JSON.stringify([...m]));
+}
+{
+  const cacheP = path.join(os.tmpdir(), 'adc-' + Date.now() + '.json');
+  let gitLogCalls = 0;
+  const gitLog = () => { gitLogCalls++; return '@2026-10-01T09:00:00+08:00\nworkflow/intents/a.md\n'; };
+  const head = 'head-sha-1';
+  const m1 = addedDatesWithCache({ head, gitLog, cachePath: cacheP });
+  const m2 = addedDatesWithCache({ head, gitLog, cachePath: cacheP });
+  check('场景 22b 缓存命中：同 HEAD 二次调用 gitLog 仅 1 次且结果一致',
+    gitLogCalls === 1 && m1.get('workflow/intents/a.md') === m2.get('workflow/intents/a.md'), 'calls=' + gitLogCalls);
+  const m3 = addedDatesWithCache({ head: 'head-sha-2', gitLog, cachePath: cacheP });
+  check('场景 22c HEAD 变更：重算（gitLog 计 2 次）', gitLogCalls === 2 && m3.get('workflow/intents/a.md') === '2026-10-01T09:00:00+08:00', 'calls=' + gitLogCalls);
+  fs.writeFileSync(cacheP, '{broken json');
+  const before = gitLogCalls;
+  const m4 = addedDatesWithCache({ head: 'head-sha-2', gitLog, cachePath: cacheP });
+  check('场景 22d 缓存损坏：fail-open 全算（gitLog 再调 1 次）且结果正确',
+    gitLogCalls === before + 1 && m4.get('workflow/intents/a.md') === '2026-10-01T09:00:00+08:00', 'calls=' + gitLogCalls);
+  const before2 = gitLogCalls;
+  addedDatesWithCache({ head: null, gitLog, cachePath: cacheP });
+  check('场景 22e 无 head：不读缓存直接全算（gitLog 再调 1 次）', gitLogCalls === before2 + 1, 'calls=' + gitLogCalls);
+  fs.rmSync(cacheP, { force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/check-stage-index.mjs

@@ -0,0 +1,40 @@
+// check-stage-index.mjs — check-loop 检查 7 模块（阶段索引同步，2026-10-09 engine-quality-round2 A1）
+// 拆分先例 = check-hygiene.mjs（检查 2/9/11/12/13）/ check-metric-claims.mjs（检查 16）：
+//   ctx 传入既有 helper（linesOf——读异常响亮出账 + 按空文档降级的语义承载者，零复刻），
+//   模块只返回 warnings 数组，不打印、不 exit、不改 ctx。
+// 输出顺序契约：调用点位置即 warnings 插入序（check-loop 原位调用，段 id 沿 sh 版 '6'——清单编号 7
+//   不动，gate-checklist 按 id 消费面不受影响）。
+// 判据（沿 sh 版逐条）：AGENTS.md 与 .agents/commands/new-task.md 须各含全部阶段指令路径串
+//   `.agents/commands/<cmd>.md`（双向索引）；缺任一 = WARN。两文件可合法缺失（text 判空预期缺失态）。
+// 测试：node templates/_agents/scripts/check-stage-index.test.mjs
+import fs from 'node:fs';
+import path from 'node:path';
+import { gateSeg, finishSegs, makeCollector, appendSegs } from './gate-seg.mjs';
+
+const STAGE_CMDS = ['plan', 'design', 'build', 'test', 'deploy', 'maintain', 'review'];
+const FACE_DOCS = ['AGENTS.md', '.agents/commands/new-task.md'];
+
+export function runCheckStageIndex(ctx) {
+  const { root: ROOT, linesOf } = ctx;
+  const warnings = [];
+  // 插桩（selfmeasure 先例）：局部收集器 + appendSegs 并入全局——模块产出局部数组，直接共用全局
+  // 游标会错账（check-hygiene.mjs:36-39 实测教训）
+  const localStats = makeCollector(warnings, []);
+  const markGate = (id, label) => { if (ctx.gateStats) gateSeg(localStats, id, label); };
+
+  markGate('6', '阶段索引同步');
+  for (const cmd of STAGE_CMDS) {
+    for (const doc of FACE_DOCS) {
+      // existsSync 守卫（2026-10-06-check19-entry-enoent 同类）：两文件可合法缺失（下方 text 判空本就
+      // 预期缺失态），fail-loud fs 读下按空跳过、不再响亮出账
+      const docPath = path.join(ROOT, doc);
+      const text = fs.existsSync(docPath) ? linesOf(docPath) : null;
+      if (text && !text.some((l) => l.includes(`.agents/commands/${cmd}.md`))) {
+        warnings.push(`- [WARN 阶段索引漂移] ${doc} 缺 ${cmd} 指令索引(两处阶段表须同步维护)`);
+      }
+    }
+  }
+
+  if (ctx.gateStats) appendSegs(ctx.gateStats, finishSegs(localStats));
+  return warnings;
+}

package/templates/_agents/scripts/check-stage-index.test.mjs

@@ -0,0 +1,77 @@
+// check-stage-index.test.mjs — 检查 7 模块直测（2026-10-09 engine-quality-round2 A1）
+// 四面：全绿 / AGENTS 侧缺索引 / new-task 文件缺失合法 / gate-seg 段归属（局部收集器并入）
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { runCheckStageIndex } from './check-stage-index.mjs';
+import { makeCollector, finishSegs } from './gate-seg.mjs';
+
+let pass = 0, fail = 0;
+const check = (name, cond, detail = '') => {
+  if (cond) { pass++; console.log(`PASS ${name}`); }
+  else { fail++; console.log(`FAIL ${name}${detail ? `——${detail}` : ''}`); }
+};
+
+// ctx 构造：linesOf 提供读异常→null 语义（与 check-loop 内部实现同语义；「判定零复刻」指模块不重写
+// 判据，测试 fixture 提供测试版 helper 是 check-hygiene.test 先例）
+function makeCtx(root, overrides = {}) {
+  const fileLinesCache = new Map();
+  const linesOf = (file) => {
+    if (!fileLinesCache.has(file)) {
+      let lines = null;
+      try { lines = fs.readFileSync(file, 'utf8').split(/\r?\n/); } catch { lines = null; }
+      fileLinesCache.set(file, lines);
+    }
+    return fileLinesCache.get(file);
+  };
+  return { root, linesOf, ...overrides };
+}
+const ROUTES = '.agents/commands/plan.md → .agents/commands/design.md → .agents/commands/build.md → .agents/commands/test.md → .agents/commands/deploy.md → .agents/commands/maintain.md';
+const mkRoot = (agentsBody, newTaskBody, { noAgents, noNewTask } = {}) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'csi-'));
+  fs.mkdirSync(path.join(root, '.agents', 'commands'), { recursive: true });
+  if (!noAgents) fs.writeFileSync(path.join(root, 'AGENTS.md'), agentsBody);
+  if (!noNewTask) fs.writeFileSync(path.join(root, '.agents', 'commands', 'new-task.md'), newTaskBody);
+  return root;
+};
+const FULL = `# AGENTS\n\n${ROUTES}\n\n**横切**：.agents/commands/review.md\n`;
+const FULL_NT = `# new-task\n\n| Plan | ${ROUTES} | Review(.agents/commands/review.md) |\n`;
+
+{
+  // ① 双面全索引 → 零告警
+  const root = mkRoot(FULL, FULL_NT);
+  const r = runCheckStageIndex(makeCtx(root));
+  check('① 双面全索引 → 零告警', r.length === 0, JSON.stringify(r));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // ② AGENTS 侧缺 plan → 仅 AGENTS.md 侧告警（new-task 索引齐全不误报）
+  const root = mkRoot(FULL.replace('.agents/commands/plan.md → ', ''), FULL_NT);
+  const r = runCheckStageIndex(makeCtx(root));
+  check('② AGENTS 侧缺 plan → WARN 点名 AGENTS.md',
+    r.some((w) => w.includes('AGENTS.md 缺 plan 指令索引')), JSON.stringify(r));
+  check('② new-task 侧不告警（其索引齐全）', !r.some((w) => w.includes('new-task.md 缺')), JSON.stringify(r));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // ③ new-task 文件不存在 = 合法缺失态（existsSync 守卫）→ 零告警
+  const root = mkRoot(FULL, FULL_NT, { noNewTask: true });
+  const r = runCheckStageIndex(makeCtx(root));
+  check('③ new-task 文件缺失 → 合法缺失零告警', r.length === 0, JSON.stringify(r));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+{
+  // ④ gate-seg 段归属：ctx.gateStats 在场时段 '6' 入账、warns 与实际 WARN 数一致（selfmeasure 接线
+  //   教训：模块须用局部收集器 + appendSegs，直接共用全局游标会错账）
+  const root = mkRoot(FULL.replace('.agents/commands/plan.md → ', ''), FULL_NT);
+  const stats = makeCollector([], []);
+  const r = runCheckStageIndex(makeCtx(root, { gateStats: stats }));
+  const seg6 = finishSegs(stats).filter((s) => s.id === '6');
+  check('④ gate-seg：段 6 入账一次且 warns 与实际 WARN 数一致',
+    seg6.length === 1 && seg6[0].warns === r.length && r.length === 1,
+    JSON.stringify({ seg6, ret: r }));
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
+process.exit(fail ? 1 : 0);