@customize-agent/server 4.59.1 → 4.59.3

package/scripts/capture-baseline.mjs

@@ -12,7 +12,7 @@
  * - ❌ **无逐调用 token/缓存遥测**——成本与缓存命中率**当前不可重建**。
  *
  * 于是「改了之后是不是退化了」在数据上无从判断（S4.2）。本脚本把这两样**在生成结束的那一刻**
- * 抄下来，与六维分一起冻结成一份可 diff 的基线。
+ * 抄下来，与七维评价回执一起冻结成一份可 diff 的基线。
  *
  * ## 为什么是「采集归档」而不是「另跑一遍管线」
  *
@@ -20,47 +20,19 @@
  * 落成一份 `*.baseline.json`。这样：
  * 1. 采集本身**零 LLM 成本**（跑一次真实文档 ~50 分钟，重跑一遍纯属浪费）；
  * 2. 基线与被评的那份文档**逐字段同源**（不会出现「基线是另一轮跑的」这种不可比）；
- * 3. A/B 两组的差异**只来自开关**（`REPAIR_CHAIN=off` / `AGENT_TOOLS=on`），不是两套采集代码。
  *
  * ## 用法
  *
  * ```bash
  * # 采集一份既有归档（docId 见 generatedDocuments/index.json）
  * node apps/server/scripts/capture-baseline.mjs --project-root . --doc doc-1790407778481-d7a36837
- * # 采集最近 N 份（自带 --run 时先触发一次生成再采集）
+ * # 采集最近 N 份
  * node apps/server/scripts/capture-baseline.mjs --project-root . --latest 2
- * node apps/server/scripts/capture-baseline.mjs --project-root . --run tpl-1790019955043 --run tpl-1790187804600
  * ```
  *
  * 落盘：`~/.customize-agent/baselines/<时间戳>-<label>.baseline.json`（**append-only**，
  * 不覆盖历史基线——「同代码重跑波动 ±7」这件事只能靠多份基线看出来）。
  *
- * ## A/B 模式（S11.2：**同一组 N 份归档，开关开/关各跑一次**）
- *
- * ```bash
- * # 腿 1（off）——需要**服务端以 REPAIR_CHAIN=off 启动**（开关读的是服务端进程的 env，脚本设不了）
- * node apps/server/scripts/capture-baseline.mjs --project-root . --latest 8 --ab REPAIR_CHAIN --ab-leg off
- * # 腿 2（on）——服务端以默认 env 重启后再跑；配对文件由腿 1 打印，无需手抄
- * node apps/server/scripts/capture-baseline.mjs --project-root . --latest 8 --ab REPAIR_CHAIN --ab-leg on
- * # 判定（**不在本脚本里**）：两腿各跑完后由 TS 侧 `services/agent/abExecution.ts` 出结论
- * ```
- *
- * 分工（这是本模式最重要的一条）：**脚本只做机制 + 抄写原始证据，绝不下结论**。
- * | 环节 | 谁 |
- * |---|---|
- * | 拒绝"这场 A/B 根本不成立"（腿值非法 / 同一腿跑两次 / 两腿输入不同 / 标签与历史基线撞车） | **本脚本**（全部在任何网络调用**之前**或落盘**之前**） |
- * | 从归档里抄 `repairChainMode` 等**原始**证据 | 本脚本（抄写，不判定） |
- * | 「这一腿的开关真的切了吗」+「on 腿是否退化」 | TS 侧 `services/agent/abExecution.ts`（复用 S4.2 的 `costModel`） |
- *
- * 为什么判定不放这儿：脚本的产物是**文件**，它不会拒绝给结论——而"标签写错的一腿"这种错
- * 只能靠"声明值 vs 归档证据"的对账抓出来，那需要两腿的归档同时在手，且必须**宁可不出结论**。
- * 脚本在此处的克制是刻意的：它连"declare=on 且归档无标记 ⇒ 视为 on"这种推断都不做。
- *
- * ★ 未核实：`AGENT_TOOLS` 这条腿今天**采集得出、判定不出**——写手循环的 `onTurn`
- * （`writerLoop.ts:134` 的 `turn.*` 载荷）在生产路径上零消费点，节点日志里没有 `turn` 节点，
- * 归档里也没有任何字段记录这个开关。脚本会对这种腿打出显式警告（跑完 8+8 份仍会拒判），
- * 免得白跑 16 次真实生成。
- * ═══════════════════════════════════════════════════════════════════════════
  */
 
 import crypto from 'node:crypto';
