sillyspec 3.32.8 → 3.32.10

package/src/timeline.js

@@ -24,6 +24,33 @@ export function parseTaskLines(tasksMd) {
   return out;
 }
 
+/** task id 归一：task-2 → task-02（与 task-tick normalizeTaskId 同口径，非 task-N 形态返 null）。 */
+function normTaskId(s) {
+  const m = /^task-(\d+)$/.exec(String(s || '').trim());
+  return m ? `task-${String(Number(m[1])).padStart(2, '0')}` : null;
+}
+
+/**
+ * 侧车勾选留痕解析（2026-10-14-timeline-ticktime-anchor-scope）：task-ticks.jsonl 行集
+ * （{ts,task,source}）→ Array<{ts,task}>。坏行跳过；id 归一；同任务取最早（时钟回拨/重复
+ * 留痕容错——勾选时刻语义=首次翻格时刻）。文件缺失/不可读由调用方 catch 成空数组。
+ */
+export function parseTickLog(raw) {
+  const byTask = new Map();
+  for (const line of String(raw || '').split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    try {
+      const o = JSON.parse(line);
+      const id = normTaskId(o && o.task);
+      const ts = Number(o && o.ts);
+      if (!id || !Number.isFinite(ts)) continue;
+      const p = byTask.get(id);
+      if (!p || ts < p.ts) byTask.set(id, { ts, task: id });
+    } catch { /* 坏行跳过 */ }
+  }
+  return [...byTask.values()];
+}
+
 /**
  * 翻格顺序推断（FR-04）：task-done（stage='tasks'）事件序列 → 每任务序号的勾选时刻。
  * 计数链衔接（from === 游标）才赋值；**中段**断裂（from ≠ 游标）标 broken 并停止赋值。
@@ -60,9 +87,12 @@ function tokensOf(text) {
 /**
  * 提交锚解析：事件流 kind=commit 的短 hash → gitLook 解析出主题/时间/token。
  * @param {Function} gitLook (hash) => null | {hash, dateISO, message}（注入面，接线层包 gitQuiet）
- * @returns {Array<{hash, ts, subject, tokens, resolvable}>} ts 取事件观测时刻（git 日期仅存证）。
+ * @param {string|null} change 变更名（2026-10-14-timeline-ticktime-anchor-scope）：在场时逐 anchor
+ *   算 sameChange=提交全消息（%B 含正文）includes(change)——锚定面据此收敛，杀跨变更 token 撞车
+ *   （litellm-retire 实证：他变更提交消息含 task-01/04/05 被误锚）；缺省恒 true 向后兼容。
+ * @returns {Array<{hash, ts, subject, tokens, resolvable, sameChange}>} ts 取事件观测时刻（git 日期仅存证）。
  */
