sillyspec 3.28.6 → 3.28.8

package/src/decision-distill.js

@@ -78,6 +78,8 @@ function applyField(entry, label, value) {
     case 'answer': case '答案': entry.answer = value; break
     case '锚点': case 'anchor': entry.anchor = value; break
     case '模块域': case '模块': case 'domains': case 'domain': entry.domains = parseListValue(value); break
+    // 文件字段（FR-01/D-001@v1，2026-09-11-cross-change-decision-guard）：列表语义同模块域 + 逐项反斜杠归一 POSIX
+    case '文件': case 'files': entry.files = parseListValue(value).map(s => s.replace(/\\/g, '/')); break
     case '否决理由': case 'reject_reason': case 'rejectreason': entry.rejectReason = value; break
     case '复潮条件': case 'revisit_when': case 'revisitwhen': entry.revisitWhen = value; break
     case 'supersedes': entry.supersedes = value; break
@@ -93,7 +95,7 @@ function applyField(entry, label, value) {
  * @returns {{ entries: Array<{
  *   id: string, number: string, version: number, title: string,
  *   type?: string, status?: string, question?: string, answer?: string,
- *   anchor?: string, domains?: string[], rejectReason?: string, revisitWhen?: string,
+ *   anchor?: string, domains?: string[], files?: string[], rejectReason?: string, revisitWhen?: string,
  *   supersedes?: string, impacts?: string, normalizedRequirement?: string,
  *   selected: 'implemented'|'rejected'|null, raw: string }>, missing: boolean }}
  *   missing=true = decisions.md 不存在；selected = FR-02 入选裁决，null 表示解析保留但不入选。
@@ -165,7 +167,7 @@ export function parseDecisions(changeDir) {
 }
 
 /** applyField 认识的字段标签白名单（行内 ｜ 分段与缩进子项只按白名单进字段，散文误伤为零） */
-const FIELD_LABEL_RE = /^(type|types|status|question|问题|answer|答案|锚点|anchor|模块域|模块|domains|domain|否决理由|reject_reason|rejectreason|复潮条件|revisit_when|revisitwhen|supersedes|impacts|影响|normalized_requirement|状态|类型)$/i
+const FIELD_LABEL_RE = /^(type|types|status|question|问题|answer|答案|锚点|anchor|模块域|模块|domains|domain|否决理由|reject_reason|rejectreason|复潮条件|revisit_when|revisitwhen|supersedes|impacts|影响|文件|files|normalized_requirement|状态|类型)$/i
 
 // ---------------------------------------------------------------------------
 // 域三级兜底（FR-03）
@@ -293,6 +295,8 @@ function renderBlockLines(entry, headHash, supersedesNote, changeName) {
   lines.push(`状态：${entry.selected}`)
   if (changeName) lines.push(`变更：${oneLine(changeName)}`)
   lines.push(`锚点：${oneLine(entry.anchor) || NOT_RECORDED}`)
+  // 文件行（FR-01/D-001@v1）：仅非空渲染——存量条目零迁移，幂等重归档不添空行
+  if (entry.files && entry.files.length > 0) lines.push(`文件：${entry.files.join(', ')}`)
   lines.push(`最近确认：${oneLine(headHash) || NOT_RECORDED}`)
   lines.push(`理由：${oneLine(entry.answer || entry.normalizedRequirement || entry.question)}`)
   if (supersedesNote) lines.push(`supersedes：${oneLine(supersedesNote)}`)

package/src/dispatch/probe.js

@@ -174,7 +174,14 @@ export async function probeSillyHub({ client, worktreePath, rootPath, ttlMs, tot
       console.warn(`[dispatch/probe] probeDaemon 抛异常（保守判 unavailable）: ${msg}`);
       reachable = false;
     }
-    if (!reachable) return cacheNegative('daemon-unreachable');
+    if (!reachable) {
+      // token 失效类型化（2026-09-11 用户实测反馈：吊销/过期 shmcp_ 被报成
+      // daemon-unreachable，误导排障——gateway 在、daemon 在，死的只是凭据）。
+      // 401 与 unreachable 分诊：进同款负面缓存（TTL 内不重试，token 不会自愈）。
+      const initStatus = typeof cli.getLastInitStatus === 'function' ? cli.getLastInitStatus() : null;
+      if (initStatus === 401) return cacheNegative('mcp-token-invalid');
+      return cacheNegative('daemon-unreachable');
+    }
 
     // 3.5+4 合并（HUB-12a）：一次 tools/list 同时拿 tools 数组（路径A schema 预热）与
     //     root_path（越界校验）。旧 client 无 listToolsWithMeta 时回退 listTools +

package/src/docs-check.js

@@ -14,10 +14,95 @@
  * 仅「目录递归」「目录单层」「字面路径」三形态）；Windows 路径归一化；兼容 CRLF/LF。
  */
 import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs'
-import { join } from 'node:path'
+import { join, resolve as pathResolve, relative as pathRelative, sep as pathSep } from 'node:path'
+import { execFileSync } from 'node:child_process'
 import jsYaml from 'js-yaml'
 import { parseModuleMapSimple } from './modules.js'
 
+// ── HEAD 模式内容解析层（坑 docs-gate-shared-worktree-parallel-block，2026-09-08 实证）──
+// pre-push gate 校验的语义对象是「被推送的提交树」，而磁盘工作区混有并行会话的未提交
+// 改动——活文档锚点被在途编辑瞬时漂移，任何会话此时推送都被拦（移动靶，5→7 波动实证）。
+// --against HEAD 模式：文档与源码内容一律取 HEAD 版本——干净文件磁盘直读（与 HEAD
+// 逐字节一致，零额外开销）、脏文件（M/D/R）git show 取 HEAD 内容、未跟踪（??）视为
+// 不存在（不随推送走，本就不该校验）。已知边界（接受并留档）：工作区未提交删除的
+// tracked 文档不出现在磁盘 doc 枚举里（walkGlob 扫盘）——其 HEAD 版本确属推送树，
+// 此边角漏检远轻于移动靶误拦；裸名引用仅命中「工作区已删」源文件时层1 找不到候选。
+// 模块级 active reader（set/try/finally restore，quicklog setQuickFileNotes 同款先例）：
+// readLines / resolveCandidates / runDocsCheck / collectInvalidDocRefs 的读统一经此层，
+// reader 未激活时行为与磁盘直读逐字节等价（既有调用方/单测零感知）。
+let _headReader = null
+/** 测试与 runDocsCheck 内部使用：激活/恢复 HEAD reader（返回前值供 finally 还原）。 */
+export function _setHeadReaderForCheck(reader) {
+  const prev = _headReader
+  _headReader = reader
+  return prev
+}
+
+function _rdText(absPath) {
+  if (!_headReader) {
+    try { return readFileSync(absPath, 'utf8') } catch { return null }
+  }
+  return _headReader.readText(absPath)
+}
+
+function _rdExists(absPath) {
+  if (!_headReader) return existsSync(absPath)
+  return _headReader.existsAt(absPath)
+}
+
+/**
+ * 构造 HEAD 模式 reader。非 git 仓 / projectRoot 非 git 根（porcelain 路径相对仓根，
+ * 归一失配）/ git 调用失败 → 返回 null（调用方回退磁盘模式并 warn）。
+ * git status 只列差异文件：不在 status 里的 tracked 文件 = 干净（磁盘读即 HEAD 读）；
+ * ?? 未跟踪 → HEAD 无此文件（existsAt=false, readText=null）；M/D/R → HEAD 仍在
+ * （existsAt=true），内容经 git show（带缓存，脏文件数量级 = 并行会话在途编辑数）。
+ */
+export function createHeadReader(projectRoot, ref = 'HEAD') {
+  const root = pathResolve(projectRoot)
+  const git = (args) => execFileSync('git', ['-C', root, ...args], {
+    encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'],
+  })
+  let toplevel
+  try { toplevel = git(['rev-parse', '--show-toplevel']).trim() } catch { return null }
+  if (toplevel.split(/[\\/]/).join('/') !== root.split(/[\\/]/).join('/')) return null
+  const status = new Map() // rel(正斜杠) → 'M' | 'D' | 'U'
+  try {
+    for (const line of git(['status', '--porcelain', '--', '.']).split(/\r?\n/)) {
+      if (!line) continue
+      const code = line.slice(0, 2)
+      let p = line.slice(3)
+      if (code.includes('R')) p = p.split(' -> ').pop() // 重命名记新路径
+      p = p.replace(/^"|"$/g, '')
+      const st = code.includes('?') ? 'U' : code.includes('D') ? 'D' : 'M'
+      status.set(p, st)
+    }
+  } catch { return null }
+  const showCache = new Map()
+  const relOf = (abs) => pathRelative(root, pathResolve(abs)).split(pathSep).join('/')
+  return {
+    ref,
+    readText(absPath) {
+      const rel = relOf(absPath)
+      const st = status.get(rel)
+      if (st === undefined) {
+        try { return readFileSync(absPath, 'utf8') } catch { return null } // 干净：磁盘即 HEAD
+      }
+      if (st === 'U') return null // 未跟踪：HEAD 无此文件
+      if (showCache.has(rel)) return showCache.get(rel)
+      let text = null
+      try { text = git(['show', `${ref}:${rel}`]) } catch { text = null }
+      showCache.set(rel, text)
+      return text
+    },
+    existsAt(absPath) {
+      const st = status.get(relOf(absPath))
+      if (st === 'U') return false // 未跟踪 → HEAD 不存在
+      if (st === 'D' || st === 'M') return true // 工作区删/改 → HEAD 仍在
+      return existsSync(absPath)
+    },
+  }
+}
+
 /** 提取 file.js:line / file.js:start-end 引用（反引号包裹与裸文本均命中，全文扫描 D-006）。
  * 扩展名覆盖（archify 借鉴 P1b，2026-09-04）：js/mjs/cjs/ts/tsx/jsx/py/java/go——
  * scan 产物面向任意技术栈项目（如 SillyHub = Python + TypeScript），只认 .js 会让
@@ -268,16 +353,19 @@ function findInTree(dir, baseName, rel = '', treeCache = null) {
 export function resolveCandidates(projectRoot, refFile, treeCache = null) {
   if (refFile.includes('/')) {
     const direct = join(projectRoot, refFile)
-    if (existsSync(direct)) return [direct]
+    if (_rdExists(direct)) return [direct]
     const inSrc = join(projectRoot, 'src', refFile)
-    if (existsSync(inSrc)) return [inSrc]
+    if (_rdExists(inSrc)) return [inSrc]
     const slash = refFile.lastIndexOf('/')
     const baseName = slash === -1 ? refFile : refFile.slice(slash + 1)
     return findInTree(join(projectRoot, 'src'), baseName, '', treeCache)
       .filter((rel) => ('src/' + rel).endsWith('/' + refFile) || 'src/' + rel === 'src/' + refFile)
       .map((rel) => join(projectRoot, 'src', rel))
+      .filter((abs) => _rdExists(abs)) // HEAD 模式：未跟踪源文件不进推送树，不作候选
   }
-  return findInTree(join(projectRoot, 'src'), refFile, '', treeCache).map((rel) => join(projectRoot, 'src', rel))
+  return findInTree(join(projectRoot, 'src'), refFile, '', treeCache)
+    .map((rel) => join(projectRoot, 'src', rel))
+    .filter((abs) => _rdExists(abs))
 }
 
 /**
@@ -301,9 +389,8 @@ export function collectInvalidDocRefs(projectRoot, docEntries) {
   const linesCache = new Map()
   for (const { name, absPath } of docEntries) {
     let content
-    try {
-      content = readFileSync(absPath, 'utf8')
-    } catch {
+    content = _rdText(absPath)
+    if (content === null) {
       readFailures++
       continue
     }
@@ -355,7 +442,9 @@ function readLines(absPath, linesCache = null) {
     return lines
   }
   try {
-    const lines = readFileSync(absPath, 'utf8').split(/\r?\n/)
+    const text = _rdText(absPath)
+    if (text === null) return null
+    const lines = text.split(/\r?\n/)
     if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop()
     return lines
   } catch { return null }
@@ -479,6 +568,28 @@ function relDisplay(absPath, projectRoot) {
  * @throws {DocsCheckConfigError} glob 形态不支持
  */
 export function runDocsCheck(opts) {
+  // --against <ref>（坑 docs-gate-shared-worktree-parallel-block）：pre-push gate 校验
+  // 「被推送的提交树」而非工作区——激活 HEAD reader 隔离并行会话在途编辑（移动靶）。
+  // 非 git 仓/子目录/git 异常 → 回退磁盘模式并附 warning。--fix 路径不经此（applyFixes
+  // 恒操作工作区磁盘内容，against 对 fix 无意义，CLI 层已拒绝组合）。
+  const against = opts && opts.against ? String(opts.against) : null
+  if (!against) return _runDocsCheckCore(opts)
+  const reader = createHeadReader(opts.projectRoot, against)
+  if (!reader) {
+    const r = _runDocsCheckCore(opts)
+    r.warnings = [...(r.warnings || []),
+      `--against ${against} 不可用（非 git 仓 / 非 git 根子目录 / git 异常），已回退磁盘模式——并行在途编辑可能造成移动靶误拦`]
+    return r
+  }
+  const prev = _setHeadReaderForCheck(reader)
+  try {
+    return _runDocsCheckCore(opts)
+  } finally {
+    _setHeadReaderForCheck(prev)
+  }
+}
+
+function _runDocsCheckCore(opts) {
   // paths/docs 显式传 null（readDocsCheckConfig 无 local.yaml 段时的回退值）须落回缺省 glob，
   // 解构默认值只挡 undefined 不挡 null——docs-check 无配置裸跑曾因此 null.flatMap 崩溃。
   const {
@@ -511,7 +622,10 @@ export function runDocsCheck(opts) {
 
   for (const docRel of docFiles) {
     const docAbs = join(projectRoot, docRel)
-    if (!existsSync(docAbs)) {
+    // HEAD 模式：未跟踪文档（walkGlob 扫盘枚举到但不随推送走）静默跳过——不是失效，
+    // 也不该以「文档不存在」入 invalid（它存在于工作区，只是不属于被推送的提交树）。
+    if (_headReader && !_rdExists(docAbs)) { skippedExempt++; continue }
+    if (!_rdExists(docAbs)) {
       invalid.push({
         doc: docRel, docLine: 0, ref: '', reason: '文档不存在',
         fix: { fixable: false, reason: '文档不存在，无法自动定位' },
@@ -521,7 +635,16 @@ export function runDocsCheck(opts) {
     // 豁免双通道（FR-3 / D-003）：路径段判定免 IO（readFileSync 前）；
     // frontmatter 判定需读文件（读取后）。豁免文档整体跳过不计 invalid。
     if (exempt && isExemptDocPath(docRel)) { skippedExempt++; continue }
-    const md = readFileSync(docAbs, 'utf8')
+    const md = _rdText(docAbs)
+    if (md === null) {
+      // HEAD 模式下未跟踪文档（不随推送走，walkGlob 扫盘枚举到此）——不计失效不报警
+      if (_headReader) { skippedExempt++; continue }
+      invalid.push({
+        doc: docRel, docLine: 0, ref: '', reason: '文档不可读',
+        fix: { fixable: false, reason: '文档不可读（权限/路径异常）' },
+      })
+      continue
+    }
     if (exempt && isExemptDocFrontmatter(md)) { skippedExempt++; continue }
     const refs = collectDocRefs(md)
     const mdLines = md.split(/\r?\n/)
@@ -836,10 +959,12 @@ export const DECISIONS_DEFAULT_BEHIND_THRESHOLD = 10
  * @param {string} yamlText local.yaml 全文
  * @returns {string[]} 键列表；无声明返回 []
  */
-function extractKnownFailureKeys(yamlText) {
+export function extractKnownFailureKeys(yamlText) {
   if (!yamlText) return []
   const yaml = String(yamlText).replace(/\r\n?/g, '\n')
-  const inline = yaml.match(/^known_failures:\s*\[([^\]]*)\]\s*(?:#.*)?$/m)
+  // 贪婪 .* 同 verify-postcheck.extractKnownFailures（坑 known-failures-inline-nested-bracket：
+  // 值内 ] 使 [^\]]* 截断、整表静默清空；两处复刻必须同口径互指）
+  const inline = yaml.match(/^known_failures:\s*\[(.*)\]\s*(?:#.*)?$/m)
   if (inline) {
     return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
   }

package/src/docs-gate.js

@@ -77,6 +77,9 @@ export async function runDocsGate(opts = {}, checkOpts = {}) {
       skip: checkOpts.skip || cfg.skip,
       keywordAssert: checkOpts.keywordAssert ?? cfg.keywordAssert,
       crossRepoRoots: checkOpts.crossRepoRoots || cfg.crossRepoRoots,
+      // 坑 docs-gate-shared-worktree-parallel-block：--against <ref> 透传——按提交树校验
+      //（pre-push 语义），隔离并行会话在途编辑的锚点瞬时漂移（移动靶）
+      ...(checkOpts.against ? { against: checkOpts.against } : {}),
     });
   } catch (e) {
     if (e instanceof DocsCheckConfigError) {

package/src/doctor-diagnostics.js

@@ -856,7 +856,7 @@ export function detectMcpEndpoints(cwd) {
  * _module-map.yaml 的 needs_review=true 清单（卡缺失/精确校验归 modules rebuild/status）。
  * 只读 fail-soft。
  */
-function detectModuleDocHealth(cwd) {
+export function detectModuleDocHealth(cwd) {
   const base = { name: 'module_doc_health', label: '模块文档健康', safe_actions: [] }
   try {
     let mapText = null
@@ -870,7 +870,8 @@ function detectModuleDocHealth(cwd) {
     if (!mapText) return { ...base, findings: ['无 _module-map.yaml（未 scan）——skipped'], pass: true, severity: null, skipped: true }
     const findings = []
     // needs_review 清单（模块块内 needs_review: true）
-    const blocks = mapText.split(/\n(?=  \\w)/)
+    // \\w 是「字面反斜杠+w」——永不分割，整文件当一块只查首个模块（ql-20260911-029）
+    const blocks = mapText.split(/\n(?=  \w)/)
     for (const blk of blocks) {
       const idM = blk.match(/^  ([\w.-]+):/)
       if (idM && /needs_review:\s*true/.test(blk)) {
@@ -999,13 +1000,24 @@ function detectLifecycleDocStaleness(cwd) {
     return { ...base, pass: true, severity: null, findings: ['文档时间戳不可解析，跳过（不误报）'] };
   }
   // 生命周期代码侧最新提交（取各敏感路径 max %ct；任一路径 untracked 新文件不在 log 里，
-  // git 不可见性注记——工作树未提交改动本就不该由 doctor 报，提交后自然可见）
+  // git 不可见性注记——工作树未提交改动本就不该由 doctor 报，提交后自然可见）。
+  // 批 E-②：单次多 pathspec git log 取 max（原逐路径 6 个串行子进程，Windows ~0.4-1s）；
+  // 仅当检出「文档落后」需要归因到具体路径时，才退回逐路径解析（罕见告警路径）。
   let srcTs = 0;
   let srcPath = null;
-  for (const p of LIFECYCLE_SENSITIVE_PATHS) {
-    const r = safeGit(cwd, ['log', '-1', '--format=%ct', '--', p]);
-    const ts = Number(r.value);
-    if (Number.isFinite(ts) && ts > srcTs) { srcTs = ts; srcPath = p; }
+  const combined = safeGit(cwd, ['log', '-1', '--format=%ct', '--', ...LIFECYCLE_SENSITIVE_PATHS]);
+  srcTs = Number(combined.value);
+  if (!Number.isFinite(srcTs) || srcTs <= 0) srcTs = 0;
+  if (docTs < srcTs) {
+    // 归因：找 ts === srcTs 的路径（等不到就取最大有限值兜底）
+    let bestTs = 0
+    for (const p of LIFECYCLE_SENSITIVE_PATHS) {
+      const r = safeGit(cwd, ['log', '-1', '--format=%ct', '--', p]);
+      const ts = Number(r.value);
+      if (!Number.isFinite(ts)) continue;
+      if (ts === srcTs) { srcPath = p; break; }
+      if (ts > bestTs) { bestTs = ts; srcPath = p; }
+    }
   }
   if (srcTs === 0) {
     return { ...base, pass: true, severity: null, findings: ['生命周期代码无提交历史，跳过'] };

package/src/friction-tally.js

@@ -26,6 +26,7 @@
 import { existsSync, mkdirSync, readFileSync, rmSync } from 'fs'
 import { dirname, join } from 'path'
 import { writeAtomicSync } from './fs-atomic.js'
+import { withFileLock } from './quicklog.js'
 import { resolveRuntimeRoot, resolveQuickSessionsDir } from './run/shared.js'
 
 /** 摩擦事件类型枚举（D-004）：审查打回走专属 review_rejected，不与 gate_rollback 重复计 */
@@ -169,13 +170,14 @@ export function renderFrictionHintLine(counts) {
  * @param {string} [p.detail] 预定义来源标签（如 verify-test/quick-audit），非字符串落 null
  * @returns {{ type: string, count: number } | null} 落盘成功返回新计数；null = 未落盘
  */
-export function recordFrictionEvent({ cwd, platformOpts, changeName, type, detail }) {
+export async function recordFrictionEvent({ cwd, platformOpts, changeName, type, detail }) {
   try {
     if (!FRICTION_TYPES.has(type)) return null
     const tallyPath = frictionTallyPath({ cwd, platformOpts, changeName })
     if (!tallyPath) return null
     // enabled=false 直通：record/consume 双 no-op，.runtime 零写入（D-003 一键全关）
     if (!readFrictionHintEnabled(deriveSpecBase(cwd, platformOpts))) return null
+    return await withFileLock(tallyPath + ".lock", async () => {
     const tally = readFrictionTally(tallyPath)
     const at = new Date().toISOString()
     const prev = Number(tally.events[type] && tally.events[type].count)
@@ -188,6 +190,7 @@ export function recordFrictionEvent({ cwd, platformOpts, changeName, type, detai
     mkdirSync(dirname(tallyPath), { recursive: true })
     writeAtomicSync(tallyPath, JSON.stringify(tally, null, 2))
     return { type, count }
+    })
   } catch {
     return null
   }
@@ -201,11 +204,12 @@ export function recordFrictionEvent({ cwd, platformOpts, changeName, type, detai
  * 会再消费一次，advisory 容忍重复，不因删失败丢提示。
  * @returns {{ hint: string | null, counts: Record<string, number> }}
  */
-export function consumeFrictionHint({ cwd, platformOpts, changeName }) {
+export async function consumeFrictionHint({ cwd, platformOpts, changeName }) {
   try {
     const tallyPath = frictionTallyPath({ cwd, platformOpts, changeName })
     if (!tallyPath || !existsSync(tallyPath)) return { hint: null, counts: {} }
     if (!readFrictionHintEnabled(deriveSpecBase(cwd, platformOpts))) return { hint: null, counts: {} }
+    return await withFileLock(tallyPath + ".lock", async () => {
     const tally = readFrictionTally(tallyPath)
     const counts = {}
     for (const type of FRICTION_TYPES) {
@@ -215,6 +219,7 @@ export function consumeFrictionHint({ cwd, platformOpts, changeName }) {
     if (Object.keys(counts).length === 0) return { hint: null, counts }
     try { rmSync(tallyPath, { force: true }) } catch { /* 删失败不吞提示 */ }
     return { hint: renderFrictionHintLine(counts), counts }
+    })
   } catch {
     return { hint: null, counts: {} }
   }

package/src/git-helper.js

@@ -124,16 +124,18 @@ export function safeGit(cwd, args, opts = {}) {
  * @returns {string|Buffer}
  */
 export function git(cwd, args, opts = {}) {
-  const { trim = true, timeout = 5000, encoding = 'utf8' } = opts
+  const { trim = true, timeout = 5000, encoding = 'utf8', env } = opts
   const fullArgs = buildFullArgs(cwd, args)
-  const value = execFileSync('git', fullArgs, { encoding, timeout, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'] })
+  // env（终批-③）：可选注入（如 baseline checkpoint 的临时 GIT identity）——调用方必须
+  // 用 { ...process.env, GIT_xxx } 展开形式，裸替换会丢 SystemRoot/USERPROFILE/TEMP（Windows）
+  const value = execFileSync('git', fullArgs, { encoding, timeout, maxBuffer: GIT_MAX_BUFFER, stdio: ['ignore', 'pipe', 'pipe'], env })
   if (Buffer.isBuffer(value)) return value
   return trim ? value.trim() : value
 }
 
 /**
  * 静默版 git：内部调 git，失败 catch 返回 null（对齐 worktree 本地 gitQuiet() 语义）。
- * ENOBUFS（输出超 32MB）不是"无输出"，静默成 null 会让调用方把大输出误当空清单——
+ * ENOBUFS（输出超 GIT_MAX_BUFFER 上限）不是"无输出"，静默成 null 会让调用方把大输出误当空清单——
  * 至少 stderr 留一行，不与正常空结果同语义。
  * @param {string} cwd
  * @param {string[]} args
@@ -145,7 +147,7 @@ export function gitQuiet(cwd, args, opts = {}) {
     return git(cwd, args, opts)
   } catch (e) {
     if (e && e.code === 'ENOBUFS') {
-      console.error(`[sillyspec] git 输出超过 32MB 上限被截断：git ${args.join(' ')}`)
+      console.error(`[sillyspec] git 输出超过 ${GIT_MAX_BUFFER / (1024 * 1024)}MB 上限被截断：git ${args.join(' ')}`)
     }
     return null
   }

package/src/hooks/worktree-guard.js

@@ -11,7 +11,7 @@
 
 import { existsSync, readFileSync, readdirSync } from 'fs'
 import path from 'path'
-import { execFileSync } from 'child_process'
+import { createRequire } from 'node:module'
 
 // ── 常量 ──
 
@@ -29,8 +29,9 @@ const READONLY_COMMANDS = new Set([
   'node', 'npm', 'npx', // 只允许 --version 等只读子命令，在 matchReadonlyWhitelist 中处理
 ])
 
-/** 只读 git 子命令（stash 不在此列：drop/clear/pop 破坏性，仅下方 matchReadonly 细化放行 list/裸查询） */
-const READONLY_GIT_SUBS = new Set(['diff', 'status', 'log', 'show', 'branch'])
+/** 只读 git 子命令（stash/branch/worktree 不在此列：branch 的 -d/-D/-m/-M 破坏性、worktree
+ *  的 remove --force 可删未提交工作区——各自在下方按参数细化放行） */
+const READONLY_GIT_SUBS = new Set(['diff', 'status', 'log', 'show'])
 
 /** 危险 git 子命令 */
 const DANGER_GIT_SUBS = new Set([
@@ -38,6 +39,14 @@ const DANGER_GIT_SUBS = new Set([
   'mv', 'rm',
 ])
 
+/** git branch 的破坏性 flag（-d/-D 删分支、-m/-M 改名、-f 强建重指；含长形同义）——
+ *  删/改分支会让 task review 的 base/head ref 引用悬空（gc 后真丢），2026-09-11 审查 P1 收口 */
+const BRANCH_DESTRUCTIVE_RE = /^(?:-[dDmMf]|--delete|--force|--move|--edit-description)(?:=|$)/
+
+function hasDestructiveBranchFlag(parts) {
+  return parts.slice(2).some(tok => BRANCH_DESTRUCTIVE_RE.test(tok))
+}
+
 /** 危险 git stash 操作 */
 const DANGER_STASH_ACTIONS = new Set(['drop', 'clear', 'pop'])
 
@@ -235,9 +244,9 @@ function isInsideWorktreeStorage(filePath, cwd) {
 /**
  * 同步只读查询 sillyspec.db 第一行第一列（不依赖外部 sqlite3 CLI）。
  *
- * 用子进程跑 node:sqlite 的 DatabaseSync（execFileSync 等待）：
- * - node:sqlite 是 Node 内置模块，子进程 require('node:sqlite') 直接可用，无需先 resolve 出
- *   绝对路径再注入（旧方案需手动解析原生绑定路径，node:sqlite 无此步骤）。
+ * 进程内 createRequire 同步加载 node:sqlite 的 DatabaseSync（2026-09-11 审查性能包②：旧实现
+ * 每次查询 spawn 一个 node 子进程，Windows 100-300ms/次，hook 每次 Write/Edit/Bash 触发 1-2 次；
+ * hook 自身就是同一 node 二进制，子进程无隔离收益只有延迟）：
  * - readOnly 打开只读连接（替代旧方案 readonly/fileMustExist 语义）：绝不写库；WAL 并发读不阻塞主进程写，
  *   且只读连接可看到已 commit 但未 checkpoint 的过渡态（修复旧 WASM 内存库裸读 .db
  *   看不见 WAL 的过渡态可见性窗口）。db 缺失/损坏由 open 异常自然触发 fail-closed（外层 catch）。
@@ -245,7 +254,7 @@ function isInsideWorktreeStorage(filePath, cwd) {
  * 环境假设（R-09）：WAL 模式下只读连接仍需在 .runtime/ 目录建/更新 -shm 索引文件，故 .runtime
  * 必须可写（与主进程一致）——“只读”指不改 DB 数据，不等于不对 -shm 加索引。
  *
- * fail-closed：db 文件不存在 / 子进程打开、查询异常 / 子进程超时或崩溃——一律 console.warn
+ * fail-closed：db 文件不存在 / 打开、查询异常 / node:sqlite 不可用——一律 console.warn
  * （含 e.stderr 详情）并返回 null，调用方（readCurrentStage/isNoWorktreeMode）对 null 走
  * fail-closed，禁止 fail-open。
  */
@@ -257,26 +266,26 @@ function queryDbFirstCell(cwd, sql) {
     console.warn('⚠️ sillyspec.db 不存在，hook 降级 fail-closed: ' + dbPath)
     return null
   }
-  // 子进程同步内置 require('node:sqlite')（DatabaseSync 是同步 API，无 async/import().then 包装）。
-  // prepare(sql).get() 取第一行整行后取首列值，无行返回 undefined（写空 stdout → 父侧 trim 后 null）。
-  const script =
-    "const {DatabaseSync}=require('node:sqlite')," +
-    "dbPath=" + JSON.stringify(dbPath) + ",sql=" + JSON.stringify(sql) + ";" +
-    "let db;" +
-    "try{db=new DatabaseSync(dbPath,{readOnly:true});" +
-    "const row=db.prepare(sql).get();" +
-    "const v=row===undefined?undefined:Object.values(row)[0];" +
-    "if(v!==undefined)process.stdout.write(String(v??''));db.close()}" +
-    "catch(e){process.stderr.write('hook db query failed: '+String(e&&e.message||e));process.exit(1)};"
+  // 进程内同步 require node:sqlite（DatabaseSync 同步 API；2026-09-11 审查性能包②：旧实现每次
+  // hook 触发 spawn 一个 node 子进程查库，Windows 100-300ms/次×每 Write/Edit/Bash 1-2 次——
+  // hook 自身就是同一 node 二进制，子进程无隔离收益只有延迟）。异常路径与旧子进程版同语义：
+  // 捕获后 warn + 返回 null，调用方（readCurrentStage 等）对 null 走 fail-closed。
   try {
-    return execFileSync(process.execPath, ['-e', script], {
-      encoding: 'utf8', timeout: 5000, stdio: ['ignore', 'pipe', 'pipe'],
-    }).trim() || null
+    const req = createRequire(import.meta.url)
+    const { DatabaseSync } = req('node:sqlite')
+    let db
+    try {
+      db = new DatabaseSync(dbPath, { readOnly: true })
+      const row = db.prepare(sql).get()
+      const v = row === undefined ? undefined : Object.values(row)[0]
+      return v === undefined ? null : (String(v ?? '') || null)
+    } finally {
+      if (db) db.close()
+    }
   } catch (e) {
-    // DB 查询失败（db 损坏 / readOnly 打开失败 / 子进程超时或崩溃）：降级返回 null，调用方
-    //（readCurrentStage 等）对 null 走 fail-closed。补 warn 让 doctor/agent 能看到根因，
-    // 而非完全静默（子进程把诊断写到了 stderr，execFileSync 抛错时挂在 e.stderr 上）。
-    const detail = (e && e.stderr ? String(e.stderr).trim() : '') || (e && e.message) || 'timeout/crash'
+    // DB 查询失败（db 损坏 / readOnly 打开失败 / node:sqlite 不可用）：降级返回 null，调用方
+    //（readCurrentStage 等）对 null 走 fail-closed。补 warn 让 doctor/agent 能看到根因。
+    const detail = (e && e.message) ? e.message : String(e)
     console.warn('⚠️ sillyspec.db 查询失败，hook 降级 fail-closed: ' + detail)
     return null
   }
@@ -532,10 +541,13 @@ function isSingleCommandReadonly(cmd, extraReadonlyCommands = []) {
   if (cmdName === 'git') {
     const sub = parts[1] || ''
     if (READONLY_GIT_SUBS.has(sub)) return true
+    // git branch：裸查询/建分支放行；-d/-D/-m/-M/-f（含长形）破坏性不放行（按参数细化，不再整类放行）
+    if (sub === 'branch' && !hasDestructiveBranchFlag(parts)) return true
     // git stash list
     if (sub === 'stash' && (parts[2] === 'list' || parts.length === 2)) return true
-    // git worktree 管理（list/add/remove）放行
-    if (sub === 'worktree') return true
+    // git worktree：仅 list（裸 worktree 同 list）。remove --force 可删含未提交改动的工作区、
+    // 且 junction 会穿透删主仓 node_modules——add/remove/prune 一律走 sillyspec worktree 命令（内建护栏）
+    if (sub === 'worktree' && (parts.length === 2 || parts[2] === 'list')) return true
     return false
   }
 
@@ -563,6 +575,10 @@ function isSingleCommandDangerous(cmd) {
   if (cmdName === 'git') {
     const sub = parts[1] || ''
     if (DANGER_GIT_SUBS.has(sub)) return true
+    // git branch -d/-D/-m/-M/-f（含长形）：删/改分支让 task review 的 base/head 引用悬空
+    if (sub === 'branch' && hasDestructiveBranchFlag(parts)) return true
+    // git worktree remove/prune：删工作区（可能含未提交改动）——清理走 sillyspec worktree cleanup
+    if (sub === 'worktree' && ['remove', 'prune'].includes(parts[2] || '')) return true
     // git stash drop/clear/pop
     if (sub === 'stash' && DANGER_STASH_ACTIONS.has(parts[2] || '')) return true
   }
@@ -603,6 +619,20 @@ function matchReadonlyWhitelist(command, extraReadonlyCommands = []) {
  * @param {string} command
  * @returns {boolean}
  */
+/**
+ * 危险拦截原因的定向指引（branch/worktree 的破坏形态有官方替代路径，提示同步到拦截消息）
+ */
+function dangerBlockHint(command) {
+  const parts = String(command).trim().toLowerCase().split(/\s+/)
+  if (parts[0] === 'git' && parts[1] === 'branch') {
+    return '——分支删除/改名/强建会让 task review 的 base/head 引用悬空；分支管理走 sillyspec worktree 流程'
+  }
+  if (parts[0] === 'git' && parts[1] === 'worktree') {
+    return '——worktree 清理走 sillyspec worktree cleanup（内建未落仓护栏），勿裸删工作区'
+  }
+  return ''
+}
+
 function matchDangerBlacklist(command) {
   const parts = splitCommandParts(command)
   return parts.some(p => isSingleCommandDangerous(p))
@@ -825,7 +855,7 @@ function shouldBlockBash(command, cwd) {
   if (stage === 'quick') {
     // 危险黑名单仍然拦截
     if (matchDangerBlacklist(command)) {
-      return { blocked: true, reason: `dangerous command blocked: ${command.trim()}` }
+      return { blocked: true, reason: `dangerous command blocked: ${command.trim()}${dangerBlockHint(command)}` }
     }
     // 检查命令是否会覆盖 baseline files（并集 = 保护所有 session 的 baseline）
     const { baselineFiles } = readAllQuickGuards(projectRoot)
@@ -843,7 +873,7 @@ function shouldBlockBash(command, cwd) {
 
   // 危险黑名单
   if (matchDangerBlacklist(command)) {
-    return { blocked: true, reason: `dangerous command blocked: ${command.trim()}` }
+    return { blocked: true, reason: `dangerous command blocked: ${command.trim()}${dangerBlockHint(command)}` }
   }
 
   // 只读白名单放行