sillyspec 3.32.6 → 3.32.7

package/src/run/complete-handlers.js

@@ -353,22 +353,42 @@ export async function archiveWorktreeCleanup(cwd, archiveChangeName, specBase, p
       if (orphan.result === 'cleaned' || orphan.result === 'force-cleaned' || orphan.result === 'partial') {
         console.log(`🧹 归档清理孤儿 worktree 残留（meta 已注销）: ${archiveChangeName}${orphan.residual?.length ? '（残留: ' + orphan.residual.join('; ') + '）' : ''}`)
       }
-      return
-    }
-    const check = meta.mode !== 'in-place-fallback' ? wm.hasUnappliedChanges(archiveChangeName) : { hasChanges: false }
-    if (check.hasChanges) {
-      console.warn(`⚠️  归档时 worktree 仍有 ${check.changedFiles.length} 个未 apply 变更，保留 worktree`)
-      console.warn(`   确认不需要后手动清理: sillyspec worktree cleanup ${archiveChangeName} --force`)
-      return
-    }
-    const cleanResult = wm.cleanup(archiveChangeName)
-    if (cleanResult.residual?.length > 0) {
-      console.warn(`⚠️  归档 worktree 清理残留: ${cleanResult.residual.join('; ')}`)
-      console.warn(`   手动处理: sillyspec worktree cleanup ${archiveChangeName} --force`)
+    } else {
+      const check = meta.mode !== 'in-place-fallback' ? wm.hasUnappliedChanges(archiveChangeName) : { hasChanges: false }
+      if (check.hasChanges) {
+        console.warn(`⚠️  归档时 worktree 仍有 ${check.changedFiles.length} 个未 apply 变更，保留 worktree`)
+        console.warn(`   确认不需要后手动清理: sillyspec worktree cleanup ${archiveChangeName} --force`)
+      } else {
+        const cleanResult = wm.cleanup(archiveChangeName)
+        if (cleanResult.residual?.length > 0) {
+          console.warn(`⚠️  归档 worktree 清理残留: ${cleanResult.residual.join('; ')}`)
+          console.warn(`   手动处理: sillyspec worktree cleanup ${archiveChangeName} --force`)
+        }
+      }
     }
   } catch (e) {
     console.warn(`⚠️  归档 worktree 清理失败（不阻断归档）: ${e.message}`)
   }
+  // ── 跨仓兜底（坑 cross-wt-ghost-metadata 缺口②，fire-equipment 2026-10-10 实证）：此前
+  //    归档链只清主仓，跨仓 worktree 清理只挂在 apply/execute reset/手工 cleanup 四个时机，
+  //    归档作为最后一道收口不补刀——apply 侧任何一次 partial，跨仓注册/目录就永久滞留。
+  //    此处对齐主仓语义收口：force=false（有未 apply 交付的跨仓仓保留并警告），幂等，fail-open
+  //    不阻断归档。目录不在的幽灵注册由 cleanupCrossWorktrees 双清复核兜（缺口①），doctor
+  //    --prune-cross-worktrees 是终网（缺口③）。──
+  try {
+    const { cleanupCrossWorktrees } = await import('../worktree-cross.js')
+    const cross = cleanupCrossWorktrees({ cwd, changeName: archiveChangeName, specBase, force: false })
+    for (const r of cross.results) {
+      if (r.result === 'cleaned') {
+        console.log(`🧹 归档兜底清理跨仓 worktree（${r.repoKey}）: ${(r.details || []).join('; ')}`)
+      } else if (r.result === 'partial') {
+        console.warn(`⚠️  归档跨仓 worktree 清理 partial（${r.repoKey}）: ${(r.details || []).join('; ')}`)
+        console.warn(`   处理: sillyspec worktree cleanup ${archiveChangeName} --force（有交付需 apply）或 sillyspec doctor --prune-cross-worktrees（悬空注册）`)
+      }
+    }
+  } catch (e) {
+    console.warn(`⚠️  归档跨仓 worktree 兜底清理失败（不阻断归档）: ${e.message}`)
+  }
 }
 
 /**
@@ -620,7 +640,7 @@ export function renderStageSourceSideMovesMessage(r) {
  * @param {{ cwd: string, specBase: string, destDir: string, destName: string }} opts
  * @returns {{ docsAdded: string[]|null, fallbackDocs: boolean }} docsAdded=null 表示走了目录级回退
  */
