sillyspec 3.32.6 → 3.32.7

package/src/index.js

@@ -85,6 +85,9 @@ SillySpec CLI — 规范驱动开发工具包
     cleanup <change> [--force]          清理 worktree
     doctor [--fix] [--stale-hours N]    健康检查 + 修复
         --cleanup-ghosts [--confirm]     归档幽灵 active 记录（db 有行无目录 / 空壳目录 0 文件超 7 天，SS-2/2b）
+        --prune-cross-worktrees [--confirm]  清跨仓仓幽灵 worktree 注册（目录已删注册残留——dry-run 预览，--confirm 执行 prune；locked 条目只提示）
+
+  sillyspec patch-reanchor --change <名>   归档收口留痕锚点回写主仓（worktree 收口后 apply 重放致 baseline/head 悬空的修复；幂等，doctor 检出时指路至此）
 
   sillyspec local detect [--dir <path>]   生成本地配置 local.yaml（纯 fs 嗅探，零 token、不跑 scan）
   sillyspec local register-repo <key> <path>  注册跨仓仓到 local.yaml repos: 段（外科手术式写入，其余内容保留）
@@ -410,6 +413,12 @@ async function main() {
     console.error('   非 init/scan 类命令需要已初始化的项目根。');
     console.error('   修复：① cd 回项目根（含 .sillyspec 的目录）再跑；② 新项目先 sillyspec init（棕地项目 sillyspec scan）；③ 或 --spec-dir <路径> 显式指定 .sillyspec 位置。');
     console.error('   查询/诊断类命令（status/doctor/progress/next/knowledge 等）不受此拦。');
+    // 跨仓精确指路（2026-10-12-cli-friction-signal）：register-repo 登记过的子仓跑 CLI——
+    // 通用三出路之上叠加登记事实与工作区路径（dogfood：三连跑错目录靠人工发现）。无标记零变化。
+    if (uninitGate.crossRepo) {
+      console.error(`   🎯 此仓已登记为 SillySpec 工作区的跨仓${uninitGate.crossRepo.key ? `「${uninitGate.crossRepo.key}」` : ''}——工作区根：${uninitGate.crossRepo.workspace}`);
+      console.error(`      请回工作区根运行本命令，或 --dir "${uninitGate.crossRepo.workspace}" 显式指定。（标记：${uninitGate.gitRoot}/.git/sillyspec-crossrepo.json）`);
+    }
     process.exit(2);
   }
   if (uninitGate.verdict === 'pass' && uninitGate.anchor && resolve(dir) !== uninitGate.anchor) {
@@ -923,6 +932,9 @@ task done 四合一（r5l 方案1）：review write（落 review.json+自动勾
       const tTask = tTaskIdx >= 0 && filteredArgs[tTaskIdx + 1] && !String(filteredArgs[tTaskIdx + 1]).startsWith("--") ? filteredArgs[tTaskIdx + 1] : null;
       const tNoteIdx = filteredArgs.indexOf('--note');
       const tNote = tNoteIdx >= 0 && filteredArgs[tNoteIdx + 1] && !String(filteredArgs[tNoteIdx + 1]).startsWith("--") ? filteredArgs[tNoteIdx + 1] : null;
+      // --evidence（2026-10-12-tick-evidence-multi-anchor）：tick 自愿证据补录（自由文本，@路径 读文件）
+      const tEvidenceIdx = filteredArgs.indexOf('--evidence');
+      const tEvidence = tEvidenceIdx >= 0 && filteredArgs[tEvidenceIdx + 1] && !String(filteredArgs[tEvidenceIdx + 1]).startsWith("--") ? filteredArgs[tEvidenceIdx + 1] : null;
       if (!tChange) { console.error('❌ 缺 --change <变更名>'); process.exit(2); }
       if (taskSub !== 'list') {
         if (!tTask || !/^task-\d+$/.test(tTask)) { console.error('❌ --task 格式应为 task-NN'); process.exit(2); }
@@ -960,7 +972,7 @@ task done 四合一（r5l 方案1）：review write（落 review.json+自动勾
         // ── 轻量勾选动词（2026-10-03-voluntary-task-tick）：翻格+进度回显+下一任务指针——
         // 纯反馈闭环（watcher task-done 事件自动上平台），自愿使用；幂等，无 review/verdict 仪式。──
         const { runTaskTick } = await import('./task-tick.js')
-        await runTaskTick({ changeName: tChange, cwd: dir, taskId: tTask, specBase: tSpecBase })
+        await runTaskTick({ changeName: tChange, cwd: dir, taskId: tTask, specBase: tSpecBase, evidence: tEvidence })
       } else if (taskSub === 'done') {
         // ── task done 四合一（r5l-forensic-verdict 方案 1 / 评审护栏#3）：13 任务 × 4 连收尾
         // 往返（review write+勾选 / finish / wt-commit）合并为单进程串行 + 合并输出——每次省
@@ -2528,6 +2540,27 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
               console.log(`   docHash 已与当前 ${result.mainDoc} 一致，跳过重写（幂等 no-op，不动文件）`);
             } else {
               console.log(`   下一步：独立审查子代理对照 ${result.mainDoc} 填 verdict/checklist 后重跑 --done`);
+              // 派发前任务书出口（2026-10-12-thick-taskbook-cli）：新生成骨架 = 待派发形态——打印
+              // 可原样粘贴的完整评审任务书（检查单生产权在 CLI，治主代理手写 leading prompt）。
+              // 条件性：--from adopt（评审已产）与 --refresh-hash（刷新既有）不打印；--json 面不混文案。
+              if (!rsrFrom && !wantRefresh) {
+                try {
+                  const { renderStageReviewerTaskbook } = await import('./stage-review.js');
+                  const { assembleProbeLinesForScope } = await import('./review-probes.js');
+                  const rsrSpecBase = rsrPlatformOpts.specRoot || join(dir, '.sillyspec');
+                  const _probeAsm = assembleProbeLinesForScope(rsrSpecBase, 'thick');
+                  for (const _w of _probeAsm.warnings) console.warn(`⚠️ review_probes：${_w}`);
+                  console.log(`\n📋 评审员任务书（原样复制给干净上下文子代理——检查单生产权在 CLI，勿手写改写）：`);
+                  console.log(renderStageReviewerTaskbook({
+                    stage: st,
+                    changeDir: join(rsrSpecBase, 'changes', rsrChange),
+                    changeName: rsrChange,
+                    reviewRunId: result.reviewRunId,
+                    reviewPath: result.reviewPath,
+                    probeLines: _probeAsm.lines.length > 0 ? _probeAsm.lines : null,
+                  }));
+                } catch { /* 任务书打印 best-effort：失败不影响注册主流程 */ }
+              }
             }
           }
         } catch (e) {
@@ -2911,6 +2944,7 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
       // 执行流：--cleanup-remnant / --cleanup-ghosts / --gc-unstamped-runs / --dump-db（结构化诊断之外的修复/取证动作）
       const cleanupRemnant = filteredArgs.includes('--cleanup-remnant');
       const cleanupGhosts = filteredArgs.includes('--cleanup-ghosts');
+      const pruneCrossWts = filteredArgs.includes('--prune-cross-worktrees');
       const gcUnstampedRuns = filteredArgs.includes('--gc-unstamped-runs');
       const dumpDbFlag = filteredArgs.includes('--dump-db');
       const doctorConfirm = filteredArgs.includes('--confirm');
@@ -3017,6 +3051,31 @@ ${generated.length} 个骨架已就绪——逐节把 <!--TODO--> 替换为语
         process.exitCode = r.errors.length > 0 ? 1 : 0;
         break;
       }
