agentic-flow-kit 0.8.0 → 0.9.1

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 };

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

@@ -146,5 +146,71 @@ const STAGES = parseStages(`| id | after | role | step | task | files | accept |
   }
 }
 
+// ---- 委派台账只读对账（status；不改 add 必填）----
+{
+  const missing = spawnSync(process.execPath, [JOURNAL_CLI, 'add', '--stage', 'a', '--status', 'pass'], { encoding: 'utf8' });
+  check('add 缺 --wf 仍失败', missing.status !== 0 && /必填/.test(missing.stderr || ''), missing.stderr || missing.stdout);
+
+  const wfOf = (id, role, files = '—') =>
+    '---\nname: demo\ndescription: d\n---\n\n'
+    + '| id | after | role | step | task | files | accept | gate | retries |\n'
+    + '|----|-------|------|------|------|-------|--------|------|---------|\n'
+    + `| ${id} | — | ${role} | — | — | ${files} | — | npm test | |\n`;
+  const row = (date, note) =>
+    `## 委派结果\n\n| 日期 | 被委派方 | 任务一句话 | 结果 | 备注 |\n|------|----------|------------|------|------|\n| ${date} | x | y | 一次通过 | ${note} |\n`;
+  const passLine = (stage, over = {}) => JSON.stringify({
+    ts: '2026-09-26T10:00:00Z', run: 'demo@1', wf: 'demo', stage, status: 'pass', attempt: 1, ...over,
+  }) + '\n';
+  const statusOf = ({ body, journal, delegations }) => {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wfj-del-'));
+    const wfRoot = path.join(tmp, 'workflows');
+    fs.mkdirSync(wfRoot);
+    fs.writeFileSync(path.join(wfRoot, 'demo.md'), body);
+    const j = path.join(tmp, 'j.jsonl');
+    if (journal != null) fs.writeFileSync(j, journal);
+    const d = path.join(tmp, 'delegations.md');
+    const args = ['status', '--wf', 'demo', '--wf-root', wfRoot, '--journal', j, '--delegations', d];
+    if (delegations != null) fs.writeFileSync(d, delegations);
+    const r = spawnSync(process.execPath, [JOURNAL_CLI, ...args], { encoding: 'utf8' });
+    fs.rmSync(tmp, { recursive: true, force: true });
+    return r;
+  };
+  const listed = (r, id) => r.status === 0
+    && (r.stdout || '').split(/\r?\n/).some((line) => line.trim() === `委派台账未记录（1）：${id}`);
+
+  let r = statusOf({ body: wfOf('build', 'implementer'), journal: passLine('build'), delegations: null });
+  check('委派表为空且 role=implementer 的 pass：列出阶段 id', listed(r, 'build'), r.stdout);
+
+  r = statusOf({ body: wfOf('review', 'independent-reviewer'), journal: passLine('review'), delegations: '' });
+  check('role=independent-reviewer 的 pass：同样列出', listed(r, 'review'), r.stdout);
+
+  r = statusOf({ body: wfOf('ui', 'ui-verifier'), journal: passLine('ui'), delegations: '' });
+  check('role=ui-verifier：不打印委派台账未记录', r.status === 0 && !(r.stdout || '').includes('委派台账未记录'), r.stdout);
+
+  r = statusOf({ body: wfOf('build', 'implementer'), journal: passLine('build'), delegations: row('2026-09-26', 'build') });
+  check('同日行含阶段 id：该阶段不列出', r.status === 0 && !(r.stdout || '').includes('委派台账未记录'), r.stdout);
+
+  r = statusOf({
+    body: wfOf('impl', 'implementer', 'workflow/intents/2026-09-26-foo.md'),
+    journal: passLine('impl'),
+    delegations: row('2026-09-26', '2026-09-26-foo.md'),
+  });
+  check('同日行含 files 里的 .md 文件名：该阶段不列出', r.status === 0 && !(r.stdout || '').includes('委派台账未记录'), r.stdout);
+
+  r = statusOf({ body: wfOf('build', 'implementer'), journal: passLine('build'), delegations: row('2026-09-25', 'build') });
+  check('行日期与 pass 的 UTC 日不同：该阶段仍列出', listed(r, 'build'), r.stdout);
+
+  r = statusOf({ body: wfOf('build', 'implementer'), journal: passLine('build'), delegations: row('2026-09-26', 'rebuild') });
+  check('阶段 id 只是更长词的一段：仍列出', listed(r, 'build'), r.stdout);
+
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'wfj-norun-'));
+  const wfRoot = path.join(tmp, 'workflows');
+  fs.mkdirSync(wfRoot);
+  fs.writeFileSync(path.join(wfRoot, 'demo.md'), wfOf('build', 'implementer'));
+  r = spawnSync(process.execPath, [JOURNAL_CLI, 'status', '--wf', 'demo', '--wf-root', wfRoot, '--journal', path.join(tmp, 'none.jsonl')], { encoding: 'utf8' });
+  check('无 journal run：不打印委派台账未记录', r.status === 0 && /就绪/.test(r.stdout || '') && !(r.stdout || '').includes('委派台账未记录'), r.stdout);
+  fs.rmSync(tmp, { recursive: true, force: true });
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/scripts/workflow-board-server.mjs

