agentic-flow-kit 0.7.0 → 0.9.0

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

@@ -61,7 +61,7 @@ const PAIRS = [
   { doctor: '3', cl: null, note: 'git 仓库与钩子——装户体检独有' },
   { doctor: '4', cl: null, note: 'kit.json managed 台账——装户体检独有' },
   { doctor: '4.5', cl: null, note: '台账覆盖率——装户体检独有（盘上有 managed 类文件未登记，2026-09-26 managed-ledger-adopt）' },
-  { doctor: '6.5', cl: null, note: 'delegations 台账结构——装户体检独有' },
+  { doctor: '6.5', cl: null, note: 'delegations 台账结构 + 快照新鲜度——装户体检独有' },
   { doctor: '6.6', cl: null, note: 'owned 漂移——装户体检独有' },
   { doctor: '6.7', cl: null, note: '跨宿主薄适配——装户体检独有' },
   { doctor: '6.8', cl: null, note: 'workflows 编排脚本 lint——装户体检独有' },
@@ -81,6 +81,9 @@ const PAIRS = [
   { doctor: '7', cl: '14', note: '经 §7 整体运行覆盖' },
   { doctor: '7', cl: '15', note: '经 §7 整体运行覆盖' },
   { doctor: '7', cl: '16', note: '经 §7 整体运行覆盖（量化断言指标签名对账，2026-09-28 claim-exceeds-fix）' },
+  { doctor: '7', cl: '17', note: '经 §7 整体运行覆盖（发版提交树上仍未收口的 intent/spec/plan）' },
+  { doctor: '7', cl: '18', note: '经 §7 整体运行覆盖（委派台账对账）' },
+  { doctor: '7', cl: '19', note: '经 §7 整体运行覆盖（逐阶段审计——起草先于入口确认 / 台账审批顺序倒置）' },
 ];
 
 // gateChecklist：按登记表对照两侧检查项（pure function；pairs 可注入供测试）

package/templates/_agents/scripts/gen-workflow-index.mjs

@@ -177,8 +177,12 @@ function previewDiff(before, after) {
   if (added.length > 10) console.log(`    + …（其余 ${added.length - 10} 行略）`);
 }
 
+// 行尾归一比较（2026-09-30：fresh clone 检出 CRLF、生成段恒 LF——直接字符串相等会在克隆环境假阳性
+// 「漂移」（doctor §6 与 check-loop 检查 11 均经 --check 判定）；仅内容差异才算漂移）
+const normEol = (s) => String(s).replace(/\r\n/g, '\n');
+
 if (CHECK) {
-  if (out === existing) {
+  if (normEol(out) === normEol(existing)) {
     console.log(`✅ workflow/INDEX.md 与磁盘一致（${summary}）`);
     process.exit(0);
   }
@@ -189,7 +193,7 @@ if (CHECK) {
 
 if (DRY) {
   console.log(`🔎 --dry-run：未写盘（${summary}）`);
-  if (out === existing) console.log('• workflow/INDEX.md：无变化');
+  if (normEol(out) === normEol(existing)) console.log('• workflow/INDEX.md：无变化');
   else previewDiff(existing, out);
 } else {
   fs.writeFileSync(INDEX_P, out, 'utf8');

package/templates/_agents/scripts/gen-workflow-index.test.mjs

@@ -85,6 +85,18 @@ const run = (root, args = []) => spawnSync(process.execPath, [GEN, ...args], { c
   fs.rmSync(root, { recursive: true, force: true });
 }
 
+// ---- 场景 2b：CRLF 检出形态（fresh clone）--check 不误报（2026-09-30 行尾归一）----
+{
+  const root = mkfix();
+  run(root);
+  const ip = path.join(root, 'workflow', 'INDEX.md');
+  fs.writeFileSync(ip, fs.readFileSync(ip, 'utf8').replace(/\r\n/g, '\n').replace(/\n/g, '\r\n'), 'utf8');
+  const crlf = run(root, ['--check']);
+  check('场景 2b：INDEX 为 CRLF 检出形态 → --check exit 0（行尾归一，不假阳性）',
+    crlf.status === 0, `exit=${crlf.status}\n${crlf.stdout}${crlf.stderr}`);
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
 // ---- 场景 3：缺 `模块:` 容忍显示 —（不报错、不阻断）----
 {
   const root = mkfix();

package/templates/_agents/scripts/policy.mjs

@@ -0,0 +1,46 @@
+// policy.mjs — check-loop 豁免锚的单源（policyVersion）
+// 新豁免改 POLICIES 并升版本，不在 check-loop 里再写散落日期。
+// kit.json 缺 policyVersion、或版本不在表内：回退版本 1（不启用版本 2 的 approved 锚）。
+// audit 不在本表：缺省视为全量检查（已装仓库与无 kit 的测试夹具）；init 新装显式写 false。
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const POLICIES = {
+  1: {
+    moduleSince: '2026-09-22',
+    check14Since: '2026-09-23',
+    confirmDocsEffective: '2026-09-27',
+    confirmIncidentsEffective: '2026-09-28',
+    bindingTs: '2026-09-28',
+  },
+  // 版本 2 = 版本 1 的五个日期 + 检查 17 的 approved 锚 + 检查 19 的 stageGateSince + check14Since 后移至确认门实际上线日（2026-09-23 → 2026-09-26）。
+  // 漏抄日期键会改动其他检查的生效日。
+  2: {
+    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', // 检查 19 逐阶段审计的生效日（2026-09-30 stage-gate-machine）；锚 = 台账 ts 的 UTC 日期（复核 P2-3：本批 ts 2026-09-29T17:33Z 落在受审范围，顺序合规故静默）；v1 无此键 → 该检查整体跳过
+  },
+};
+
+export function loadKitPolicy(root) {
+  let raw = null;
+  try {
+    raw = JSON.parse(fs.readFileSync(path.join(root, '.agents', 'kit.json'), 'utf8'));
+  } catch { /* 无 kit 或不可解析 */ }
+  const requested = raw && Number.isInteger(raw.policyVersion) ? raw.policyVersion : 1;
+  const policyVersion = Object.prototype.hasOwnProperty.call(POLICIES, requested) ? requested : 1;
+  return {
+    ...POLICIES[policyVersion],
+    policyVersion,
+    requestedVersion: requested,
+    audit: raw && typeof raw.audit === 'boolean' ? raw.audit : undefined,
+  };
+}
+
+export function auditEnabled(policy) {
+  return policy.audit !== false;
+}

package/templates/_agents/scripts/solidify-task.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+// solidify-task: 将 L1 液态草稿一次性固化为正式 workflow 文档（迁移 + 批量确认 + 索引更新）
+// 用法：node .agents/scripts/solidify-task.mjs --topic "主题" [--root <仓库根>]
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const SCRIPT_DIR = path.dirname(fileURLToPath(import.meta.url));
+const ROOT = process.argv.includes('--root') ? 
+  process.argv[process.argv.indexOf('--root') + 1] : 
+  process.cwd();
+const DRAFTS_DIR = path.join(ROOT, '.zcode', 'drafts');
+const WF_ROOT = path.join(ROOT, 'workflow');
+
+function fail(msg) { console.error('❌ ' + msg); process.exit(1); }
+
+function parseArgs() {
+  const topicIdx = process.argv.indexOf('--topic');
+  if (topicIdx === -1 || !process.argv[topicIdx + 1]) {
+    console.error('用法: node .agents/scripts/solidify-task.mjs --topic "主题"');
+    process.exit(1);
+  }
+  return process.argv[topicIdx + 1];
+}
+
+async function run() {
+  const topic = parseArgs();
+  console.log(`🚀 开始固化 L1 任务: ${topic}...`);
+
+  if (!fs.existsSync(DRAFTS_DIR)) fail('草稿目录 .zcode/drafts/ 不存在');
+
+  // 1. 搜寻草稿
+  const files = fs.readdirSync(DRAFTS_DIR).filter(f => f.includes(topic) && f.endsWith('.md'));
+  if (!files.length) fail(`在 ${DRAFTS_DIR} 中未找到主题为 ${topic} 的草稿文件`);
+
+  const today = new Date().toISOString().slice(0, 10);
+  const solidified = [];
+
+  // 2. 迁移并规范化命名
+  for (const file of files) {
+    const content = fs.readFileSync(path.join(DRAFTS_DIR, file), 'utf8');
+    let targetDir = '';
+    
+    // 简单启发式判定类型
+    if (content.includes('# INTENT')) targetDir = 'intents';
+    else if (content.includes('# PLAN')) targetDir = 'plans';
+    else if (content.includes('# SPEC')) targetDir = 'specs';
+    else if (content.includes('# INCIDENT')) targetDir = 'incidents';
+    else continue;
+
+    const targetName = `${today}-${file.replace(/.*-/, '').replace('.md', '.md')}`;
+    if (!targetName.startsWith('20')) {
+       // 如果文件名没日期前缀，强制加上
+       // 假设文件名为 <topic>.md
+    }
+    
+    // 统一处理：强制 YYYY-MM-DD- 前缀
+    const finalName = /^\d{4}-\d{2}-\d{2}-/.test(file) ? file : `${today}-${file}`;
+    const targetPath = path.join(WF_ROOT, targetDir, finalName);
+
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.copyFileSync(path.join(DRAFTS_DIR, file), targetPath);
+    
+    solidified.push({
+      rel: `workflow/${targetDir}/${finalName}`,
+      abs: targetPath,
+      type: targetDir
+    });
+    console.log(`  📦 迁移: ${file} -> ${targetKebab(targetDir)}/${finalName}`);
+  }
+
+  function targetKebab(dir) { return dir; }
+
+  // 3. 批量确认 (Delegated)
+  console.log('🛡️  执行批量确认...');
+  for (const item of solidified) {
+    const res = spawnSync('node', [
+      path.join(SCRIPT_DIR, 'confirm-doc.mjs'), 
+      item.rel, 
+      '--delegated', 
+      `固化 L1 任务 ${topic}：用户确认草稿无误，执行固化归档`
+    ], { encoding: 'utf8' });
+    
+    if (res.status !== 0) {
+      console.error(`  ❌ 确认失败 [${item.rel}]: ${res.stderr}`);
+      // 此时不 exit，尝试继续其他文件的确认
+    } else {
+      console.log(`  ✅ 已确认: ${item.rel}`);
+    }
+  }
+
+  // 4. 更新索引
+  console.log('📖 更新工作流索引...');
+  spawnSync('node', [path.join(SCRIPT_DIR, 'gen-workflow-index.mjs')], { stdio: 'inherit' });
+
+  console.log(`\n✨ 任务 ${topic} 已成功固化！`);
+  console.log(`👉 建议执行: git add workflow/ .agents/confirmations.jsonl && git commit -m "docs(workflow): solidify L1 task ${topic}"`);
+}
+
+run();

package/templates/_agents/scripts/stage-gates.mjs

@@ -0,0 +1,256 @@
+// stage-gates.mjs — 逐阶段前置判定的单源（fill-spec / fill-plan / confirm-doc 共享；2026-09-30 stage-gate-machine）
+// 口径（与 check-loop 检查 19 内联实现互引——改一处须跟另一处）：
+//   入口「已确认」= 文件存在且 frontmatter 状态 ∈ {approved, done}，且【机器事实源】满足其一：
+//     ① confirmations.jsonl 台账存在该 doc 的 stage ∈ {approved, done} 行（经 confirm-doc 才产生，防手改状态冒充）；
+//     ② 存量口径：文档日期早于 policy.confirmDocsEffective，或行首含「流程: legacy」。
+//   incident 入口 = 文件存在 + 「时间线」小节内、行首列表条目含「用户确认」（原 maintain.md §3 约定；
+//     2026-09-30 复核 P2-1 收窄为小节内行首条目；第三轮复核 P1-1 起接受日期前缀形态，与模板样例一致）；
+//     状态 ∈ {open, fixed, closed}（spec/plan 须先于 fixed 起草，故 open 即为有效态）。
+//   入口「级别」须 ∈ L0-L3；缺失即拒（fail-closed）——**但库存量形态短路**（`流程: legacy` 或 日期早于
+//     确认门生效日）：跳过级别校验与 spec 档（2026-09-30 增量复核 N1——存量最可能缺级别，硬拒会锁死
+//     spec 起草与确认）。
+//   注意：**库存量信号本身即等于「入口已确认」**（judgeDoc：`台账行 || 存量口径`，与检查 15 / 检查 1 /
+//     配对门的既有口径一致——早于确认门生效日的自报日期即存量豁免，不要求另有台账行）；此处「短路」
+//     只额外豁免**级别前置与 spec 档**，不是对台账要求的二次豁免（P2-1：原注释把二者写反，已订正）。
+//   plan 门追加：入口级别（取入口 frontmatter 级别，不取工具 --level）为 L2/L3 时，同名 spec 须已确认（同口径）。
+//   探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening）：同名 intent 仍为 draft 且风险泳道为
+//     L0/L1（级别优先；级别缺失或非法时回落 risk_level——fill-intent 双写同值）→「先起草后确认」是协作道
+//     语义（check-loop 检查 19 同款豁免口径），放行 spec/plan 起草与确认；L2/L3 防御道维持入口确认前置。
+//     incident 入口不豁免（过目留痕本就轻量）。收口由 check-loop --hardening 加固门兜底（入 main 前须
+//     intent approved/done + spec/plan 在场）。
+// 信任边界声明（沿 2026-09-28 audit-gate-hardening 口径）：本地可写台账 / 手改状态仍可伪造——本模块只把
+//   「顺手绕过」抬到「主动伪造」，不宣称通道关闭；事后对质靠 git 历史与台账。
+// 设计先例：fill-* 已 import 同目录 workflow-enums.mjs；check-loop 检查 19 内联同口径（门禁脚本自包含、防兄弟依赖）。
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { loadKitPolicy } from './policy.mjs';
+
+export const ENTRY_STATUSES = ['approved', 'done'];
+export const INCIDENT_STATUSES = ['open', 'fixed', 'closed'];
+
+// readFm：frontmatter 区（首 --- 至闭合 ---）取单字段值；无 frontmatter / 无该键 → ''
+export function readFm(abs, key) {
+  let text;
+  try { text = fs.readFileSync(abs, 'utf8'); } catch { return ''; }
+  const lines = text.replace(/\r\n/g, '\n').split('\n');
+  if (!/^---\s*$/.test(lines[0] || '')) return '';
+  for (let i = 1; i < lines.length; i++) {
+    if (/^---\s*$/.test(lines[i])) break;
+    const m = lines[i].match(new RegExp(`^${key}:\\s*(.*)$`));
+    if (m) return m[1].trim();
+  }
+  return '';
+}
+
+function readBody(abs) {
+  try { return fs.readFileSync(abs, 'utf8'); } catch { return ''; }
+}
+
+// readLedger：confirmations.jsonl 追加式台账（坏行容忍跳过；与 check-loop 检查 15 同容错口径）
+export function readLedger(root) {
+  const p = path.join(root, '.agents', 'confirmations.jsonl');
+  let text = '';
+  try { text = fs.readFileSync(p, 'utf8'); } catch { return []; }
+  const out = [];
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try { out.push(JSON.parse(line)); } catch { /* 坏行跳过 */ }
+  }
+  return out;
+}
+
+// judgeDoc：状态枚举 + 机器事实源判定（供入口 / spec 复用）
+// legacy：库存量信号（`流程: legacy` 标记 或 日期 < confirmDocsEffective）——所有调用方与门禁其余部分
+// 同口径（配对门 / 检查 1 / 检查 15 / 检查 19）；2026-09-30 复核 N1：存量入口须先短路，不得被
+// 「缺级别」fail-closed 硬拒（存量最可能缺级别，硬拒会锁死 spec 起草/确认，违反「存量零新增」契约）。
+function judgeDoc(root, abs, rel, statuses) {
+  const st = readFm(abs, '状态');
+  if (!statuses.includes(st)) {
+    return { ok: false, status: st, legacy: false, reason: `状态「${st || '缺失'}」不在 ${statuses.join(' / ')}` };
+  }
+  const policy = loadKitPolicy(root);
+  const body = readBody(abs);
+  const legacyByMarker = body.split(/\r?\n/).some((l) => /^流程: legacy/.test(l));
+  const d = readFm(abs, '日期') || readFm(abs, '发现');
+  const legacyByDate = /^\d{4}-\d{2}-\d{2}$/.test(d) && d < policy.confirmDocsEffective;
+  const legacy = legacyByMarker || legacyByDate;
+  const hasRow = readLedger(root).some((e) => e && e.doc === rel && (e.stage === 'approved' || e.stage === 'done'));
+  if (hasRow || legacy) return { ok: true, status: st, legacy };
+  return { ok: false, status: st, legacy: false, reason: `无确认台账行（门禁后的入口须经 confirm-doc，且台账无 ${rel} 的 approved / done 行）` };
+}
+
+// entryStorageLegacy：入口是否属「库存量」形态（`流程: legacy` 标记 或 日期早于确认门生效日）——
+// 与 judgeDoc 的存量信号同口径，供门在**级别校验**处短路（2026-09-30 增量复核 N1）。注意：本短路
+// **只豁免 level 前置**（存量多为门禁前建档、无级别字段），**不豁免台账要求**——`judgeDoc` 的
+// hasRow||legacy 仍照常判定（门禁后无台账行即拒，不因日期早于生效日而放行）。
+export function entryStorageLegacy(root, abs) {
+  const body = readBody(abs);
+  if (body.split(/\r?\n/).some((l) => /^流程: legacy/.test(l))) return true;
+  const d = readFm(abs, '日期') || readFm(abs, '发现');
+  return /^\d{4}-\d{2}-\d{2}$/.test(d) && d < loadKitPolicy(root).confirmDocsEffective;
+}
+
+// incidentMarked：「## 时间线」小节内、行首列表条目形态的「用户确认」（维持口径；正文叙述句不算——
+// 2026-09-30 复核 P2-1 实证：全仓唯一历史命中为叙述句，非过目留痕）。
+// 行首可选日期前缀（`- 2026-09-30 用户确认：…`）与可选加粗（`- **用户确认**：…`）均接受——
+// 与 _TEMPLATE.md 时间线样例形态保持一致（2026-09-30 第三轮复核 P1-1：样例若不可解析即误导）。
+export function incidentMarked(body) {
+  let inTimeline = false;
+  for (const l of String(body).replace(/\r\n/g, '\n').split('\n')) {
+    if (/^##\s/.test(l)) { inTimeline = /^##\s*时间线/.test(l); continue; }
+    if (inTimeline && MARK_RE.test(l)) return true;
+  }
+  return false;
+}
+
+// MARK_RE：行首列表条目 + 可选日期前缀（YYYY-MM-DD 或 <日期> 占位）+ 可选加粗围栏（词前 / 词后均可）
+// + 「用户确认」+ **须紧跟冒号或行尾**（词边界）。
+// 形态矩阵（2026-09-30 四/五轮复核收敛，8 正例 / 5 负例由 fill-spec.test S19/S20 钉死）：
+//   命中：`- 用户确认：…` / `- **用户确认**：…` / `- 2026-09-30 用户确认：…` / `- <日期> **用户确认**：…` / 行尾无冒号
+//   拒绝：`- 2026-09-30 用户确认了方案` / `- 用户确认书已归档` / `- 用户确认。` / `- 待用户确认：…`
+//   注：词前的 `\**` 与词后的 `\**` 必须都允许——只开一侧即产生结构性假阴性（第五轮复核 P1 实证：
+//   加粗围栏形态被拒，与 _TEMPLATE.md 自述契约冲突）。
+export const MARK_RE = /^\s*[-*]\s*(?:\d{4}-\d{2}-\d{2}|<日期>)?\s*\**用户确认\**(?=\s*[：:]|\s*$)/;
+
+// entryConfirmed：同主题入口判定（intent 优先；否则 incidents）——返回 {ok, kind, rel, level, status, reason?}
+export function entryConfirmed(root, base) {
+  const intentRel = `workflow/intents/${base}.md`;
+  const intentAbs = path.join(root, intentRel);
+  if (fs.existsSync(intentAbs)) {
+    const r = judgeDoc(root, intentAbs, intentRel, ENTRY_STATUSES);
+    return { ...r, kind: 'intent', rel: intentRel, level: readFm(intentAbs, '级别'), risk: readFm(intentAbs, 'risk_level'), storageLegacy: entryStorageLegacy(root, intentAbs) };
+  }
+  const incRel = `workflow/incidents/${base}.md`;
+  const incAbs = path.join(root, incRel);
+  if (fs.existsSync(incAbs)) {
+    const st = readFm(incAbs, '状态');
+    const level = readFm(incAbs, '级别');
+    if (INCIDENT_STATUSES.includes(st) && incidentMarked(readBody(incAbs))) {
+      return { ok: true, kind: 'incident', rel: incRel, level, status: st, legacy: false };
+    }
+    const why = !INCIDENT_STATUSES.includes(st) ? `状态「${st || '缺失'}」非法` : '「时间线」小节缺「用户确认」条目（maintain.md §3）';
+    return { ok: false, kind: 'incident', rel: incRel, level, status: st, legacy: false, reason: `同名 incident 未过目确认——${why}` };
+  }
+  return { ok: false, kind: null, rel: null, level: '', status: '', reason: `未找到同名入口（workflow/intents 与 workflow/incidents 均无 ${base}.md）` };
+}
+
+// specConfirmed：plan 门的 L2/L3 追加要求
+export function specConfirmed(root, base) {
+  const rel = `workflow/specs/${base}.md`;
+  const abs = path.join(root, rel);
+  if (!fs.existsSync(abs)) return { ok: false, reason: `缺同名 spec（${rel}）` };
+  return judgeDoc(root, abs, rel, ENTRY_STATUSES);
+}
+
+// draftGateFor：起草门总判（kind = 'spec' | 'plan'，fill 工具与 confirm-doc 逐阶段门共用）
+export function draftGateFor(kind, root, base) {
+  const entry = entryConfirmed(root, base);
+  if (!entry.ok) {
+    // 探索泳道豁免（2026-09-30 hybrid-governance-explore-hardening，口径见头部注释）：L0/L1 draft intent
+    // 放行起草——「先动手后确认」；泳道取级别优先、缺失/非法回落 risk_level（与 fill-intent 双写兼容，
+    // 级别合法但为 L2/L3 时不回落——fail-closed 就严）。
+    const lane = /^L[0-3]$/.test(entry.level || '') ? entry.level : entry.risk;
+    if (entry.kind === 'intent' && entry.status === 'draft' && (lane === 'L0' || lane === 'L1')) {
+      return { ok: true, entry, laneBypass: true };
+    }
+    return {
+      ok: false,
+      reason: `同主题入口未确认——${entry.reason}`,
+      hint: '先走 plan.md 完成入口确认（修复类走 maintain.md，incident 草稿过目后在时间线留「用户确认」条目）',
+    };
+  }
+  // 库存量形态短路（2026-09-30 增量复核 N1）：**只额外豁免「级别前置」与「spec 档」**——
+  // 库存量入口（`流程: legacy` / 日期早于确认门生效日）多为门禁前建档、常缺「级别」字段，硬拒会锁死
+  // spec 起草与确认。注意：库存量信号**本身即等于入口已确认**（judgeDoc 的 `台账行 || 存量口径`，
+  // 与检查 1 / 15 / 配对门同口径）——台账豁免发生在 judgeDoc，不在本处；本处不做二次豁免
+  // （第三轮复核 P2-1：原句「台账要求不豁免」把两件事写反，已订正）。
+  if (!entry.storageLegacy && !/^L[0-3]$/.test(entry.level)) {
+    return {
+      ok: false,
+      reason: `入口缺合法「级别」字段（现「${entry.level || '缺失'}」，无法判定前置深度）`,
+      hint: '先给入口补「级别: L0-L3」字段，再继续',
+    };
+  }
+  if (kind === 'plan' && !entry.storageLegacy && (entry.level === 'L2' || entry.level === 'L3')) {
+    const sp = specConfirmed(root, base);
+    if (!sp.ok) {
+      return { ok: false, reason: `入口级别 ${entry.level}，前置 spec 未确认——${sp.reason}`, hint: '先走 design.md 完成 spec 确认' };
+    }
+  }
+  return { ok: true, entry };
+}
+
+// confirmGateFor：确认门总判（confirm-doc 用；docRel = workflow/specs/... 或 workflow/plans/...）
+export function confirmGateFor(root, docRel) {
+  const base = path.basename(docRel).replace(/\.md$/, '');
+  const kind = docRel.startsWith('workflow/specs/') ? 'spec' : 'plan';
+  return draftGateFor(kind, root, base);
+}
+
+// ---- done 前置门族（2026-09-30 confirm-gate-approved-history）----
+// 背景：stage-gate-machine 关单后检查 14 报「确认态缺失」×2——approved→done 期间从未提交、首次提交即
+// done 态（先 done 后提交），git 历史无 approved 中间态；检查 14 是事后审计（发现即定局），本族把
+// 校验收口到 confirm-doc 的「→done」跳转——「approved 态还在工作区」的最后一刻，即唯一可拦截窗口。
+// 命中判据单源：approvedTraceHit 命令行与 check-loop 检查 14 逐字一致（-G '^状态:[[:space:]]*approved'），
+// 本模块为唯一实现、两调用方共享（2026-09-30 复核 N3 教训：双份字面量靠注释同步必漂移）。
+// 注（2026-09-30 复核 P2-2 登记）：gitRun 的 GIT 解析 / maxBuffer / 失败语义与 check-loop.mjs 的
+// gitOut、gitReady 与检查 14 段级两条 rev-parse 为**同口径的两份实现**（未合并——检查 14 段结构不动
+// 属本单非目标）——任一侧调整（如加 --no-pager）须同步另一侧，防段级门与文档级判据分叉。
+const GIT = process.platform === 'win32' ? 'git.exe' : 'git';
+
+function gitRun(root, args) {
+  const r = spawnSync(GIT, args, { cwd: root, encoding: 'utf8', maxBuffer: 32 * 1024 * 1024 });
+  if (r.error || r.status !== 0) return null;
+  return r.stdout || '';
+}
+
+// gitReady：git 环境可用（在仓库内且已有 HEAD）——与检查 14 段级两条 rev-parse 同口径
+export function gitReady(root) {
+  return gitRun(root, ['rev-parse', '--git-dir']) !== null
+    && gitRun(root, ['rev-parse', '-q', '--verify', 'HEAD']) !== null;
+}
+
+// approvedTraceHit：命中判定单源——git 历史是否出现过行首「状态: approved」（经提交进入历史才算，
+// 当前工作区未提交的 approved 不算——这正是「留痕」语义）。rel = 仓库根相对路径。
+// 返回：'' = 从未出现；<sha> = 命中；null = git 调用失败（调用方按各自容错口径处理——检查 14 不报、
+// done 门跳过，均沿 fail-open 边界；诚实边界声明见 spec）。
+export function approvedTraceHit(root, rel) {
+  const r = gitRun(root, ['log', '-1', '--format=%H', '-G', '^状态:[[:space:]]*approved', '--', rel]);
+  return r === null ? null : r.trim();
+}
+
+// doneGateFor：confirm-doc「→done」前置门（三件套 intent/spec/plan 均适用；incidents 的 fixed/closed 不在本门）。
+// 豁免与顺序：① 行首 `流程: legacy` ② 行含「存量确认态豁免（」声明（与检查 14 同标记，显式逃生口）
+// ③ 非 git 环境 ④ git 调用失败 → 均跳过（不误拦）。未豁免且未命中 → 拒绝（调用方负责非零退出 +
+// 零落账 + 零写盘 + 回退指引）。
+export function doneGateFor(root, abs, rel) {
+  const body = readBody(abs);
+  if (body.split(/\r?\n/).some((l) => /^流程: legacy/.test(l))) return { ok: true, skipped: 'legacy' };
+  if (body.split(/\r?\n/).some((l) => l.includes('存量确认态豁免（'))) return { ok: true, skipped: 'declared' };
+  if (!gitReady(root)) return { ok: true, skipped: 'no-git' };
+  const hit = approvedTraceHit(root, rel);
+  if (hit === null) return { ok: true, skipped: 'git-error' };
+  if (hit === '') {
+    return {
+      ok: false,
+      reason: 'git 历史中从未出现行首「状态: approved」——确认态未留痕（先 done 后提交 / 两跳同批提交）',
+      hint: '先把该文档的 approved 态提交（git add 该文件并 commit）后再重试关单',
+    };
+  }
+  return { ok: true, hit };
+}
+
+// resolveWorkspace：从输出路径推导工作区根与主题名；output 路径不含 workflow 段 → null（仓外草稿，不校验）
+export function resolveWorkspace(outputPath, rootOverride) {
+  const abs = path.resolve(outputPath);
+  const base = path.basename(abs).replace(/\.md$/, '');
+  if (rootOverride) return { root: path.resolve(rootOverride), base };
+  const parts = abs.split(path.sep);
+  for (let i = parts.length - 2; i >= 0; i--) {
+    if (parts[i].toLowerCase() === 'workflow') return { root: parts.slice(0, i).join(path.sep) || path.sep, base };
+  }
+  return null;
+}
+
+export default { entryConfirmed, specConfirmed, draftGateFor, confirmGateFor, doneGateFor, gitReady, approvedTraceHit, resolveWorkspace, readFm, readLedger };

package/templates/_agents/scripts/trust-mode.mjs

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+// trust-mode: AI 自治信任等级管理（2026-09-30 ai-autonomy-trust；同日 hybrid-governance-risk-lanes 加名称双轨）
+// 管理 .agents/trust-mode.json，授权 AI 对 L0/L1 文档进行自治放行（--auto）。
+// 等级语义（名称 ↔ 数值双轨：confirm-doc.mjs 读数值 enabled/level，人机接口名称与数值皆收）：
+//   Strict   (level 0, enabled=false): AI 自治关闭（默认）——confirm-doc --auto 一律拒绝
+//   Standard (level 1): AI 可自批 L0/L1 draft -> approved
+//   Trusted  (level 2): AI 可自批 L0/L1 draft -> approved 及 approved -> done（全闭环）
+// 安全默认值：未开启（enabled: false）时，confirm-doc.mjs --auto 一律拒绝。
+import fs from 'node:fs';
+import path from 'node:path';
+
+const CONFIG_PATH = path.join(process.cwd(), '.agents', 'trust-mode.json');
+const NAME_BY_LEVEL = { 0: 'Strict', 1: 'Standard', 2: 'Trusted' };
+const LEVEL_BY_NAME = { Strict: 0, Standard: 1, Trusted: 2 };
+
+function readConfig() {
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  } catch {
+    return { enabled: false, level: 0, name: 'Strict', enabledAt: null };
+  }
+}
+
+function writeConfig(config) {
+  fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const config = readConfig();
+
+  if (args.includes('--enable')) {
+    const levelIdx = args.indexOf('--level');
+    const raw = levelIdx !== -1 ? String(args[levelIdx + 1] ?? '') : '1';
+    const level = LEVEL_BY_NAME[raw] ?? (['0', '1', '2'].includes(raw) ? Number(raw) : NaN);
+    if (![0, 1, 2].includes(level)) {
+      console.error('❌ --level 必须为 Strict|Standard|Trusted（或 0|1|2）');
+      process.exit(1);
+    }
+    if (level === 0) {
+      writeConfig({ enabled: false, level: 0, name: 'Strict', enabledAt: null });
+      console.log('🔒 AI 自治模式已关闭（Strict）');
+      return;
+    }
+    writeConfig({ enabled: true, level, name: NAME_BY_LEVEL[level], enabledAt: new Date().toISOString() });
+    console.log(`✅ AI 自治模式已开启 (${NAME_BY_LEVEL[level]} / Level ${level})`);
+    console.log(level === 1 ? '   授权范围：L0/L1 文档 draft -> approved' : '   授权范围：L0/L1 文档全闭环 (approved + done)');
+    return;
+  }
+
+  if (args.includes('--disable')) {
+    writeConfig({ enabled: false, level: 0, name: 'Strict', enabledAt: null });
+    console.log('🔒 AI 自治模式已关闭 (Strict)');
+    return;
+  }
+
+  if (args.includes('--status')) {
+    console.log(JSON.stringify({ name: NAME_BY_LEVEL[config.level] || 'Strict', ...config }, null, 2));
+    return;
+  }
+
+  console.log('用法: node .agents/scripts/trust-mode.mjs [--enable --level <Strict|Standard|Trusted|1|2> | --disable | --status]');
+  process.exit(config.enabled ? 0 : 1);
+}
+
+main();

package/templates/_agents/scripts/wf-journal.mjs

@@ -10,7 +10,7 @@
 //   node .agents/scripts/wf-journal.mjs add --wf <编排名> --stage <id> --status <pass|fail|blocked>
 //        [--form role|step|gate|human] [--attempt N] [--note <文本>] [--run <runId>] [--new-run]
 //        [--journal <文件>]（默认 .agents/cache/orchestration-runs.jsonl，按 cwd）
-//   node .agents/scripts/wf-journal.mjs status --wf <编排名> [--run <runId>] [--journal <文件>] [--wf-root <目录>]
+//   node .agents/scripts/wf-journal.mjs status --wf <编排名> [--run <runId>] [--journal <文件>] [--wf-root <目录>] [--delegations <文件>]
 // 测试：node templates/_agents/scripts/wf-journal.test.mjs（fixture + 真实仓库场景）
 import fs from 'node:fs';
 import path from 'node:path';
@@ -151,8 +151,77 @@ if (isMain) {
     console.log(`  ▶ 就绪（${plan.ready.length}）：${plan.ready.map((s) => (s.retry ? `${s.id}（重试就绪×${s.retry}）` : s.id)).join('、') || '无'}`);
     console.log(`  ⏸ 待定（${plan.pending.length}）：${plan.pending.map((s) => s.id + (s.depBlocked ? '（依赖中止）' : '')).join('、') || '无'}`);
     console.log(`  ⛔ 中止（${plan.blocked.length}）：${plan.blocked.map((s) => `${s.id}${s.note ? `（${s.note}）` : ''}`).join('、') || '无'}`);
+    const wfLines = fs.readFileSync(wfFile, 'utf8').split(/\r?\n/);
+    const gaps = unmatchedPasses({
+      stages, state, wfLines,
+      delegationsText: readDelegationsText(typeof a.delegations === 'string' ? a.delegations : null),
+    });
+    if (gaps.length) console.log(`  委派台账未记录（${gaps.length}）：${gaps.join('、')}`);
     process.exit(0);
   }
   fail(`未知命令：${a.cmd ?? ''}（add | status，用法见文件头注释）`);
 }
-export default { replayRun, planStages, latestRun, readJournalLines };
+function readDelegationsText(file) {
+  const p = file || path.join(process.cwd(), 'workflow', 'delegations.md');
+  try { return fs.readFileSync(p, 'utf8'); } catch { return ''; }
+}
+
+function delegationSectionRows(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  let inSec = false;
+  const rows = [];
+  for (const line of lines) {
+    if (/^##\s+/.test(line)) {
+      if (inSec) break;
+      if (/^##\s+委派结果\s*$/.test(line)) inSec = true;
+      continue;
+    }
+    if (!inSec || !/^\s*\|/.test(line)) continue;
+    const cells = line.trim().replace(/^\|/, '').replace(/\|$/, '').split('|').map((c) => c.trim());
+    if (!cells.length || cells.every((c) => /^[-: ]*$/.test(c))) continue;
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(cells[0])) continue;
+    rows.push({ date: cells[0], line });
+  }
+  return rows;
+}
+
+function mdBasenames(text) {
+  const out = [];
+  const re = /[^\s|`]+?\.md/g;
+  let m;
+  while ((m = re.exec(String(text || '')))) {
+    const base = m[0].replace(/\\/g, '/').split('/').pop();
+    if (base && !out.includes(base)) out.push(base);
+  }
+  return out;
+}
+
+function idInRow(id, line) {
+  const escaped = String(id).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`(^|[^A-Za-z0-9_-])${escaped}([^A-Za-z0-9_-]|$)`).test(line);
+}
+
+// unmatchedPasses：末次 pass 且 role 为 implementer 或 independent-reviewer、
+// 委派结果表没有与 pass 的 UTC 日相同、且含阶段 id 或阶段上 .md 文件名的一行。
+export function unmatchedPasses({ stages, state, wfLines, delegationsText }) {
+  const rows = delegationSectionRows(delegationsText);
+  const gaps = [];
+  for (const s of stages) {
+    if (s.role !== 'implementer' && s.role !== 'independent-reviewer') continue;
+    const st = state[s.id];
+    if (st?.status !== 'pass') continue;
+    const day = String(st.ts || '').slice(0, 10);
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) continue;
+    const raw = wfLines[(s._line || 0) - 1] || '';
+    const names = [...mdBasenames(s.files), ...mdBasenames(st.note), ...mdBasenames(raw)];
+    const hit = rows.some((r) => {
+      if (r.date !== day) return false;
+      if (idInRow(s.id, r.line)) return true;
+      return names.some((name) => r.line.includes(name));
+    });
+    if (!hit) gaps.push(s.id);
+  }
+  return gaps;
+}
+
+export default { replayRun, planStages, latestRun, readJournalLines, unmatchedPasses };