-export function archiveNarrowedGitAdd({ cwd, specBase, destDir, destName }) {
+export function archiveNarrowedGitAdd({ cwd, specBase, destDir, destName, extraDocs = null }) {
   // changes 侧：本变更归档目录精确收窄（quick 轻量归档 closeSingleQuickLinkedChange 同款）
   safeGit(cwd, ['add', '--', `.sillyspec/changes/archive/${destName}/`])
 
@@ -643,6 +663,19 @@ export function archiveNarrowedGitAdd({ cwd, specBase, destDir, destName }) {
     console.warn(`⚠️ knowledge 侧 add 失败（fail-soft，不阻断归档链）：${e && e.message ? e.message : e}`)
   }
 
+  // extraDocs（2026-10-12-thin-module-gate-and-feed 二档）：thin 变更索引回写文件精确入暂存
+  // （文件级 pathspec；与下方 module-impact 精确集/目录级回退对本文件集是幂等重复 add——
+  // 本通道不依赖回退路径存活，回退面未来收紧时回写暂存不受影响）。
+  if (Array.isArray(extraDocs) && extraDocs.length > 0) {
+    try {
+      const posixDocs = [...new Set(extraDocs.map((p) => String(p).replace(/\\/g, '/')))]
+      for (const batch of chunkPaths(posixDocs)) safeGit(cwd, ['add', '--', ...batch])
+      console.log(`   📖 模块变更索引回写入暂存：${posixDocs.length} 个文件`)
+    } catch (e) {
+      console.warn(`⚠️ 回写文件入暂存失败（fail-soft，不阻断归档链）：${e && e.message ? e.message : e}`)
+    }
+  }
+
   // docs 侧：module-impact「更新结果」done 行 → 精确文件集。
   // 三态（对齐修复④要求）：
   //   - module-impact.md 无「## 更新结果」段 / 文件缺失 / 读取异常 → docPaths=null → 回退目录级
@@ -880,7 +913,7 @@ export function resolveArchiveCommitPathspecs({ changeName, stagedNameStatus, he
   return { pathspecs, dropped }
 }
 
-export async function runArchiveChain({ pm, cwd, specBase, changeName, srcDir, destDir, skipApply = false, skipPlanCheck = false, deliverableFiles = null, docsIncrement = null } = {}) {
+export async function runArchiveChain({ pm, cwd, specBase, changeName, srcDir, destDir, skipApply = false, skipPlanCheck = false, deliverableFiles = null, docsIncrement = null, extraDocs = null } = {}) {
   const archiveDir = dirname(destDir) // 抽取补：原闭包变量（changes/archive），从 destDir 推导等价
   // ── 模块文档认领 advisory（资产三小件③，2026-09-23）──
   // flow done/burst 收口不产生模块文档增量（旧流程挂在 execute/verify 步骤）——交付面 ×
@@ -1013,7 +1046,7 @@ export async function runArchiveChain({ pm, cwd, specBase, changeName, srcDir, d
   // porcelain 实证）。basename(destDir) 与调用方 destDir 恒一致（flow.js 与 run archive 同构）。
   const destName = basename(destDir)
   try {
-    archiveNarrowedGitAdd({ cwd, specBase, destDir, destName })
+    archiveNarrowedGitAdd({ cwd, specBase, destDir, destName, extraDocs })
   } catch (e) {
     console.warn(`⚠️ 归档窄化 git add 异常（不阻断归档，交付面靠下方探测块兜底/agent git status 核对）: ${(e && e.message) || e}`)
   }

package/src/run/gates.js

@@ -377,9 +377,16 @@ export async function enforceDepsGate(stageName, cwd, changeName, step, steps, c
     console.error('❌ ── deps 门控阻断（本次 --done 未完成，进度未推进）──')
     for (const { repoKey, meta: cm } of crossFailed) {
       console.error(`   跨仓 repo ${repoKey} 依赖未就绪（depsStatus=${cm.depsStatus || 'unknown'}）——workdir: ${cm.worktreePath}`)
-      if (cm.depsError) console.error(`   上次供给错误：${cm.depsError}`)
+      // 报错一次给全（2026-10-12-cli-friction-signal，dogfood 实证：首条阻断只有标题无明细、
+      // agent 二跑定位 + 最终两次手改内部 meta.json 才过门）——三要素 + 逃生口 + 防手改警告。
+      if (cm.depsError) {
+        const tail = String(cm.depsError)
+        console.error(`   上次供给错误（尾部 ≤200 字符）：${tail.length > 200 ? '…' + tail.slice(-200) : tail}`)
+      }
+      console.error(`   状态文件：${join(cm.worktreePath || '', 'meta.json')}（勿手改——doctor 以实态校正，假状态会被下次校验打回）`)
     }
     console.error('   修复：进上述跨仓 worktree 手动安装依赖（用该仓的包管理器），或重跑 sillyspec run execute 让 CLI 重试供给后 --done。')
+    console.error('   正规逃生口：sillyspec worktree doctor --fix（按实态重供并回写 meta.json）。')
     if (persist) { try { await persist() } catch { /* 落盘失败不吞阻断语义 */ } }
     process.exit(1)
   }
@@ -455,7 +462,15 @@ export async function enforceDepsGate(stageName, cwd, changeName, step, steps, c
     console.error(`   原因：依赖未就绪（depsStatus=${depsStatus || 'unknown'}），不得在无构建/测试能力时声称完成。`)
     console.error(`   修复：sillyspec worktree doctor --fix${changeName ? ` --change ${changeName}` : ''}`)
     console.error('   或在 worktree 内手动安装依赖后重试。')
-    if (meta?.depsError) console.error(`   上次供给错误：${meta.depsError}`)
+    if (meta?.depsError) {
+      const tail = String(meta.depsError)
+      console.error(`   上次供给错误（尾部 ≤200 字符）：${tail.length > 200 ? '…' + tail.slice(-200) : tail}`)
+    }
+    // 状态文件路径 + 防手改（2026-10-12-cli-friction-signal）：dogfood 实证 agent 被迫手改
+    // meta.json 假状态过门——路径透明 + 明示正规校正通道，堵死「改状态绕门」的路。
+    try {
+      if (wm && changeName) console.error(`   状态文件：${join(wm.getWorktreePath(changeName), 'meta.json')}（勿手改——doctor 以实态校正）`)
+    } catch { /* worktree 路径解析失败省略该行 */ }
   }
   if (persist) { try { await persist() } catch { /* 落盘失败不吞阻断语义 */ } }
   process.exit(1)

package/src/run/shared.js

@@ -445,6 +445,20 @@ export function resolveUninitCwdGate(command, { dir, specDir, platformFlags } =
     }
   }
   const gitRoot = safeGit(resolvedDir, ['rev-parse', '--show-toplevel']).value || null
+  // 跨仓标记指路（2026-10-12-cli-friction-signal）：该仓被 register-repo 登记过（标记在 .git/ 内，
+  // registerRepoInLocalYaml 写入）→ block 态附 crossRepo 事实，index.js 门文案据此精确指回工作区
+  // （dogfood：agent 在跨仓子仓跑 CLI 三连跑错目录靠人工发现）。标记损坏/缺失按无标记零变化。
+  if (gitRoot) {
+    try {
+      const markerPath = join(gitRoot, '.git', 'sillyspec-crossrepo.json')
+      if (existsSync(markerPath)) {
+        const m = JSON.parse(readFileSync(markerPath, 'utf8'))
+        if (m && typeof m.workspace === 'string' && m.workspace) {
+          return { verdict: 'block', gitRoot, crossRepo: { workspace: m.workspace, key: typeof m.key === 'string' ? m.key : null } }
+        }
+      }
+    } catch { /* 标记损坏按无标记 */ }
+  }
   return { verdict: 'block', gitRoot }
 }
 

package/src/stage-contract.js

@@ -982,7 +982,7 @@ function validateAcceptanceMatrix(cwd, changeName, context = {}) {
     errors.push(
       `探针 7 验收×测试覆盖矩阵有 ${matrix.missingEvidence} 行证据缺失` +
       `（covered/covered-service/partial 证据须含测试锚点：\`.test.\` 文件名 / file:line / 反引号包裹的测试名；non-testable 证据须写一句理由）：${list}。` +
-      `修复：在证据列补测试锚点（如 \`test/foo.test.mjs\` 或 \`src/x.js:42\`）或 non-testable 理由。`
+      `修复：在证据列补测试锚点（如 \`test/foo.test.mjs\` 或 \`src/x.js:42\`）或 non-testable 理由（运行验证移交场景适用：构建回执+移交去向一句话）。`
     )
   }
 
@@ -1300,7 +1300,7 @@ export function judgeApiCoverageMatrix(args) {
         : `声明 ${N} 端点而 covered/covered-service 端点行仅 ${coveredCount}（解析零行降级，无法逐条列端点——按声明行拆出每端点行填判定）`
       errors.push(
         `接口验证覆盖矩阵覆盖不足：有效分母 ${validDenominator}（N=${N} − non-testable ${nonTestableCount}），covered+covered-service 分子 ${coveredCount}——缺覆盖端点：${list}。` +
-        `修复：补验证用例/冒烟步骤后把端点行改 covered 并填五形态锚点；端点行为由 service 层测试锁定的改 covered-service 并填测试锚点（\`.test.\` / file:line / 反引号）；不适用端点改 non-testable 并写一句理由；确未覆盖的走「## 移交项（结构化）」承载并保持 partial/uncovered（FR-04）。`
+        `修复：补验证用例/冒烟步骤后把端点行改 covered 并填五形态锚点；端点行为由 service 层测试锁定的改 covered-service 并填测试锚点（\`.test.\` / file:line / 反引号）；不适用端点改 non-testable 并写一句理由（含运行验证移交场景：构建级验证已过、运行冒烟移交部署后执行——理由写构建回执+移交去向，该行不计入分母，勿硬凑 covered-service）；确未覆盖的走「## 移交项（结构化）」承载并保持 partial/uncovered（FR-04）。`
       )
     }
     // covered-service 承接 advisory（D-001/R-01 第一版，只进 warnings 不进 errors）：端点级与

package/src/stage-review.js

@@ -15,12 +15,14 @@
 
 import { existsSync, readFileSync, mkdirSync, readdirSync } from 'fs'
 import { writeAtomicSync } from './fs-atomic.js'
-import { join } from 'path'
+import { join, dirname } from 'path'
 import { createHash } from 'crypto'
 import jsYaml from 'js-yaml'
 import { VALID_VERDICTS, REVIEW_SCHEMA_VERSION } from './task-review.js'
 import { detectSpecDirTypo } from './spec-dir-typo.js'
 import { resolveRuntimeRoot, resolveSpecDir } from './run/shared.js'
+import { REVIEW_CHECKLISTS } from './stage-review-checklist.js'
+import { assembleProbeLinesForScope } from './review-probes.js'
 
 // 文档型 stage review 的合法 reviewType
 const STAGE_REVIEW_TYPES = ['design', 'plan', 'proposal', 'code', 'acceptance']
@@ -738,6 +740,51 @@ export function validateStageReviewWithAutoRefresh(opts) {
   return { result: recheck, autoRefreshed: recheck.ok, refreshedPath: reviewPath, previousErrors: result.errors, refreshOrdinal, hashDrift: `${oldHashShort}→${newHashShort}` }
 }
 
+/**
+ * 厚档评审员任务书（agent 通道，2026-10-12-thick-taskbook-cli）：可原样粘贴给干净上下文子代理
+ * 的完整派发 prompt——检查单生产权收归 CLI（dogfood 实证 fire-equipment 会话：主代理手写 9 份
+ * 派发 prompt，6 份带 leading 措辞——「本变更的修复：…」预设结论、「构建已跑过你无需重跑」
+ * 外包验证；三个生产缺陷全漏检的根因是检查单由主代理手写）。与 thin 面 renderReviewerTaskbook
+ * （flow-review.js）同哲学；平台通道任务书在 review-dispatch.js buildReviewerTaskBook（不动）。
+ * 契约复用 renderReviewJsonContract 单源渲染——禁止第二套手写 schema 摘要（防契约漂移；
+ * 其通道优先序段面向派发方，评审员读到无害）。
+ * 放本模块而非 review-dispatch：契约渲染器与校验器同模块，且 review-dispatch 静态 import
+ * 本模块（反向成环）。诚实边界：任务书仍由主代理复制转发——CLI 单源降 leading 概率，
+ * 不防恶意篡改（与 thin 同界）。
+ * @param {{ stage: string, changeDir: string, changeName?: string, reviewRunId?: string,
+ *   reviewPath: string, probeLines?: string[]|null }} opts
+ * @returns {string}
+ */
+export function renderStageReviewerTaskbook({ stage, changeDir, changeName, reviewRunId, reviewPath, probeLines = null }) {
+  const mainDoc = STAGE_MAIN_DOC[stage] || 'design.md'
+  const reviewType = STAGE_REVIEW_TYPE[stage] || 'design'
+  const items = (REVIEW_CHECKLISTS[stage] || []).map((t, i) => `  ${i + 1}. ${t}`)
+  const probeSection = Array.isArray(probeLines) && probeLines.length > 0
+    ? ['', '【项目评审探针（local.yaml review_probes 注入——CLI 单源生产，项目特有面必查）】',
+      ...probeLines.map((l) => `  - ${l}`),
+      '  （逐条作答：pass 给证据锚点 / gap 给缺件 / fail 给违诺实证——与检查单同口径，未答=未审）']
+    : []
+  return [
+    `⚖️ 独立评审任务书 — ${stage} 阶段（agent 通道派发，原样复制给子代理——检查单生产权在 CLI，勿自行改写增删）`,
+    `══════════════════════════════════════`,
+    `【角色】你是独立评审员（干净上下文，未参与实现）——拿承诺对文档与代码，不信自述，逐条给证据锚点。`,
+    `【评审对象】${join(changeDir || '', mainDoc)}（reviewType=${reviewType}${changeName ? `，change=${changeName}` : ''}）`,
+    ``,
+    `【检查单（逐条 pass / gap / fail + 证据锚点）】`,
+    ...items,
+    ...probeSection,
+    ``,
+    `【请求预算】硬帽 12 次——超帽即止；材料不足以作答的项如实标 cannot_verify 并列缺件，勿猜。`,
+    `【纪律】只读——禁止修改任何文件、禁止 git 写操作。`,
+    `【产物】把 review.json 写到：${reviewPath}`,
+    `   docHash 可占位 "TODO"——写完由主会话跑 sillyspec register-stage-review --change ${changeName || '<名>'} --stage ${stage} --refresh-hash 代填（保留 verdict/checklist）。`,
+    ``,
+    renderReviewJsonContract({ stage, changeDir, reviewRunId, tier: 'independent' }),
+    ``,
+    `【完成后】告知主会话重跑：sillyspec run ${stage} --done --change ${changeName || '<名>'}（断点续，已完成子步幂等跳过）`,
+  ].join('\n')
+}
+
 /**
  * 打印 stage review 校验结果
  * @param {{ ok: boolean, errors: string[], warnings: string[] }} result
@@ -789,6 +836,25 @@ export function printStageReviewResult(result, context = {}) {
     if (result.errors.some(e => String(e).includes('docHash')) && changeName) {
       console.error(`   docHash 失配修复：sillyspec register-stage-review --change ${changeName} --stage ${stage} --refresh-hash（主文档改版多阶段联动用 --all）`)
     }
+    // 厚档评审任务书（2026-10-12-thick-taskbook-cli）：缺 review.json = 待派发形态——打印可原样
+    // 粘贴的完整任务书（thin 面同款时机：评审需要而未产）。条件性：仅缺件形态打印，docHash 失配/
+    // schema 错等其他失败不打印（防重复撞门噪音）。探针装配 fail-soft：specBase 由 runtimeRoot
+    // 父目录推导（平台模式 runtimeRoot 在外时 miss → 零注入），打印失败不影响 gate 原错误输出。
+    if (reviewRunId && runtimeRoot && changeName
+      && result.errors.some(e => String(e).includes('缺少') && String(e).includes('review.json'))) {
+      try {
+        const _probeAsm = assembleProbeLinesForScope(dirname(runtimeRoot), 'thick')
+        for (const _w of _probeAsm.warnings) console.error(`   ⚠️ review_probes：${_w}`)
+        console.error(`\n   📋 评审员任务书（原样复制给干净上下文子代理——检查单生产权在 CLI，勿手写改写）：`)
+        console.error(renderStageReviewerTaskbook({
+          stage, reviewRunId,
+          changeDir: join(dirname(runtimeRoot), 'changes', changeName),
+          changeName,
+          reviewPath: join(runtimeRoot, 'stage-reviews', `${stage}-${reviewRunId}`, 'review.json'),
+          probeLines: _probeAsm.lines.length > 0 ? _probeAsm.lines : null,
+        }).split('\n').map((l) => `   ${l}`).join('\n'))
+      } catch { /* 任务书打印 best-effort：失败不影响 gate 原有输出与退出码 */ }
+    }
   }
 
   if (result.warnings.length > 0) {

package/src/task-tick.js

@@ -69,11 +69,36 @@ export function tickTasksMd({ tasksMd, taskId }) {
   }
 }
 
+/**
+ * 证据解析（2026-10-12-tick-evidence-multi-anchor）：自由文本或 @路径 引用——@file 读文件内容
+ * （帽 8KB，超帽截断留痕）；读取失败 fail-soft 原样登记「@路径」文本并告警（不拒翻格——证据是
+ * 自愿补录面，不进门禁判据）。dogfood 驱动：限流截断场景构建回执（/tmp 日志 exit 0）无法补录，
+ * 恢复后只能重跑构建。
+ */
+export function resolveTickEvidence({ evidence }) {
+  const raw = String(evidence ?? '').trim()
+  if (!raw) return { text: null, warning: null }
+  if (!raw.startsWith('@')) return { text: raw, warning: null }
+  const path = raw.slice(1)
+  try {
+    let content = readFileSync(path, 'utf8')
+    if (Buffer.byteLength(content, 'utf8') > 8192) {
+      content = Buffer.from(content, 'utf8').subarray(0, 8192).toString('utf8') + '…（超 8KB 截断）'
+    }
+    const text = `@${path}\n${content.trim()}`
+    if (!content.trim()) return { text: `@${path}（空文件）`, warning: `⚠️ 证据文件 ${path} 为空——原样登记引用` }
+    return { text, warning: null }
+  } catch (e) {
+    return { text: raw, warning: `⚠️ 证据文件 ${path} 读取失败（${e && e.code ? e.code : '不可读'}）——原样登记引用文本，未拒翻格` }
+  }
+}
+
 /**
  * IO 编排（index.js 分派入口）：定位变更目录 → tickTasksMd → 原子写盘 → 回显。
  * exit 0=翻格/幂等；exit 2=未知 id / 缺 tasks.md / 已归档。
+ * evidence（可选）：自愿证据补录——翻格成功后追加 task-evidence.jsonl（幂等重勾零追加）。
  */
-export async function runTaskTick({ changeName, cwd, taskId, specBase }) {
+export async function runTaskTick({ changeName, cwd, taskId, specBase, evidence = null }) {
   const changesRoot = join(specBase, 'changes')
   const tasksPath = join(changesRoot, changeName, 'tasks.md')
   if (!existsSync(tasksPath)) {
@@ -90,9 +115,24 @@ export async function runTaskTick({ changeName, cwd, taskId, specBase }) {
     console.error(`❌ tasks.md 中无 ${taskId}——可选任务：${ids}`)
     process.exit(2)
   }
+  // 证据预解析（翻格前展开 @file——证据不先于事实：翻格失败不产生证据行）
+  const ev = resolveTickEvidence({ evidence })
+  if (ev.warning) console.warn(ev.warning)
   if (r.kind === 'ticked') {
     const { writeAtomicSync } = await import('./fs-atomic.js')
     writeAtomicSync(tasksPath, r.tasksMd)
+    // 证据补录（2026-10-12-tick-evidence-multi-anchor）：翻格成功后追加四键 JSONL——
+    // 幂等重勾零追加（already 分支不进此块）；自愿面不接任何收口门判据。
+    if (ev.text) {
+      try {
+        appendFileSync(join(changesRoot, changeName, 'task-evidence.jsonl'), JSON.stringify({
+          ts: Date.now(), task: normalizeTaskId(taskId) || taskId, evidence: ev.text, source: 'task-tick',
+        }) + '\n', 'utf8')
+        console.log(`📎 证据已登记：${join(changesRoot, changeName, 'task-evidence.jsonl')}（task ${normalizeTaskId(taskId) || taskId}）`)
+      } catch (e) {
+        console.warn(`⚠️ 证据登记失败（${e && e.message ? e.message : e}）——翻格不受影响`)
+      }
+    }
     // 事件直写（2026-10-07-thin-tasks-v3）：精确单格跳进事件流，节奏门按 source 去重采样合并跳。
     try {
       const { resolveRuntimeRoot } = await import('./run/shared.js')
@@ -102,6 +142,7 @@ export async function runTaskTick({ changeName, cwd, taskId, specBase }) {
       appendFileSync(eventsPath, JSON.stringify({
         ts: Date.now(), kind: 'task-done', stage: 'tasks',
         detail: `checked ${from}→${r.checked}`, provisional: true, source: 'task-tick',
+        ...(ev.text ? { evidence: ev.text.slice(0, 300) } : {}), // 事件面截 300 字符（全文在 task-evidence.jsonl）
       }) + '\n', 'utf8')
     } catch { /* 事件 best-effort：写失败翻格不受影响（节奏门退回采样判） */ }
     // 工件即时重推（2026-10-07-allticked-gate-docs-resync）：翻格即任务面变更——顺带触发
@@ -118,4 +159,4 @@ export async function runTaskTick({ changeName, cwd, taskId, specBase }) {
   return r
 }
 
-export default { tickTasksMd, runTaskTick, normalizeTaskId }
+export default { tickTasksMd, runTaskTick, normalizeTaskId, resolveTickEvidence }

package/src/verify-probes.js

@@ -2678,7 +2678,7 @@ function renderApiCoverageMatrixLines(apiFace) {
   const endpoints = face && Array.isArray(face.endpoints) ? face.endpoints : []
   const declared = face && typeof face.declared === 'number' ? face.declared : null
   const L = [`${API_MATRIX_HEADING} [层：人工判断——CLI 预填复核]`]
-  L.push('<!-- 口径注记（与探针 7 互指，R-07）：探针 7 = 验收项 × 测试承接面（每条 acceptance 由哪些测试承接）；本矩阵 = 接口端点 × 验证用例面（design 接口段每个端点由哪些验证用例/冒烟步骤覆盖）——两者并排互补，双矩阵并行存在。端点集来自 design.md 接口段 tolerant 解析（parseDesignApiTable：段头宽收 + 方法/路径双条件），预填≠结论，agent 逐行复核。判定枚举（五选一）：covered / covered-service / partial / uncovered / non-testable——covered-service 适用：端点行为由 service 层等非端点层测试锁定；证据须含测试文件锚点三形态之一（`.test.` / file:line / 反引号包裹的路径或测试名）。 -->')
+  L.push('<!-- 口径注记（与探针 7 互指，R-07）：探针 7 = 验收项 × 测试承接面（每条 acceptance 由哪些测试承接）；本矩阵 = 接口端点 × 验证用例面（design 接口段每个端点由哪些验证用例/冒烟步骤覆盖）——两者并排互补，双矩阵并行存在。端点集来自 design.md 接口段 tolerant 解析（parseDesignApiTable：段头宽收 + 方法/路径双条件），预填≠结论，agent 逐行复核。判定枚举（五选一）：covered / covered-service / partial / uncovered / non-testable——covered-service 适用：端点行为由 service 层等非端点层测试锁定；证据须含测试文件锚点三形态之一（`.test.` / file:line / 反引号包裹的路径或测试名）；non-testable 适用（含运行验证移交场景）：目标环境不可达、构建级验证已过而运行冒烟移交部署后执行——证据写构建回执+移交去向一句话，该行不计入有效分母（勿硬凑 covered-service）。 -->')
   L.push('<!-- 预填说明：端点行由 CLI 机械预填，判定/用例依据 ID/结果/证据由 agent 逐格填写——用例依据 ID 锚点五形态（可复制样例）：design接口表#POST /api/xx（# 后必须 METHOD /path，仅表名/行号/散文描述不计命中）、权限矩阵[admin×读]、契约表@任务卡字段清单、DDL@users.id、载荷@e2e_body.json（须真实命中对应表/段，防空指）。 -->')
   L.push('<!-- 文法注释：子行 = 端点行下一行、两空格缩进、以「↳ <消费端>:」前缀书写（消费端细分承接面，不计矩阵行账）；探索行 = 判定 uncovered 且证据列含 [探索] 标记（探索性验证不算覆盖）。 -->')
   if (endpoints.length === 0 && declared === null) {

package/src/worktree-apply.js

@@ -26,6 +26,7 @@ import { collectActiveQuickGuardFiles } from './quicklog.js';
 import { appendWriteAudit, WRITE_AUDIT_FILE_CAP } from './write-audit.js';
 import { detectCommittedDrift, formatCommittedDriftWarning } from './run/concurrent-detect.js';
 import { readWorktreePolicy } from './worktree-policy.js';
+import { reAnchorChangePatch } from './patch-reanchor.js';
 
 const CHANGES_REL = '.sillyspec/changes';
 
@@ -2208,6 +2209,27 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
         result.warnings.push(`cleanup 失败（不影响应用结果；Windows 手动清理先解 junction 再删，勿 rm -rf）: ${cleanupErr.message}`);
       }
 
+      // --- 8.5 归档锚点回写（2026-10-12-close-trace-freeze-integrity FR-03）：worktree 内收口的
+      // change-patch.json 记的是 worktree 本地 SHA，apply 重放/清理后主仓侧锚点改写——best-effort
+      // 回写为可解析主仓锚（幂等；merge 路径提交已落主仓即刻生效，patch 路径 agent 提交前的
+      // no-op 留给 doctor/patch-reanchor 补位；失败仅警告不阻断）。
+      try {
+        const reanchorBase = allowSpecBase || join(projectRoot, '.sillyspec');
+        for (const cand of [join(reanchorBase, 'changes', changeName), join(reanchorBase, 'changes', 'archive', changeName)]) {
+          if (!existsSync(join(cand, 'change-patch.json'))) continue
+          const r = reAnchorChangePatch({ projectRoot, changeDir: cand, changeName });
+          if (r.ok && r.noop) break
+          if (r.ok && !r.noop) {
+            console.log(`📦 归档锚点已回写主仓：${changeName} baseline/head → ${String(r.baseline).slice(0, 10)}/${String(r.head).slice(0, 10)}（change.patch 重冻结+sha256 重锚）`);
+            break
+          }
+          result.warnings.push(`归档锚点回写未完成（${cand}）：${r.reason}——收口提交后可跑 sillyspec patch-reanchor --change ${changeName} 补位`);
+          break
+        }
+      } catch (reErr) {
+        result.warnings.push(`归档锚点回写异常（不影响应用结果）: ${reErr.message}`);
+      }
+
     } catch (e) {
       // ENOBUFS 自动降级（坑 apply-spawnsync-enobufs，2026-08-22 实证：大 diff 的 binary patch
       // 超 maxBuffer 抛 ENOBUFS，此前只能 agent 手动 git merge 绕行）——git apply 路径走不通时

package/src/worktree-cross.js

@@ -386,14 +386,49 @@ export function ensureCrossWorktrees({ cwd, changeName, specBase }) {
   return { created, reused, skippedLegacy };
 }
 
+/**
+ * 探测跨仓仓 worktree 注册状态（双清契约的复核原语，坑 cross-wt-ghost-metadata 2026-10-10
+ * fire-equipment 实证：目录被清、.git/worktrees/ 注册残留占住分支——prune 静默失败/locked
+ * 条目被 prune 跳过都产出零报错幽灵，必须以 git worktree list 的答复为准）。
+ * 路径归一对齐 gate-snapshot worktreeListContains（反斜杠归正斜杠 + win32 大小写不敏感）。
+ * @param {string} repoRoot 跨仓仓根
+ * @param {string} wtPath worktree 路径
+ * @returns {{registered: boolean, locked: boolean, unknown?: boolean}} 查询失败（git 不可达）
+ *   按 registered:true 返回（fail-safe——复核不过走 partial，绝不静默判清）。
+ */
+export function probeCrossWorktreeEntry(repoRoot, wtPath) {
+  const out = gitQuiet(repoRoot, ['worktree', 'list', '--porcelain'], { timeout: 30000 });
+  if (out == null) return { registered: true, locked: false, unknown: true };
+  const norm = (s) => {
+    const v = String(s).replace(/\\/g, '/');
+    return process.platform === 'win32' ? v.toLowerCase() : v;
+  };
+  const target = norm(wtPath);
+  const lines = String(out).split('\n');
+  const idx = lines.findIndex((l) => l.startsWith('worktree ') && norm(l.slice('worktree '.length)) === target);
+  if (idx === -1) return { registered: false, locked: false };
+  // 该条目属性行：到下一条 worktree 行或空行为止；locked 可带原因尾巴（git ≥2.30 lock 原因）
+  let locked = false;
+  for (let i = idx + 1; i < lines.length; i++) {
+    const l = lines[i];
+    if (l.startsWith('worktree ') || l.trim() === '') break;
+    if (l === 'locked' || l.startsWith('locked ')) { locked = true; break }
+  }
+  return { registered: true, locked };
+}
+
 /**
  * 清理某变更的全部跨仓 worktree（幂等）。
  *
- * 顺序对齐主仓 cleanup 的 Windows 防护：先解 node_modules junction（裸删会穿透删跨仓主工作
- * 副本的 node_modules），再 git worktree remove --force，最后**保留分支** sillyspec/<change>
+ * 顺序对齐主仓 cleanup 的 Windows 防护：先解 node_modules junction（裸删会穿透删跨仓主
+ * 工作副本的 node_modules），再 git worktree remove --force，最后**保留分支** sillyspec/<change>
  * 作 review 锚点（分支删除在主仓侧有 review 锚点 + 双保护，跨仓侧 v1 保守不删，残 branch
  * 可人工清理）。目录残留（remove 失败）走 safeRemoveWorktreeDir 兜底 + residual 上报。
  *
+ * 双清契约（坑 cross-wt-ghost-metadata 缺口①，对齐 gate-snapshot D-004@v2）：remove 退出码
+ * 为零 / prune 不抛 ≠ 注册已清——两条路径收尾都以 git worktree list 复核注册已消失，复核
+ * 不过 → partial + residual（locked 条目附 unlock 指引），注册表键只在验证通过后回收。
+ *
  * @param {{ cwd: string, changeName: string, specBase?: string, force?: boolean }} opts
  * @returns {{ results: Array<{repoKey, result: 'cleaned'|'skipped'|'partial', details: string[], residual: string[]}> }}
  */
@@ -406,18 +441,33 @@ export function cleanupCrossWorktrees({ cwd, changeName, specBase, force = false
     const repoRoot = meta.crossRepoRoot;
     const wtPath = meta.worktreePath || crossWorktreePath(base, changeName, repoKey);
     if (!existsSync(wtPath)) {
-      try { if (repoRoot) gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch {}
-      removePlacementRegistryEntry(base, changeName, repoKey); // 挪位清理后注册表键回收（FR-02）
-      results.push({ repoKey, result: 'skipped', details: ['目录不存在（已清理）'], residual });
+      // 目录不在：prune 悬空注册——但 prune 会静默失败/静默跳过 locked 条目，prune 后必须
+      // 复核（git worktree list 答复为准）才销账；复核不过 → partial + unlock 指引。
+      let entry = repoRoot ? probeCrossWorktreeEntry(repoRoot, wtPath) : { registered: false, locked: false };
+      if (entry.registered) {
+        try { gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch { residual.push(`git worktree prune 失败（${repoRoot}）`) }
+        entry = repoRoot ? probeCrossWorktreeEntry(repoRoot, wtPath) : { registered: false, locked: false };
+      }
+      if (!entry.registered) {
+        removePlacementRegistryEntry(base, changeName, repoKey); // 挪位清理后注册表键回收（FR-02）
+        results.push({ repoKey, result: 'skipped', details: ['目录不存在（注册 prune 后复核通过）'], residual });
+      } else {
+        if (entry.locked) details.push(`条目 locked（prune 静默跳过）——git -C ${repoRoot} worktree unlock ${wtPath} 后重试`);
+        residual.push(`幽灵注册残留 ${wtPath}（目录不存在但注册仍在）`);
+        results.push({ repoKey, result: 'partial', details, residual });
+      }
       continue;
     }
     if (!force) {
       // fail-closed：worktree 内还有未落地交付（相对 baseHash 有 diff）时拒绝清理（对齐主仓
-      // hasUnappliedChanges 哲学；跨仓侧以「分支上有交付 diff 且未 apply」近似）
+      // hasUnappliedChanges 哲学；跨仓侧以「分支上有交付 diff 且未 apply」近似）。
+      // 自家 meta.json 不算交付（坑 cross-wt-ghost-metadata 顺带修正：CLI 写的 meta.json 恒为
+      // untracked，此前计入未 apply 面使 force=false 清理对刚建的空 worktree 恒误报 blocked）。
       try {
         const diff = gitQuiet(wtPath, ['diff', '--name-only', meta.baseHash]) || '';
-        const untracked = gitQuiet(wtPath, ['ls-files', '--others', '--exclude-standard']) || '';
-        if (diff.trim() || untracked.trim()) {
+        const untracked = (gitQuiet(wtPath, ['ls-files', '--others', '--exclude-standard']) || '')
+          .split('\n').map((s) => s.trim()).filter((f) => f && f !== META_FILE);
+        if (diff.trim() || untracked.length > 0) {
           results.push({ repoKey, result: 'partial', details: [`blocked: 跨仓 worktree 有未 apply 的交付改动（git diff ${String(meta.baseHash).slice(0, 8)} 非空）——先 apply 或显式 --force`], residual: [wtPath] });
           continue;
         }
@@ -429,11 +479,26 @@ export function cleanupCrossWorktrees({ cwd, changeName, specBase, force = false
     try {
       git(repoRoot, ['worktree', 'remove', '--force', wtPath], { timeout: 60000 });
     } catch {
-      // remove 失败（脏文件/锁）：解链后安全删目录 + prune 注册
+      // remove 失败（脏文件/锁/locked——locked 条目 remove 被拒，解锁需两次 --force，不自动解除
+      // 用户显式保护意图，只提示）：解链后安全删目录 + prune 注册
       // allowCross:true——本函数就是跨仓清理的显式路径（主仓守卫放行；见 safeRemoveWorktreeDir 注释）
+      const probe = repoRoot ? probeCrossWorktreeEntry(repoRoot, wtPath) : { registered: false, locked: false };
+      if (probe.locked) details.push(`worktree locked（remove 被拒）——git -C ${repoRoot} worktree unlock ${wtPath} 后重跑`);
       try { safeRemoveWorktreeDir(wtPath, meta, { allowCross: true }) } catch (e) { residual.push(`目录残留 ${wtPath}: ${e.message}`) }
       try { gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch { residual.push(`git worktree prune 失败（${repoRoot}）`) }
     }
+    // 双清复核：remove 退出码为零 ≠ 注册已清（prune 未生效/竞态/locked 残留时 list 仍含该
+    // root）——以 git worktree list 答复为准（对齐 gate-snapshot D-004@v2）。无 repoRoot 的
+    // legacy 假 meta（测试夹具/手写形态）无从复核，视同未注册不误伤。
+    let entry = repoRoot ? probeCrossWorktreeEntry(repoRoot, wtPath) : { registered: false, locked: false };
+    if (entry.registered) {
+      try { gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch { residual.push(`git worktree prune 失败（${repoRoot}）`) }
+      entry = repoRoot ? probeCrossWorktreeEntry(repoRoot, wtPath) : { registered: false, locked: false };
+    }
+    if (entry.registered) {
+      if (entry.locked) details.push(`条目 locked（prune 静默跳过）——git -C ${repoRoot} worktree unlock ${wtPath} 后重跑`);
+      residual.push(`worktree 注册残留（复核 git worktree list 仍含 ${wtPath}）`);
+    }
     details.push(`分支 ${meta.branch} 保留作 review 锚点（确认无需回溯后可 git -C ${repoRoot} branch -D ${meta.branch}）`);
     if (residual.length === 0) {
       removePlacementRegistryEntry(base, changeName, repoKey); // cleaned 后注册表键回收（FR-02）
@@ -447,3 +512,87 @@ export function cleanupCrossWorktrees({ cwd, changeName, specBase, force = false
   if (swept.length > 0) results.push({ repoKey: '(registry-sweep)', result: 'cleaned', details: [`悬挂注册表键已清: ${swept.join('、')}`], residual: [] });
   return { results };
 }
+
+/**
+ * 扫描 local.yaml repos 各仓的幽灵 worktree 注册（缺口③，坑 cross-wt-ghost-metadata
+ * 2026-10-10 fire-equipment 实证：目录被清、跨仓仓 .git/worktrees/ 注册残留 → 分支被幽灵
+ * 占用无法 checkout；且 meta.json 随目录同亡，cleanup/归档链对该形态天然隐身——从跨仓仓
+ * 自己的注册面反扫是唯一可见面）。
+ *
+ * 只报「注册指向不存在路径」的条目（与 git prune 同语义面，不动活 worktree、不碰分支）；
+ * locked 条目单独标注（prune 对它们静默跳过，需先 unlock）。只读零副作用。
+ *
+ * @param {string} cwd 主仓根（读 cwd/.sillyspec/local.yaml repos 段）
+ * @returns {{ repos: Array<{repoKey, repoRoot}>, ghosts: Array<{repoKey, repoRoot, worktreePath, locked}>, errors: Array<{repoKey, repoRoot, error}> }}
+ */
+export function scanCrossWorktreeGhosts(cwd) {
+  const repos = [...readRepoRegistry(cwd).entries()].map(([repoKey, repoRoot]) => ({ repoKey, repoRoot }));
+  const ghosts = [];
+  const errors = [];
+  for (const { repoKey, repoRoot } of repos) {
+    let out = null;
+    try { out = gitQuiet(repoRoot, ['worktree', 'list', '--porcelain'], { timeout: 30000 }) } catch { out = null }
+    if (out == null) {
+      errors.push({ repoKey, repoRoot, error: 'git worktree list 不可达（非 git 仓/路径失效）' });
+      continue;
+    }
+    let cur = null;
+    let locked = false;
+    const flush = () => { if (cur && !existsSync(cur)) ghosts.push({ repoKey, repoRoot, worktreePath: cur, locked }) };
+    for (const line of String(out).split('\n')) {
+      if (line.startsWith('worktree ')) {
+        flush();
+        cur = line.slice('worktree '.length).trim();
+        locked = false;
+      } else if (line === 'locked' || line.startsWith('locked ')) {
+        locked = true;
+      } else if (line.trim() === '') {
+        flush();
+        cur = null;
+        locked = false;
+      }
+    }
+    flush();
+  }
+  return { repos, ghosts, errors };
+}
+
+/**
+ * 清理跨仓幽灵 worktree 注册（doctor --prune-cross-worktrees 动作体，对齐 --cleanup-ghosts
+ * 范式：默认 dry-run 只列，confirm=true 才执行）。
+ *
+ * confirm 语义：对每个有非 locked 幽灵的仓跑 `git worktree prune`（git 自身只清指向不存在
+ * 位置的注册，活 worktree 不受影响），随后**复扫断言**（清了什么以复扫为准，不信任 prune
+ * 退出码）；locked 条目一律跳过并列出 unlock 指引（locked 是用户显式保护意图，不自动解除）。
+ *
+ * @param {{ cwd: string, confirm?: boolean }} opts
+ */
+export function pruneCrossWorktreeGhosts({ cwd, confirm = false }) {
+  const before = scanCrossWorktreeGhosts(cwd);
+  if (!confirm) {
+    return { confirm: false, repos_scanned: before.repos.length, count: before.ghosts.length, ghosts: before.ghosts, errors: before.errors };
+  }
+  const skippedLocked = [];
+  const pruneByRepo = new Map();
+  for (const g of before.ghosts) {
+    if (g.locked) { skippedLocked.push(g); continue }
+    if (!pruneByRepo.has(g.repoRoot)) pruneByRepo.set(g.repoRoot, []);
+    pruneByRepo.get(g.repoRoot).push(g);
+  }
+  const errors = [...before.errors];
+  for (const repoRoot of pruneByRepo.keys()) {
+    try { gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch (e) { errors.push({ repoRoot, error: `prune 失败: ${e.message}` }) }
+  }
+  // 复扫断言：prune 退出码为零 ≠ 注册已清（双清契约同源）
+  const after = scanCrossWorktreeGhosts(cwd);
+  const afterPaths = new Set(after.ghosts.map((g) => g.worktreePath));
+  const pruned = [];
+  for (const g of before.ghosts) {
+    if (g.locked) continue;
+    if (!afterPaths.has(g.worktreePath)) pruned.push(g);
+    else if (!errors.some((e) => e.repoRoot === g.repoRoot && String(e.error).includes('prune 失败'))) {
+      errors.push({ repoKey: g.repoKey, repoRoot: g.repoRoot, error: 'prune 后复扫仍在（疑似 locked 或 git 锁竞态）' });
+    }
+  }
+  return { confirm: true, repos_scanned: before.repos.length, count: before.ghosts.length, pruned, skipped_locked: skippedLocked, remaining: after.ghosts, errors };
+}