@@ -71,21 +43,17 @@ import path from 'node:path';
 const DEFAULT_BASE_URL = process.env.BASELINE_BASE_URL || 'http://localhost:17321';
 
 function parseArgs(argv) {
-  const args = { projectRoot: process.cwd(), docs: [], runs: [], latest: 0, label: '', baseUrl: DEFAULT_BASE_URL, timeoutMinutes: 90, ab: '', abLeg: '', abPair: '', abSize: null };
+  const args = { projectRoot: process.cwd(), docs: [], corpora: [], latest: 0, label: '', baseUrl: DEFAULT_BASE_URL, timeoutMinutes: 90 };
   for (let index = 0; index < argv.length; index += 1) {
     const token = argv[index];
     const next = () => argv[++index];
     if (token === '--project-root') args.projectRoot = path.resolve(next());
     else if (token === '--doc') args.docs.push(next());
-    else if (token === '--run') args.runs.push(next());
+    else if (token === '--corpus') args.corpora.push(next());
     else if (token === '--latest') args.latest = Number(next());
     else if (token === '--label') args.label = next();
     else if (token === '--base-url') args.baseUrl = next();
     else if (token === '--timeout-minutes') args.timeoutMinutes = Number(next());
-    else if (token === '--ab') args.ab = next();
-    else if (token === '--ab-leg') args.abLeg = next();
-    else if (token === '--ab-pair') args.abPair = next();
-    else if (token === '--ab-size') args.abSize = Number(next());
     else if (token === '--help' || token === '-h') { printHelp(); process.exit(0); }
     else throw new Error(`未知参数：${token}（--help 看用法）`);
   }
@@ -99,16 +67,14 @@ function printHelp() {
     '  --project-root <dir>   文档所属项目根（默认当前目录；决定归档目录）',
     '  --doc <docId>          采集指定文档（可重复）',
     '  --latest <N>           采集最近 N 份已完成文档',
-    '  --run <templateId>     先触发一次生成再采集（可重复；需要服务在跑）',
-    '  --label <name>         基线标签（默认按开关自动命名 a-on / b-off）',
+    '  --corpus <关键词>      **按既有归档的输入原样重跑一份**再采集（可重复）：从归档里找最近一份',
+    '                         匹配该关键词（材料组名/要求文本）的记录，用它的 promptIds/requirement/',
+    '                         title/materialRoot 重跑——这是"改了代码之后同一份语料还能不能达到同样质量"',
+    '                         的取数方式（含巢湖/合工大这类真实语料）',
+    '  --label <name>         基线标签（默认 baseline）',
     '  --base-url <url>       服务地址（默认 http://localhost:17321）',
     '  --timeout-minutes <N>  单份生成等待上限（默认 90）',
     '',
-    'A/B（S11.2：同 N 份归档，开/关各跑一次；判定在 TS 侧 abExecution.ts）：',
-    '  --ab <SWITCH>          开关名（本工具支持 REPAIR_CHAIN / AGENT_TOOLS）',
-    '  --ab-leg <on|off>      本腿的开关取值（同一腿只能采一次）',
-    '  --ab-pair <file>       配对文件（默认按 开关+项目 定形，腿 1 打印出来供腿 2 复用）',
-    '  --ab-size <N>          本场 A/B 的归档份数（腿 1 默认 8；腿 2 缺省沿用本场已声明的份数）',
     '',
   ].join('\n'));
 }
