sillyspec 3.32.9 → 3.32.10

package/src/stage-review.js

@@ -366,6 +366,31 @@ export function stageReviewMarkerPath(runtimeRoot, stage, changeName) {
   return join(runtimeRoot, `current-stage-review-run-id-${suffix}`)
 }
 
+/**
+ * stage review 目录读侧归一（坑 stage-review-dir-naming-mismatch，2026-10-15 消费仓三阶段
+ * 连环实证）：规范目录 = `<stage>-<runId>`（runId 自带 review- 前缀，拼出来恰一次 review 字样）。
+ * skill 文档字面 `<stage>-review-<run-id>` + 「run-id 必须 review- 前缀」诱导出两类错位目录：
+ *   ① 裸 runId 目录（agent 拿 marker 值当目录名）：<runId>/
+ *   ② 双前缀目录（字面拼装）：<stage>-review-<runId>/
+ * 本助手按 规范 → ②双前缀 → ①裸 runId 顺序探测 review.json 在场性，返回首个命中目录；全不在
+ * 则返回规范目录（保持既有「期望路径」报错文案语义）。只读不搬文件——写入侧恒规范路径，读侧
+ * 容错让 gate / refresh-hash / autoRefresh 对错位文件天然可用。
+ * @param {string} runtimeRoot - .runtime 绝对路径
+ * @param {string} stage - brainstorm|plan|execute
+ * @param {string} reviewRunId - run id（review-<ts>）
+ * @returns {string} review 目录绝对路径（容错命中或规范缺省）
+ */
+export function resolveStageReviewDir(runtimeRoot, stage, reviewRunId) {
+  const base = join(runtimeRoot, 'stage-reviews')
+  const canonical = join(base, `${stage}-${reviewRunId}`)
+  const doublePrefix = join(base, `${stage}-review-${reviewRunId}`)
+  const bare = join(base, reviewRunId)
+  for (const dir of [canonical, doublePrefix, bare]) {
+    if (existsSync(join(dir, 'review.json'))) return dir
+  }
+  return canonical
+}
+
 /**
  * 获取最新的 stage review run id
  *
@@ -395,33 +420,37 @@ export function getLatestStageReviewRunId(runtimeRoot, stage, changeName) {
     }
   } catch {}
 
-  // fallback：扫描 stage-reviews/<stage>-review-* 目录取字典序最新（向后兼容无 marker 旧数据）
+  // fallback：扫描 stage-reviews/ 目录取字典序最新（向后兼容无 marker 旧数据）。候选两形：
+  // 规范/双前缀 `<stage>-review-*` + 裸 runId `review-*`（坑 stage-review-dir-naming-mismatch
+  // 错位目录——裸目录不编码 stage，须 reviewType 归属校验防跨段误认）
   const dir = join(runtimeRoot, 'stage-reviews')
   if (!existsSync(dir)) return null
   try {
     const entries = readdirSync(dir, { withFileTypes: true })
-      .filter(e => e.isDirectory() && e.name.startsWith(`${stage}-review-`))
-      .map(e => e.name)
-      .sort()
+      .filter(e => e.isDirectory() && (e.name.startsWith(`${stage}-review-`) || e.name.startsWith('review-')))
+      .map(e => ({ name: e.name, runId: e.name.startsWith(`${stage}-`) ? e.name.slice(stage.length + 1) : e.name }))
+      .sort((a, b) => (a.name < b.name ? -1 : 1))
       .reverse()
     if (!entries[0]) return null
     // cross-change 防护（execute 复盘 b1）：changeName 提供时按 review.json 的 reviewedFiles[0] 归属过滤。
     // 契约 reviewedFiles[0] = `changes/<change>/<mainDoc>`（renderReviewJsonContract），据此排除他变更的 review，
     // 否则批量完成 marker 缺失时可能读到 proxy 等其他变更的 acceptance review 报错误导。
+    // 裸目录另加 reviewType 校验（STAGE_REVIEW_TYPE 段专属，防他 stage 的错位文件串台）。
     if (changeName) {
       const matching = entries.find(e => {
         try {
-          const rj = JSON.parse(readFileSync(join(dir, e, 'review.json'), 'utf8'))
+          const rj = JSON.parse(readFileSync(join(dir, e.name, 'review.json'), 'utf8'))
+          if (!e.name.startsWith(`${stage}-`) && rj.reviewType && rj.reviewType !== STAGE_REVIEW_TYPE[stage]) return false
           const r0 = Array.isArray(rj.reviewedFiles) ? String(rj.reviewedFiles[0]) : ''
           return r0.includes(`changes/${changeName}/`)
         } catch { return false }
       })
-      if (matching) return matching.slice(stage.length + 1)
+      if (matching) return matching.runId
       console.warn(`⚠️ 无 ${stage} 的 review marker，且 stage-reviews/ 下无归属变更 ${changeName} 的 review（reviewedFiles 应含 changes/${changeName}/）；为避免跨变更串台不再取最新，返回 null（fail-closed，由调用方报缺 review.json）`)
       return null
     }
-    // entries[0] = "plan-review-2026-..."，剥掉 `${stage}-` 前缀得到 runId "review-2026-..."
-    return entries[0].slice(stage.length + 1)
+    // 规范形 "plan-review-2026-..." 剥 `${stage}-` 前缀得 runId；裸形目录名即 runId
+    return entries[0].runId
   } catch {
     return null
   }
@@ -613,7 +642,8 @@ export function validateStageReview(opts) {
   const errors = []
   const warnings = []
 
-  const reviewDir = join(runtimeRoot, 'stage-reviews', `${stage}-${reviewRunId}`)
+  // 读侧目录归一（坑 stage-review-dir-naming-mismatch）：容错命中裸 runId / 双前缀错位目录
+  const reviewDir = resolveStageReviewDir(runtimeRoot, stage, reviewRunId)
   const reviewPath = join(reviewDir, 'review.json')
 
   if (!reviewRunId || !existsSync(reviewPath)) {
@@ -705,7 +735,7 @@ export function validateStageReviewWithAutoRefresh(opts) {
     && result.errors.every(e => String(e).includes('docHash 与主审查文档'))
   if (!mismatchOnly) return { result, autoRefreshed: false }
 
-  const reviewDir = join(opts.runtimeRoot, 'stage-reviews', `${opts.stage}-${opts.reviewRunId}`)
+  const reviewDir = resolveStageReviewDir(opts.runtimeRoot, opts.stage, opts.reviewRunId)
   const reviewPath = join(reviewDir, 'review.json')
   // 定位主文档并重算 hash（与 verifyStageReviewDocHash 同法：reviewedFiles[0] × searchDirs）
   const primaryRel = Array.isArray(result.review.reviewedFiles) ? result.review.reviewedFiles[0] : null
@@ -922,8 +952,11 @@ export function registerStageReview({ changeName, stage, fromFile, cwd, platform
   if (refreshHash) {
     if (fromFile) throw new Error('register-stage-review: --refresh-hash 与 --from 互斥（refresh 就地更新既有 review，adopt 引入新文件）')
     const existingRunId = getLatestStageReviewRunId(runtimeRoot, stage, changeName)
+    // 读侧目录归一（坑 stage-review-dir-naming-mismatch）：--refresh-hash 按 marker 取 runId 后
+    // 经 resolveStageReviewDir 容错定位——review.json 落在裸 runId / 双前缀错位目录也能刷新，
+    // 不再恒报「无对应 run」。
     const existingPath = existingRunId
-      ? join(runtimeRoot, 'stage-reviews', `${stage}-${existingRunId}`, 'review.json')
+      ? join(resolveStageReviewDir(runtimeRoot, stage, existingRunId), 'review.json')
       : null
     if (!existingPath || !existsSync(existingPath)) {
       throw new Error(`register-stage-review: --refresh-hash 找不到 ${stage} 的既有 review.json（marker ${existingRunId || '无'} 无对应 run）——先去掉 --refresh-hash 生成骨架，或派审查子代理产出 review`)

package/src/stage-templates.js

@@ -120,6 +120,8 @@ created_at: <now-datetime>
 - normalized_requirement: 可测试的约束
 - impacts: [FR-01, task-01, verify-01]
 - evidence: 用户回答轮次或代码/文档路径
+- 否决理由: <一句话核心劣势>（status=rejected 时必填——distill 入库前置要求，缺失则该条目不进知识库防复潮通道）
+- 复潮条件: <何种信号下可重议本方案>（status=rejected 时必填）
 \`\`\`
 
 > 可选字段（按需另加，旧格式决策缺这些字段不受影响）：**锚点**（决策落点主文件，\`<src 路径>:<行号或符号>\`；status=confirmed 时必填）；**模块域**（决策涉及的模块 ID，可多个逗号分隔——合法 id 只取**当前变更所属项目**的 \`{SPEC_ROOT}/docs/<project>/modules/_module-map.yaml\`，多项目仓勿读其他子项目的 map（核验不认，报错会点名归属）；规划中的新模块用 \`NEW:<名>\` 前缀声明，冒号后不加空格：\`NEW:foo\` 合法、\`NEW: foo\` 属书写错误。「生成规范文件」步 --done 的模块域核验对不认识的 id 直接阻断）；**否决理由**（status=rejected 时必填）；**复潮条件**（status=rejected 时必填）；**故障面**（本决策引入的新失败模式——新机制落地时留痕它引入什么失败模式；type=architecture 时建议填写，可选）；**退役判据**（出现什么信号时简化或删除本机制——信号出现就该简化它；type=architecture 时建议填写，可选）。

package/src/stages/brainstorm.js

@@ -58,7 +58,7 @@ export const definition = {
 - **明显 small**（满足：单上下文可吞吐的纯执行类——改文案/修 bug/样式调整/配置微调，预计无 Wave 编排/上下文分片需求）→ 输出：「此变更规模较小，建议直接走轻量变更」+ 一句依据，给出可照抄建议命令（--input 引号内换行合法）：
 
 \`\`\`
-sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>
+sillyspec flow start --change <YYYY-MM-DD-名> --input "<一句中文概括（首行即变更标题）；随后动机与背景
 
 成功标准：
 - <可验证标准>"
@@ -188,6 +188,8 @@ sillyspec flow start --change <YYYY-MM-DD-名> --input "<动机与背景>
 - evidence: <文件路径/代码位置/用户回答轮次>（源码引用写仓根相对全路径+行号，如 src/stage-contract.js:789——裸文件名在 docs-check 层1 靠 basename 全仓扫描找候选，找不到候选或关键词窗口不匹配即失效，到 pre-push 才拦，2026-09-19 实证 64 处返工）
 - 故障面: <本决策引入的新失败模式>（可选，type=architecture 时建议填写）
 - 退役判据: <出现什么信号时简化/删除本机制>（可选，type=architecture 时建议填写）
+- 否决理由: <一句话核心劣势>（status=rejected 时必填——distill 入库前置要求，缺失则该条目不进知识库防复潮通道）
+- 复潮条件: <何种信号下可重议本方案>（status=rejected 时必填）
 \`\`\`
 
 - 幂等：写入前按 D-xxx@vN 查重，已存在的不重复追加；后续修正走新版本 D-001@v2 + supersedes（见 Design Grill 版本规则）
@@ -491,6 +493,8 @@ ${REVIEW_CHECKLISTS.brainstorm.slice(3).map((item) => '- ' + item).join('\n')}
 - evidence: design.md §3/§7, src/cache/...
 - 故障面: <本决策引入的新失败模式>（可选，type=architecture 时建议填写）
 - 退役判据: <出现什么信号时简化/删除本机制>（可选，type=architecture 时建议填写）
+- 否决理由: <一句话核心劣势>（status=rejected 时必填——distill 入库前置要求，缺失则该条目不进知识库防复潮通道）
+- 复潮条件: <何种信号下可重议本方案>（status=rejected 时必填）
 \`\`\`
 
 ### 输出格式

package/src/stages/knowledge.js

@@ -110,8 +110,16 @@ export async function cmdSearch(dir, args, opts = {}) {
   // 复用 knowledge-match 引擎（三层 hybrid：路由→平台向量→本地词片，2026-09-29-knowledge-vector-recall）
   const result = await matchKnowledgeHybrid(knowledgeDir, query, { cwd: dir })
 
+  // 向量开关发现性提示（2026-10-15-vector-switch-discoverability）：平台已连接+开关未开
+  // （缺省关）→ hint 键（vectorSwitchHint 单源，flow 注入零命中行同款文案）；其余空串零输出。
+  let vectorHint = ''
+  try {
+    const { vectorSwitchHint } = await import('../knowledge-vector.js')
+    vectorHint = vectorSwitchHint(dir)
+  } catch { /* 提示 fail-open */ }
+
   if (!result.matched) {
-    output(true, { query, matches: [] })
+    output(true, { query, matches: [], ...(vectorHint ? { hint: vectorHint } : {}) })
     return
   }
 