-export function resolveCommitAnchors(events, gitLook) {
+export function resolveCommitAnchors(events, gitLook, change = null) {
   const out = [];
   for (const e of events || []) {
     if (!e || e.kind !== 'commit' || !e.detail) continue;
@@ -75,6 +105,7 @@ export function resolveCommitAnchors(events, gitLook) {
       subject: info ? String(info.message || '').split(/\r?\n/)[0] : null,
       tokens: info ? tokensOf(info.message) : [],
       resolvable: Boolean(info),
+      sameChange: !change || (info ? String(info.message || '').includes(change) : false),
     });
   }
   return out;
@@ -125,11 +156,13 @@ function fmtDur(ms) {
  * @param {string} args.change 变更名
  * @param {Array} args.events 事件流（readWatcherEvents.events）
  * @param {Array|null} args.tasks parseTaskLines 产物（null=任务面缺失）
- * @param {Array} args.anchors resolveCommitAnchors 产物
+ * @param {Array} args.anchors resolveCommitAnchors 产物（锚定只取 sameChange!==false 的行）
  * @param {number|null} args.birthTs 诞生锚（工件 frontmatter created_at 毫秒；null=缺）
  * @param {string|null} args.tier flow-state tier（null=缺/未知）
+ * @param {Array|null} args.tickLog parseTickLog 产物（2026-10-14-timeline-ticktime-anchor-scope：
+ *   侧车勾选留痕——任务行时刻三级降级：侧车精确（无 ≈）> 事件流推断（≈）> ?）
  */
-export function renderTimeline({ change, events, tasks, anchors, birthTs, tier }) {
+export function renderTimeline({ change, events, tasks, anchors, birthTs, tier, tickLog = null }) {
   const L = [];
   L.push(`📅 ${change} — 合成时间线（${tier || 'tier 未知'}｜事件流 × tasks.md × git 提交锚）`);
   L.push('');
@@ -140,16 +173,22 @@ export function renderTimeline({ change, events, tasks, anchors, birthTs, tier }
 
   if (tasks) {
     L.push('');
-    L.push('── 任务面（勾选时刻 ≈ 顺序推断｜tasks.md 描述行 × 提交锚）──');
+    L.push('── 任务面（勾选时刻：精确=task tick 侧车留痕｜≈=事件流顺序推断｜tasks.md 描述行 × 提交锚）──');
     const { times, broken } = inferFlipTimes(events, tasks.length);
-    if (broken) L.push('（计数链中段断裂——断裂点后勾选时刻推断不可用，标 ?）');
-    if (tasks.some((t, i) => t.checked && times[i] == null)) L.push('（已勾任务缺推断时刻——观测盲窗/水位丢失，标 ?）');
+    const tickMap = new Map((tickLog || []).map((r) => [String(r && r.task), Number(r && r.ts)]));
+    // 断裂注按需打（2026-10-14-timeline-ticktime-anchor-scope）：侧车已覆盖全部已勾位时推断层
+    // 与展示无关——watcher 重复采样（0→1 双拍）也会撞断游标，此时打断裂注是误导噪音。
+    const inferenceMatters = tasks.some((t) => t.checked && !tickMap.has(t.id));
+    if (broken && inferenceMatters) L.push('（计数链中段断裂——断裂点后勾选时刻推断不可用，标 ?）');
+    if (tasks.some((t, i) => t.checked && times[i] == null && !tickMap.has(t.id))) L.push('（已勾任务缺推断时刻——观测盲窗/水位丢失，标 ?）');
     for (let i = 0; i < tasks.length; i++) {
       const t = tasks[i];
-      const when = t.checked
-        ? (times[i] != null ? `≈${fmtHMS(times[i])}` : '?')
-        : '未勾';
-      const anchor = anchors.filter((a) => a.tokens.includes(t.id)).sort((a, b) => a.ts - b.ts)[0];
+      const when = !t.checked
+        ? '未勾'
+        : tickMap.has(t.id) ? fmtHMS(tickMap.get(t.id))
+          : times[i] != null ? `≈${fmtHMS(times[i])}`
+            : '?';
+      const anchor = anchors.filter((a) => a && a.sameChange !== false && a.tokens.includes(t.id)).sort((a, b) => a.ts - b.ts)[0];
       const ev = anchor ? anchor.hash : (t.checked ? '无提交锚⚠️' : '—');
       L.push(`${t.id}  ${when.padEnd(10)}  ${clip(t.desc, 44).padEnd(46)}${ev}`);
     }
@@ -169,7 +208,7 @@ export function renderTimeline({ change, events, tasks, anchors, birthTs, tier }
   if (stages.length > 0) {
     L.push(`阶段墙钟：${stages.map((s) => `${s.stage} ${fmtDur(s.durationMs)}`).join('｜')}`);
   }
-  L.push('注：观测起点≠诞生时刻（watcher 后拉起/单飞锁盲窗）；勾选时刻为顺序推断（事件不记任务 id）；描述行含机器稿截断。');
+  L.push('注：观测起点≠诞生时刻（watcher 后拉起/单飞锁盲窗）；勾选时刻精确值=task tick 侧车留痕（task-ticks.jsonl），≈=事件流顺序推断（事件不记任务 id）；描述行含机器稿截断。');
   return L.join('\n');
 }
 
@@ -179,27 +218,29 @@ export function renderTimeline({ change, events, tasks, anchors, birthTs, tier }
  * 烤制落盘——诚实注记而非数据错误。eventsCopySkipped=副本未随包形态（尺寸超帽或读源失败，
  * 评审 P3-1：注记必须与实际产出一致，不虚报副本在场）。
  */
-export function renderBakedTimeline({ change, events, tasks, anchors, birthTs, tier, bakedAtIso, eventsCopySkipped = false }) {
+export function renderBakedTimeline({ change, events, tasks, anchors, birthTs, tier, bakedAtIso, eventsCopySkipped = false, tickLog = null }) {
   const head = [
     `# 合成时间线快照 — ${change}`,
     '',
     `> 烤制于归档链（${bakedAtIso}）：事件流机本位（.runtime gitignore），本快照随归档包进 git 跨机可读。`,
-    '> 末尾事件（含「目录已移入 archive」终拍）可能晚于烤制未入快照；勾选时刻为顺序推断（≈）。',
+    '> 末尾事件（含「目录已移入 archive」终拍）可能晚于烤制未入快照；勾选时刻：精确=task tick 侧车留痕，≈=事件流顺序推断。',
     eventsCopySkipped
       ? '> 原始事件副本未随包（尺寸超帽或读源失败）——细粒度复核回本机 .runtime 或平台 observation 事件面。'
       : '> 原始事件副本：本目录 watcher-events.jsonl（时点快照）。',
     '',
   ]
-  return head.join('\n') + renderTimeline({ change, events, tasks, anchors, birthTs, tier })
+  return head.join('\n') + renderTimeline({ change, events, tasks, anchors, birthTs, tier, tickLog })
 }
 
-/** change 目录双路径探测（活跃 > 归档）+ tasks.md 读取 → {changeDir, tasksMd}（缺 tasksMd=null）。 */
+/** change 目录双路径探测（活跃 > 归档）+ tasks.md / task-ticks.jsonl 读取 → {changeDir, tasksMd, tickLog}（缺 tasksMd=null、tickLog=空数组）。 */
 export function loadChangeTasks(specBase, change) {
   const active = join(specBase, 'changes', change);
   const archived = join(specBase, 'changes', 'archive', change);
   const dir = [active, archived].find((d) => { try { return readFileSync(join(d, 'tasks.md'), 'utf8') != null } catch { return false } });
-  if (!dir) return { changeDir: null, tasksMd: null };
-  return { changeDir: dir, tasksMd: readFileSync(join(dir, 'tasks.md'), 'utf8') };
+  if (!dir) return { changeDir: null, tasksMd: null, tickLog: [] };
+  let tickLog = [];
+  try { tickLog = parseTickLog(readFileSync(join(dir, 'task-ticks.jsonl'), 'utf8')); } catch { /* 侧车缺失/不可读按空 */ }
+  return { changeDir: dir, tasksMd: readFileSync(join(dir, 'tasks.md'), 'utf8'), tickLog };
 }
 
 /** 诞生锚：change 目录工件 frontmatter created_at（requirements > proposal > design > tasks）。 */
@@ -215,4 +256,4 @@ export function readBirthTs(changeDir) {
   return null;
 }
 
-export default { parseTaskLines, inferFlipTimes, resolveCommitAnchors, renderTimeline, renderBakedTimeline, loadChangeTasks, readBirthTs };
+export default { parseTaskLines, parseTickLog, inferFlipTimes, resolveCommitAnchors, renderTimeline, renderBakedTimeline, loadChangeTasks, readBirthTs };

package/src/verify-postcheck.js

@@ -2867,17 +2867,34 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   // cd 前缀保留（2026-09-25-deps-cwd-prefix，R15/R16 实证）：剥前缀后从 worktree 根跑 uv，根上无
   // pyproject.toml → uv 解析到无 dev extras 的错环境 → aiobotocore 假红（两轮 known_failures 顶着）。
   // 前缀在则批次文件路径按该 dir 重定基（模块命令的文件参即 dir 相对口径，如 app/modules/...）。
+  // py 按包根分组（坑 flow-dynamic-subset-root-scripts-path，2026-10-13 实证：主仓根
+  // scripts/test_x.py 被拼进 backend 的 cd 批——相对路径在 backend cwd 下必然 not found，
+  // 整批 exit 2 假败）。每个 .py 文件按最近 pyproject/uv.lock 祖先归组（与 runner 推断
+  // 同款就近原则——monorepo 子项目各自独立环境）；组内共用该包根的 runner 命令与重定基。
+  // 显式命中命令串（hits）优先且整批共用（用户显式配置语义优先，不拆组）。
   let pyRunner = null
   for (const h of hits || []) {
     const cmd = String(h.test || '')
     const m = /^((?:cd\s+[^&|;]+&&\s*)*[^&|;]*?pytest)/.exec(cmd) || /(?:^|&&|;|\|\|)\s*([^&|;]*pytest)/.exec(cmd)
     if (m) { pyRunner = m[1].trim(); break }
   }
-  if (!pyRunner && cwd && pyRun.length > 0) {
-    const inferred = inferPyRunner(cwd, pyRun[0])
-    pyRunner = inferred.command
+  // pyGroups: Map<dirKey, { files, command }>；dirKey null = 主仓根（无 cd 前缀）
+  const pyGroups = new Map()
+  const pyGroupOf = (f) => {
+    if (pyRunner) return null // 显式命中命令：整批一组（既有语义）
+    if (!cwd) return null
+    const inferred = inferPyRunner(cwd, f)
+    return inferred.dir || null
+  }
+  for (const f of pyRun) {
+    const key = pyGroupOf(f)
+    if (!pyGroups.has(key)) {
+      const command = pyRunner || (cwd ? inferPyRunner(cwd, f).command : 'python -m pytest')
+      pyGroups.set(key, { files: [], command })
+    }
+    pyGroups.get(key).files.push(f)
   }
-  if (!pyRunner) pyRunner = 'python -m pytest'
+  if (!pyRunner && pyGroups.size > 0) pyRunner = pyGroups.values().next().value.command
   // JSX 运行器推断（2026-09-26-residual-runner-parity 起 + 结构推断源）：.tsx/.jsx 是 node
   // 原生 type stripping 跑不了的（node --test 直跑恒败——R18 verify 段 ~11 次尝试的坑），
   // ① 命中命令串提取 vitest/jest（旧路径）② 无命中命令时最近含 vitest/jest 的 package.json；
@@ -2928,7 +2945,19 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   // 批计数分列（2026-10-06-fr-regress-cap-drop）：count=实跑总数、prioCount=实跑中优先面数、
   // dropped 只计普通依赖弃置、prioDropped=防御路径计数（构造上恒 0——quotaFill 保证优先面零弃置，
   // >0 即组卷逻辑被破坏，消费面 loud 披露）。js 批经 jsNative/jsProject 内容分流后计数随分流面。
-  if (pyRun.length > 0) batches.push({ name: 'deps(auto-py)', short: 'py', command: `${pyRunner} ${pyRun.map(rebase).join(' ')}`, count: pyRun.length, prioCount: pyQ.prioCount, dropped: pyQ.dropped, prioDropped: pyQ.prioDropped, files: pyRun })
+  // py 多批（坑 flow-dynamic-subset-root-scripts-path）：按包根分组逐批 push——每组
+  // 重定基按本组 dir（跨组文件不再共享单一 cdDir）；组序稳定（Map 插入序=pyRun 排序序）。
+  {
+    let gi = 0
+    for (const [dirKey, grp] of pyGroups) {
+      // hits 命中形态 dirKey=null——从本组命令的 cd 前缀提取重定基目录（坑 deps-cwd-prefix
+      // ① 用例：显式配置 'cd backend && uv run pytest …' 时路径须按 backend/ 重定基）
+      const cmdDir = dirKey || /(?:^|\s)cd\s+(\S+)\s*&&/.exec(grp.command)?.[1] || null
+      const rebasePy = (f) => (cmdDir && f.startsWith(cmdDir + '/')) ? f.slice(cmdDir.length + 1) : f
+      batches.push({ name: pyGroups.size > 1 ? `deps(auto-py:${dirKey || 'root'})` : 'deps(auto-py)', short: 'py', command: `${grp.command} ${grp.files.map(rebasePy).join(' ')}`, count: grp.files.length, prioCount: grp.files.filter(f => prio(f) === 0).length, dropped: pyQ.dropped, prioDropped: pyQ.prioDropped, tap: true, files: grp.files, pyRoot: dirKey || null })
+      gi++
+    }
+  }
   if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: jsTest.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
   if (jsMeta.length > 0) batches.push({ name: 'deps(auto-js-meta-skip)', short: 'js-meta-skip', command: null, count: jsMeta.length, dropped: 0, skip: true, files: jsMeta, reason: '套件编排器（run-tests.mjs=npm test 组卷入口）非单测文件——内嵌执行=递归全量套件（嵌套 runner 污染假败）；全量门由收口实测/CI 的 npm test 承担' })
 
@@ -4194,6 +4223,51 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
     }
   }
 
+  // —— EOL-only 噪声过滤（坑 verify-close-gate-staggered-exposure 建议④，2026-10-15 消费仓实证：
+  //    gen:types 幂等重生成纯行尾 diff 进 actual 面 → ③类 undeclared 假红，agent 被迫为零内容
+  //    改动补声明或回退）。手法与 run/shared.js quick 审计的 eolOnly 先例同源：同一 git 范围
+  //    跑 plain 名单与 --ignore-cr-at-eol 名单，差集 = 纯行尾差异 → 剔出对账面，eolOnlyFiles
+  //    软留痕。两条硬边界：① 必须正向出现在 plain diff 且内容零变更才剔——absence-based
+  //    （「不在真实集即剔」）会误伤 B3 pathspec/救援窗口来源的已交付文件（它们不在任何
+  //    git diff 里）；② --name-only 不吃 --ignore-cr-at-eol（git 实测怪癖），内容过滤必须走
+  //    --numstat。探测失败 fail-open 不过滤；untracked 天然不在 plain diff 不受影响；删除/
+  //    重命名是内容变更（numstat 在场）不受影响。——
+  const eolOnlyFiles = []
+  try {
+    const eolOnlySet = new Set()
+    const probePair = (dir, refs) => {
+      const plainOut = gitQuiet(dir, ['diff', '--name-only', ...refs], { timeout: 30 * 1000, trim: false })
+      if (plainOut === null) return
+      const realOut = gitQuiet(dir, ['diff', '--numstat', '--ignore-cr-at-eol', ...refs], { timeout: 30 * 1000, trim: false })
+      if (realOut === null) return
+      const real = new Set()
+      for (const l of realOut.split('\n')) {
+        const i = l.lastIndexOf('\t')
+        if (i > 0) real.add(normalizeReconcilePath(l.slice(i + 1)))
+      }
+      for (const f of plainOut.split('\n').map(x => x.trim()).filter(Boolean)) {
+        const n = normalizeReconcilePath(f)
+        if (!real.has(n)) eolOnlySet.add(n)
+      }
+    }
+    // 工作树（HEAD 对照）：主仓 + worktree（form A 双仓各自 HEAD）
+    const probeDirs = [cwd]
+    if (form === 'worktree' && wtMeta && wtMeta.gitDir && wtMeta.gitDir !== cwd) probeDirs.push(wtMeta.gitDir)
+    for (const dir of probeDirs) probePair(dir, ['HEAD'])
+    // 已提交侧：form B B1 同基点（mergeBase 对照工作树）；form A worktree 已提交段（meta 锚点..HEAD）
+    if (form === 'post-apply' && baseAnchor) {
+      probePair(cwd, [baseAnchor])
+    } else if (form === 'worktree' && wtMeta) {
+      const mb = wtMeta.meta && (wtMeta.meta.baselineCommit || wtMeta.meta.actualBaseHash || wtMeta.meta.baseHash)
+      if (mb) probePair(wtMeta.gitDir, [mb, 'HEAD'])
+    }
+    for (const f of eolOnlySet) {
+      if (union.has(f)) {
+        union.delete(f)
+        eolOnlyFiles.push(f)
+      }
+    }
+  } catch { /* EOL 探测异常 → 不过滤（fail-open，行为与修复前一致） */ }
   const files = [...new Set(filterDeliverableFiles([...union]).filter(Boolean))].sort()
   // 多会话推进死锁诊断（reconcile-source-isolation，R18-SF-full 实证）：post-apply 形态下
   // 实际面全空（B1 无 ref + porcelain 无未提交面 + 无 apply-pathspec 兜底）= 典型「主仓被
@@ -4203,7 +4277,7 @@ export function resolveReconcileActualFiles({ cwd, specBase, runtimeRoot, change
   const parallelAdvanceHint = (form === 'post-apply' && files.length === 0 && union.size === 0 && !sources.some((s) => s.startsWith('main:diff-merge-base') || s.startsWith('apply-pathspec')))
     ? '⚠️ actual 源全空（无分支锚点 diff + 主仓无未提交面 + 无 apply-pathspec 兜底）——典型「主仓被并行会话推进」形态（本变更的提交/暂存可能已被他侧裸提交扫走）。切勿用「暂存物化」自救（touch 文件进共享暂存区——会被再次扫走且污染他侧，R18-SF-full 实证 matched=0 死循环）；出路：① 恢复/登记本变更分支（worktree meta.json 的 branch 字段）让锚定 diff 生效后重跑 ② 确属全量已在他侧提交：与该会话按 AGENTS 规则 18 对账后以该提交为锚核销'
     : null
-  return { ok: true, form, files, sources, foreignExcluded, foreignExcludedFiles, degradedReason: null, baseAnchor, commitWindowFiles, parallelAdvanceHint }
+  return { ok: true, form, files, sources, foreignExcluded, foreignExcludedFiles, degradedReason: null, baseAnchor, commitWindowFiles, parallelAdvanceHint, eolOnlyFiles }
 }
 
 /**
@@ -4433,6 +4507,9 @@ export function reconcileTargetFiles({ cwd, specBase = null, changeName = null,
     notes.push(`③类另有 ${scaffoldTotal} 个工具/平台脚手架文件（platform ${scaffoldBuckets.platform} / tool ${scaffoldBuckets.tool}，如 ${scaffoldSamples.join('、')}${scaffoldTotal > scaffoldSamples.length ? ' 等' : ''}）已聚合不逐条列——非交付物（scope-audit 设施桶同口径）`)
   }
 
+  if (Array.isArray(actual.eolOnlyFiles) && actual.eolOnlyFiles.length > 0) {
+    notes.push(`EOL-only 剔除：${actual.eolOnlyFiles.length} 个文件仅行尾差异（--ignore-cr-at-eol 对照零内容变更，如 gen 脚本幂等重生成）已剔出对账面——${actual.eolOnlyFiles.slice(0, 5).join('、')}${actual.eolOnlyFiles.length > 5 ? ' 等' : ''}（.gitattributes 统一行尾可根治）`)
+  }
   // 状态聚合：②在场即 ERROR 态优先（gates 阻断语义靠它兑现）；仅③ → WARNING 态
   const status = missing.length > 0 ? 'missing_declared' : (undeclared.length > 0 ? 'undeclared' : 'ok')
   return { status, matched, missing, undeclared, undeclaredScaffold: scaffoldTotal, skipReason: null, notes, form: actual.form, sources: actual.sources, crossRepo }

package/src/verify-probes.js

@@ -1952,7 +1952,7 @@ function prefillMatrixCells(item, testFiles, hint) {
  * @param {{ applicable: boolean, tasks: Array<{task: string, acceptance: string[], testFiles: string[], hints: Record<number, {terms: string[], files: string[], anchors?: Array<{term: string, file: string, line: number}>}>}> }} p7
  * @returns {string[]} 行数组（含段标题；调用方自理前后空行）
  */
-function renderProbe7Lines(p7) {
+export function renderProbe7Lines(p7) {
   const L = [PROBE7_HEADING]
   if (!p7 || !p7.applicable) {
     L.push('- 不适用（无 TaskCard）')
@@ -1986,8 +1986,12 @@ function renderProbe7Lines(p7) {
     L.push('| acceptance 条目 | 归属测试文件 | 关键词命中（提示，命中≠判定） | 判定 | 证据 |')
     L.push('|---|---|---|---|---|')
     t.acceptance.forEach((item, i) => {
+      // 展示帽（坑 probe-noise-and-commit-suggest-quality 坑A，2026-10-15 消费仓实证：宽目录
+      // allowed_paths 递归把 82 个测试文件全量塞进单格（单行数千字符 ×3 行），信号全淹——照
+      // 探针 3 既有 slice 截断先例收敛为前 5 + 「共 N 个」折叠；路径经 mdEscapeCell 防竖线破表）
       const attribCell = (t.testFiles && t.testFiles.length > 0)
-        ? t.testFiles.map(f => `\`${f}\``).join('<br>')
+        ? t.testFiles.slice(0, 5).map(f => `\`${mdEscapeCell(f, 120)}\``).join('<br>')
+          + (t.testFiles.length > 5 ? `<br>…共 ${t.testFiles.length} 个（目录级候选全量在 facts/trace，归属按关键词命中与证据锚点收窄）` : '')
         : '无归属测试——判定大概率 uncovered'
       const h = (t.hints && t.hints[i]) || null
       const hintCell = h
@@ -2251,7 +2255,9 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
             if (t && isProbe7TestPath(t) && !fromDependents.includes(t)) fromDependents.push(t)
           }
         }
-        const testFiles = [...new Set([...fromAllowed, ...fromReview, ...fromDependents])]
+        // 收集帽（坑 probe-noise-and-commit-suggest-quality 坑A）：目录级 allowed_paths 递归可卷
+        // 入整仓测试树（实证 82 个）——去重后截前 20（展示层另有 5 个硬帽；hints/trace 消费同集）
+        const testFiles = [...new Set([...fromAllowed, ...fromReview, ...fromDependents])].slice(0, 20)
         // 无归属卡注入 FR 关联回归既有用例候选（task-02；有归属卡 existingTests 恒空——零噪音）
         const existingTests = []
         if (frLinkedExisting && testFiles.length === 0) {
@@ -2259,7 +2265,7 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
             if (isProbe7TestPath(f) && !existingTests.includes(f)) existingTests.push(f)
           }
         }
-        const finalTestFiles = existingTests.length > 0 ? [...new Set([...testFiles, ...existingTests])] : testFiles
+        const finalTestFiles = existingTests.length > 0 ? [...new Set([...testFiles, ...existingTests])].slice(0, 20) : testFiles
         probe7.tasks.push({
           task: card.task,
           acceptance: card.acceptance,
@@ -2663,6 +2669,33 @@ const API_MATRIX_HEADING = '## 接口验证覆盖矩阵'
 // 权限矩阵段有对应行或显式豁免（「无权限约束」）——warning 计算归 task-05，此处只定集合。
 const API_MATRIX_WRITE_METHODS = new Set(['POST', 'PUT', 'DELETE', 'PATCH'])
 
+/**
+ * design.md 接口段实况解析面（gate/derive 预检注入用，2026-10-14-gate-verify-apiface-preflight）：
+ * 与 backfillFactsFromMdAndTests 落盘的 facts.apiFace 同形同源（同一 parseDesignApiTable、同一
+ * writeEndpoints 过滤——单一产物源，禁第二套解析文法），零落盘。背景：facts.apiFace 唯一生产者
+ * 是 run verify --done 收尾前置 backfill（run/gates.js），gate 路径不回填且 --init 刻意不落键 →
+ * 预检 parseSet 空/旧 → design接口表# 锚点恒空指（平台 6 轮 gate 实证）。gate 侧经本 helper
+ * 实况解析后经 context.apiFaceLive 注入 validator（stage-contract 零 import 纪律：注入不做
+ * 函数调用），「预检过=必过」对锚点核对成立；design.md 缺失/不可读返回 null（调用方不注入，
+ * 退回 facts 口径——2026-10-14 评审 P1：空面注入会覆写有效 facts.apiFace 反致误阻断）、解析
+ * 异常由调用方 fail-soft 承接（不注入退回 facts）。
+ * @param {string} designPath changeDir/design.md 路径（缺失/不可读 → null=不注入信号）
+ * @returns {{ endpoints: Array<{method: string, path: string, rowIdx: number}>, declared: number|null, writeEndpoints: Array }|null}
+ */
+export function computeApiFaceFromDesign(designPath) {
+  let designText = null
+  if (existsSync(designPath)) {
+    try { designText = readFileSync(designPath, 'utf8') } catch { designText = null }
+  }
+  if (designText === null) return null
+  const face = parseDesignApiTable(designText)
+  return {
+    endpoints: face.endpoints,
+    declared: face.declared,
+    writeEndpoints: face.endpoints.filter(e => e && API_MATRIX_WRITE_METHODS.has(e.method)),
+  }
+}
+
 /**
  * 渲染「## 接口验证覆盖矩阵」段（task-04）。
  * 三态：解析有端点 → 逐端点预填行（判定列 `<待填：五选一>` 占位，同 probe7 预填口径供 agent
@@ -2731,7 +2764,12 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
   // v2（2026-09-08-ir-verify-facts）：probes 机器段原样；conclusion/tests/requiredEvidence/
   // runtimeEvidence/factsConsistency 五段是 slot-backfill/实测回填段（D-001@v2），--init 快照
   // 不落键（writeVerifyFacts 分段合并时保留既有固化段），由 backfillFactsFromMdAndTests 填。
-  return {
+  // apiFace 例外（坑 verify-close-gate-staggered-exposure 建议③连带，2026-10-15 消费仓实证）：
+  // --init 即落键——runVerifyProbes 的 apiFace 与 --done backfill 同源同形（computeApiFaceFromDesign），
+  // 原「刻意不落」使「重跑 --init 刷新 facts」救不了空指预检（报错文案也没提这一点），且空指
+  // 诊断方向被误导去改 design 文档。键只在值在场时出现（undefined 值键会在 writeVerifyFacts
+  // 合并 spread 时覆盖 prev 固化段）。
+  const factsSkeleton = {
     schemaVersion: 2,
     change: changeName,
     generatedAt: now || new Date().toISOString(),
@@ -2796,6 +2834,8 @@ export function buildVerifyFacts(result, { changeName, now } = {}) {
       },
     },
   }
+  if (result && result.apiFace && typeof result.apiFace === 'object') factsSkeleton.apiFace = result.apiFace
+  return factsSkeleton
 }
 
 /**
@@ -2832,7 +2872,16 @@ export function writeVerifyFacts(changeDir, result, changeName, opts = {}) {
   try {
     const prev = JSON.parse(readFileSync(factsPath, 'utf8'))
     if (prev && prev.schemaVersion === FACTS_SCHEMA_VERSION) {
+      // backfill 固化段保留（坑 verify-close-gate-staggered-exposure，2026-10-15）：旧白名单只保
+      // 五段，re-init 会把 --done 回填的 apiFace/consumerHints/handover/dbScriptDeclarations 等
+      // 整个抹掉（--init 后预检又空指）。此处先铺 prev 固化段再被 fresh 覆盖：apiFace 由 fresh
+      // 侧重算（同源 computeApiFaceFromDesign，值应等价），fresh 未带的键原样保留。
+      const preservedBackfill = {}
+      for (const k of ['apiFace', 'consumerHints', 'handover', 'dbScriptDeclarations', 'matrixPartialRows', 'smokeRan']) {
+        if (prev[k] !== undefined) preservedBackfill[k] = prev[k]
+      }
       facts = {
+        ...preservedBackfill,
         ...fresh,
         conclusion: prev.conclusion,
         tests: prev.tests,
@@ -3140,20 +3189,14 @@ export function backfillFactsFromMdAndTests(factsPath, { verifyMd, testCheckResu
   // validator 判 N=0 走零行为注记）；与 runVerifyProbes 同一解析器（单一产物源）。
   {
     const changeDir = dirname(factsPath)
-    const designPath = join(changeDir, 'design.md')
-    let designText = null
-    if (existsSync(designPath)) {
-      try { designText = readFileSync(designPath, 'utf8') } catch { designText = null }
-    }
-    const face = parseDesignApiTable(designText || '')
-    facts.apiFace = {
-      endpoints: face.endpoints,
-      declared: face.declared,
-      writeEndpoints: face.endpoints.filter(e => e && API_MATRIX_WRITE_METHODS.has(e.method)),
-    }
+    // backfill 契约=恒落对象面（缺失/不可读 → 空面，基线口径不变）：helper 的 null 是 gate
+    // 注入通道的「不注入」信号，非 backfill 落盘形态（2026-10-14 评审 P3——null 落盘会让
+    // 「design 蒸发×矩阵段缺失×严格档」窄角从基线 error 降 warning，重构不得夹带行为变化）。
+    facts.apiFace = computeApiFaceFromDesign(join(changeDir, 'design.md'))
+      || { endpoints: [], declared: null, writeEndpoints: [] }
     let designPaths = []
-    if (designText !== null) {
-      try { designPaths = parseFileChangeListDetailed(designPath).map(e => String(e.path)) } catch { designPaths = [] }
+    if (existsSync(join(changeDir, 'design.md'))) {
+      try { designPaths = parseFileChangeListDetailed(join(changeDir, 'design.md')).map(e => String(e.path)) } catch { designPaths = [] }
     }
     facts.consumerHints = classifyConsumerHints(designPaths)
   }

package/templates/agents-instruction.md

@@ -6,15 +6,16 @@
 ## 选道（动手前先对号入座）
 | 需求形态 | 走法 |
 |---|---|
-| 需求已含决策（改什么、成功标准说得清） | **轻量变更（默认快道）**：`flow start` → 直接干活 → `flow done`（2 次协议调用；操作细节见 `/sillyspec:flow` skill 与 flow start 输出） |
-| 需求不清晰 / 需要方案探索 | 头脑风暴预段：`run brainstorm --change <名>` → 完成后 `flow start --change <名>` 收编续跑（design 以头脑风暴版为准） |
+| 需求已含决策（改什么、成功标准说得清——成功标准须来自**用户原话或既有文档转写**；要靠你推断拟出的标准＝需求不清晰） | **轻量变更（默认快道）**：`flow start` → 直接干活 → `flow done`（2 次协议调用；操作细节见 `/sillyspec:flow` skill 与 flow start 输出） |
+| 用户显式要求极速（「极速/别验证/只要 spec 和代码」类原话）且需求已含决策 | **轻量变更极速版**：同上行加 `--turbo`（`flow start --change <名> --input "<...>" --turbo`）——**仅用户显式触发，禁止你自行启用**；收口跳过实测与重仪式门（hunk/dirty/ui 探针/评审），spec 结构校验/tasks 全勾/ledger/patch 冻结/distill/归档照常（跳的是验证不是证据）；升厚即失效恢复全量仪式；收口输出显式标注「不含测试客观核验」。预段组合极速：头脑风暴预段走轻量跑判定+单轮合并问询+burst 一次 --done，收编时按用户要求带 --turbo |
+| 需求不清晰 / 需要方案探索（含「成功标准要你替用户拟」的形态——自己拟标准再自答是把默认共识伪装成共识） | 头脑风暴预段：`run brainstorm --change <名>` → 完成后 `flow start --change <名>` 收编续跑（design 以头脑风暴版为准）。上个轻量变更被 route-hindsight 标记时全新 start 会被同意门拦下要求显式选道：确认已含决策带 `--no-prestage` 声明留痕，否则先走本行预段 |
 | 大改动：跨模块取舍 / Wave 计划编排 / 多阶段治理 / 设计期人机对抗 | 完整流程五阶段：`run brainstorm → plan → execute → verify → archive`（每阶段一次渲染 + 一次 --done 收口；细节见各阶段 skill 与 CLI 输出） |
 | 代码已先写好（倒推收尾） | 不回头补流程装样子：`flow start --change <YYYY-MM-DD-名> --input` 按下方过门格式写（动机=已做改动的描述，成功标准=已验证达标的行为）→ `flow done` 一步收口 |
 
 `--input` 过门格式（轻量道首次调用即过，勿靠报错学；引号内换行合法，下例可照抄）：
 
 ```bash
-sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>
+sillyspec flow start --change <YYYY-MM-DD-名> --input "<一句中文概括（首行即变更标题）；随后动机与背景
 
 成功标准：
 - <可验证标准>"
@@ -30,7 +31,7 @@ sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>
 ## 核心规则
 1. **禁止绕过本文件规则和 SillySpec 流程**。所有变更走 sillyspec 流程，不裸改裸提交。
 2. **改代码前必须先说明依据**——依据的文档路径（design.md / 模块文档 / file-lifecycle.md（如有））或现有代码依据，无依据不改。
-3. **执行顺序**：文档 → 读代码 → 写测试 → 写实现 → 跑测试 → 验收 → 更新文档。
+3. **执行顺序**：文档 → 读代码 → 写测试 → 写实现 → 跑测试 → 验收 → 更新文档。测试按层适用：纯逻辑先写测试，行为契约断言用户可见行为，视觉样式与纯配置/文档不写测试（记「不适用：理由」，验收靠规范与人工）。
 4. **实证核验再收口**：触及 `src`/`test` 的改动，CLI 会在收口时亲自实测（实测失败阻断收口；纯 doc/配置自动跳过）。测试面按变更动态推断（本变更测试 ∪ FR 关联回归 ∪ import 依赖，runner 自项目结构推断——无需配置）；lint 走 `.sillyspec/local.yaml` 的 `commands.lint`。以落盘文件与测试结果为准，不信口头"已完成"。
 5. **非测试逻辑本身有误时，禁止改测试来"通过"**——修逻辑，不修测试。
 6. **git hook 拦截提交时禁止跳过**（如 `.husky/pre-push`），修复问题后再提交。

package/templates/prompts/testcase-design.md

@@ -3,6 +3,11 @@
 写测试是为了拦住回归，不是"有测试文件"。
 **基础习惯照做、不展开**：FIRST（快/独立/可重复/自校验/及时）、金字塔分层（单元为主/集成少量/E2E 只冒烟）、AAA 结构、测试名描述场景、测试数据轻量构造（Object Mother/Builder）、覆盖率不追数字。
 
+**先判该不该写：按层适用**（一句话判据——能写成「当 X 发生时，用户应看到/发生 Y」→ 写测试；只能描述成「看起来更精致/更美观」→ 不写，靠规范与人工验收）：
+- **纯逻辑**（校验规则/数据变换/状态规则/重试策略）→ 严格 test-first：先写测试再实现。
+- **行为契约**（用户做 X 后应看到/发生 Y 的关键交互，组件/API 皆然）→ 断言用户可见行为；主干断言可先行，mock 细节允许实现后补；不为样式类/className 写断言。
+- **视觉样式与纯配置**（颜色/布局/间距/动效；配置/文档/CI）→ 不写测试——断言样式是负资产，改一次样式碎一片；测试绑定记「不适用：<理由>」。
+
 逐条对照检查：
 1. **覆盖**：正常路径 + 边界 + 异常/非法输入，不只写业务正例；单测全绿 ≠ 集成正确。
 2. **断言**：断言真实输出/副作用，禁止只"不抛错"的空断言；不 mock 被测方法自身。