@@ -53,37 +53,40 @@ function parseAcceptance(text) {
 }
 export { parseAcceptance };
 
-// ---- 配对断裂检测：按 slug 聚合同族（同名 intent/incident/plan/spec），异常卡附 alerts ----
-// 规则（口径对齐 check-loop.sh 的硬断档 + 状态枚举，看板为预警层、不阻断；枚举读单源 workflow-enums.txt）：
+// ---- 配对断裂检测：按完整文件名（含日期）聚合同族，异常卡附 alerts ----
+// 与 check-loop 检查 1 的 basename 同一口径。slug（去掉日期）只给界面分组，不参与配对。
+// 规则（看板为预警层、不阻断；枚举读单源 workflow-enums.txt）：
 //   孤儿 spec / 孤儿 plan（无同名 intent·incident 入口）；入口 done 但 plan 未终态（看板启发式）；
 //   入口缺 plan（intent 一律要求；incident 需非 legacy 且级别 L1/L2/L3）；L2/L3 入口缺同名 spec；
 //   spec L3 确认三件缺失（确认结果 / 确认时间 / 正文独立复核行）；
-//   状态不在枚举内或缺失（doc=confirmed 集；incident=all 集）
+//   状态不在全量枚举内或缺失；draft 是合法起点，提示「尚未确认」
 const PLAN_TERMINAL = ENUMS['doc.status.terminal'];