@@ -139,7 +147,7 @@ export async function cmdSearch(dir, args, opts = {}) {
     }
   })
 
-  output(true, { query, matches })
+  output(true, { query, matches, ...(vectorHint ? { hint: vectorHint } : {}) })
 }
 
 // ── inspect ──
@@ -610,7 +618,8 @@ export async function cmdKnowledge(args, dir, opts = {}) {
       '  digest                治理信号卡（rot/伪域/坏绑定——纯读）',
       '  stats                 覆盖率/死条目统计（纯读）',
       '  refresh               重扫 scan 文档重写 generated/ 区（**写盘**——先 validate 再用）',
-      '  propose / classify / inbox / graph / stats',
+      '  propose / classify / inbox / graph / stats / renumber',
+      '  renumber [--dry-run|--apply]  存量决策号迁移为全局号（dry-run 先行；apply 写盘幂等）',
       '',
       '写盘面子命令（refresh/propose/classify）先跑同名只读命令确认现状；探索用法先看本帮助。',
     ]
@@ -693,11 +702,53 @@ export async function cmdKnowledge(args, dir, opts = {}) {
       }
       return
     }
+    case 'renumber': {
+      // 存量决策号一次性迁移（2026-10-14-decision-legacy-renumber）：--dry-run 打印计划，
+      // --apply 执行重写（快照指纹校验 + 原子写；重跑幂等——原编号在场节段零触碰）。
+      const specBase = opts.specDir || join(dir, '.sillyspec')
+      const rest = args.slice(1)
+      const apply = rest.includes('--apply')
+      try {
+        const { planRenumber, applyRenumberPlan } = await import('../decision-renumber.js')
+        const plan = planRenumber(join(specBase, 'knowledge'))
+        const st = plan.stats
+        console.log(`🗺️ 决策号迁移计划：legacy ${st.legacySections} 节段｜fanout ${st.fanoutGroups} 组（${st.fanoutCopies} 副本→单一身份）｜发号 ${st.mintedNumbers}｜无变更条目 ${st.noChangeEntries}（逐节独立发号）｜epoch 零触碰 ${st.untouchedEpoch}`)
+        for (const [dom, n] of Object.entries(st.perDomainStart)) console.log(`   域 ${dom}：号段自 ${String(n).padStart(3, '0')} 起`)
+        if (!apply) {
+          console.log('（--dry-run 形态——加 --apply 执行重写；git 可回退）')
+          output(true, { subcommand: 'renumber', dryRun: true, ...st })
+          return
+        }
+        if (plan.files.every((f) => !f.ops || f.ops.length === 0)) {
+          console.log('✅ 无可迁移节段（幂等重跑——零变化）')
+          output(true, { subcommand: 'renumber', filesWritten: 0, ...st })
+          return
+        }
+        let filesWritten = 0
+        for (const fe of plan.files) {
+          if (!fe.ops || !fe.ops.length) continue
+          const p = join(specBase, 'knowledge', fe.file)
+          const cur = readFileSync(p, 'utf8')
+          if (cur !== fe.content) {
+            console.error(`❌ 快照漂移：${fe.file} 在计划后被并行修改——中止不覆盖（重跑重新计划）`)
+            process.exitCode = 1
+            return
+          }
+          writeAtomicSync(p, applyRenumberPlan(new Map([[fe.file, cur]]), plan).get(fe.file))
+          filesWritten++
+        }
+        console.log(`✅ 迁移完成：${filesWritten} 文件重写、${st.mintedNumbers} 号铸出（epoch 形态）——重跑 --apply 验证零变化；平台侧随后 platform sync 推送`)
+        output(true, { subcommand: 'renumber', filesWritten, ...st })
+      } catch (e) {
+        output(false, {}, { code: 'renumber_failed', message: String((e && e.message) || e) })
+      }
+      return
+    }
     default:
       output(false, {}, {
         code: 'unknown_subcommand',
-        subcommand: subCommand,
-        available: ['search', 'inspect', 'validate', 'refresh', 'propose', 'classify', 'inbox', 'stats', 'digest', 'graph'],  // dump 随 graph 路由面（2026-10-09-graph-dump-layout）
+        subCommand: subCommand,
+        available: ['search', 'inspect', 'validate', 'refresh', 'propose', 'classify', 'inbox', 'stats', 'digest', 'graph', 'renumber'],  // dump 随 graph 路由面（2026-10-09-graph-dump-layout）
       })
   }
 }