+      if (pruneCrossWts) {
+        // 坑 cross-wt-ghost-metadata 缺口③（fire-equipment 2026-10-10 实证）：跨仓仓 .git/worktrees/
+        // 幽灵注册（目录已删、注册残留占分支）对 cleanup/归档链隐身（meta.json 随目录同亡）——
+        // 本动作从注册面反扫清理。默认 dry-run，--confirm 才 prune；locked 条目只提示 unlock
+        // 不自动解除（用户显式保护意图）。
+        const { pruneCrossWorktreeGhosts } = await import('./worktree-cross.js');
+        const r = pruneCrossWorktreeGhosts({ cwd: doctorEffectiveDir, confirm: doctorConfirm });
+        if (json) {
+          console.log(JSON.stringify(r, null, 2));
+        } else {
+          console.log(
+            doctorConfirm
+              ? `👻 跨仓幽灵 worktree 注册清理（repos: ${r.repos_scanned ?? '—'}）：${(r.pruned || []).length} 已 prune / ${(r.skipped_locked || []).length} locked 跳过 / ${(r.remaining || []).length} 残留`
+              : `👻 跨仓幽灵 worktree 注册扫描（repos: ${r.repos_scanned ?? '—'}）：待清理 ${r.count} 个（dry-run）`,
+          );
+          for (const g of (doctorConfirm ? r.pruned : r.ghosts) || []) console.log(`   ${doctorConfirm ? '✅' : '-'} ${g.repoKey}: ${g.worktreePath}`);
+          for (const g of (r.skipped_locked || [])) console.log(`   🔒 ${g.repoKey}: ${g.worktreePath}（locked——先 git -C ${g.repoRoot} worktree unlock ${g.worktreePath} 后重跑）`);
+          const lockedPaths = new Set((r.skipped_locked || []).map((s) => s.worktreePath));
+          for (const g of (r.remaining || []).filter((x) => !lockedPaths.has(x.worktreePath))) console.log(`   ⚠️  ${g.repoKey}: ${g.worktreePath}（prune 后复扫仍在）`);
+          for (const e of (r.errors || [])) console.log(`   ❌ ${e.repoKey || ''}${e.repoRoot ? `（${e.repoRoot}）` : ''}: ${e.error}`);
+          if (!doctorConfirm && r.count > 0) console.log(`\n加 --confirm 执行 prune（git 只清指向不存在路径的注册，不动活 worktree、不碰分支）。`);
+        }
+        process.exitCode = (r.errors && r.errors.length > 0) ? 1 : 0;
+        break;
+      }
       if (gcUnstampedRuns) {
         // ql-20260908-006-5f04：无戳 execute-runs 一次性清扫。默认 dry-run，--confirm 才删。
         // 不进 archive 热路径（pruneArchivedChangeRuntime 故意不猜无戳 run）。
@@ -3999,6 +4058,40 @@ SillySpec worktree — git worktree 隔离管理
       await cmdAgentLog(filteredArgs.slice(1), { json, cwd: dir, specDir });
       break;
     }
