sillyspec 3.32.9 → 3.33.0

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/ui-visual.js

@@ -17,6 +17,8 @@
  */
 import { existsSync, readFileSync } from 'node:fs'
 import { join } from 'node:path'
+import jsYaml from 'js-yaml'
+import { parseRepoRegistry } from './stages/plan-postcheck.js'
 
 export const UI_VISUAL_PROBE_HEADING = '#### 探针 12：UI 视觉证据（分级门）'
 export const UI_EVIDENCE_FILENAME = 'visual-evidence.md'
@@ -48,8 +50,114 @@ export function detectUiTouchInPaths(paths) {
 
 /* ── flow start 须知（仓中立；证据约定与探针同源）── */
 
-export function buildUiGuidanceLines() {
-  return [
+/**
+ * local.yaml ui_prototype 段解析（2026-10-15-ui-proto-form-config，FR-01）。
+ * 每仓原型形态契约：form: real-code | single-html；豁免（single-html）须带 ruling{by,at,reason}
+ * 全三字段（用户裁决留痕——缺任一=登记不完整，消费方须警告）；repos.<子仓键> 同构 override。
+ * fail-soft：段缺席/文件不可读/YAML 坏/值非法 → registered:false 零抛出（与 readUiVisualGate
+ * 同根同哲学）。诚实边界：工具只消费登记与注入指引，不校验原型质量。
+ */
+export function readUiPrototypeForm(specBase) {
+  const empty = { registered: false, form: null, ruling: null, rulingComplete: false, repos: {} }
+  if (!specBase) return empty
+  let raw
+  try {
+    raw = jsYaml.load(readFileSync(join(specBase, 'local.yaml'), 'utf8'))
+  } catch { return empty }
+  const section = raw && typeof raw === 'object' ? raw.ui_prototype : null
+  if (!section || typeof section !== 'object') return empty
+  const parseEntry = (e) => {
+    if (!e || typeof e !== 'object') return null
+    const form = e.form === 'real-code' || e.form === 'single-html' ? e.form : null
+    if (!form) return null
+    const r = e.ruling && typeof e.ruling === 'object' ? e.ruling : null
+    const rulingComplete = !!(r && r.by && r.at && r.reason)
+    return { form, ruling: r, rulingComplete }
+  }
+  const top = parseEntry(section)
+  const repos = {}
+  if (section.repos && typeof section.repos === 'object') {
+    for (const [key, val] of Object.entries(section.repos)) {
+      const entry = parseEntry(val)
+      if (entry) repos[key] = entry
+    }
+  }
+  if (!top) return { registered: false, form: null, ruling: null, rulingComplete: false, repos }
+  return { registered: true, ...top, repos }
+}
+
+/**
+ * 多仓 override 解析（FR-02）：触达路径与 local.yaml repos 注册匹配——子仓若在
+ * ui_prototype.repos 有 override 则该形态优先；未命中走仓级兜底。返回形态条目数组（去重）：
+ * 每项 { scope: '仓级'|'<子仓键>', form, ruling, rulingComplete, registered }。
+ * 匹配三通道（评审 P2 清偿：注入语料常为相对路径，纯绝对前缀会让 override 静默失效）：
+ *   ① 绝对前缀：归一（反斜杠→斜杠/去尾斜杠/大小写不敏感）后 startsWith 注册路径；
+ *   ② 相对键前缀：路径以 `<repoKey>/` 开头（语料常见 `spdemo/src/...` 形态）；
+ *   ③ 相对基名前缀：路径以注册路径 basename + `/` 开头（键与目录名不同名时兜底）。
+ */
+export function resolveUiPrototypeFor(specBase, paths = []) {
+  const proto = readUiPrototypeForm(specBase)
+  const out = []
+  const seen = new Set()
+  const push = (entry) => {
+    const key = `${entry.form}|${entry.rulingComplete}`
+    if (seen.has(key)) return
+    seen.add(key)
+    out.push(entry)
+  }
+  if (paths.length > 0) {
+    let repoPaths = {}
+    try {
+      // 复用既有注册解析（plan-postcheck _parseRepoEntries 同语义出口：字符串条目=路径、
+      // 对象条目取 path 子键）——不走 js-yaml 裸读，防对象形态静默漏配。
+      repoPaths = Object.fromEntries(parseRepoRegistry(readFileSync(join(specBase, 'local.yaml'), 'utf8')))
+    } catch { /* 解析失败=零子仓命中，仓级兜底 */ }
+    const norm = (p) => String(p).replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase()
+    for (const [key, registeredPath] of Object.entries(repoPaths)) {
+      if (typeof registeredPath !== 'string' || !registeredPath) continue
+      const reg = norm(registeredPath)
+      const regBase = reg.split('/').pop()
+      const hit = paths.some((p) => {
+        const np = norm(p)
+        return np.startsWith(reg + '/') || np === reg
+          || np.startsWith(key.toLowerCase() + '/')
+          || np.startsWith(regBase + '/')
+      })
+      const override = proto.repos[key]
+      if (hit && override) push({ scope: key, registered: true, ...override })
+    }
+  }
+  push(proto.registered
+    ? { scope: '仓级', registered: true, form: proto.form, ruling: proto.ruling, rulingComplete: proto.rulingComplete }
+    : { scope: '仓级', registered: false, form: null, ruling: null, rulingComplete: false })
+  return out
+}
+
+/** 须知第 5 节：按形态条目组合「本仓原型形态」行（FR-03 四态；生态命令词禁入——neutrality 契约）。 */
+function uiPrototypeFormLines(entries) {
+  const lines = [`📐 本仓原型形态（local.yaml ui_prototype 登记；工具只查声明在场不验质量）：`]
+  let anyContent = false
+  for (const e of entries) {
+    const scope = e.scope === '仓级' ? '' : `【子仓 ${e.scope}】`
+    if (!e.registered) {
+      anyContent = true
+      lines.push(`   ⚠️ ${scope}未登记原型形态——本次按阶梯执行：有真实前端工具链→定稿原型必须真码；查无真码管线→先单开一个轻量变更搭最小入口（管线建设与业务变更分离），或登记豁免（form: single-html + ruling 用户裁决留痕）。收口前把 local.yaml ui_prototype 登记补上（强提醒，不阻断）。`)
+    } else if (e.form === 'single-html' && !e.rulingComplete) {
+      anyContent = true
+      lines.push(`   ⚠️ ${scope}豁免登记不完整（single-html 缺 ruling{by,at,reason} 某字段）——这是静默漂移入口：补齐用户裁决留痕（by/at/reason）后再依赖豁免；本次仍按阶梯执行。`)
+    } else if (e.form === 'single-html') {
+      anyContent = true
+      lines.push(`   📋 ${scope}豁免生效（single-html；裁决 by=${e.ruling.by} at=${e.ruling.at}）：定稿原型＝自包含 HTML + 真值 token（来源须声明：token 源文件/组件参照），反向翻译税为已裁决接受项。`)
+    } else {
+      anyContent = true
+      lines.push(`   🔒 ${scope}真码契约（real-code）：定稿原型必须与实现同方言真码；查无管线先单开轻量变更搭最小入口（bootstrap 与业务变更分离）。`)
+    }
+  }
+  return anyContent ? lines : []
+}
+
+export function buildUiGuidanceLines(specBase = null, paths = []) {
+  const lines = [
     `🎨 UI 变更执行须知（本变更触及前端页面或 UI——advisory 引导非门禁）：`,
     `   1. 定稿原型必须是可复跑的真码产物（与实现同方言、能被本项目工具链构建）——手绘单文件`,
     `      仅限一次性粗选对比，不作为交付原型（2026-09-28 frontend-apple-style 实证：手绘定稿后每条意见都要反向翻译回真实代码）；`,
@@ -62,6 +170,13 @@ export function buildUiGuidanceLines() {
     `      必须停下找用户签字，裁决记录写进 ${UI_EVIDENCE_FILENAME}（含「用户裁决」字样段）——`,
     `      静默降级会在收口被「UI 视觉证据」探针硬拦（error 门）。`,
   ]
+  if (specBase) {
+    try {
+      const entries = resolveUiPrototypeFor(specBase, paths)
+      lines.push('', ...uiPrototypeFormLines(entries))
+    } catch { /* 登记解析失败零打扰（fail-soft 同 readUiVisualGate） */ }
+  }
+  return lines
 }
 
 /* ── 分级探针 ── */
@@ -173,8 +288,8 @@ export function uiEvidenceExecuteAdvisory({ changeDir, specBase = null }) {
   }
 }
 
-/** design 文件变更清单行的路径粗提（反引号/裸路径行——探针侧仅作 UI 扩展名兜底命中，不追求全解）。 */
-function extractQuotedPaths(designText) {
+/** design 文件变更清单行的路径粗提（反引号/裸路径行——探针侧仅作 UI 扩展名兜底命中，不追求全解；导出供 prompt.js 组子仓 override 匹配路径用）。 */
+export function extractQuotedPaths(designText) {
   if (!designText) return []
   const paths = []
   for (const m of designText.matchAll(/`([^`]+)`/g)) {

package/src/verify-postcheck.js

@@ -2821,6 +2821,31 @@ function inferFullTestCommand(projectRoot) {
  * 相关回归）。组卷改配额制：每组优先面整跑，普通 import 依赖只填剩余席位（可为 0）——帽
  * 只界普通依赖尾。批尺寸上界护栏由 TEST_TIMEOUT_MS 兜底（超时=失败 fail-closed 不变）。
  */
+/**
+ * 批命令长度分块（2026-10-15 平台侧实证，跨仓事故驱动最小修复）：Windows cmd 执行器
+ * 命令行上限 ~8191 字符——大依赖面（广被引用的前端文件变更 → 依赖测试 100+ 个）拼单条
+ * vitest/node --test 命令必炸「命令行太长」exit 1，且失败批进增量账本自我循环恒败
+ * （实测：137 文件批反复重跑复败，verify 门禁无法收口）。按「命令前缀+文件参数拼接
+ * 总长」分块：单块保持原名（零回归），多块命名 <base>:N（N 从 1 起）；每块独立计账。
+ */
+function chunkByCommandLength(prefix, files, maxLen = 6000) {
+  const chunks = []
+  let cur = []
+  let curLen = prefix.length
+  for (const f of files) {
+    const add = f.length + 1
+    if (cur.length > 0 && curLen + add > maxLen) {
+      chunks.push(cur)
+      cur = []
+      curLen = prefix.length
+    }
+    cur.push(f)
+    curLen += add
+  }
+  if (cur.length > 0) chunks.push(cur)
+  return chunks
+}
+
 function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, priorityFiles = [] }) {
   const norm = (p2) => String(p2).replace(/\\/g, '/')
   const changedSet = new Set((changedFiles || []).map(norm))
@@ -2930,10 +2955,11 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   const jsProjectRun = jsProject.filter(f => !E2E_DIR_RE.test(_norm(f)))
   const e2eDroppedFiles = jsProject.filter(f => E2E_DIR_RE.test(_norm(f)))
   let jsxRunner = null
+  let jsxRunnerFromHits = false
   for (const h of hits || []) {
     const cmd = String(h.test || '')
     const m = /^((?:cd\s+[^&|;]+&&\s*)*[^&|;]*?(?:vitest|jest))(?=\s|$)/.exec(cmd) || /(?:^|&&|;|\|\|)\s*([^&|;]*(?:vitest|jest)(?:\s|$))/.exec(cmd)
-    if (m) { jsxRunner = m[1].trim(); break }
+    if (m) { jsxRunner = m[1].trim(); jsxRunnerFromHits = true; break }
   }
   if (!jsxRunner && cwd && jsProjectRun.length > 0) {
     const inferred = inferJsxRunner(cwd, jsProjectRun[0])
@@ -2958,24 +2984,59 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
       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 (jsNative.length > 0) {
+    const jsPrefix = 'node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout '
+    const jsChunks = chunkByCommandLength(jsPrefix, jsNative)
+    jsChunks.forEach((chunk, i) => {
+      const isMulti = jsChunks.length > 1
+      batches.push({ name: isMulti ? `deps(auto-js:${i + 1}/${jsChunks.length})` : 'deps(auto-js)', short: 'js', command: jsPrefix + chunk.join(' '), count: chunk.length, prioCount: chunk.filter(f => prio(f) === 0).length, dropped: i === 0 ? (jsTest.length - jsRun.length) : 0, prioDropped: i === 0 ? jsQ.prioDropped : 0, tap: true, files: chunk })
+    })
+  }
   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 承担' })
 
   if (nonTestFiles.length > 0) batches.push({ name: 'deps(auto-nontest-skip)', short: 'nontest-skip', command: null, count: nonTestFiles.length, dropped: 0, skip: true, files: nonTestFiles, reason: `非测试形态文件 ${nonTestFiles.length} 个不进单测执行批（node --test 语义「文件即测试」/ vitest No test suite found / pytest 0 collected exit 5——直跑必假败；坑 verify-dynamic-subset-node-test-ts-source）：${nonTestFiles.slice(0, 3).join('、')}${nonTestFiles.length > 3 ? ' 等' : ''}——FR 绑定面脏数据可 sillyspec tests --unbind --tests <路径> 清行` })
   if (jsProjectRun.length > 0) {
-    if (jsxRunner) {
-      const isVitest = /vitest/.test(jsxRunner)
-      // jsx 批的 cd 重定基（评审 MEDIUM 清偿）：cdDir 只源 pyRunner——jsxRunner 自带 cd 前缀
-      // （cd frontend && pnpm exec vitest）时文件未重定基产双前缀错路径；独立提取 jsxDir。
-      const jsxDir = /(?:^|\s)cd\s+(\S+)\s*&&/.exec(jsxRunner)?.[1]
-      const rebaseJsx = (f) => (jsxDir && f.startsWith(jsxDir + '/')) ? f.slice(jsxDir.length + 1) : f
-      // R20（2026-09-27-thin-display-fix 实证，用户授权修复）：Windows cmd 执行器对含
-      // 括号/方括号/空格的路径（src/app/(dashboard)/workspaces/[id]/...）不加引号会以
-      // 「此时不应有 <。」语法错误炸整批——文件参数含特殊字符时逐个 wrap 双引号。
-      const quoteWinPath = (f) => (/[()\[\]\s&^%,;!]/.test(f) ? `"${f}"` : f)
-      batches.push({ name: 'deps(auto-jsx)', short: 'jsx', command: `${jsxRunner} ${isVitest ? 'run ' : ''}${jsProjectRun.map(rebaseJsx).map(quoteWinPath).join(' ')}`, count: jsProjectRun.length, dropped: 0, files: jsProjectRun })
-    } else {
-      batches.push({ name: 'deps(auto-jsx-skip)', short: 'jsx-skip', command: null, count: jsProjectRun.length, dropped: 0, skip: true, files: jsProjectRun, reason: `JSX 测试文件（tsx/jsx，${jsProjectRun.length} 个）node 原生不可跑且项目结构无 vitest/jest 运行器可推断——转项目运行器执行并如实披露，不制造恒败段（R18-SF-full 残差段 11 连败的坑）` })
+    // R20（2026-09-27-thin-display-fix 实证，用户授权修复）：Windows cmd 执行器对含
+    // 括号/方括号/空格的路径（src/app/(dashboard)/workspaces/[id]/...）不加引号会以
+    // 「此时不应有 <。」语法错误炸整批——文件参数含特殊字符时逐个 wrap 双引号。
+    const quoteWinPath = (f) => (/[()\[\]\s&^%,;!]/.test(f) ? `"${f}"` : f)
+    // jsx 批按包根分组（2026-10-15-zcode-engine-appserver verify 实证，跨仓事故驱动修复）：
+    // 混合包根（frontend/ 的 tsx 测试 + sillyhub-daemon/ 的 ts 测试同批）共享单一 runner
+    // 前缀时，非本根路径在 runner 的 cwd 下「No test files found」exit 1 恒败（分块修复
+    // 后暴露：第二块全 daemon 路径仍跑 cd frontend）。与 pyGroups 同款：每文件按最近
+    // package.json 推断自身 runner/根；显式命中命令（hits）保持整批单组旧语义。
+    const jsxGroups = new Map() // key: 组命令前缀
+    const jsxUngrouped = []
+    for (const f of jsProjectRun) {
+      // 命中命令（hits）→ 整批单组旧语义；全局推断（jsProjectRun[0]）仅兜底，逐文件按自身包根推断优先。
+      let command = null
+      let dirKey = null
+      if (!jsxRunnerFromHits && cwd) {
+        const inferred = inferJsxRunner(cwd, f)
+        if (inferred) { command = inferred.command; dirKey = inferred.dir || null }
+      }
+      if (!command) command = jsxRunner
+      if (!command) { jsxUngrouped.push(f); continue }
+      if (!jsxGroups.has(command)) jsxGroups.set(command, { files: [], dirKey })
+      jsxGroups.get(command).files.push(f)
+    }
+    const multiGroup = jsxGroups.size > 1
+    for (const [command, grp] of jsxGroups) {
+      const isVitest = /vitest/.test(command)
+      const jsxPrefix = `${command} ${isVitest ? 'run ' : ''}`
+      const grpDir = grp.dirKey || /(?:^|\s)cd\s+(\S+)\s*&&/.exec(command)?.[1] || null
+      const rebaseJsx = (f) => (grpDir && f.startsWith(grpDir + '/')) ? f.slice(grpDir.length + 1) : f
+      const jsxArgs = grp.files.map(rebaseJsx).map(quoteWinPath)
+      const jsxChunks = chunkByCommandLength(jsxPrefix, jsxArgs)
+      const baseName = multiGroup ? `deps(auto-jsx:${grp.dirKey || 'root'})` : 'deps(auto-jsx)'
+      jsxChunks.forEach((chunk, i) => {
+        const isMulti = jsxChunks.length > 1
+        batches.push({ name: isMulti ? `${baseName}:${i + 1}/${jsxChunks.length}` : baseName, short: 'jsx', command: jsxPrefix + chunk.join(' '), count: chunk.length, dropped: 0, files: chunk })
+      })
+    }
+    if (jsxUngrouped.length > 0) {
+      // 无运行器可推断的文件（含 !jsxRunner && !cwd 全量形态）：skip 批如实披露（原整批 skip 语义按文件收窄）。
+      batches.push({ name: multiGroup || jsxGroups.size > 0 ? 'deps(auto-jsx-skip:unresolved)' : 'deps(auto-jsx-skip)', short: 'jsx-skip', command: null, count: jsxUngrouped.length, dropped: 0, skip: true, files: jsxUngrouped, reason: `JSX 测试文件（tsx/jsx，${jsxUngrouped.length} 个）node 原生不可跑且各自最近 package.json 无 vitest/jest 运行器可推断——转项目运行器执行并如实披露，不制造恒败段（R18-SF-full 残差段 11 连败的坑）` })
     }
   }
   if (e2eDroppedFiles.length > 0) {
@@ -3042,6 +3103,26 @@ function traceRepoRoots({ specBase, cwd }) {
 }
 
 /** 残差解析：active·非 superseded·锚命中的 trace 行 → { anchors, rows, files, dangling, perFile } */
+/**
+ * 主仓侧候选解析根（worktree 感知；2026-10-15-zcode-engine-appserver verify 实证，跨仓
+ * 事故驱动最小修复）：变更在隔离 worktree 内实现时，新增测试文件在主仓根不可见——
+ * 悬空判定对主仓文件按「主仓根 ∪ 变更 worktree 根」多根解析（任一存在即非悬空）；
+ * 残差执行根同款（文件在 worktree 存在则从 worktree 根跑）。meta 缺失/不可读 → 仅主仓。
+ */
+function traceMainRoots({ specBase, changeName, cwd }) {
+  const roots = [cwd]
+  try {
+    const metaPath = join(specBase, '.runtime', 'worktrees', changeName, 'meta.json')
+    if (existsSync(metaPath)) {
+      const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+      if (meta && typeof meta.worktreePath === 'string' && meta.worktreePath && existsSync(meta.worktreePath) && meta.worktreePath !== cwd) {
+        roots.push(meta.worktreePath)
+      }
+    }
+  } catch { /* meta 不可读 → 仅主仓（零回归） */ }
+  return roots
+}
+
 export function resolveTraceResidual({ specBase, changeName, cwd }) {
   const anchors = resolveVerifyAnchorSet({ specBase, changeName })
   if (anchors.length === 0) return { anchors, rows: [], files: [], dangling: [], perFile: [] }
@@ -3050,6 +3131,7 @@ export function resolveTraceResidual({ specBase, changeName, cwd }) {
   // tests 条目可携带用例锚（2026-09-26-binding-anchor-fidelity）——文件面/悬空判定走剥锚。
   // FR-06（2026-10-09）：文件按行 repo 归属配对（perFile），悬空判定/残差执行按行根解析。
   const repoRoots = traceRepoRoots({ specBase, cwd })
+  const mainRoots = traceMainRoots({ specBase, changeName, cwd })
   const seen = new Set()
   const perFile = []
   for (const r of rows) {
@@ -3061,8 +3143,13 @@ export function resolveTraceResidual({ specBase, changeName, cwd }) {
     }
   }
   const files = [...new Set(perFile.map(x => x.file))].sort()
+  // 主仓文件多根解析：解析到 worktree 根则记录 resolvedRoot（残差执行同款消费）。
+  for (const x of perFile) {
+    if (x.repo) { x.resolvedRoot = repoRoots.get(x.repo) || cwd; continue }
+    x.resolvedRoot = mainRoots.find(root => existsSync(resolve(root, x.file))) || cwd
+  }
   const dangling = perFile
-    .filter(x => !existsSync(resolve((x.repo && repoRoots.get(x.repo)) || cwd, x.file)))
+    .filter(x => !existsSync(resolve(x.resolvedRoot, x.file)))
     .map(x => x.repo ? `${x.repo}:${x.file}` : x.file)
   return { anchors, rows, files, dangling, perFile }
 }
@@ -3141,7 +3228,8 @@ export function applyTraceResidual({ mainResult, action, cwd, specBase, changeNa
   for (const x of (tr.perFile || [])) {
     if (provable.has(String(x.file).replace(/\\/g, '/'))) continue
     const _rk = x.repo || null
-    const _root = (_rk && _repoRoots.get(_rk)) || cwd
+    // worktree 感知（同悬空判定口径）：主仓行按 resolvedRoot（主仓或变更 worktree 根）取执行根。
+    const _root = (_rk && _repoRoots.get(_rk)) || x.resolvedRoot || cwd
     const _gk = _rk + '' + _root
     if (!_gmap.has(_gk)) _gmap.set(_gk, { repo: _rk, root: _root, files: [] })
     _gmap.get(_gk).files.push(x.file)
@@ -3284,8 +3372,20 @@ export function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures
     // not ok 以测试文件为套件名（not ok N - test/b.test.mjs），用判账行集匹配批内文件名把
     // 「批失败」收窄到「文件失败」；归因不出（非 TAP/行集缺文件名）保守全记批文件。
     failedFiles: (() => {
+      // 基建失败甄别（坑 verify-incremental-rerun-infra-batch-growth，2026-10-15 两变更实证：
+      // Windows argv 超限/runner 启动失败类批失败无任何测试级失败行，重跑不可能转绿——计入
+      // 前轮失败批只会让增量面随轮膨胀（141→159 自锁）。判据：输出无 not ok/FAILED/ERROR/
+      // AssertionError 任何测试级痕迹，且 reason 命中基建关键词（命令行太长/E2BIG/spawn/
+      // Cannot find module/No test files found）——此类批不进失败批账本，loud 留痕供人工。
+      const INFRA_REASON_RE = /命令行太长|E2BIG|spawn|Cannot find module|No test files found|ENAMETOOLONG/i
+      const TEST_FAILURE_RE = /not ok \d|FAILED|ERROR|AssertionError|assert/i
       const out = new Set()
       for (const r of perModule.filter(x => x.status === 'failed')) {
+        const text = String(r.outputFull || r.outputTail || '')
+        if (!TEST_FAILURE_RE.test(text) && INFRA_REASON_RE.test(String(r.reason || '') + text)) {
+          console.warn(`⚠️ 批 ${r.name} 判定基建失败（${String(r.reason || 'runner 层失败').slice(0, 80)}）——不进增量失败批账本（重跑不可能转绿），修复基建后整轮重测`)
+          continue
+        }
         for (const f of attributeFailedFiles(r)) out.add(f)
       }
       return [...out].sort()
@@ -4223,6 +4323,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 兜底）= 典型「主仓被
@@ -4232,7 +4377,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 }
 }
 
 /**
@@ -4462,6 +4607,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 }