-const STATUS_ENUM = {
-  intents: ENUMS['doc.status.confirmed'],
-  specs: ENUMS['doc.status.confirmed'],
-  plans: ENUMS['doc.status.confirmed'],
+const STATUS_ALL = {
+  intents: ENUMS['doc.status.all'],
+  specs: ENUMS['doc.status.all'],
+  plans: ENUMS['doc.status.all'],
   incidents: ENUMS['incident.status.all'],
 };
 const NO_STATUS = '（未填）';
 const L3_REVIEW = /^- 独立复核：[ \t]*[^<\s]/m; // 正文独立复核行须有实质内容（对照 check-loop 锚定）
 
-function detectAlerts(cards) {
-  const bySlug = new Map();
+export function detectAlerts(cards) {
+  const byName = new Map();
   for (const c of cards) {
-    if (!bySlug.has(c.slug)) bySlug.set(c.slug, []);
-    bySlug.get(c.slug).push(c);
+    if (!byName.has(c.name)) byName.set(c.name, []);
+    byName.get(c.name).push(c);
   }
   for (const c of cards) {
-    const fam = bySlug.get(c.slug) || [];
+    const fam = byName.get(c.name) || [];
     const types = new Set(fam.map((x) => x.type));
     const alerts = [];
     const isEntry = c.type === 'intents' || c.type === 'incidents';
     // legacy 复盘件免配对类告警（口径同 check-loop）；孤儿 spec / 孤儿 plan 两条仍按 spec·plan 自身判定
     const legacyIncident = c.type === 'incidents' && c.flow === 'legacy';
-    if (!STATUS_ENUM[c.type].includes(c.status))
-      alerts.push(`状态不在枚举内：须为 ${STATUS_ENUM[c.type].join('/')}（现 ${c.status === NO_STATUS ? '缺失' : c.status}）`);
+    if (!STATUS_ALL[c.type].includes(c.status))
+      alerts.push(`状态不在枚举内：须为 ${STATUS_ALL[c.type].join('/')}（现 ${c.status === NO_STATUS ? '缺失' : c.status}）`);
+    else if (c.status === 'draft')
+      alerts.push('尚未确认');
     if (c.type === 'specs' && !types.has('intents') && !types.has('incidents'))
       alerts.push('孤儿 spec：无同名 intent/incident 入口');
     if (c.type === 'plans' && !types.has('intents') && !types.has('incidents'))
@@ -97,7 +100,7 @@ function detectAlerts(cards) {
       alerts.push('入口缺 plan：无同名 plan');
     if (isEntry && !legacyIncident && ['L2', 'L3'].includes(c.level) && !types.has('specs'))
       alerts.push(`${c.level} 入口缺同名 spec`);
-    if (c.type === 'specs' && c.level === 'L3' && !ENUMS['doc.status.abandoned'].includes(c.status)) {
+    if (c.type === 'specs' && c.level === 'L3' && c.status !== 'draft' && !ENUMS['doc.status.abandoned'].includes(c.status)) {
       if (c.confirm !== 'approved') alerts.push(`L3 确认缺失：确认结果须为 approved（现 ${c.confirm || '缺失'}）`);
       if (!c.confirmTime) alerts.push('L3 确认缺失：须记录确认时间');
       if (!c.hasReview) alerts.push('L3 复核缺失：须记录新会话独立复核结论');

package/templates/_agents/scripts/workflow-board-server.test.mjs

@@ -12,7 +12,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { parseLoopHardBlocks, parseAcceptance } from './workflow-board-server.mjs';
+import { parseLoopHardBlocks, parseAcceptance, detectAlerts } from './workflow-board-server.mjs';
 import { computeFingerprint } from './confirm-doc.mjs';
 
 let pass = 0;
@@ -132,5 +132,34 @@ const CHECK_LOOP = path.join(SCRIPT_DIR, 'check-loop.mjs');
   check('⑤markdown 语法不受剥标签影响', strip(md) === md);
 }
 
+// ---- ⑥按完整文件名配对；draft 是合法起点 ----
+{
+  const has = (card, text) => (card.alerts || []).some((a) => a.includes(text));
+  const card = (over) => ({
+    type: 'intents', name: '2026-09-01-topic', slug: 'topic', status: 'approved', level: 'L1',
+    ...over,
+  });
+  const paired = card();
+  const plan = card({ type: 'plans', status: 'approved' });
+  const other = card({ name: '2026-09-02-topic', status: 'draft' });
+  detectAlerts([paired, plan, other]);
+  check('⑥同 slug 不同日期：有同名 plan 的 intent 不报缺 plan', !has(paired, '入口缺 plan'));
+  check('⑥同 slug 不同日期：没有同名 plan 的 intent 报缺 plan', has(other, '入口缺 plan'), JSON.stringify(other.alerts));
+  check('⑥draft 提示尚未确认，不报非法枚举', has(other, '尚未确认') && !has(other, '状态不在枚举内'), JSON.stringify(other.alerts));
+  const okIntent = card({ name: '2026-09-03-keep', status: 'approved' });
+  const okPlan = card({ type: 'plans', name: '2026-09-03-keep', status: 'approved' });
+  detectAlerts([okIntent, okPlan]);
+  check('⑥approved 同名配对：无非法枚举、无尚未确认、无缺 plan',
+    !has(okIntent, '状态不在枚举内') && !has(okIntent, '尚未确认') && !has(okIntent, '入口缺 plan'),
+    JSON.stringify(okIntent.alerts));
+  const doneIntent = card({ name: '2026-09-04-done', status: 'done' });
+  const draftPlan = card({ type: 'plans', name: '2026-09-04-done', status: 'draft' });
+  detectAlerts([doneIntent, draftPlan]);
+  check('⑥入口 done 而同名 plan 仍是 draft：plan 报未终态', has(draftPlan, '未终态'), JSON.stringify(draftPlan.alerts));
+  const bogus = card({ name: '2026-09-05-bad', status: 'nope' });
+  detectAlerts([bogus]);
+  check('⑥未知状态仍报不在枚举内', has(bogus, '状态不在枚举内'), JSON.stringify(bogus.alerts));
+}
+
 console.log(`\n合计: PASS ${pass} / FAIL ${fail}`);
 process.exit(fail ? 1 : 0);

package/templates/_agents/workflows/pipeline-closing.md

@@ -9,7 +9,7 @@ concurrency: 2
 
 | id | after | role | step | task / params | files（授权） | accept（验收判据） | gate | human | retries |
 |----|-------|------|------|---------------|--------------|-------------------|------|-------|---------|
-| author | — | implementer | — | 起草 intent + plan（双写 fill-{intent,plan}.mjs 生成草稿 + AI 填实），状态 draft | workflow/intents/<date>-<topic>.md, workflow/plans/<date>-<topic>.md | intent frontmatter 5 字段齐 + 状态 draft + 验收标准 ≥ 5 条；plan L1 极简 2 节齐 | | | 1 |
+| author | — | implementer | — | 起草 intent + plan（双写 fill-{intent,plan}.mjs 生成草稿 + AI 填实），状态 draft | workflow/intents/<date>-<topic>.md, workflow/plans/<date>-<topic>.md | intent frontmatter 6 字段齐（含 risk_level）+ 状态 draft + 验收标准 ≥ 5 条；plan L1 极简 2 节齐 | | | 1 |
 | gate-doc | author | — | — | — | — | — | node .agents/scripts/fill-intent.test.mjs && node .agents/scripts/fill-plan.test.mjs | | |
 | confirm | gate-doc | — | — | plan 草稿全文过目，用户对话内一句"可以" → plan 状态 draft → approved + 回填「确认与复核」节 | — | plan 状态 approved + 「确认结果：approved（YYYY-MM-DD 用户对话内确认）」 | | 用户确认（plan 确认门） | |
 | plan-commit | confirm | implementer | — | 提交 plan 立项 commit（docs(workflow)） | workflow/intents/, workflow/plans/, workflow/INDEX.md | pre-commit 钩子全过；commit message 含 plan 改动面摘要 | | | 0 |

package/templates/_githooks/pre-commit

@@ -1,6 +1,6 @@
 #!/bin/sh
 # Git 原生 pre-commit hook（经 core.hooksPath 挂载，git 执行、不依赖 agent 客户端）— agentic-flow-kit 通用编排
-# 通用门禁序：闭环配对(增量) → wiki 台账(增量) → 常驻面体积预算(增量) → 双源一致性(增量) → managed 台账快检(包源恒跑) → 项目门禁(local-pre-commit) → 敏感信息扫描+条件构建(commit-check.cjs)
+# 通用门禁序：闭环配对(增量) → 泳道完整性(增量) → wiki 台账(增量) → 常驻面体积预算(增量) → 双源一致性(增量) → managed 台账快检(包源恒跑) → 项目门禁(local-pre-commit) → 敏感信息扫描+条件构建(commit-check.cjs)
 # 项目专属门禁（架构红线/业务守卫等）放 .agents/hooks/local-pre-commit——存在即在本钩子内执行，返回非零即阻断提交
 # 合并提交场景由 .githooks/pre-merge-commit 原样转发到本脚本（合并时 git 调的是 pre-merge-commit，
 # 不是 pre-commit）——门禁清单只此一份，避免两处分叉
@@ -19,7 +19,38 @@ run_gate() {
 }
 
 # 闭环配对门禁（增量版，check-pairing-incremental.sh：本次暂存的 intents/incidents 入口须已有同名 plan）
-run_gate "闭环配对（增量）" .agents/hooks/check-pairing-incremental.sh
+# experiment/* 泳道分支（2026-09-30 hybrid-governance-explore-hardening）：降级为 advisory——快速 PoC
+# 迭代不因闭环文档断档被拦（断档报告照出），转正合入 main 由 pre-push 加固门（check-loop --hardening）兜底。
+# 仅降级闭环文档面：双源 / 台账 / 常驻面 / 敏感信息扫描等门禁不豁免。分支不可判（detached HEAD 等）走严格模式。
+pairing_gate_mode=strict
+case "$(git rev-parse --abbrev-ref HEAD 2>/dev/null)" in
+  experiment/*) pairing_gate_mode=advisory ;;
+esac
+if [ "$pairing_gate_mode" = "advisory" ]; then
+  echo "pre-commit: experiment/* 泳道分支——闭环配对门禁降级为 advisory（报告不阻断；转正入 main 须过加固门）" >&2
+  if command -v sh >/dev/null 2>&1; then
+    sh .agents/hooks/check-pairing-incremental.sh || echo "pre-commit: （advisory）闭环配对断档已在上方列出——experiment 泳道不阻断提交" >&2
+  else
+    bash .agents/hooks/check-pairing-incremental.sh || echo "pre-commit: （advisory）闭环配对断档已在上方列出——experiment 泳道不阻断提交" >&2
+  fi
+else
+  run_gate "闭环配对（增量）" .agents/hooks/check-pairing-incremental.sh
+fi
+
+# 泳道完整性（增量，check-lane-surface.mjs——2026-10-01 drift-hardening）：
+#   检查 A「触达面判低」——暂存命中项目 L2 触达面（.agents/lane-surfaces.txt，ERE 逐行；缺失/空=跳过，
+#   装户无感）且活跃入口（draft/approved / open/fixed）全为 L0/L1 → 拦；有活跃 L2/L3 → 放行；无活跃入口 →
+#   仅 advisory（docs/bootstrap 豁免类）。experiment/* 分支降级 advisory（转正由 pre-push 加固门兜底）。
+#   检查 B「探索标记缺失」——experiment/* 分支暂存 intent 缺「阶段: exploring」→ 拦（标记零成本，
+#   advisory 免纪律不免标记——标记是加固门覆盖率的前提）。
+#   旧装副本无脚本自然跳过；node 缺失时本门跳过（其后 commit-check 节点检查仍会拦提交，无空洞）。
+#   注意：不经 run_gate（其实现为 sh "$@"，会把 node 当脚本解释——直接 node 调用，模式同双源门禁块）。
+if [ -f .agents/scripts/check-lane-surface.mjs ] && command -v node >/dev/null 2>&1; then
+  if ! node .agents/scripts/check-lane-surface.mjs; then
+    echo "pre-commit: 泳道完整性（增量）未通过，提交已阻止" >&2
+    exit 1
+  fi
+fi
 
 # wiki 台账门禁（增量，check-wiki-ledger.sh：暂存区触及 wiki/ 时跑 verify-wiki-consistency 三方一致性；
 # 无 wiki/ 变更即跳过）

package/templates/_githooks/pre-push

@@ -3,30 +3,78 @@
 # 跑 .agents/scripts/check-loop.sh：扫 workflow/ 闭环骨架断档
 #   - 硬阻断（exit 1）= 配对断裂 / 回路断档 → push 立即阻断
 #   - 警告（advisory）= 状态未确认 / 模板占位残留 / 引用漂移 等卫生项 → 仅打印提示
+# stdin 有行时，每个非删除的本地 sha 用 --rev 扫那棵树。没有行时（手跑钩子）仍无参数扫工作区。
 #
-# 机器门：本地钩子（唯一本地机器门）——CI 配置为本地未入库件（.gitignore 排除），不构成跨环境保证。
+# experiment/* 泳道（2026-09-30 hybrid-governance-explore-hardening）：**目标分支**为 experiment/* 时，
+#   闭环扫描降级 advisory（报告不阻断）——快速 PoC 推送不因闭环断档被拦；转正（目标为 main）由加固门兜底。
+# 加固门（同日；2026-10-01 v09-review-defects 修正判定键）：推送**目标**为 refs/heads/main 时以
+#   --hardening 运行（无论来源分支——experiment/* 直推 main 同样覆盖），exploring 任务须先收口
+#   （intent approved/done + 同名 plan 在场 + L2/L3 另须同名 spec；判据见 check-loop.mjs 加固门段），
+#   hard 失败即阻断 push，防「未文档化的探索件」进 main。
+#
+# 机器门：本地钩子（唯一本地机器门）——服务端兜底（如有）= 项目自有 CI；本 kit 不附带 CI 配置，裸装无跨环境保证。
+# 本仓：.github/workflows/ci.yml 于 push main / 全部 PR 复跑 check-loop / doctor / source-sync-check --gate / workflows-check 四道门。
 # 不要用 `git push --no-verify` 绕开——发现 hard-block 应先修 workflow 文档再推。
 
 cd "$(git rev-parse --show-toplevel)" || exit 1
 
-# 读 stdin（pre-push 协议要求消费 stdin：本地 ref + 远端 ref + sha x2 每行）
-while read -r _ _ _ _; do :; done
-
 SCRIPT=".agents/scripts/check-loop.sh"
 if [ ! -f "$SCRIPT" ]; then
   echo "pre-push: 未找到 $SCRIPT，跳过闭环扫描" >&2
   exit 0
 fi
 
-# Windows 下 git 自带 bash 能直接执行 sh 脚本；其它环境 sh 兼容
+run_loop() {
+  if command -v sh >/dev/null 2>&1; then
+    sh "$SCRIPT" "$@"
+  else
+    bash "$SCRIPT" "$@"
+  fi
+}
+
+saw=0
+rc=0
+while read -r local_ref local_sha remote_ref _remote_sha; do
+saw=1
+case "$local_sha" in
+*[!0]*) ;;
+*) continue ;;
+esac
+# 按目标分支三态分派（2026-10-01 v09-review-defects：判定键从 local_ref 改为 remote_ref——
+# 修复 experiment/*→main 直推被 advisory continue 吞掉加固门的漏口）：
+#   main            → 加固门（必带 --hardening）
+#   experiment/*    → advisory（报告不阻断）
+#   其他            → 全量扫描
+case "$remote_ref" in
+refs/heads/main|main)
+run_loop --rev "$local_sha" --hardening
+;;
+refs/heads/experiment/*|experiment/*)
+echo "pre-push: experiment/* 目标分支（$remote_ref）——闭环扫描降级 advisory，不阻断" >&2
 if command -v sh >/dev/null 2>&1; then
-  sh "$SCRIPT"
+sh "$SCRIPT" --rev "$local_sha" >&2 || echo "pre-push: （advisory）闭环断档已在上方列出——experiment 泳道可推送，转正（推 main）须过加固门" >&2
 else
-  bash "$SCRIPT"
+bash "$SCRIPT" --rev "$local_sha" >&2 || echo "pre-push: （advisory）闭环断档已在上方列出——experiment 泳道可推送，转正（推 main）须过加固门" >&2
+fi
+;;
+*)
+run_loop --rev "$local_sha"
+;;
+esac
+one=$?
+if [ "$one" -ne 0 ] && [ "$rc" -eq 0 ]; then
+rc=$one
 fi
-rc=$?
-if [ $rc -ne 0 ]; then
+done
+
+if [ "$saw" -eq 0 ]; then
+  run_loop
+  rc=$?
+fi
+
+if [ "$rc" -ne 0 ]; then
   echo "pre-push: 闭环骨架断档（hard-block）未通过，push 已阻断。修 workflow 文档后重推——不要用 --no-verify 绕过（本钩子是唯一机器门，无服务端兜底，见头部说明）" >&2
-  exit $rc
+  echo "pre-push: 若为「加固未过」= experiment 泳道件转正前须收口：intent approved/done + 同名 plan（L2/L3 另须 spec）且状态非 draft" >&2
+  exit "$rc"
 fi
 exit 0

package/templates/workflow/README.md

@@ -15,7 +15,7 @@
 
 **命名一律英文 kebab-case**（如 `2026-09-07-<主题>.md`），**禁中文文件名**——check-loop 对非 ASCII 文件名给 warning。文档内容（标题/正文）不受此限。
 
-**文档协议（frontmatter 受限子集）**：四类文档头部一律为 YAML frontmatter（每行 `键: 值`，机器字段唯一来源）——`状态`（intent/spec/plan：draft/approved/done/superseded/cancelled；incident：open/fixed/closed，**严格枚举，单源 `.agents/workflow-enums.txt`**——check-loop / 看板 / 检索 / fill-* 一律读它，改枚举改那边；附注写 `备注:` 键）、`级别`（L0-L3，同单源）、`日期`/`发现`（YYYY-MM-DD）、`模块`（**新建文档必填**，取值见 `.agents/workflow-modules.txt` 词表，单值取主导模块；存量不回填，AI 触碰时顺手补）、L3 spec 的 `确认结果`/`确认时间`、回填件 `流程: legacy`。**`状态` 迁移须经 `approved`**（确认环节的机器可见态，`done` 只在关单出现）：新建的 spec/plan 若已 done 而 git 历史中从未出现行首 `状态: approved`，check-loop 报「确认态缺失」warning。check-loop 只扫 frontmatter 取机器字段（`fm_get` 字段断言），正文不再写「状态：/级别：」行；叙述性字段（独立复核/复盘三件套/验收勾验）仍留正文按节锚定。
+**文档协议（frontmatter 受限子集）**：四类文档头部一律为 YAML frontmatter（每行 `键: 值`，机器字段唯一来源）——`状态`（intent/spec/plan：draft/approved/done/superseded/cancelled；incident：open/fixed/closed，**严格枚举，单源 `.agents/workflow-enums.txt`**——check-loop / 看板 / 检索 / fill-* 一律读它，改枚举改那边；附注写 `备注:` 键）、`级别`（L0-L3，同单源）、intent 的 `risk_level`（=级别，混合治理风险泳道选道字段，fill-intent 落）、`日期`/`发现`（YYYY-MM-DD）、`模块`（**新建文档必填**，取值见 `.agents/workflow-modules.txt` 词表，单值取主导模块；存量不回填，AI 触碰时顺手补）、L3 spec 的 `确认结果`/`确认时间`、回填件 `流程: legacy`。**`状态` 迁移须经 `approved`**（确认环节的机器可见态，`done` 只在关单出现）：新建的 spec/plan 若已 done 而 git 历史中从未出现行首 `状态: approved`，check-loop 报「确认态缺失」warning。check-loop 只扫 frontmatter 取机器字段（`fm_get` 字段断言），正文不再写「状态：/级别：」行；叙述性字段（独立复核/复盘三件套/验收勾验）仍留正文按节锚定。
 
 各子目录内 `_TEMPLATE.md` 为起步模板，复制后填写，不直接改动模板本身。
 
@@ -32,19 +32,38 @@
 - **量化**：委派/自做结果记 `delegations.md`，聚合跑 `node .agents/scripts/agg-delegations.cjs`（**并发扩容门槛见该文件——数字达标前不扩并发**）；语料与常驻面体积的**月度快照**跑 `node .agents/scripts/gen-workflow-metrics.mjs`（每月一行落 `metrics.md`，同月重跑即更新；明细看 stdout）
 - **追溯**：git 即审计——文档随代码同 commit、上线打 `release/<日期>` tag，`git log` 全链路可查；多人评审暂缓，git 历史即评审记录
 - **级别**：L0 例行 ｜ L1 实现级（页面 / 交互 / 样式等，未命中 L2/L3）｜ L2 规则 / 契约（编码权威 / 共享契约 / 既有接口语义 / 全局横切口径，触达面闭集见 `.agents/commands/new-task.md` §级别判断）｜ L3 数据与运行时结构（schema / 迁移 SQL / DI 链 / 认证与中间件管线）；混合改动就高不就低
+- **风险泳道（混合治理）**：级别即风险级（L0 最低 → L3 最高），按级选道——**L0 / L1 协作道（敏捷优先）**：L0 豁免 intent 直接 commit；L1 已确认 intent + 极简 plan 即动工，独立复核不设同步前置，审计异步补（check-loop、事后 review 兜底）；**L2 / L3 防御道（严谨优先）**：同步确认门——spec 确认通过方可起草 plan、plan 确认后方可动手（闭环规则 1-2），L3 加新会话独立复核，未确认不放行。intent frontmatter 以 `risk_level`（=级别）落机器可读标记；批量代录与 AI 自治（confirm-doc `--batch` / `--auto`，trust-mode Standard｜Trusted）均限协作道 L0/L1，协作道勾触达红线会被 check-loop 判「红线判低」hard 拦截
+- **探索泳道（experiment/ 前缀分支，Explore-to-Harden，2026-09-30 hybrid-governance-explore-hardening）**：experiment/ 前缀分支上的 PoC 任务在 intent frontmatter 加 `阶段: exploring` 标记——提交/推送门降级 advisory（pre-commit 闭环配对、pre-push 闭环扫描报告不阻断）；L0/L1 的 draft intent 允许 spec/plan 起草与确认先于入口确认（stage-gates 起草门泳道豁免，「先起草后确认」）。**转正（合入 main）必须过加固门**：pre-push 对目标 refs/heads/main 以 `check-loop --hardening` 运行——exploring 任务的 intent 须为 approved/done、同名 plan 在场且收口（L2/L3 另须同名 spec），未收口 hard 阻断；探索作废走显式放弃态 superseded/cancelled（出列不加固）。诚实边界：分支名不进 commit——experiment/* 分支上暂存 intent 缺「阶段: exploring」由 pre-commit「泳道完整性」门禁拦截（2026-10-01 drift-hardening），残余暴露面仅剩绕过本地钩子的提交（`--no-verify` 禁令纪律覆盖）
+- **Trusted 自动泳道（2026-09-30 hybrid-governance-explore-hardening）**：trust-mode.json = Trusted（level 2）时，confirm-doc 的非 TTY 单份调用对 L0/L1 文档**免旗标**（无需 `--delegated` 原话 / `--auto`）自动按 AI 自治放行（台账 source=ai-auto-trust-L2）；L2/L3 与 incidents 仍须人工，Standard / Strict 不隐式（fail-closed）
 
 ## 执行模型
 
 - 默认宿主主智能体负责阶段路由、用户确认、关键判断和最终验收，不注册为额外角色。
 - 阶段命令仅在边界明确时委派 `.agents/roles/implementer.md`、`.agents/roles/independent-reviewer.md`、`.agents/roles/ui-verifier.md`。
-- 各 agent 宿主（OpenCode / Trae / ZCode 等）通过其适配目录（`.opencode/agents/`、`.trae/agents/`、`.zcode/agents/` 等）下的薄 Adapter 注册角色；角色行为只维护在 `.agents/roles/`。
+- 各 agent 宿主通过其适配目录下的薄 Adapter 注册角色（`.claude/`、`.cursor/`、`.codex/`、`.opencode/`、`.trae/`、`.zcode/`、`.omp/`）。角色行为只维护在 `.agents/roles/`。Codex 自动读取的是仓库根 `AGENTS.md` 与 `.codex/skills/`；`.codex/commands` 与 `.codex/agents` 是同形薄转发，供显式引用。Cursor 自动加载 `.cursor/commands/`。Claude Code 自动加载 `.claude/commands/` 与 `.claude/agents/`。
 - 宿主不支持子智能体时按命令 frontmatter 的 `fallback` 执行；L2 / L3 独立复核不得回退为原主智能体自查。
 - 子智能体不得跨越用户确认门，也不得自行提交、合入或上线；所有结果由主智能体复核后交用户决策。
 
+## 硬规则
+
+`kit.json` 的 `audit: false`（`init` 新装的默认值）时，check-loop 只阻断下面与文档闭环直接相关的项。`audit` 字段缺省时保持全量检查，已装仓库升级不会突然丢掉卫生警告。本字段设为 `true` 时卫生检查照常打印。豁免日期的唯一表是 `.agents/scripts/policy.mjs` 的 `policyVersion`（`kit.json` 同名字段；未知版本回退到 1）。
+
+1. **同名配对**：L1 有 plan；L2/L3 有 spec 与 plan。incident 的回路断档同样阻断。
+2. **验收勾验**：新建 intent 关到 done 时，验收标准未勾则阻断。
+3. **确认留痕**：approved / done / fixed / closed 须经 `confirm-doc.mjs`，指纹与台账一致。`--delegated` 原话仅限用户对话内明确确认的当次措辞——官方脚本/门禁不得自动代录或编造 quote（2026-10-01 v09-review-defects：solidify-task 曾自动伪造原话，已修复并纳入回归）。
+4. **敏感信息**：pre-commit 的 commit-check 扫描密钥。
+5. **双源与台账**：doctor 核对 managed / owned 的 sha；引擎改动改包源 `templates/` 再 `sync`。
+
+其余检查（占位符、引用、模块字段、常驻面预算、量化签名、阶段索引、适配器断线）只在 `audit` 不是 `false` 时出警告。
+
+**发版草稿**：最近一次改动 `package.json` 的 `version` 的那次提交里，当时已经是 draft 或 approved 的 intent、spec、plan，若被扫描的树上仍是 draft 或 approved，则阻断。当时已是 draft 的不看版本锚。当时已是 approved 的，只在发版版本大于 `policy.mjs` 的 `check17UnclosedAfter` 时阻断；版本 1 没有该键。不带 `--rev` 时现在的状态读工作区，带 `--rev` 时读被推送的那棵树。那次提交之后新建的文件不在范围内。状态为 open 的 incident 不在此列。
+
+**委派台账**：L2 或 L3 的 intent、spec、plan 状态为 done，或同级别 incident 状态为 fixed 或 closed 时，若 `workflow/delegations.md` 的「委派结果」表与「自做任务结果」表中均没有日期不早于该文档日期、且含该文件名（带 / 不带 `.md` 均匹配）的一行，check-loop 打出警告。incident 的日期取 frontmatter「发现」。`audit: false` 时这条警告与其他卫生警告一起被吞掉。退出码仍由阻断项决定。
+
 ## 闭环规则
 
 1. L1 以上新需求始于已确认的 intent；L1 以上修复始于已确认的 incident 草稿（作为 intent 等价入口）
-2. L2 / L3 变更必须先有与入口文档同名的 spec 确认通过（L3 加新会话独立复核），方可起草 plan；L1 用极简 plan——改动面 + 验证方式两节起步，多文件多步骤再加任务拆解/执行顺序
+2. L2 / L3 变更必须先有与入口文档同名的 spec 确认通过（L3 加新会话独立复核），方可起草 plan；L1 用极简 plan——改动面 + 验证方式两节起步，多文件多步骤再加任务拆解/执行顺序。**逐阶段前置已机器强制**（2026-09-30 stage-gate-machine）：fill-spec / fill-plan / confirm-doc 校验入口与 spec 前置未过即拒；顺序审计 = check-loop 检查 19
 3. 实现产物必须通过静态门（构建 + 测试 + 项目门禁）
 4. 线上 / 实测缺陷回落到 `incidents/`，复盘三件套（新 intent、防复发验证、规范条目）缺一不可；**根因属「门禁缺位 / 规范未落地 / 系统性问题」时，即使结构性修复已完成也必须立新 intent** 追踪系统性改进，禁止以「修复已完成」为由绕过 intent 回路
 5. 关单在 test：逐条勾验入口文档「验收标准」并补证据后 intent → done（不依赖是否上 prod）。done 仍有未勾项会被 check-loop 拦（新建 intent hard-block）。上 prod 另走 deploy（tag / 回滚 / 观察）

package/templates/workflow/incidents/_TEMPLATE.md

@@ -10,6 +10,10 @@
 
 ## 时间线
 - <发现 → 定位 → 止血 → 恢复，带时刻>
+- 用户确认：草稿过目通过（<日期>）
+<!-- 上行是**L2/L3 起草 spec 的机器前置**（fill-spec / confirm-doc 校验）：须为「时间线」小节内的行首条目；
+     接受形态 `- 用户确认：…` / `- **用户确认**：…` / `- <日期> 用户确认：…`（词前词后加粗、日期前缀均可）；
+     正文叙述句（如「用户确认了方案」）不算留痕。形态清单写在本注释内，避免样例行自含描述文字 -->
 
 ## 影响面
 - <页面 / 接口 / 数据范围>

package/templates/workflow/intents/_TEMPLATE.md

@@ -8,6 +8,7 @@
 # INTENT — <主题>
 <!-- 复制本模板为 YYYY-MM-DD-<主题>.md 后填写；plans/ 下同名文件与本文件配对 -->
 <!-- frontmatter 受限子集（2026-09-13）：每行 `键: 值`；状态∈draft/approved/done/superseded/cancelled（严格枚举，附注写备注键）；级别∈L0/L1/L2/L3；check-loop 只扫 frontmatter 取机器字段，正文不再写状态/级别行 -->
+<!-- 探索泳道（可选，2026-09-30 hybrid-governance-explore-hardening）：experiment/ 前缀分支上的 PoC 任务在 frontmatter 加「阶段: exploring」——提交/推送门降级 advisory，spec/plan 可先于本入口确认起草（限 L0/L1）；转正合入 main 前须收口（本档 approved/done + 同名 plan/spec 在场，check-loop --hardening 加固门），或显式放弃（superseded/cancelled） -->
 
 ## 背景与问题
 <为什么做；写明需求来源（工单 / 沟通记录 / 待办事项）>