package/src/sync.js

@@ -273,6 +273,32 @@ function combineSignals(external, timeoutMs = REQUEST_TIMEOUT_MS) {
   return external ? AbortSignal.any([timeoutSignal, external]) : timeoutSignal;
 }
 
+/**
+ * 非 2xx 回显折叠（坑 probe-noise-and-commit-suggest-quality 坑C，2026-10-15 消费仓实证：
+ * 409 冲突响应体含整段 platform_progress 大对象，text.slice(0,200) 密排回显挂在每条 CLI 命令
+ * 尾部刷屏）。结构化冲突体折叠为一行摘要（conflict 标识 + 关键时间戳/变更字段，不回显大
+ * 对象）；其他 JSON 体打键名摘要；非 JSON/解析失败退回截断原文（既有形态零回归）。
+ */
+export function formatSyncHttpErrorLine(method, url, status, text) {
+  const raw = String(text || '');
+  let body = null;
+  try { body = JSON.parse(raw); } catch { body = null; }
+  const m = method || 'GET';
+  if (body && typeof body === 'object') {
+    if (body.conflict === true) {
+      const parts = ['conflict'];
+      if (body.change) parts.push(`change=${body.change}`);
+      if (typeof body.last_pushed_at === 'string') parts.push(`last_pushed_at=${body.last_pushed_at}`);
+      if (body.base_ts !== undefined) parts.push(`base_ts=${body.base_ts}`);
+      if (body.reason) parts.push(`reason=${String(body.reason).slice(0, 80)}`);
+      return `[sync] ${m} ${url} → ${status} ${parts.join(' ')}（冲突响应体已折叠为一行）`;
+    }
+    const keys = Object.keys(body).slice(0, 6).join(',');
+    return `[sync] ${m} ${url} → ${status} ${keys ? `json(${keys})` : '(空响应体)'}`;
+  }
+  return `[sync] ${m} ${url} → ${status} ${raw.slice(0, 200)}`;
+}
+
 async function fetchJson(url, options = {}) {
   const signal = combineSignals(options.signal);
   // noMute 是本模块的闸门开关不是 fetch 参数，先剥掉再透传
@@ -281,7 +307,7 @@ async function fetchJson(url, options = {}) {
     const res = await fetch(url, { ...init, signal });
     if (!res.ok) {
       const text = await res.text().catch(() => '');
-      const line = `[sync] ${options.method || 'GET'} ${url} → ${res.status} ${text.slice(0, 200)}`;
+      const line = formatSyncHttpErrorLine(options.method, url, res.status, text);
       // 连接类失败（404=端点未就绪 / 5xx）走跨进程噪音闸：平台未就绪期每条命令的自动
       // 同步都撞同一批失败，重复刷屏淹没门禁输出（见 sync-noise.js 模块头）。409 冲突与
       // 其余 4xx 业务态每轮都该看见，不走闸。用户显式命令（connect health ping）传 noMute。
@@ -320,7 +346,7 @@ async function fetchJsonWithStatus(url, options = {}) {
       try { body = JSON.parse(text); } catch { body = null; }
     }
     if (!res.ok) {
-      const line = `[sync] ${options.method || 'GET'} ${url} → ${res.status} ${text.slice(0, 200)}`;
+      const line = formatSyncHttpErrorLine(options.method, url, res.status, text);
       if (!noMute && isConnectionClassStatus(res.status)) syncConnectionWarn(line);
       else console.warn(line);
     }

package/src/task-tick.js

@@ -145,6 +145,18 @@ export async function runTaskTick({ changeName, cwd, taskId, specBase, evidence
         ...(ev.text ? { evidence: ev.text.slice(0, 300) } : {}), // 事件面截 300 字符（全文在 task-evidence.jsonl）
       }) + '\n', 'utf8')
     } catch { /* 事件 best-effort：写失败翻格不受影响（节奏门退回采样判） */ }
+    // 侧车勾选留痕（2026-10-14-timeline-ticktime-anchor-scope）：{ts,task,source} 追加进 change 目录
+    // 的 task-ticks.jsonl——勾选时刻的事实源（timeline 任务面精确时刻），落 change 目录随归档进 git
+    // 跨机可读，不随 .runtime 机本位/观测盲窗蒸发（2026-10-14-deploy-release-notes 实证：盲窗内
+    // 勾选两个记录面全空）。事件面不带任务 id（节奏门只读 checked N→M），id 口径以本侧车为权威。
+    // best-effort：写失败仅告警，翻格不受影响（timeline 退事件流推断）。
+    try {
+      appendFileSync(join(changesRoot, changeName, 'task-ticks.jsonl'), JSON.stringify({
+        ts: Date.now(), task: normalizeTaskId(taskId) || taskId, source: 'task-tick',
+      }) + '\n', 'utf8')
+    } catch (e) {
+      console.warn(`⚠️ 勾选留痕写失败（task-ticks.jsonl：${e && e.code ? e.code : e}）——翻格不受影响，timeline 勾选时刻退事件流推断`)
+    }
     // 工件即时重推（2026-10-07-allticked-gate-docs-resync）：翻格即任务面变更——顺带触发
     // spec-sync，平台不再停留 start 时点快照（真实会话实证：改写后平台恒显初稿）。best-effort。
     try {

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

@@ -4223,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 兜底）= 典型「主仓被
@@ -4232,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 }
 }
 
 /**
@@ -4462,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 }