@@ -138,17 +104,20 @@ function num(value) {
 }
 
 /**
- * 六维 + 专业分 + 阻断数（评分口径单源在服务端；脚本只做**抄写**，不做换算）。
+ * 冻结合同七维回执与阻断数，直接读取当前正文的实际测量。
  * 换算会让基线与被评文档的差异混入「脚本口径」这个第三变量。
  */
 function scoresOf(record) {
-  const report = record?.reviewMetadata?.qualityReport || {};
-  const dims = report.dimensions || report.dimensionScores || null;
+  const report = record?.reviewMetadata?.contractQuality;
+  const score = report?.score;
   return {
-    overall: num(report.overall ?? report.overallScore),
-    dimensions: dims,
-    requirementChecklist: Array.isArray(report.requirementChecklist) ? report.requirementChecklist.length : null,
-    // 阻断数：导出闸门里的 blockingIssues（**不是**六维分——两套口径，方案 §六 顺带发现）
+    contractId: report?.contractId ?? null,
+    documentHash: report?.documentHash ?? null,
+    overallInterval: { lower: num(score?.lower), upper: num(score?.upper) },
+    dimensions: score?.dimensions ?? null,
+    meetsInitialTargets: score?.meetsInitialTargets ?? null,
+    measuredCriteria: Array.isArray(report?.findings) ? report.findings.length : null,
+    // 导出门禁保留实际阻断数；缺少评价回执不能当作零分或通过。
     blockingCount: Array.isArray(record?.draft?.exportGate?.blockingIssues) ? record.draft.exportGate.blockingIssues.length : null,
     exportGatePassed: record?.draft?.exportGate?.passed ?? null,
   };
@@ -195,18 +164,20 @@ function repairChainOf(record) {
 
 function baselineOf(record, options) {
   const diagnostics = record?.reviewMetadata?.diagnostics || {};
+  const startedAt = num(record.createdAt);
+  const endedAt = num(record.completedAt);
+  const elapsedMs = num(record.elapsedMs) ?? (startedAt !== null && endedAt !== null && endedAt >= startedAt ? endedAt - startedAt : null);
   return {
     schema: 'capture-baseline/v1',
     capturedAt: new Date().toISOString(),
-    // ★ 开关状态必须进基线：A/B 两组**只差开关**，基线里没有开关就分不清这份是哪一组
-    switches: {
-      repairChain: diagnostics.repairChain?.mode || 'on',
-      agentTools: process.env.AGENT_TOOLS || 'off',
-      agendEmitNodeStageMirror: process.env.AGENT_EMIT_NODE_STAGE_MIRROR || 'default',
-    },
+    recordContentHash: crypto.createHash('sha256').update(JSON.stringify(record)).digest('hex'),
+    runId: record.runId ?? null,
+    workflowVersion: record.workflowVersion ?? null,
+    // 阶段墙钟不能相加当成等待时间；并发阶段与调用耗时可能重叠。
+    metrics: diagnostics.metrics ?? record.reviewMetadata?.metrics ?? record.draft?.reviewMetadata?.diagnostics?.metrics ?? null,
     doc: {
       id: record.id, title: record.title, templateId: record.templateId, templateName: record.templateName,
-      status: record.status, elapsedMs: num(record.elapsedMs), wordCount: num(record.wordCount),
+      status: record.status, elapsedMs, wordCount: num(record.wordCount),
       markdownChars: typeof record.markdown === 'string' ? record.markdown.length : null,
       completedAt: record.completedAt ?? null,
     },
@@ -218,200 +189,7 @@ function baselineOf(record, options) {
   };
 }
 
-// ── A/B 配对（S11.2：同 N 份归档，开/关各跑一次） ─────────────────────────
-
-/**
- * 本工具认识的 A/B 开关（与 TS 侧 `services/agent/abExecution.ts` 的 `abSwitchEvidence()` 逐条同集合）。
- *
- * ★ 刻意**不**接受 `SKILLS`/`PAUSE`：它们的关闭效果在归档里没有可对账的痕迹
- * （技能不参与 ≠ 模板缺字段，暂停被忽略 ≠ 终态不是 paused，两者都可能由别的原因造成）。
- * 在这里放行会让操作者以为"A/B 做过了"，而判定侧只会拒判——把"跑过"当成"验过"是本仓红线。
- */
-const AB_SWITCHES = ['REPAIR_CHAIN', 'AGENT_TOOLS'];
-const AB_LEGS = ['on', 'off'];
-/** 归档证据**当前不可用**的开关（跑完仍会拒判）——采集不拦，但必须**事先**说清 */
-const AB_UNVERIFIABLE = { AGENT_TOOLS: '归档里没有任何字段记录这个开关：写手循环的 onTurn（writerLoop.ts:134 的 turn.* 载荷）在生产路径上零消费点，节点日志里没有 turn 节点' };
-
-function baselinesDir() {
-  return path.join(os.homedir(), '.customize-agent', 'baselines');
-}
-
-/** 配对文件：显式 `--ab-pair` 优先；否则按「开关 + 项目」定形（腿 2 无需手抄路径） */
-function abPairPathOf(args) {
-  if (args.abPair) return path.resolve(args.abPair);
-  return path.join(baselinesDir(), `ab-${args.ab.toLowerCase()}-${projectIdOf(args.projectRoot)}.abpair.json`);
-}
-
-function loadPairOrNull(file) {
-  if (!fs.existsSync(file)) return null;
-  const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
-  if (parsed?.schema !== 'ab-pair/v1' || !Array.isArray(parsed.legs)) {
-    throw new Error(`配对文件形状不对（期望 schema=ab-pair/v1）：${file}`);
-  }
-  return parsed;
-}
-
-/**
- * A/B 的全部「这场实验不成立」判定——**在任何网络调用之前**跑完。
- *
- * 为什么必须前置：`--run` 会触发真实生成（一份 40–60 分钟、真金白银）。等到采完 8+8 份
- * 才发现"同一腿采了两次"，代价是十几小时机时与一份**没法用**的数据——而那种数据最危险的地方
- * 是它看起来能用。故这里宁可多拦。
- */
-function abPreflight(args) {
-  const touched = args.ab !== '' || args.abLeg !== '' || args.abPair !== '' || args.abSize !== null;
-  if (!touched) return null;
-  if (!args.ab) throw new Error('--ab-leg / --ab-pair / --ab-size 需要同时给 --ab <SWITCH>（否则参数会被静默忽略）');
-  if (!AB_SWITCHES.includes(args.ab)) {
-    throw new Error(`--ab 不支持 ${args.ab}：本工具只做 ${AB_SWITCHES.join(' / ')}（判定侧同集合；其它开关在归档里没有可对账的痕迹）`);
-  }
-  const leg = args.abLeg;
-  if (leg === '') throw new Error(`--ab ${args.ab} 必须给 --ab-leg <${AB_LEGS.join('|')}>：不给就分不清这份归档属于哪一腿，而两腿的归档**除开关外必须一致**`);
-  if (!AB_LEGS.includes(leg)) throw new Error(`--ab-leg 只认 ${AB_LEGS.join('|')}，收到「${args.abLeg}」（含糊取值在 A/B 里是结论级差错：'true'/'1' 到底算哪一腿没有唯一答案）`);
-  if (args.abSize !== null && (!Number.isInteger(args.abSize) || args.abSize <= 0)) {
-    throw new Error(`--ab-size 需要正整数，收到「${args.abSize}」（0 / 负数 / 小数都不收：含糊值一律拒绝，不静默取默认）`);
-  }
-  // 两腿必须各有自己的标签：判定侧**按标签配对**，两腿同标签会让 on/off 指到同一份基线文件
-  if (args.label !== '') {
-    throw new Error('A/B 模式下不允许 --label：两腿必须各有自己的标签（本模式自动命名为 ab-<开关>-<腿>-<时刻>），同标签会让判定侧把两腿指到同一份基线');
-  }
-
-  const pairFile = abPairPathOf(args);
-  const pair = loadPairOrNull(pairFile);
-  // 份数缺省取**本场已声明的**（腿 2 不必重抄 --ab-size；显式给了不一致的值仍然拒）
-  const size = args.abSize === null ? (pair?.size ?? 8) : args.abSize;
-  if (pair) {
-    if (pair.switchName !== args.ab) throw new Error(`配对文件是给 ${pair.switchName} 的，本次是 ${args.ab}：${pairFile}`);
-    const existing = pair.legs.map(item => item.leg);
-    if (existing.includes(leg)) {
-      throw new Error(`「${leg}」腿已经采过了（${pairFile}）：A/B 是**开/关各一次**，同一腿采两次只会让配对无法收敛到"两腿只差开关"（已采：${existing.join('、')}）`);
-    }
-    if (pair.size !== size) throw new Error(`配对文件的份数是 ${pair.size}，本次 --ab-size ${size}：两腿必须同份数，改份数等于换了一场实验（请新建一场）`);
-  }
-
-  // 事前把"这条腿的证据不存在"说清——免得白跑 8 份真实生成
-  if (AB_UNVERIFIABLE[args.ab]) {
-    process.stdout.write(`[baseline] ⚠ 本腿（${args.ab}=${leg}）可采集但**判定会拒绝出结论**：${AB_UNVERIFIABLE[args.ab]}\n`);
-    process.stdout.write('[baseline] ⚠ 若目的是"建立"该证据通道，先把写入接上再跑；否则这 8 份归档只能当原始素材，不能当 A/B 证据。\n');
-  }
-  // 开关读的是**服务端进程**的 env（生成跑在服务端，本脚本设不了）——本地 env 只是提示，不是证据
-  const localEnv = process.env[args.ab] || '(未设)';
-  if (args.runs.length > 0) {
-    process.stdout.write(`[baseline] ⚠ 本腿要求服务端 env：${args.ab}=${leg}（脚本设不了它；本地 env=${localEnv}）——请**重启服务**后再跑 --run，否则采到的是另一腿。\n`);
-  }
-
-  return { switchName: args.ab, leg, size, pairFile, pair, legCount: (pair?.legs.length ?? 0) + 1 };
-}
-
-/** 归档证据：关链标记（`documentPipeline.ts:160` 只在**关**时写）+ 节点日志里 turn 节点条数（今天恒 0） */
-function abObserveLeg({ projectRoot, records }) {
-  const modes = [];
-  const turnCounts = [];
-  const notes = [];
-  for (const record of records) {
-    const mode = record?.reviewMetadata?.diagnostics?.repairChain?.mode ?? record?.draft?.reviewMetadata?.diagnostics?.repairChain?.mode ?? null;
-    modes.push(mode);
-    const count = turnNodeCountOf({ projectRoot, docId: record.id });
-    turnCounts.push(count);
-    if (count === null) notes.push(`${record.id}：无节点日志（turn 条数记为「未知」，不是 0）`);
-  }
-  const distinct = [...new Set(modes.map(mode => mode ?? '(缺)'))].sort();
-  return {
-    // 关腿应全体带标记；混着来（如 'off+(缺)'）在判定侧会被判为"标签对不上"并给出这段原文
-    repairChainMode: modes.length > 0 && distinct.length === 1 && distinct[0] === '(缺)' ? null : distinct.join('+'),
-    turnNodeCount: turnCounts.some(count => count !== null) ? turnCounts.reduce((sum, count) => sum + (count ?? 0), 0) : null,
-    notes,
-    perDoc: records.map((record, index) => ({ docId: record.id, repairChainMode: modes[index], turnNodeCount: turnCounts[index] })),
-  };
-}
-
-/** 节点日志里 `turn.*` 节点条数；**日志不存在 ⇒ null（未知）**，绝不写成 0（0 是"查过了，没有"） */
-function turnNodeCountOf({ projectRoot, docId }) {
-  const file = path.join(archiveDir(projectRoot), 'drafts', `${docId}.nodes.jsonl`);
-  if (!fs.existsSync(file)) return null;
-  let count = 0;
-  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
-    if (line.trim() === '') continue;
-    try {
-      const parsed = JSON.parse(line);
-      if (String(parsed?.type || '').startsWith('turn.')) count += 1;
-    } catch { /* 撕裂尾行：不计入（也不当成 0——上面的 existsSync 已经区分了"没有日志"） */ }
-  }
-  return count;
-}
-
-/**
- * 落盘**之前**的输入集校验：两腿必须跑同一组输入。
- *
- * 为什么这条值钱：`--latest 8` 的选片随"最近完成"变化。若两腿之间又完成了一份文档，
- * 腿 2 采到的就是另一组——而**分数差异会被读成开关的效果**。这种错在结果里看不出来
- * （两组分数都"正常"），只能靠这次集合比对拦住。
- */
-function abAssertInputs(ab, baselines) {
-  if (baselines.length !== ab.size) {
-    throw new Error(`本腿采到 ${baselines.length} 份，与 --ab-size ${ab.size} 不符：A/B 的前提是两腿同份数（拒绝落盘）`);
-  }
-  const templates = baselines.map(item => item.doc.templateId || item.doc.templateName || '(未知模板)');
-  const docs = baselines.map(item => item.doc.id);
-  const other = ab.pair?.legs?.[0];
-  if (other) {
-    const mine = [...templates].sort().join('\u0000');
-    const theirs = [...other.templates].sort().join('\u0000');
-    if (mine !== theirs) {
-      throw new Error(`两腿输入不是同一组模板（本腿 ${templates.join('、')} vs 另一腿 ${other.templates.join('、')}）：差的就不是开关了（拒绝落盘）`);
-    }
-    const overlap = docs.filter(id => other.docIds.includes(id));
-    if (overlap.length > 0) {
-      throw new Error(`两腿归档重合 ${overlap.length} 份（${overlap.slice(0, 3).join('、')}…）：同一份归档不能同时代表"开"与"关"（拒绝落盘）`);
-    }
-  }
-  return { templates, docs };
-}
-
-/** A/B 模式下拒绝与历史基线**撞标签**：标签是判定侧的配对键，撞了就会把两场会话混成一场 */
-function abAssertLabelFree(label) {
-  const dir = baselinesDir();
-  if (!fs.existsSync(dir)) return;
-  for (const name of fs.readdirSync(dir)) {
-    if (!name.endsWith('.baseline.json')) continue;
-    try {
-      const parsed = JSON.parse(fs.readFileSync(path.join(dir, name), 'utf8'));
-      if (parsed?.label === label) {
-        throw new Error(`标签「${label}」已被 ${name} 占用：A/B 的判定按标签配对，撞标签会把两场会话混成一场（A/B 模式下 --label 不可用，把旧基线移出目录或删掉即可；正常情况不会撞——标签里带采集时刻）`);
-      }
-    } catch (error) {
-      if (error instanceof Error && error.message.includes('已被')) throw error; // 上面的拒绝照原样抛出
-      /* 解析失败的历史文件不参与撞标签判定（`loadBaselines` 侧同样跳过并告警） */
-    }
-  }
-}
-
-/** 写配对状态（腿记录**只追加不删**；文件本身重写是因为它是状态不是产物） */
-function abWriteLeg({ ab, label, outFile, records }) {
-  const observed = abObserveLeg({ projectRoot: ab.projectRoot, records });
-  const leg = {
-    leg: ab.leg,
-    label,
-    baselineFile: path.basename(outFile),
-    declared: ab.leg,
-    capturedAt: new Date().toISOString(),
-    templates: ab.observed.templates,
-    docIds: ab.observed.docs,
-    observed,
-  };
-  const pair = {
-    schema: 'ab-pair/v1',
-    switchName: ab.switchName,
-    pairId: `ab-${ab.switchName.toLowerCase()}-${projectIdOf(ab.projectRoot)}`,
-    projectRoot: path.resolve(ab.projectRoot),
-    size: ab.size,
-    legs: [...(ab.pair?.legs ?? []), leg],
-  };
-  fs.writeFileSync(ab.pairFile, `${JSON.stringify(pair, null, 2)}\n`);
-  return { pair, openLeg: AB_LEGS.filter(item => !pair.legs.some(entry => entry.leg === item)) };
-}
-
-// ── 服务交互：触发与轮询 ────────────────────────────────────────────────
+function baselinesDir() { return path.join(os.homedir(), '.customize-agent', 'baselines'); }
 
 async function postJson(url, body, timeoutMs = 60000) {
   const response = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(timeoutMs) });
@@ -421,22 +199,42 @@ async function postJson(url, body, timeoutMs = 60000) {
   return { status: response.status, body: parsed ?? text };
 }
 
-async function getJson(url, timeoutMs = 60000) {
-  const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
-  const text = await response.text();
-  try { return { status: response.status, body: JSON.parse(text) }; } catch { return { status: response.status, body: text }; }
+/**
+ * ★ 实测修正（2026-09-30，A3 腿）：轮询超时 60s → **180s**，且**轮询失败不再终止采集**。
+ *
+ * 现场：生成中的服务端被 LLM 调用打满时，列表端点可能 >60s 才回答，`AbortSignal.timeout(60000)`
+ * 直接抛 `The operation was aborted due to timeout` ⇒ **采集脚本死在轮询上，而生成还在跑**
+ * （本轮 A3 腿就是这么丢的：脚本 05:29 报失败、文档仍在 generating）。
+ * 采集器的职责是"等"，不是"因为服务忙就放弃"——超时只该由 `deadline`（`--timeout-minutes`）决定。
+ */
+async function getJson(url, timeoutMs = 180000) {
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+    const text = await response.text();
+    try { return { status: response.status, body: JSON.parse(text) }; } catch { return { status: response.status, body: text }; }
+  } catch (error) {
+    // 轮询失败 ⇒ 返回空体（调用方继续等）；**不 throw**（服务忙不等于生成失败）
+    process.stdout.write(`[baseline] 轮询失败（继续等，不影响生成）：${error instanceof Error ? error.message : String(error)}\n`);
+    return { status: 0, body: undefined };
+  }
 }
 
 const TERMINAL = new Set(['completed', 'completed_with_issues', 'warning', 'failed', 'aborted']);
 
-async function triggerAndWait({ baseUrl, projectRoot, templateId, timeoutMinutes }) {
-  const started = await postJson(`${baseUrl}/api/documents/generate`, { templateId, requirement: '', projectRoot }, 120000);
+/**
+ * ★ 2026-09-28：触发入参改成 **§12.1 三字段 + 语料四件套**（原实现传的是已退役的 `templateId` 单字段）。
+ * `corpus` 给出时，用它的 `promptIds/requirement/title/materialRoot` **原样重跑**——
+ * 语料可复现是基线可比的前提（换了提示词或材料组就不是同一份文档了）。
+ */
+async function triggerAndWait({ baseUrl, projectRoot, corpus, timeoutMinutes }) {
+  const started = await postJson(`${baseUrl}/api/documents/generate`,
+    { promptIds: corpus.promptIds, requirement: corpus.requirement || '', title: corpus.title, materialRoot: corpus.materialRoot, projectRoot }, 120000);
   if (started.status !== 202 && started.status !== 200) {
     throw new Error(`触发失败（HTTP ${started.status}）：${typeof started.body === 'string' ? started.body : JSON.stringify(started.body)}`);
   }
   const documentId = started.body?.documentId || started.body?.record?.id || started.body?.id;
   if (!documentId) throw new Error(`触发返回里没有 documentId：${JSON.stringify(started.body).slice(0, 400)}`);
-  process.stdout.write(`[baseline] 已触发 ${templateId} → ${documentId}（等待生成，通常 40–60 分钟）\n`);
+  process.stdout.write(`[baseline] 已触发 ${corpus.title}（语料：${corpus.materialRoot}） → ${documentId}（等待生成，通常 40–60 分钟）\n`);
   const deadline = Date.now() + timeoutMinutes * 60000;
   let lastLog = 0;
   for (;;) {
@@ -459,6 +257,35 @@ function loadArchivedRecord({ projectRoot, docId }) {
   return JSON.parse(fs.readFileSync(file, 'utf8'));
 }
 
+/**
+ * ★ 2026-09-28：按关键词找**最近的语料记录**并抽出重跑所需的输入（四件套 + 项目根）。
+ * 匹配面：`materialRoot`（材料组名）与 `requirement`（要求文本）——真实语料通常两者都带关键词。
+ */
+function findCorpus({ projectRoot, keyword }) {
+  const dir = path.join(archiveDir(projectRoot), 'drafts');
+  if (!fs.existsSync(dir)) throw new Error(`归档目录不存在：${dir}`);
+  const candidates = fs.readdirSync(dir)
+    .filter(name => name.endsWith('.json') && !name.endsWith('.meta.json'))
+    .map(name => {
+      const full = path.join(dir, name);
+      try { return { full, stat: fs.statSync(full), record: JSON.parse(fs.readFileSync(full, 'utf8')) }; } catch { return undefined; }
+    })
+    .filter(Boolean)
+    .filter(item => `${item.record.materialRoot || ''} ${item.record.requirement || ''} ${item.record.title || ''}`.includes(keyword))
+    .sort((left, right) => right.stat.mtimeMs - left.stat.mtimeMs);
+  if (candidates.length === 0) throw new Error(`归档里找不到含「${keyword}」的记录（材料组名/要求文本/标题都没命中）：${dir}`);
+  const newest = candidates[0].record;
+  if (!newest.promptIds?.length) throw new Error(`「${keyword}」最近一份记录没有 promptIds（旧记录），无法原样重跑`);
+  return {
+    sourceDocId: newest.id,
+    promptIds: newest.promptIds,
+    requirement: newest.requirement || '',
+    title: newest.templateName || newest.title || '',
+    materialRoot: newest.materialRoot || '',
+    projectRoot: newest.projectRoot || projectRoot,
+  };
+}
+
 function latestDocIds({ projectRoot, count }) {
   const indexFile = path.join(archiveDir(projectRoot), 'index.json');
   if (!fs.existsSync(indexFile)) throw new Error(`索引不存在：${indexFile}`);
@@ -474,16 +301,17 @@ function latestDocIds({ projectRoot, count }) {
 
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  // ★ A/B 的拒绝**全部**在这里（任何网络调用之前）：腿值非法 / 同一腿采两次 / 份数不一致…
-  const ab = abPreflight(args);
-  if (ab) {
-    ab.projectRoot = args.projectRoot;
-    process.stdout.write(`[baseline] A/B：${ab.switchName}=${ab.leg}（第 ${ab.legCount}/2 腿，共 ${ab.size} 份）配对文件 ${ab.pairFile}\n`);
-  }
   const records = [];
 
-  for (const templateId of args.runs) {
-    records.push(await triggerAndWait({ baseUrl: args.baseUrl, projectRoot: args.projectRoot, templateId, timeoutMinutes: args.timeoutMinutes }));
+  /**
+   * ★ 2026-09-28：**按既有归档的输入原样重跑**（真实语料基线：巢湖 / 合工大这类）。
+   * 每个关键词解析出一份语料四件套，逐份触发 + 等待 + 采集——同一份语料在改动前后各跑一次，
+   * 两次的 `*.baseline.json` 可直接 diff（脚本的产物是可 diff 的基线，判定仍不在这里）。
+   */
+  for (const keyword of args.corpora) {
+    const corpus = findCorpus({ projectRoot: args.projectRoot, keyword });
+    process.stdout.write(`[baseline] 语料「${keyword}」命中 ${corpus.sourceDocId}：标题「${corpus.title}」材料组「${corpus.materialRoot}」\n`);
+    records.push(await triggerAndWait({ baseUrl: args.baseUrl, projectRoot: args.projectRoot, corpus, timeoutMinutes: args.timeoutMinutes }));
   }
   if (args.latest > 0) {
     for (const docId of latestDocIds({ projectRoot: args.projectRoot, count: args.latest })) {
@@ -495,16 +323,9 @@ async function main() {
 
   const baselines = records.map(record => baselineOf(record, args));
   const stamp = new Date().toISOString().replace(/[:.]/gu, '-');
-  // A/B 的标签带**时刻**：判定侧按标签配对，两场会话天然可分（同开关可重复做 A/B，不必先归档旧基线）
-  const label = args.label || (ab ? `ab-${ab.switchName.toLowerCase()}-${ab.leg}-${stamp}` : (baselines[0].switches.repairChain === 'off' ? 'b-off' : 'a-on'));
+  const label = args.label || 'baseline';
   const outDir = baselinesDir();
   fs.mkdirSync(outDir, { recursive: true });
-  if (ab) {
-    // ★ 落盘前的最后两道拒绝：两腿输入不同 / 标签与历史基线撞车。
-    //   抛在这里 ⇒ 本腿**一份文件都不写**（不留"半套配对"这种看起来能用的状态）
-    ab.observed = abAssertInputs(ab, baselines);
-    abAssertLabelFree(label);
-  }
   const outFile = path.join(outDir, `${stamp}-${label}.baseline.json`);
   fs.writeFileSync(outFile, `${JSON.stringify({ capturedAt: new Date().toISOString(), label, projectRoot: path.resolve(args.projectRoot), baselines }, null, 2)}\n`);
 
@@ -512,27 +333,16 @@ async function main() {
   for (const item of baselines) {
     const dims = item.scores.dimensions ? JSON.stringify(item.scores.dimensions) : '(无 dimensions)';
     process.stdout.write(
-      `  ${item.doc.id}  ${item.doc.title}  状态=${item.doc.status}  ${Math.round((item.doc.elapsedMs || 0) / 60000)}min\n`
-      + `    综合=${item.scores.overall ?? '?'}  阻断=${item.scores.blockingCount ?? '?'}  六维=${dims}\n`
+      `  ${item.doc.id}  ${item.doc.title}  状态=${item.doc.status}  ${item.doc.elapsedMs === null ? '耗时未知' : Math.round(item.doc.elapsedMs / 60000) + 'min'}\n`
+      + `    综合区间=${item.scores.overallInterval.lower ?? '?'}～${item.scores.overallInterval.upper ?? '?'}  阻断=${item.scores.blockingCount ?? '?'}  七维=${dims}\n`
       + `    块账=${item.blockLedger.rows} 块 Σ目标=${item.blockLedger.targetChars} Σ实际=${item.blockLedger.actualChars}\n`
       + `    LLM 调用=${item.llm.calls ?? '?'} 缓存命中/未命中=${item.llm.promptCacheHitTokens ?? '?'}/${item.llm.promptCacheMissTokens ?? '?'}\n`
-      + `    修复链净增=${item.repairChain.netChars?.delta ?? '?'}（${item.repairChain.netChars ? (item.repairChain.netChars.ratio * 100).toFixed(1) + '%' : '?'}）开关=${item.switches.repairChain}\n`,
+      + `    修复链净增=${item.repairChain.netChars?.delta ?? '?'}（${item.repairChain.netChars ? (item.repairChain.netChars.ratio * 100).toFixed(1) + '%' : '?'}）\n`,
     );
   }
   process.stdout.write(`[baseline] 落盘：${outFile}\n`);
-  if (ab) {
-    const { pair, openLeg } = abWriteLeg({ ab, label, outFile, records });
-    process.stdout.write(`[baseline] A/B 状态：${ab.pairFile}（已采 ${pair.legs.map(item => item.leg).join('、')}）\n`);
-    if (openLeg.length > 0) {
-      process.stdout.write(`[baseline] 还差「${openLeg.join('、')}」腿：服务端 env 切到 ${ab.switchName}=${openLeg[0]} 并重启后，用**同一批输入**再跑一次\n`);
-      process.stdout.write(`[baseline]   （--ab ${ab.switchName} --ab-leg ${openLeg[0]} --ab-pair ${ab.pairFile}；--latest/--doc 的选片必须与上一腿同组）\n`);
-    } else {
-      process.stdout.write('[baseline] 两腿齐了。判定（**不在本脚本里**，跑 TS 侧车道）：\n');
-      process.stdout.write(`[baseline]   AB_PAIR=${ab.pairFile} npx vitest run --config vitest.manual.config.ts apps/server/test/services/agent/abExecution.manual.ts\n`);
-    }
-    process.stdout.write('[baseline] ★ 本脚本只采集与抄写证据，**不下结论**：标签对不对、是否退化，由 TS 侧 abExecution（复用 S4.2）判。\n');
-  }
-  process.stdout.write('[baseline] ★ 同代码重跑波动 ±7（方案 14.5 族 6 实测）——单点差值不足以归因，A/B 要比的是**维度构成**。\n');
+  process.stdout.write('[baseline] 基线只抄写归档已有值，未测项保留为空。\n');
+
 }
 
 main().catch(error => {