+    case 'patch-reanchor': {
+      // 收口留痕锚点回写（2026-10-12-close-trace-freeze-integrity FR-03）：worktree 内收口的
+      // change-patch.json 记 worktree 本地 SHA，apply 重放回主仓后悬空——按提交主题归属推导
+      // 主仓锚点区间回写 + change.patch 重冻结（幂等；doctor 检出悬空时指路本命令）。
+      const prChangeIdx = filteredArgs.indexOf('--change');
+      const prChange = prChangeIdx >= 0 && filteredArgs[prChangeIdx + 1] && !String(filteredArgs[prChangeIdx + 1]).startsWith('--') ? filteredArgs[prChangeIdx + 1] : null;
+      if (!prChange) {
+        console.error('用法: sillyspec patch-reanchor --change <名> [--spec-dir <路径>] [--json]');
+        process.exit(2);
+      }
+      const specRootPr = resolvePlatformSpecDir(dir, specDir) || join(dir, '.sillyspec');
+      const { locateChangeDir, reAnchorChangePatch } = await import('./patch-reanchor.js');
+      const changeDirPr = locateChangeDir(specRootPr, prChange);
+      if (!changeDirPr) {
+        console.error(`❌ 变更目录未找到（活跃区与归档区均无）：${prChange}`);
+        process.exit(1);
+      }
+      const r = reAnchorChangePatch({ projectRoot: dir, changeDir: changeDirPr, changeName: prChange });
+      if (!r.ok) {
+        console.error(`❌ 锚点回写未执行：${r.reason}`);
+        process.exit(1);
+      }
+      if (json) {
+        console.log(JSON.stringify({ schema_version: 1, change: prChange, noop: r.noop === true, baseline: r.baseline || null, head: r.head || null, rewritten: r.rewritten || [] }, null, 2));
+      } else if (r.noop) {
+        console.log(`✅ 锚点已可解析，无需回写（幂等 no-op）：${prChange}`);
+      } else {
+        console.log(`📦 锚点已回写主仓：${prChange}`);
+        console.log(`   baseline → ${r.baseline.slice(0, 10)}（原 worktree 锚留档 worktreeBaseline）`);
+        console.log(`   head     → ${r.head.slice(0, 10)}（原 worktree 锚留档 worktreeHead）`);
+        console.log(`   change.patch 已按主仓区间重冻结，patchSha256 重锚（${(r.rewritten || []).join('、')}）`);
+      }
+      break;
+    }
     case 'handoff': {
       // 阶段跑者瘦会话交接块（P1-5 v1，2026-09-20 对撞实验驱动）：打印下一阶段新会话
       // 启动块（保持 SILLYSPEC_SESSION_ID）+ 状态摘要。纯只读。CLI prompt 自足——

package/src/local-register.js

@@ -15,7 +15,7 @@
  * `sillyspec local detect` / `platform connect` 各自补齐）。落盘走 writeAtomicSync
  * （tmp+rename，防多会话并发写半截，与 local detect 写入口径一致）。
  */
-import { existsSync, readFileSync, mkdirSync } from 'fs'
+import { existsSync, readFileSync, mkdirSync, statSync } from 'fs'
 import { dirname, join } from 'path'
 import { writeAtomicSync } from './fs-atomic.js'
 import { withFileLock } from './quicklog.js'
@@ -58,9 +58,27 @@ export async function registerRepoInLocalYaml(yamlPath, key, repoPath) {
   const posixPath = String(repoPath).replace(/\\/g, '/')
   const entryLine = `  ${key}: ${posixPath}`
 
+  // 跨仓标记（2026-10-12-cli-friction-signal）：注册成功后 best-effort 向目标仓 .git/ 内写
+  // 指路标记——uninit 门据此把「在子仓跑 CLI」精确指回工作区（dogfood：三连跑错目录靠人工
+  // 发现）。.git/ 内零工作区污染；linked worktree 的 .git 是文件则跳过；失败仅告警不拦注册。
+  const tryWriteMarker = () => {
+    try {
+      const gitDir = join(String(repoPath), '.git')
+      if (!existsSync(gitDir) || !statSync(gitDir).isDirectory()) return
+      writeAtomicSync(join(gitDir, 'sillyspec-crossrepo.json'), JSON.stringify({
+        workspace: dirname(dirname(yamlPath)).replace(/\\/g, '/'),
+        key,
+        registeredAt: new Date().toISOString(),
+      }, null, 2) + '\n')
+    } catch (e) {
+      console.warn(`⚠️ 跨仓标记写入失败（${e && e.message ? e.message : e}）——注册仍成功，未初始化门指路退化为通用文案`)
+    }
+  }
+
   const write = (text) => {
     mkdirSync(dirname(yamlPath), { recursive: true })
     writeAtomicSync(yamlPath, text)
+    tryWriteMarker()
   }
 
   const lines = raw.split('\n')
@@ -93,6 +111,7 @@ export async function registerRepoInLocalYaml(yamlPath, key, repoPath) {
         // 编辑器写入），内存归一后比对相等直接跳过 → 磁盘永不治愈 + CLI 报 ✅ 假成功 → 解析侧
         // （修复前）空 Map → MultiRepoContext 报「未注册」→ 死循环。幂等路径也落盘一次治愈。
         if (hadCr) write(lines.join('\n'))
+        tryWriteMarker() // 幂等重注册也补标记（标记被删后可经重注册恢复——uninit 门指路依赖）
         return { fileCreated: false, sectionCreated: false, replaced: false } // 值未变，幂等跳过
       }
       lines[i] = entryLine

package/src/patch-reanchor.js

@@ -0,0 +1,131 @@
+/**
+ * patch-reanchor.js — 收口留痕锚点回写（2026-10-12-close-trace-freeze-integrity FR-03）。
+ *
+ * 事故形态（multi-agent-platform 2026-10-12 ws-ref 五变更取证）：thin 流程在会话专属
+ * worktree（独立克隆/事后清理）内收口，change-patch.json 冻结的 baseline/head 是 worktree
+ * 本地 SHA；worktree apply 重放回主仓时 SHA 全部改写且原对象被清理——归档锚点悬空，
+ * `git diff baseline..head` 不可解析，归档溯源死链。
+ *
+ * 回写约定：按「提交主题含变更名」归属（仓内提交规范 `(<变更名>)` 后缀族，与
+ * filterCommittedFace 的 commitAttribution 同一约定），`git log --all --grep` 取归属提交链：
+ * head=拓扑末笔、baseline=首笔^；区间一致性（首笔^ 必须是 head 祖先、区间 diff 与留档
+ * files[] 至少一文件重叠）不过即 fail-closed 不改写。原 worktree 锚降级为
+ * worktreeBaseline/worktreeHead 溯源字段，patchSha256 按重冻正文重锚。
+ *
+ * 依赖边界：本模块被 worktree-apply.js 静态引入（apply 尾声自动回写），而 scope-audit.js
+ * 已静态引入 worktree-apply（评审 G3「内核绝不 import scope-audit」）——故本模块禁止
+ * import scope-audit/worktree-apply（防环），diff 采集自实现（pathspec 分块）。
+ */
+import { createHash } from 'node:crypto'
+import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import { writeAtomicSync } from './fs-atomic.js'
+
+function git(cwd, args, opts = {}) {
+  try {
+    return execFileSync('git', args, { cwd, encoding: 'utf8', timeout: 60000, windowsHide: true, ...opts }).trim()
+  } catch { return null }
+}
+
+const resolves = (cwd, sha) => Boolean(sha) && /^[0-9a-f]{40}$/i.test(String(sha)) && git(cwd, ['cat-file', '-e', `${sha}^{commit}`]) !== null
+
+/** pathspec 分块（命令行长度上限防御，与 worktree-apply.chunkPaths 同上限语义，本地实现防环） */
+function chunkPaths(paths, maxChars = 8000) {
+  const chunks = []
+  let cur = []
+  let len = 0
+  for (const p of paths) {
+    if (cur.length > 0 && len + p.length + 1 > maxChars) { chunks.push(cur); cur = []; len = 0 }
+    cur.push(p); len += p.length + 1
+  }
+  if (cur.length > 0) chunks.push(cur)
+  return chunks
+}
+
+/**
+ * 定位变更目录：活跃区 → 归档区精确名 → 归档区 `<日期>-<名>` 后缀匹配（归档重命名形态）。
+ * @returns {string|null}
+ */
+export function locateChangeDir(specBase, changeName) {
+  const active = join(specBase, 'changes', changeName)
+  if (existsSync(join(active, 'change-patch.json')) || existsSync(join(active, 'design.md'))) return active
+  const archiveExact = join(specBase, 'changes', 'archive', changeName)
+  if (existsSync(join(archiveExact, 'change-patch.json')) || existsSync(join(archiveExact, 'design.md'))) return archiveExact
+  try {
+    const archiveRoot = join(specBase, 'changes', 'archive')
+    if (existsSync(archiveRoot)) {
+      const suffix = `-${changeName}`
+      const hit = readdirSync(archiveRoot).filter((d) => d.endsWith(suffix)).sort()
+      if (hit.length === 1) return join(archiveRoot, hit[0])
+    }
+  } catch { /* 归档扫描失败走 null */ }
+  return null
+}
+
+/**
+ * 归档锚点回写核心（幂等）。
+ * @param projectRoot 主仓根（锚点可解析性判定与重冻区间的仓）
+ * @param changeDir 变更目录（活跃或归档侧）
+ * @param changeName 变更名（提交主题归属 grep 锚）
+ * @returns {{ ok: boolean, noop?: boolean, baseline?: string, head?: string, reason?: string, rewritten?: string[] }}
+ */
+export function reAnchorChangePatch({ projectRoot, changeDir, changeName }) {
+  const cpPath = join(changeDir, 'change-patch.json')
+  if (!existsSync(cpPath)) return { ok: false, reason: 'change-patch.json 不在案（本变更无收口冻结件）' }
+  let meta
+  try { meta = JSON.parse(readFileSync(cpPath, 'utf8')) } catch (e) { return { ok: false, reason: `change-patch.json 不可解析：${e && e.message ? e.message.split('\n')[0] : e}` } }
+
+  const headOk = resolves(projectRoot, meta.head)
+  const baseOk = resolves(projectRoot, meta.baseline)
+  if (headOk && (baseOk || !meta.baseline)) return { ok: true, noop: true }
+
+  // 归属提交链：主题含变更名（提交规范后缀族）；--all 覆盖主干/分支，date-order 保拓扑可读
+  const grepRaw = git(projectRoot, ['log', '--all', '--date-order', '--format=%H%x01%s', `--grep=${changeName}`])
+  if (!grepRaw) return { ok: false, reason: `主仓无可归属提交（git log --all --grep=${changeName} 空/失败）——锚点推导无据，fail-closed` }
+  const rows = grepRaw.split('\n').map((l) => l.trim()).filter(Boolean).map((l) => { const i = l.indexOf('\u0001'); return [l.slice(0, i), l.slice(i + 1)] })
+  if (rows.length === 0) return { ok: false, reason: `主仓无可归属提交——锚点推导无据，fail-closed` }
+  const oldest = rows[rows.length - 1][0]
+  const newest = rows[0][0]
+  const isAncestor = (a, b) => git(projectRoot, ['merge-base', '--is-ancestor', a, b]) !== null
+  if (!isAncestor(oldest, newest)) return { ok: false, reason: `归属提交链拓扑不一致（首笔 ${oldest.slice(0, 10)} 非末笔 ${newest.slice(0, 10)} 祖先）——疑似同名异源提交混入，fail-closed` }
+  const baseRaw = git(projectRoot, ['rev-parse', `${oldest}^`])
+  if (!baseRaw || !resolves(projectRoot, baseRaw)) return { ok: false, reason: `首笔归属提交无第一父（根提交形态）——baseline 不可推导，fail-closed` }
+  if (!isAncestor(baseRaw, newest)) return { ok: false, reason: `推导区间不一致（首笔^ 非 head 祖先）——fail-closed` }
+
+  // 区间与留档 files[] 至少一文件重叠（防错归属整链改写）
+  const rangeFiles = String(git(projectRoot, ['diff', '--name-only', '--no-color', baseRaw, newest]) || '')
+    .split('\n').map((s) => s.trim().replace(/\\/g, '/')).filter(Boolean)
+  const recorded = (Array.isArray(meta.files) ? meta.files : []).map((f) => String(f).replace(/\\/g, '/'))
+  const overlap = rangeFiles.filter((f) => recorded.includes(f) || recorded.some((r) => r.startsWith(`${f}/`) || f.startsWith(`${r}/`)))
+  if (recorded.length > 0 && overlap.length === 0) {
+    return { ok: false, reason: `推导区间（${baseRaw.slice(0, 10)}..${newest.slice(0, 10)}）与留档 files[] 零重叠——归属可疑，fail-closed` }
+  }
+
+  // 重冻正文：区间 diff 按 files[] pathspec 限面（重放后的主仓区间即归档真相）
+  const face = recorded.length > 0 ? recorded : rangeFiles
+  const parts = []
+  for (const chunk of chunkPaths(face)) {
+    const d = git(projectRoot, ['diff', '--no-color', baseRaw, newest, '--', ...chunk])
+    if (d) parts.push(d)
+  }
+  const patchBody = parts.length > 0 ? (parts.join('\n').endsWith('\n') ? parts.join('\n') : parts.join('\n') + '\n') : null
+  if (!patchBody) return { ok: false, reason: `主仓区间 diff 为空（${baseRaw.slice(0, 10)}..${newest.slice(0, 10)} × ${face.length} 文件）——重冻无据，fail-closed` }
+
+  const sha256 = createHash('sha256').update(patchBody.replace(/\r\n/g, '\n'), 'utf8').digest('hex')
+  const rewritten = []
+  if (meta.baseline !== baseRaw) { meta.worktreeBaseline = meta.baseline ?? null; meta.baseline = baseRaw; rewritten.push('baseline') }
+  if (meta.head !== newest) { meta.worktreeHead = meta.head ?? null; meta.head = newest; rewritten.push('head') }
+  if (meta.scopeAudit && typeof meta.scopeAudit === 'object' && meta.scopeAudit.baseAnchor !== baseRaw) {
+    meta.scopeAudit = { ...meta.scopeAudit, baseAnchor: baseRaw }
+    rewritten.push('scopeAudit.baseAnchor')
+  }
+  meta.patchSha256 = sha256
+  meta.patchStatus = 'ok'
+  meta.reanchoredAt = new Date().toISOString()
+  meta.reanchorNote = `apply/回填后主仓重锚（原 worktree 锚悬空：${meta.worktreeBaseline ? String(meta.worktreeBaseline).slice(0, 10) : '—'}/${meta.worktreeHead ? String(meta.worktreeHead).slice(0, 10) : '—'}；归属约定=提交主题含变更名）——2026-10-12-close-trace-freeze-integrity FR-03`
+  writeAtomicSync(cpPath, JSON.stringify(meta, null, 2) + '\n')
+  writeAtomicSync(join(changeDir, 'change.patch'), patchBody)
+  rewritten.push('change.patch', 'patchSha256')
+  return { ok: true, noop: false, baseline: baseRaw, head: newest, rewritten }
+}

package/src/review-dispatch.js

@@ -22,6 +22,7 @@ import { join, dirname } from 'node:path'
 import jsYaml from 'js-yaml'
 import { writeAtomicSync } from './fs-atomic.js'
 import { REVIEW_CHECKLISTS } from './stage-review-checklist.js'
+import { assembleProbeLinesForScope } from './review-probes.js'
 import { CEREMONY_TIERS } from './ceremony-tier.js'
 import { withFileLock } from './quicklog.js'
 import {
@@ -161,15 +162,20 @@ export function extractReviewFromArtifacts(artifacts) {
  * docblock 规则）②review.json 契约（与 gate 同源）③期望产出方式（read_only worker：
  * 结论经 artifacts 返回，**不写任何文件**——落盘归 CLI）④铁律段（禁改文件/禁 git commit）。
  */
-export function buildReviewerTaskBook({ stage, changeDir, reviewRunId, channelPriority }) {
+export function buildReviewerTaskBook({ stage, changeDir, reviewRunId, channelPriority, probeLines = null }) {
   const mainDoc = STAGE_MAIN_DOC[stage] || 'design.md'
   const items = (REVIEW_CHECKLISTS[stage] || []).map((t, i) => `${i + 1}. ${t}`).join('\n')
   const contract = renderReviewJsonContract({ stage, changeDir, reviewRunId, tier: 'independent', channelPriority })
+  // 项目评审探针（2026-10-12-review-probe-injection）：local.yaml 数据驱动注入，缺省零变化。
+  const probeSection = Array.isArray(probeLines) && probeLines.length > 0
+    ? ['', '## 项目评审探针（local.yaml 注入——逐条 pass/gap/fail + 证据锚点，未答=未审）', ...probeLines.map((l) => `- ${l}`)]
+    : []
   const workerPrompt = [
     `你是独立审查者（platform 通道派发）。审查对象：${changeDir ? join(changeDir, mainDoc) : mainDoc}`,
     '',
     '## 审查清单（逐条给 pass/gap/fail + 证据锚点）',
     items,
+    ...probeSection,
     '',
     contract,
     '',
@@ -285,7 +291,7 @@ export async function runReviewDispatch(opts = {}) {
         } catch { /* marker 写失败不阻断派发（status 回收时再补） */ }
       }
       const changeDir = join(specBase, 'changes', changeName)
-      const book = buildReviewerTaskBook({ stage, changeDir, reviewRunId: runId, channelPriority: readReviewChannelPriority(cwd) })
+      const book = buildReviewerTaskBook({ stage, changeDir, reviewRunId: runId, channelPriority: readReviewChannelPriority(cwd), probeLines: probeLinesForThick(specBase) })
       const mission = await client.createMission({ objective: book.objective, orchestrationMode: 'external', budgetUsd })
       const missionId = mission && mission.missionId
       if (!missionId) return { ok: false, reason: 'create_mission 未返回 missionId', guidance: renderFallbackGuidance(cwd) }
@@ -694,7 +700,7 @@ export async function dispatchShadowReview(opts = {}) {
       // 影子 runId 独立生成（R-06 隔离通道②：绝不读写主线 marker / stageReviewMarkerPath）
       const shadowRunId = generateShadowReviewRunId()
       const changeDir = join(specBase, 'changes', changeName)
-      const book = buildReviewerTaskBook({ stage, changeDir, reviewRunId: shadowRunId, channelPriority: readReviewChannelPriority(cwd) })
+      const book = buildReviewerTaskBook({ stage, changeDir, reviewRunId: shadowRunId, channelPriority: readReviewChannelPriority(cwd), probeLines: probeLinesForThick(specBase) })
       const workerPrompt = book.workerPrompt + '\n（影子审查：本结论将由 CLI 回收到 stage-reviews-shadow/ 独立命名空间做轻/重对照记账，不影响主线任何判定。）\n'
       const mission = await client.createMission({ objective: book.objective, orchestrationMode: 'external', budgetUsd: budget })
       const missionId = mission && mission.missionId
@@ -840,6 +846,15 @@ export async function dispatchShadowReview(opts = {}) {
 
 // task-06 消费契约预留（配置读取在该 task 落地；此处常量为缺省值单一来源）
 const DEFAULT_REVIEW_DISPATCH_CONFIG = { budget_usd: 1.0, stall_ms: 900_000, timeout_ms: 0 }
+/** 厚档任务书探针装配（2026-10-12-review-probe-injection）：失败/未配置返回 null（零注入零阻断）。 */
+function probeLinesForThick(specBase) {
+  try {
+    const { lines, warnings } = assembleProbeLinesForScope(specBase, 'thick')
+    for (const w of warnings) console.warn(`⚠️ review_probes：${w}`)
+    return lines.length > 0 ? lines : null
+  } catch { return null }
+}
+
 export function readReviewDispatchConfig(cwd) {
   try {
     const p = join(cwd || process.cwd(), '.sillyspec', 'local.yaml')

package/src/review-probes.js

@@ -0,0 +1,161 @@
+/**
+ * review-probes.js — 项目评审探针（2026-10-12-review-probe-injection）。
+ *
+ * 定位：把「项目特有的评审必查面」从主代理手写检查单收归 CLI 单源注入——dogfood 实证
+ * （2026-10-10~12 fire-equipment 会话）：三个生产缺陷（dva 双注册、MyBatis typeAliases
+ * 撞名、原型表头未实现）全部由用户报障发现，独立评审零捕获，根因是检查单由主代理手写、
+ * 主代理没想到的面无人查。
+ *
+ * 开放世界红线（用户 2026-10-12 定规）：CLI 零内容枚举、零语言/框架绑定——探针是纯数据
+ * （local.yaml `review_probes` 段：id 自由文本 / lines 自由文本清单行 / command 任意 shell
+ * 命令，stdout 非空行追加），CLI 只做装配与容量治理。scope 枚举（thin|thick|all）是 CLI
+ * 自有的两个任务书面（轻量 renderReviewerTaskbook / 厚档 buildReviewerTaskBook），非内容
+ * 枚举。与 ceremony/docs-check 等 local.yaml 段同消费哲学：读键容错、缺省空、未配置零注入。
+ *
+ * 容量帽：防误配把任务书撑爆或命令拖死渲染——条目 ≤16、每条静态行 ≤12、单行 ≤300 字符、
+ * 命令超时 10s、命令输出 ≤2KB 且 ≤20 行；超帽截断并在 provenance 留痕（不静默吞）。
+ * fail-soft：坏条目跳过+告警、命令失败/超时跳过该行源——探针面永不阻断任务书渲染。
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import yaml from 'js-yaml'
+
+export const PROBE_LIMITS = {
+  MAX_PROBES: 16,
+  MAX_LINES_PER_PROBE: 12,
+  MAX_LINE_CHARS: 300,
+  COMMAND_TIMEOUT_MS: 10_000,
+  COMMAND_OUTPUT_MAX_BYTES: 2048,
+  COMMAND_OUTPUT_MAX_LINES: 20,
+}
+
+/** scope 合法面（CLI 自有任务书面集合——封闭小集，非内容枚举）。 */
+const SCOPES = new Set(['thin', 'thick', 'all'])
+
+const cleanLine = (s) => String(s ?? '').replace(/\s+$/, '')
+
+/**
+ * 校验+归一探针声明（纯函数，零抛出）。
+ * @param {unknown} raw - local.yaml review_probes 段原值
+ * @returns {{ probes: Array<{id:string, scope:string, lines:string[], command:string|null}>, warnings: string[] }}
+ */
+export function parseReviewProbes(raw) {
+  const warnings = []
+  if (raw == null) return { probes: [], warnings }
+  if (!Array.isArray(raw)) return { probes: [], warnings: ['review_probes 段非数组——整段忽略'] }
+  const probes = []
+  raw.slice(0, PROBE_LIMITS.MAX_PROBES).forEach((entry, i) => {
+    const label = `review_probes[${i}]`
+    if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+      warnings.push(`${label} 非对象——跳过`); return
+    }
+    const id = cleanLine(entry.id)
+    if (!id || id.length > 64) { warnings.push(`${label} id 缺失或超 64 字符——跳过`); return }
+    let scope = entry.scope == null ? 'all' : String(entry.scope)
+    if (!SCOPES.has(scope)) { warnings.push(`${label}(${id}) scope 非法（${scope}，合法 thin|thick|all）——按 all 处理`); scope = 'all' }
+    const lines = Array.isArray(entry.lines)
+      ? entry.lines.map(cleanLine).filter((l) => l.length > 0)
+      : []
+    if (lines.length > PROBE_LIMITS.MAX_LINES_PER_PROBE) {
+      warnings.push(`${label}(${id}) lines ${lines.length} 行超帽 ${PROBE_LIMITS.MAX_LINES_PER_PROBE}——截断`)
+      lines.length = PROBE_LIMITS.MAX_LINES_PER_PROBE
+    }
+    for (const l of lines) {
+      if (l.length > PROBE_LIMITS.MAX_LINE_CHARS) {
+        warnings.push(`${label}(${id}) 单行超 ${PROBE_LIMITS.MAX_LINE_CHARS} 字符——截断`)
+        break
+      }
+    }
+    const linesCapped = lines.map((l) => l.length > PROBE_LIMITS.MAX_LINE_CHARS ? l.slice(0, PROBE_LIMITS.MAX_LINE_CHARS) : l)
+    const command = typeof entry.command === 'string' && entry.command.trim() ? entry.command : null
+    if (linesCapped.length === 0 && !command) { warnings.push(`${label}(${id}) lines 与 command 均空——跳过`); return }
+    probes.push({ id, scope, lines: linesCapped, command })
+  })
+  if (raw.length > PROBE_LIMITS.MAX_PROBES) {
+    warnings.push(`review_probes ${raw.length} 条超帽 ${PROBE_LIMITS.MAX_PROBES}——仅取前 ${PROBE_LIMITS.MAX_PROBES} 条`)
+  }
+  return { probes, warnings }
+}
+
+/**
+ * 装载 local.yaml 的 review_probes 段（IO，容错缺省空——无段/无文件/解析失败均零探针零阻断）。
+ * @returns {{ probes: Array, warnings: string[] }}
+ */
+export function loadReviewProbes(specBase) {
+  try {
+    const p = join(specBase || '', 'local.yaml')
+    if (!existsSync(p)) return { probes: [], warnings: [] }
+    const doc = yaml.load(readFileSync(p, 'utf8'))
+    const section = doc && typeof doc === 'object' ? doc.review_probes : null
+    return parseReviewProbes(section)
+  } catch (e) {
+    return { probes: [], warnings: [`review_probes 装载失败（${e && e.message ? e.message : e}）——按未配置处理`] }
+  }
+}
+
+/**
+ * 命令输出封帽（纯函数，评审 P3①② 清偿）：字节帽按 UTF-8 实字节数（非 UTF-16 字符数——中文
+ * 场景旧口径实际可注入 ~3× 标称值）；行帽 20；命令输出行同享静态行单行 300 字符帽。
+ * 多字节截断可能切在字符中间（Buffer subarray + utf8 解码产生替换符）——留痕已示截断，可接受。
+ */
+export function capCommandOutput(raw) {
+  let out = String(raw ?? '')
+  const provenance = []
+  const bytes = Buffer.byteLength(out, 'utf8')
+  if (bytes > PROBE_LIMITS.COMMAND_OUTPUT_MAX_BYTES) {
+    out = Buffer.from(out, 'utf8').subarray(0, PROBE_LIMITS.COMMAND_OUTPUT_MAX_BYTES).toString('utf8')
+    provenance.push(`命令输出超 ${PROBE_LIMITS.COMMAND_OUTPUT_MAX_BYTES}B 截断`)
+  }
+  let lines = out.split(/\r?\n/).map(cleanLine).filter((l) => l.length > 0)
+  if (lines.some((l) => l.length > PROBE_LIMITS.MAX_LINE_CHARS)) {
+    lines = lines.map((l) => (l.length > PROBE_LIMITS.MAX_LINE_CHARS ? l.slice(0, PROBE_LIMITS.MAX_LINE_CHARS) : l))
+    provenance.push(`命令输出单行超 ${PROBE_LIMITS.MAX_LINE_CHARS} 字符截断`)
+  }
+  if (lines.length > PROBE_LIMITS.COMMAND_OUTPUT_MAX_LINES) {
+    lines = lines.slice(0, PROBE_LIMITS.COMMAND_OUTPUT_MAX_LINES)
+    provenance.push(`命令输出超 ${PROBE_LIMITS.COMMAND_OUTPUT_MAX_LINES} 行截断`)
+  }
+  return { lines, provenance }
+}
+
+/** 缺省命令执行器：shell 执行 + 超时 + 输出帽（字节/行/单行三帽，超帽截断留痕）。 */
+function defaultRunCommand(command) {
+  const r = spawnSync(command, { shell: true, timeout: PROBE_LIMITS.COMMAND_TIMEOUT_MS, encoding: 'utf8', windowsHide: true })
+  if (r.error || r.status !== 0) {
+    const why = r.error && r.error.code === 'ETIMEDOUT' ? `超时 >${PROBE_LIMITS.COMMAND_TIMEOUT_MS}ms` : `退出码 ${r.status ?? '?'}`
+    return { ok: false, warning: `命令失败（${why}）`, lines: [] }
+  }
+  const { lines, provenance } = capCommandOutput(r.stdout)
+  return { ok: true, lines, provenance }
+}
+
+/**
+ * 解析某任务书面的探针清单行（纯函数，runCommand 注入可测）。
+ * @param {{ probes: Array, scope?: 'thin'|'thick', runCommand?: (cmd:string)=>{ok:boolean,lines:string[],warning?:string,provenance?:string[]} }} opts
+ * @returns {{ lines: string[], provenance: string[] }}
+ */
+export function resolveProbeLines({ probes, scope = 'thin', runCommand = defaultRunCommand } = {}) {
+  const lines = []
+  const provenance = []
+  for (const p of probes || []) {
+    if (p.scope !== 'all' && p.scope !== scope) continue
+    for (const l of p.lines) lines.push(`${p.id}｜${l}`)
+    if (p.command) {
+      const r = runCommand(p.command)
+      if (!r.ok) { provenance.push(`探针 ${p.id} ${r.warning || '命令失败'}——命令行源跳过`); continue }
+      for (const l of r.lines) lines.push(`${p.id}｜${l}`)
+      for (const pv of r.provenance || []) provenance.push(`探针 ${p.id}：${pv}`)
+    }
+  }
+  return { lines, provenance }
+}
+
+/** 装配便捷面（调用点单行接线）：装载→scope 过滤→行合并，warnings 汇含装载告警与帽留痕。 */
+export function assembleProbeLinesForScope(specBase, scope) {
+  const { probes, warnings } = loadReviewProbes(specBase)
+  const { lines, provenance } = resolveProbeLines({ probes, scope })
+  return { lines, warnings: [...warnings, ...provenance] }
+}
+
+export default { parseReviewProbes, loadReviewProbes, resolveProbeLines, assembleProbeLinesForScope, capCommandOutput, PROBE_LIMITS }