sillyspec 3.28.6 → 3.28.7

package/meta.json

@@ -0,0 +1,11 @@
+{
+  "name_zh": "worktree 元数据",
+  "changeName": "2026-09-11-cross-change-decision-guard",
+  "branch": "sillyspec/2026-09-11-cross-change-decision-guard",
+  "baseBranch": "main",
+  "baseHash": "42aa9927f71b78c903709fadd681d71719855d66",
+  "worktreePath": "C:\\Users\\qinyi\\IdeaProjects\\sillyspec\\.sillyspec\\.runtime\\worktrees\\2026-09-11-cross-change-decision-guard",
+  "mode": "worktree",
+  "createdAt": "2026-09-11T06:50:20.659Z",
+  "provisioning": true
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sillyspec",
-  "version": "3.28.6",
+  "version": "3.28.7",
   "description": "SillySpec CLI — 流程状态机，让 AI 严格按步骤来",
   "icon": "logo.jpg",
   "homepage": "https://sillyspec.ppdmq.top/",

package/src/config-schema.js

@@ -173,6 +173,14 @@ export const LOCAL_YAML_SCHEMA = {
         { path: 'friction_hint.enabled', type: 'boolean', optional: true, status: 'live', readers: ['readFrictionHintEnabled (src/friction-tally.js)'], desc: '摩擦提示开关，默认 true；设 false 关闭摩擦提示（gate 回滚/验证失败/审查打回的收尾 advisory 与计数落盘全停，.runtime 零写入）。', example: 'true' },
       ],
     },
+    {
+      id: 'semantic_guard',
+      title: '语义守卫开关',
+      note: 'quick 进场注入与 --done 断言 WARNING 的跨变更决策守卫配置（cross-change-decision-guard）。读键按「存在则读、不存在用缺省」容错：读失败与未配置同兜底为默认开（fail-open，advisory 误开无害）。',
+      keys: [
+        { path: 'semantic_guard.enabled', type: 'boolean', optional: true, status: 'live', readers: ['readSemanticGuardEnabled (src/semantic-guard.js)'], desc: '语义守卫总开关，默认 true；设 false 时 quick 进场注入与 --done 断言 WARNING 全停零开销。', example: 'true' },
+      ],
+    },
   ],
 };
 
@@ -307,6 +315,11 @@ decisions:
 friction_hint:
   enabled: true
 
+# ── 语义守卫开关（quick 进场注入 + --done 断言 WARNING 的跨变更决策守卫）──
+# 默认 true 开启；false 一键全停（进场注入与断言 WARNING 双停，零开销）
+semantic_guard:
+  enabled: true
+
 # ── 预存失败豁免清单（变更前就失败的测试行；务必定期复核，防误豁免真实失败）──
 known_failures:
   - tests/some-old-stable-failure

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/knowledge-match.js

@@ -5,6 +5,8 @@
  * 路由行发现——路由行由 decision-distill 幂等写入，本引擎只消费不写）——命中路由行的
  * 决策文件解析为 decisionHits（rejected 优先），供 brainstorm Step2 防复潮注入（task-04，FR-05）。
  * decisions 库不存在时（INDEX 无 Decisions 段/文件不存在）一切行为与无 decisions 库时一致。
+ * 另导出 matchDecisionsByFiles（task-02，FR-02）：决策条目按代码文件路径反查——条目
+ * 「文件：」字段精确命中 ∪「锚点：」路径形态 token 提取兜底（quick 语义护栏的文件键引擎）。
  */
 
 import { existsSync, readFileSync } from 'fs'
@@ -59,19 +61,57 @@ function isDecisionRoute(entry) {
 }
 
 const DECISION_HEADER_RE = /^##\s+(D-\d+@v\d+)\s*(.*)$/
-const DECISION_FIELD_RE = /^(状态|理由|否决理由|复潮条件)\s*[：:]\s*(.*)$/
+const DECISION_FIELD_RE = /^(状态|文件|理由|否决理由|复潮条件)\s*[：:]\s*(.*)$/
+// 「锚点：」单独标签精确匹配读入（仿 docs-check.js parseDecisionEntries 先例）——绝不并入
+// DECISION_FIELD_RE：其 else-if 链末尾的 reason 回填（else if (!cur.reason)）会把锚点值
+// 误吞进 reason（Grill X-002 隐性回归）。
+const DECISION_ANCHOR_RE = /^锚点\s*[：:]\s*(.*)$/
+// 变更：单独标签（变更名限定——D-xxx 是变更内局部序号，跨变更同号互不相干，去重键依赖它）
+const DECISION_CHANGE_RE = /^变更\s*[：:]\s*(.*)$/
+
+/** 「文件：」值切分 + 逐项反斜杠归一 POSIX（与 decision-distill 的 entry.files 契约对齐：
+ *  split /[,，、\s]+/ + replace(/\\/g,'/')）。 */
+function splitDecisionFiles(value) {
+  return String(value || '')
+    .split(/[,，、\s]+/)
+    .map(s => s.replace(/\\/g, '/'))
+    .filter(Boolean)
+}
+
+// 锚点路径 token 提取：路径形态 token + 扩展名白名单（扩展名按长度降序排列——
+// (js|…|jsx) 短前缀在前会把 foo.jsx 截断成 foo.js）。
+const ANCHOR_FILE_TOKEN_RE = /[\w./-]+\.(?:mjs|cjs|jsx|tsx|js|ts|py|go|java|rs)/g
+
+/**
+ * 锚点值 → 代码文件路径集（条目无「文件：」字段时的兜底命中源）。
+ * 真实先例：D-905 形态「锚点：src/quicklog.js:493」→ 提取 src/quicklog.js
+ * （token 字符类不含 : 故止于行号前，再防御性剥 :line/:line-line/:符号 后缀）。
+ * 「未记录」/无路径形态 token → []。
+ */
+function anchorFilePaths(anchor) {
+  const a = String(anchor || '').trim().replace(/\\/g, '/')
+  if (!a || a === '未记录') return []
+  const out = new Set()
+  for (const token of a.match(ANCHOR_FILE_TOKEN_RE) || []) {
+    const p = token.replace(/:(?:\d+(?:-\d+)?|[A-Za-z_$][A-Za-z0-9_$]*)$/, '')
+    if (p) out.add(p)
+  }
+  return [...out]
+}
 
 /**
  * 解析单个 decisions/<域>.md 的 D-xxx@vN 条目。
  * reason 语义：rejected 条目取「否决理由」（expects_from task-02 的 reject_reason），
  * 其余条目回退「理由」一句话；revisitWhen 仅 rejected 条目非空（复潮条件）。
+ * files =「文件：」字段切分归一（task-02，FR-02）；anchor =「锚点：」行原值（单独标签读入，
+ * 不进 reason 回填链——Grill X-002）。
  * @param {string} filePath 决策文件绝对路径
  * @param {string} file INDEX 相对路径（decisions/<域>.md），原样进 decisionHits.file
- * @returns {{ file: string, id: string, title: string, status: string, reason: string, revisitWhen: string }[]}
+ * @returns {{ file: string, id: string, title: string, status: string, reason: string, revisitWhen: string, files: string[], anchor: string }[]}
  */
 function parseDecisionFile(filePath, file) {
   let content
-  try { content = readFileSync(filePath, 'utf8') } catch { return [] }
+  try { content = readFileSync(filePath, 'utf-8') } catch { return [] }
   const hits = []
   let cur = null
   const flush = () => {
@@ -82,14 +122,22 @@ function parseDecisionFile(filePath, file) {
     const h = line.match(DECISION_HEADER_RE)
     if (h) {
       flush()
-      cur = { file, id: h[1], title: h[2].trim(), status: '', reason: '', revisitWhen: '' }
+      cur = { file, id: h[1], title: h[2].trim(), status: '', reason: '', revisitWhen: '', files: [], anchor: '', change: '' }
       continue
     }
     if (!cur) continue
+    // 锚点：单独标签先于字段链匹配（不在 DECISION_FIELD_RE 内，见常量处注释）
+    const a = line.match(DECISION_ANCHOR_RE)
+    if (a) { cur.anchor = a[1].trim(); continue }
+    // 变更：单独标签读入（坑 decision-cross-change-id-shadow，2026-09-11 语义护栏 dogfood 首跑实证：
+    // 域文件跨变更同号条目常见（D-xxx 是变更内局部序号），去重键须含变更名否则先到条目遮蔽后来者）
+    const c = line.match(DECISION_CHANGE_RE)
+    if (c) { cur.change = c[1].trim(); continue }
     const f = line.match(DECISION_FIELD_RE)
     if (!f) continue
     const value = f[2].trim()
     if (f[1] === '状态') cur.status = value.toLowerCase()
+    else if (f[1] === '文件') cur.files = splitDecisionFiles(value)
     else if (f[1] === '否决理由') cur.reason = value
     else if (f[1] === '复潮条件') cur.revisitWhen = value
     else if (!cur.reason) cur.reason = value // 理由：仅作 implemented（或否决理由缺失）时的回填
@@ -115,16 +163,52 @@ export function parseDecisionEntries(indexDir, indexEntries = null) {
     if (!existsSync(filePath)) continue // 路由行失效（域文件已删）→ 跳过不阻断
     hits.push(...parseDecisionFile(filePath, route.file))
   }
-  // 多条路由行指向同一域文件时按 file+id 去重
+  // 多条路由行指向同一域文件时按 file+id+变更 去重（完全重复折叠）；键含变更名——
+  // 跨变更同号条目（D-xxx 是变更内局部序号，域文件内同 id 不同变更常见）不再被先到者
+  // 遮蔽（坑 decision-cross-change-id-shadow，2026-09-11 dogfood 实证：runtime.md 七个
+  // D-001@v1 分属七变更，旧键只放行首个——同号 rejected 决策在 {DECISION_HITS} 防复潮
+  // 注入同样被遮蔽）。无「变更：」行的 legacy 条目 change='' 与同号 legacy 条目互折叠
+  // （维持旧行为，不放大历史条目数）。
   const seen = new Set()
   return hits.filter(h => {
-    const key = `${h.file}#${h.id}`
+    const key = `${h.file}#${h.id}#${h.change || ''}`
     if (seen.has(key)) return false
     seen.add(key)
     return true
   })
 }
 
+/**
+ * 决策条目按代码文件路径反查（task-02，FR-02）——quick 语义护栏（task-03/05/06）的
+ * 文件键引擎。条目命中源 = 「文件：」字段（cur.files）∪「锚点：」路径形态 token 提取
+ * （anchorFilePaths 兜底）；查询侧与条目侧路径统一 POSIX 归一。
+ * @param {string} indexDir knowledge 目录路径
+ * @param {string[]} files 查询代码文件路径列表
+ * @returns {{ [file: string]: Array<{ id: string, title: string, status: string, reason: string, file: string }> }}
+ *   键 = 归一后的查询路径（结果键 ⊆ 查询集）；条目 file 字段沿 parseDecisionFile 既有
+ *   口径（INDEX 相对 decisions/<域>.md 路径）；rejected 条目同样进结果（status 透传，
+ *   消费方按需过滤）；无 decisions 库 / 路由失效 / 空查询 → {}。
+ */
+export function matchDecisionsByFiles(indexDir, files) {
+  const queries = [...new Set(
+    (Array.isArray(files) ? files : [files])
+      .map(f => String(f || '').trim().replace(/\\/g, '/'))
+      .filter(Boolean)
+  )]
+  if (queries.length === 0) return {}
+  const querySet = new Set(queries)
+  const result = {}
+  for (const hit of parseDecisionEntries(indexDir)) {
+    const sources = new Set([...(hit.files || []), ...anchorFilePaths(hit.anchor)])
+    for (const src of sources) {
+      if (!querySet.has(src)) continue
+      if (!result[src]) result[src] = []
+      result[src].push({ id: hit.id, title: hit.title, status: hit.status, reason: hit.reason, file: hit.file })
+    }
+  }
+  return result
+}
+
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }

package/src/progress/change-registry.js

@@ -62,6 +62,32 @@ export class ChangeRegistry {
     } catch { return null; }
   }
 
+  /**
+   * 读某变更最近一次进度活动时刻（quick-done-autoarchive-misfire 缺陷②，D-002@v1 复潮
+   * 2026-09-11 实证：stage 阶段态区分不了「活跃在途」与「启动后弃单」——brainstorm
+   * in_progress + tasks.md 仅含他者 quick 行时「全勾」是空洞真值）。取该变更全部
+   * stages/steps completed_at 的最大值：活跃会话分钟级在推进（最近活动必新）；僵尸的
+   * 最后一步完成时刻必然陈旧。只读不抛：无变更/无完成行/读失败返回 null（调用方按
+   * 无近期活动放行，僵尸逃生通道语义不变——与 getStageCompletedAt 同族容错）。
+   */
+  getLatestActivityAt(cwd, changeName) {
+    try {
+      const db = this.pm._ensureDB(cwd);
+      const sqlDb = db.getDb();
+      const ch = sqlDb.prepare(`SELECT id FROM changes WHERE name = ?`).get(changeName);
+      if (!ch) return null;
+      const row = sqlDb.prepare(
+        `SELECT MAX(ts) AS latest FROM (
+           SELECT MAX(completed_at) AS ts FROM stages WHERE change_id = ?
+           UNION ALL
+           SELECT MAX(st.completed_at) AS ts FROM steps st
+             JOIN stages s ON st.stage_id = s.id WHERE s.change_id = ?
+         )`
+      ).get(ch.id, ch.id);
+      return row && row.latest ? row.latest : null;
+    } catch { return null; }
+  }
+
   /**
    * 读某变更某阶段的 started_at（2026-09-10 用户反馈②：evidence mtime 窗口锚点从
    * execute completed_at 放宽到 started_at——证据合法产自 execute 或 verify 两窗口，

package/src/progress.js

@@ -908,6 +908,9 @@ export class ProgressManager {
   // verifyStartAt 基准只读（2026-09-08-ir-verify-facts）：execute 行 completed_at；无行 null 走 R-05 fallback
   getStageCompletedAt(cwd, changeName, stage) { return this._changeRegistry.getStageCompletedAt(cwd, changeName, stage); }
 
+  // 最近进度活动时刻只读（D-002@v1 复潮）：quick --done 自动归档闸的时近性信号
+  getLatestActivityAt(cwd, changeName) { return this._changeRegistry.getLatestActivityAt(cwd, changeName); }
+
   // evidence mtime 窗口锚点（2026-09-10 用户反馈②）：execute 行 started_at——证据合法产自 execute
   // 或 verify 两窗口，锚「完成时刻」会把 execute 期间产的证据判旧（时序两难）；无行 null 走 completed_at → R-05
   getStageStartedAt(cwd, changeName, stage) { return this._changeRegistry.getStageStartedAt(cwd, changeName, stage); }

package/src/review-dispatch.js

@@ -262,7 +262,13 @@ export async function runReviewDispatch(opts = {}) {
       const probeFn = probe || (await import('./dispatch/probe.js')).probeSillyHub
       const pr = await probeFn({ client, worktreePath: null, cwd })
       if (!pr || pr.available !== true) {
-        return { ok: false, reason: `平台通道不可用（${pr && pr.reason ? pr.reason : 'probe 异常'}）`, guidance: renderFallbackGuidance(cwd) }
+        const why = pr && pr.reason ? pr.reason : 'probe 异常'
+        // token 失效给「重连再配对」出口（2026-09-11 用户实测：gateway/daemon 都活着，
+        // 死的只是凭据——一把 platform connect 就能救活平台通道，比直接降级更对症）。
+        const tokenHint = why === 'mcp-token-invalid'
+          ? `mcp token 已失效（吊销/过期）——重跑 \`sillyspec platform connect ${client && client._url ? client._url : '<平台url>'} --token <user级token>\` 重连（connect 会成对签发 read+dispatch 新 token 自动覆盖写 mcp 段），然后重试平台通道。\n若暂不重连，按通道优先序降级：\n`
+          : ''
+        return { ok: false, reason: `平台通道不可用（${why}）`, guidance: tokenHint + renderFallbackGuidance(cwd) }
       }
       // reviewRunId：优先复用 marker（与 prompt/gate 同链，勿手算）
       let runId = reviewRunId

package/src/run/complete-handlers.js

@@ -22,8 +22,9 @@
  * archiveChangeDirectory 的 6 处 process.exit 全 exit(1)：5 个顶层 guard 直接终止；L1325 在 catch 内主动 exit
  * （非被外层吞）；process.exit 不可被 try 捕获 → 搬迁行为完全等价。
  */
-import { basename, join, resolve, relative, isAbsolute } from 'node:path'
+import { basename, dirname, join, resolve, relative, isAbsolute } from 'node:path'
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, rmSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { renameSyncRetry, writeAtomicSync } from '../fs-atomic.js'
 import { gitQuiet } from '../git-helper.js'
 import { resolveChangeDir, resolveQuickSessionsDir, safeGit, auditQuickCompletion, triggerSync, isQuickMetadata, isQuicklogFileLineNoise, resolveRuntimeRoot, collectOtherQuickSessionDeclarations, mergeQuickBoundaryFiles } from './shared.js'
@@ -1313,20 +1314,26 @@ export async function handleQuickStageCompletion({ stageName, steps, currentIdx,
         if (quickRows && quickRows.length > 0) {
           const patchesDir = join(specBase, 'quicklog', 'patches')
           mkdirSync(patchesDir, { recursive: true })
-          const { ...snapRest } = snapResult || {}
-          delete snapRest.frozenPatch
-          writeFileSync(join(patchesDir, `${qlId}.json`), JSON.stringify({
+          const { frozenPatch: _fp, ...snapRest } = snapResult || {}
+          const snapObj = {
             ...snapRest,
             rows: quickRows,
             totals: { files: quickRows.length, additions: quickRows.reduce((n, r) => n + (Number.isFinite(r.additions) ? r.additions : 0), 0), deletions: quickRows.reduce((n, r) => n + (Number.isFinite(r.deletions) ? r.deletions : 0), 0) },
             qlId,
             sessionId: changeName,
             savedAt: new Date().toISOString(),
-          }, null, 2) + '\n')
+          }
+          snapObj.note = 'quick --done 时点冻结（本文件落盘时采集）'
           if (typeof frozenPatch === 'string' && frozenPatch) {
-            writeFileSync(join(patchesDir, `${qlId}.patch`), frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n')
+            const patchText = frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n'
+            writeFileSync(join(patchesDir, `${qlId}.patch`), patchText)
+            snapObj.patchSha256 = createHash('sha256').update(patchText, 'utf8').digest('hex')
+            snapObj.patchStatus = 'ok'
+          } else if (frozenPatch === null) {
+            snapObj.patchStatus = 'failed'
           }
-          console.log(`📦 范围快照已落 quicklog/patches/${qlId}.json${typeof frozenPatch === 'string' && frozenPatch ? ' + .patch（--done 时点冻结）' : ''}`)
+          writeFileSync(join(patchesDir, `${qlId}.json`), JSON.stringify(snapObj, null, 2) + '\n')
+          console.log(`📦 范围快照已落 quicklog/patches/${qlId}.json${snapObj.patchStatus === 'ok' ? ' + .patch（--done 时点冻结，sha256 已锚）' : snapObj.patchStatus === 'failed' ? '——patch 采集失败已留痕' : ''}`)
         }
       } catch (e) {
         console.warn(`   ⚠️ quick 范围快照落盘失败（不阻断收尾）：${e && e.message ? String(e.message).split('\n')[0] : e}`)
@@ -1465,6 +1472,10 @@ async function closeSingleQuickLinkedChange({ pm, cwd, specBase, changeName, pla
  */
 const QUICK_CLOSE_ALLOWED_STAGES = new Set(['', 'scan', 'brainstorm'])
 
+/** 时近性闸窗口（缺陷②复潮实现）：最近进度活动 60 分钟内的变更不自动归档——活跃会话
+ * 步进间隔为分钟级（brainstorm 8 步通常 <1h），僵尸的最后活动以小时/天计。 */
+const QUICK_CLOSE_ACTIVITY_WINDOW_MS = 60 * 60 * 1000
+
 /**
  * quick --done 完成后，自动关闭任务已全部完成的关联真实变更。
  * quick-<hex> sessionId 自身不在此处理（由调用方单独注销）。
@@ -1514,6 +1525,25 @@ export async function closeQuickLinkedChanges({ pm, cwd, specBase, linkedChanges
         })
         continue
       }
+      // 时近性闸（quick-done-autoarchive-misfire 缺陷②，D-002@v1 复潮，2026-09-11
+      // cross-change-decision-guard 实证）：阶段态区分不了「活跃在途」与「启动后弃单」——
+      // brainstorm in_progress + tasks.md 仅含他者 quick 行时「全勾」是空洞真值（完整流程
+      // plan 前无自有任务行），关联 quick --done 勾掉 ql 行即触发在途变更被轻量归档。
+      // 信号取时近性：最近一次 stage/step 完成时刻在窗口内 = 会话分钟级在推进（在途），
+      // 不自动归档；僵尸的最后活动必然陈旧（或无完成步 → null），逃生通道语义不变
+      //（既有「真·僵尸 in_progress→closed」行为保留）。pm 无此方法（旧 mock/旧进度库）
+      // 按无近期活动放行——与 getChangeStage 缺失 skip 的 fail-safe 不同向：本闸误放行的
+      // 最坏后果是回到缺陷②现状（有 D-002 防护兜底），误拦截则僵尸永不清——权衡取放行。
+      if (typeof pm.getLatestActivityAt === 'function') {
+        const latest = pm.getLatestActivityAt(cwd, changeName)
+        if (latest && Date.now() - new Date(latest).getTime() < QUICK_CLOSE_ACTIVITY_WINDOW_MS) {
+          skipped.push({
+            name: changeName,
+            reason: `变更 ${Math.round((Date.now() - new Date(latest).getTime()) / 60000)} 分钟内仍有进度活动（在途会话，非僵尸），不自动归档——确已弃单请走原流程收尾或窗口过后重试`,
+          })
+          continue
+        }
+      }
       if (!isChangeTasksComplete(specBase, changeName)) {
         skipped.push({ name: changeName, reason: 'tasks.md 未全勾选或不存在' })
         continue

package/src/run/complete.js

@@ -18,6 +18,7 @@
  */
 import { join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { gitQuiet } from '../git-helper.js'
 import { withFileLock } from '../quicklog.js'
@@ -817,28 +818,39 @@ function scopeAuditPathSet(result) {
 
 /** execute 完成路径：全表 + 审计级快照/patch 落盘（quick-359a48f1：changes/<变更名>/ 随归档
  *  入库；patch 为收尾时点全量冻结——--file 真·当时内容比对的数据源。写失败只提示，verify
- *  对比按无快照降级） */
+ *  对比按无快照降级。审查修复：freshActual 绕过 settled 快照捷径防陈旧回写（execute 重跑
+ *  场景 C-F01）；落盘 note 换冻结措辞防「自述漂移」污染（C-F06）；patchSha256/patchStatus
+ *  留防篡改锚与失败痕（A-F01/C-F07） */
 async function printExecuteScopeAudit({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit, renderScopeAuditTable }) {
-  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, collectPatch: true })
+  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, collectPatch: true, freshActual: true })
   console.log(`\n${renderScopeAuditTable(result, { maxRows: 60 })}`)
   try {
-    const changeDir = join(specBase, 'changes', changeName)
+    // 归档竞态（审查 C-F10）：目录已被并行归档移动 → 写归档侧，不在活跃区重建假目录
+    const activeDir = join(specBase, 'changes', changeName)
+    const changeDir = existsSync(activeDir) ? activeDir : join(specBase, 'changes', 'archive', changeName)
     mkdirSync(changeDir, { recursive: true })
     const { frozenPatch, ...snap } = result
-    writeFileSync(join(changeDir, 'scope-audit.json'), JSON.stringify({ ...snap, savedAt: new Date().toISOString() }, null, 2) + '\n')
+    snap.note = 'execute --done 时点冻结（本文件落盘时采集）'
     if (typeof frozenPatch === 'string') {
-      writeFileSync(join(changeDir, 'scope-audit.patch'), frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n')
+      const patchText = frozenPatch.endsWith('\n') ? frozenPatch : frozenPatch + '\n'
+      writeFileSync(join(changeDir, 'scope-audit.patch'), patchText)
+      snap.patchSha256 = createHash('sha256').update(patchText, 'utf8').digest('hex')
+      snap.patchStatus = 'ok'
+    } else if (frozenPatch === null) {
+      snap.patchStatus = 'failed'
     }
-    console.log(`   📦 范围快照已落变更目录（scope-audit.json${typeof frozenPatch === 'string' ? ' + scope-audit.patch（收尾时点冻结）' : ''}）`)
+    writeFileSync(join(changeDir, 'scope-audit.json'), JSON.stringify({ ...snap, savedAt: new Date().toISOString() }, null, 2) + '\n')
+    console.log(`   📦 范围快照已落变更目录（scope-audit.json${snap.patchStatus === 'ok' ? ' + scope-audit.patch（收尾时点冻结，sha256 已锚）' : snap.patchStatus === 'failed' ? '——patch 采集失败已留痕' : ''}）`)
   } catch (e) {
     console.warn(`   ⚠️ 范围对账快照写入失败（不阻断，verify 漂移对比将按无快照降级）：${e && e.message ? String(e.message).split('\n')[0] : e}`)
   }
 }
 
 /** verify 完成路径：读 execute 时点快照对比文件集差集，一行结论（行数不比——execute 形态 A 锚
- *  worktree meta、verify 形态 B 锚 merge-base，基点不同行数天然抖动，比行数必假阳） */
+ *  worktree meta、verify 形态 B 锚 merge-base，基点不同行数天然抖动，比行数必假阳）。
+ *  审查 C-F01：current 侧 freshActual——settled 快照捷径会让本函数变成快照比快照恒「一致」 */
 async function printVerifyScopeDrift({ cwd, changeName, specBase, platformOpts, computeChangeScopeAudit }) {
-  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts })
+  const result = await computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, freshActual: true })
   const totals = result?.totals && typeof result.totals === 'object' ? result.totals : {}
   const scopeLine = `变更范围：${totals.files ?? (Array.isArray(result?.rows) ? result.rows.length : 0)} 文件 +${totals.additions ?? 0}/-${totals.deletions ?? 0}`
   if (result?.ok !== true) {

package/src/run/prompt.js

@@ -22,7 +22,8 @@ import { basename, join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, readdirSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { stageRegistry } from '../stages/index.js'
-import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, WAIT_MARKER_RE, QUICK_SID_RE } from './shared.js'
+import { resolvePromptIncludes, resolveRuntimeRoot, safeGit, parsePorcelainPath, WAIT_MARKER_RE, QUICK_SID_RE } from './shared.js'
+import { renderSemanticGuardBlock, readSemanticGuardEnabled } from '../semantic-guard.js'
 import { renderStageContract } from '../stage-contract-spec.js'
 import { nowWallClock } from '../datetime.js'
 import { parseModuleMapSimple } from '../modules.js'
@@ -181,6 +182,44 @@ export function buildQuickContextDigest(specBase, projectName) {
   }
 }
 
+/**
+ * quick step1 语义护栏进场注入拼装（task-05，FR-03，D-001@v1 模块四）：开关 → 候选文件采集 →
+ * renderSemanticGuardBlock 反查。候选 = 会话声明文件（guard.allowedFiles，readQuickGuardField
+ * 同源读取：session guard 优先 / legacy 单文件回退）∪ git status --porcelain 脏文件
+ * （parsePorcelainPath 同款解析口径：引号剥离 / -> rename / 反斜杠归一），反斜杠归一去重封顶 20。
+ * 返回 ''（开关关 / 无候选 / 双零命中——prompt 与现状字节一致，零命中静默）或 advisory 段；
+ * 全链 fail-soft：异常返回单行降级说明，不阻断 quick 启动。导出供注入单测直测
+ * （test/semantic-guard-prompt-inject.test.mjs）。
+ */
+export function buildQuickSemanticGuardInjection({ specBase, cwd, changeName } = {}) {
+  try {
+    // 开关首行（Grill X-012）：false 直接零输出——不采候选文件、不跑反查（开关语义全停非半停）
+    if (!readSemanticGuardEnabled(specBase)) return ''
+    // 会话声明文件（--files 落 guard.allowedFiles；缺失 / 形态异常按空）
+    const declaredRaw = readQuickGuardField(changeName, specBase, 'allowedFiles')
+    const declared = Array.isArray(declaredRaw) ? declaredRaw : []
+    // git 脏文件：porcelain 解析同源 quick-audit（trim:false——首列前导空格是状态码，trim 会削掉
+    // 致 parsePorcelainPath 丢首字符；.sillyspec/ 运行时产物过滤同款——候选面是代码文件）
+    let dirty = []
+    const statusResult = safeGit(cwd, ['status', '--porcelain'], { trim: false })
+    if (!statusResult.error) {
+      dirty = (statusResult.value || '').split('\n').filter(Boolean)
+        .map(l => parsePorcelainPath(l))
+        .filter(Boolean)
+        .filter(f => !f.startsWith('.sillyspec/'))
+    }
+    // 去重（反斜杠归一后；renderSemanticGuardBlock 内侧亦有同款归一，此处为封顶前的口径）
+    // 封顶 20 —— 与 collectRecentForeignDelivery 内侧文件封顶同数
+    const candidateFiles = [...new Set(
+      [...declared, ...dirty].map(f => String(f || '').trim().replace(/\\/g, '/')).filter(Boolean)
+    )].slice(0, 20)
+    if (candidateFiles.length === 0) return ''
+    return renderSemanticGuardBlock({ specBase, cwd, candidateFiles, currentChange: changeName })
+  } catch (e) {
+    return `【语义护栏】注入失败（${e && e.message ? e.message : e}）——跳过反查，不阻断本步骤；需要时自查 knowledge/INDEX.md 与 git log`
+  }
+}
+
 // parseModuleMapSimple 复用 modules.js 的 canonical 实现（合并历史 copy-paste 副本，2026-08-07；
 // 无循环依赖：modules.js 仅 import fs/path/db.js，prompt.js → modules.js 单向）。
 /**
@@ -1061,6 +1100,19 @@ export async function outputStep(stageName, stepIndex, steps, cwd, changeName, d
     }
   }
 
+  // ── 语义护栏进场注入（task-05，FR-03，D-001@v1 模块四）──
+  // 判定口径独立：与上方模块上下文注入同锚（quickFirstStep——quick step1「理解任务」），不嵌进
+  // {QUICK_CONTEXT_DIGEST} 占位符守卫内——模板改版去占位符时护栏静默失效（plan 审查 N2）。
+  // 非空追加到 step1 prompt 末尾；空串（开关关 / 零命中）prompt 与现状字节一致（零命中静默）。
+  // 渲染层注入，src/stages/quick.js 模板零变更（design 明确不改清单）。全链 fail-soft 见 helper。
+  if (quickFirstStep) {
+    const sgSpecBase = resolvePromptSpecBase(platformOpts, cwd)
+    const semanticGuardBlock = buildQuickSemanticGuardInjection({ specBase: sgSpecBase, cwd, changeName })
+    if (semanticGuardBlock) {
+      promptText = promptText + '\n\n' + semanticGuardBlock
+    }
+  }
+
   // 平台模式 prompt 自检：确保没有裸相对输出路径
   // 只匹配正向写入指令中的裸路径，避免误杀「禁止写入 .sillyspec/」等安全说明
   if ((platformOpts?.specRoot || platformOpts?.runtimeRoot) && stageName === 'scan') {

package/src/run/quick-audit.js

@@ -13,6 +13,7 @@
  */
 import { join } from 'node:path'
 import { parsePorcelainPath, safeGit } from './shared.js'
+import { collectRecentForeignDelivery, detectAssertionRewrites, readSemanticGuardEnabled } from '../semantic-guard.js'
 
 /**
  * 打印 quick 完成审计结论（按 review.status 输出 SAFE/WARNING/BLOCKED）。
@@ -242,6 +243,32 @@ export async function resolveQuickLinkedChanges({ pm, cwd, specDir, quickFiles,
 
 // ============ quick --done test+lint 硬门禁（2026-09-02 跨 agent 工单 P0-2）============
 
+/**
+ * 语义护栏命中组装（change: 2026-09-11-cross-change-decision-guard，task-06，FR-04，
+ * D-001@v1）：断言重写检测 ∩ 近因他者交付归因 → hits 清单，gate 内一行调用拼进返回对象。
+ * 单独抽出导出是为了可测性（runQuickTestLintGate 会真跑 test/lint 命令，检测组装层
+ * 独立测可避免测试里真跑 npm test——卡内可测性豁免）。
+ * - 步骤 0 总开关：readSemanticGuardEnabled false → 跳过检测，hits 恒空（fail-open 同 task-03）
+ * - 纯新增断言（detect 不命中）/ 无他者归因标记 / 非测试文件 → 落不到 hits
+ * - WARNING 级非阻断：本函数只组装数据，不参与 gate action/failed 判定
+ * @param {{ cwd?: string, specBase?: string, files?: string[], changeName?: string|null }} opts
+ * @returns {{ hits: Array<{ file: string, deliveredBy: string, sampleLines: string[] }> }}
+ */
+export function buildSemanticGuardHits({ cwd, specBase, files, changeName } = {}) {
+  if (!readSemanticGuardEnabled(specBase)) return { hits: [] }
+  const rewrites = detectAssertionRewrites({ cwd, files: Array.isArray(files) ? files : [] })
+  if (Object.keys(rewrites).length === 0) return { hits: [] }
+  // 归因只查断言命中文件（省 git log 调用；collectRecentForeignDelivery 内部封顶 20 文件）
+  const delivery = collectRecentForeignDelivery({ cwd, files: Object.keys(rewrites), currentChange: changeName })
+  const hits = []
+  for (const file of Object.keys(rewrites)) {
+    // 无归因不点名：纯新增断言 / 无标记提交 / 交付者是本变更（currentChange 透传跳过）同落空
+    if (!delivery[file]) continue
+    hits.push({ file, deliveredBy: delivery[file], sampleLines: rewrites[file] })
+  }
+  return { hits }
+}
+
 /**
  * quick --done 内置 test+lint 实测门禁：把 CLAUDE.md 规则 8「触及 src/test 的改动先
  * npm test + npm run lint」从 agent 自律下沉为 CLI 卡点。
@@ -265,8 +292,11 @@ export async function resolveQuickLinkedChanges({ pm, cwd, specDir, quickFiles,
  * @param {string} opts.specBase - .sillyspec 目录（local.yaml 读取源，信任边界见 runVerifyTestCheck SEC-02 注释）
  * @param {string[]} [opts.changedFiles] - 审计口径的本轮变更文件（仓库根相对 POSIX 路径；空/null → 回退 declaredFiles）
  * @param {string[]} [opts.declaredFiles] - 会话声明边界（guard.allowedFiles；changedFiles 为空时的兜底判定源）
- * @param {string} [opts.changeName] - quick 会话名（evidence-auto 策略解析用）
- * @returns {Promise<{action:'pass'|'fail'|'skip', failed:string[], reason:string, test:object|null, lint:object|null}>}
+ * @param {string} [opts.changeName] - quick 会话名（evidence-auto 策略解析用 + 语义护栏归因 currentChange 透传）
+ * @returns {Promise<{action:'pass'|'fail'|'skip', failed:string[], reason:string, test:object|null, lint:object|null,
+ *   semanticGuard?:{hits:Array<{file:string,deliveredBy:string,sampleLines:string[]}>}}>}
+ *   semanticGuard 仅检测跑过（三条早退 skip 路径不跑检测、无字段）时挂载；WARNING 级
+ *   非阻断——action/failed 判定不受它影响（调用方 complete-handlers.js 只读 action/failed，零改动）。
  */
 export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], declaredFiles = [], changeName = null }) {
   if (process.env.SILLYSPEC_QUICK_TEST_GATE === 'skip') {
@@ -284,6 +314,13 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
     return { action: 'skip', failed: [], reason: `纯 doc/配置改动（${files.length} 个文件均未触及 src/test，规则 8 语义跳过 test+lint）`, test: null, lint: null }
   }
 
+  // ── 语义护栏检测（task-06，FR-04 断言重写 WARNING，D-001@v1 非阻断）──
+  // 三条早退（env skip / 无文件 / 纯 doc）已在上文 return，检测不跑——语义一致。
+  // 检测对主仓 cwd 执行而非 gateCwd 隔离快照（下方才建快照）：检测对象是本会话工作树
+  // 未提交改动（git diff HEAD 须见它），快照语义是 test/lint 实测隔离——两者不同层
+  // （Grill X-001 附注）。specBase 同理用主仓的（快照副本 local.yaml 不参与开关判定）。
+  const semanticGuard = buildSemanticGuardHits({ cwd, specBase, files, changeName })
+
   const { runVerifyTestCheck, runVerifyLintCheck } = await import('../verify-postcheck.js')
 
   // ── 隔离快照执行（2026-09-10 驾驭小结第六批②，用户实证「lint 实测对账在主仓跑被并行
@@ -319,6 +356,8 @@ export async function runQuickTestLintGate({ cwd, specBase, changedFiles = [], d
         : `触及 src/test 共 ${codeFiles.length} 个文件，test+lint 实测通过（或未配置命令自动跳过）${snapshot ? '（隔离快照口径：并行会话脏文件不计入）' : ''}`,
       test,
       lint,
+      // 语义护栏 WARNING（task-06）：只增可选字段，action/failed 判定与调用方读取面均不受影响
+      semanticGuard,
     }
   } finally {
     if (snapshot) { try { snapshot.cleanup() } catch { /* 清理失败不连坐门禁结论 */ } }
@@ -350,4 +389,18 @@ export function printQuickTestLintGate(gate) {
   } else {
     console.log(`\n✅ quick test+lint 门禁 — PASS（${gate.reason}）`)
   }
+
+  // 语义护栏 WARNING（task-06 / FR-04，非阻断——D-001@v1：误报校准数据为零先 advisory，
+  // 复潮条件：误报率实证后可升 block）：他者近因交付的测试文件既有断言行被改 → 点名
+  // 文件 + 交付变更 + 被改样例行（上游 detectAssertionRewrites 已封顶 5/文件，渲染侧
+  // 再 slice(0,5) 兜底）。hits 空 / 字段缺失（三条早退 skip 路径不跑检测）→ 零输出。
+  const sgHits = gate.semanticGuard && Array.isArray(gate.semanticGuard.hits) ? gate.semanticGuard.hits : []
+  if (sgHits.length > 0) {
+    console.warn(`\n⚠️ 语义护栏 — 断言重写 WARNING（非阻断）：他者近因交付的测试文件既有断言被改`)
+    for (const h of sgHits) {
+      console.warn(`   - ${h.file} ← ${h.deliveredBy} 交付`)
+      for (const s of (h.sampleLines || []).slice(0, 5)) console.warn(`       被改: ${String(s).trim()}`)
+    }
+    console.warn(`   ➜ 若确需重写：重写理由写进 quicklog --solution（--done 四参数收尾）；并复查 ${[...new Set(sgHits.map(h => h.deliveredBy))].join('、')} 的关联决策——勿以改断言重定义绿灯。`)
+  }
 }

package/src/scope-audit.js

@@ -19,6 +19,7 @@
  * 纯读：不落盘、不改 guard/进度库。Windows 路径 \\→/ 归一，ESM-only，零新依赖。
  */
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { join, dirname } from 'node:path'
 import { locateQuickSessionGuard, auditQuickCompletion, resolveRuntimeRoot, collectOtherQuickSessionDeclarations, ancestorSpecDirs } from './run/shared.js'
 import { safeGit } from './git-helper.js'
@@ -41,7 +42,9 @@ function toPosix(p) {
 function extractRenameTarget(raw) {
   const brace = raw.match(/^(.*)\{([^{}]*)=>([^{}]*)\}(.*)$/)
   if (brace) {
-    const merged = brace[1] + brace[3] + brace[4]
+    // git 花括号形态 `src/{old => new}.js`：组3 带前导对齐空格须剥（审查 C-F03——
+    // 不剥则拼出 `src/ new.js` 键错，改名文件落 untracked wc-l 档记成整文件新增）
+    const merged = brace[1] + brace[3].replace(/^ /, '') + brace[4]
     return merged.replace(/\/{2,}/g, '/')
   }
   const arrow = raw.indexOf(' => ')
@@ -262,6 +265,21 @@ function filterPatchForFiles(patchText, filesSet) {
   return out.join('\n')
 }
 
+/**
+/** patch 内容 sha256（A-F01 防篡改锚——写入方存 json.patchSha256，读取方校验） */
+function sha256Text(text) {
+  return createHash('sha256').update(text, 'utf8').digest('hex')
+}
+
+/**
+ * 冻结 patch 完整性校验（A-F01）：json 记录的 patchSha256 与 patch 实文比对。
+ * @returns {boolean|null} true=一致；false=不匹配（可能被篡改）；null=未记录 hash（旧记录）
+ */
+function verifyPatchIntegrity(recordedSha, patchText) {
+  if (!recordedSha || typeof recordedSha !== 'string') return null
+  return sha256Text(patchText) === recordedSha
+}
+
 /**
  * 冻结 patch 生成（quick-359a48f1 审计级 / quick-90015473 归属口径修正）：tracked 改动 =
  * `git diff --no-color <baseRef>` 后**按 files 过滤段**（与 rows 同归属口径，不含并行会话
@@ -438,8 +456,12 @@ async function computeQuickAudit({ cwd, platformOpts, sessionId, located, collec
     }
   }
 
+  // 审查 C-F05：patch 文件集对齐落盘 rows（declared+soft）——undeclared 可能是并行会话的
+  // 改动，冻结进本会话审计 patch 违背 filterPatchForFiles 的归属契约（json rows 落盘时
+  // complete-handlers 滤 undeclared，patch 必须同口径）
+  const patchFiles = [...new Set([...attributed, ...softSet])]
   const frozenPatch = collectPatch
-    ? buildFrozenPatch(sessionRoot, rowFiles, { baseRef: 'HEAD' })
+    ? buildFrozenPatch(sessionRoot, patchFiles, { baseRef: 'HEAD' })
     : undefined
 
   return {
@@ -462,7 +484,7 @@ async function computeQuickAudit({ cwd, platformOpts, sessionId, located, collec
  * only；baseAnchor 缺失 → 行数按 HEAD 未提交窗口兜底（quick 模式同口径，不再恒 —）；
  * 归档且实时窗口空 → execute 时点快照记录态（快照也缺 → 空表诚实说明）。
  */
-async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, collectPatch }) {
+async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, collectPatch, freshActual }) {
   const sb = specBase || join(cwd, '.sillyspec')
   const runtimeRoot = resolveRuntimeRoot(platformOpts, sb)
   const changeDirInfo = resolveChangeDir(sb, changeName)
@@ -474,7 +496,30 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   const hasWorktreeMeta = existsSync(join(sb, '.runtime', 'worktrees', changeName, 'meta.json'))
   const hasBranch = !!safeGit(cwd, ['rev-parse', '--verify', '--quiet', `sillyspec/${changeName}^{commit}`], { timeout: 15 * 1000 }).value
   const hasAuditTag = !!safeGit(cwd, ['rev-parse', '--verify', '--quiet', `sillyspec-audit/sillyspec/${changeName}^{commit}`], { timeout: 15 * 1000 }).value
-  if (!hasWorktreeMeta && !hasBranch && !hasAuditTag) {
+  // 审查 C-F02：预执行判定必须排除归档（归档=流程走完，58/77 归档变更三信号全缺被误判
+  // 「未执行」实证——tag 只在分支被 review 引用时才打）+ 补四类证据：快照文件本身 /
+  // execute-runs change 戳（task-review readExecuteRunChangeStamp 同口径）/ apply-pathspec /
+  // execute-cleanup 回执。任一命中 = 进过 execute。
+  const hasSnapshotFile = changeDirInfo
+    ? existsSync(join(changeDirInfo.dir, 'scope-audit.json')) || existsSync(join(runtimeRoot, `scope-audit-${changeName}.json`))
+    : existsSync(join(runtimeRoot, `scope-audit-${changeName}.json`))
+  const hasApplyPathspec = existsSync(join(runtimeRoot, `apply-pathspec-${changeName}.txt`))
+  const hasCleanupReceipt = existsSync(join(runtimeRoot, `execute-cleanup-${changeName}.json`))
+  let hasExecuteRunStamp = false
+  if (!hasWorktreeMeta && !hasBranch && !hasAuditTag && !hasSnapshotFile && !hasApplyPathspec && !hasCleanupReceipt) {
+    try {
+      const runsDir = join(runtimeRoot, 'execute-runs')
+      if (existsSync(runsDir)) {
+        for (const e of readdirSync(runsDir)) {
+          try {
+            if (readFileSync(join(runsDir, e, 'change'), 'utf8').trim() === changeName) { hasExecuteRunStamp = true; break }
+          } catch { /* 无戳 run 跳过 */ }
+        }
+      }
+    } catch { /* 扫描失败视为无证据（fail-open 到预执行视图，note 有 hedge） */ }
+  }
+  const isArchived = !!(changeDirInfo && changeDirInfo.archived)
+  if (!isArchived && !hasWorktreeMeta && !hasBranch && !hasAuditTag && !hasSnapshotFile && !hasApplyPathspec && !hasCleanupReceipt && !hasExecuteRunStamp) {
     const emptyBase = {
       mode: 'full-flow', ok: true, degradedReason: null, baseAnchor: null,
       totals: { files: 0, additions: 0, deletions: 0 }, rows: [],
@@ -495,8 +540,8 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
       totals: { files: preRows.length, additions: 0, deletions: 0 },
       rows: preRows,
       note: preRows.length > 0
-        ? '变更尚未进入 execute（无 worktree/分支/审计 tag）——下表为 design 清单（全部待实现）；工作区其他未提交改动归属各自会话/变更，不在本表（若确已执行过但三信号均被手工清理，此处会误判——git log 核实）'
-        : '变更尚未进入 execute（无 worktree/分支/审计 tag）且 design 无可解析清单——暂无可对账内容',
+        ? '变更尚未进入 execute（无 worktree/分支/审计 tag/快照/execute-run 戳/apply 记录）——下表为 design 清单（全部待实现）；工作区其他未提交改动归属各自会话/变更，不在本表（若确已执行过但全部执行证据被清理，此处会误判——git log 核实）'
+        : '变更尚未进入 execute（无 worktree/分支/审计 tag/快照/execute-run 戳/apply 记录）且 design 无可解析清单——暂无可对账内容',
     }
   }
 
@@ -558,7 +603,9 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
   // 快照即冻结记录（含行数）——已收尾一律先出快照；实时窗口（开放区间）只作快照缺失的兜底，
   // note 明示会漂。tag 封闭区间不可用：分支上仅 baseline checkpoint（并行 WIP 快照），本变更
   // 改动经工作树 apply 从未 commit 到分支。 ——
-  const settled = changeDirInfo && (changeDirInfo.archived || actual.form === 'post-apply')
+  // freshActual（审查 C-F01）：verify 漂移 current 侧走快照捷径会变成快照比快照恒「一致」
+  // （假阴性）；execute --done 采集重跑也会陈旧回写——两处传 true 绕过，快照捷径只留给查询面
+  const settled = !freshActual && changeDirInfo && (changeDirInfo.archived || actual.form === 'post-apply')
   if (settled) {
     const snap = readScopeSnapshot(changeDirInfo.dir, runtimeRoot, changeName)
     if (snap && snap.rows.length > 0) {
@@ -571,7 +618,9 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
       const needsStats = rows.some(r => r && !Number.isFinite(r.additions) && r.kind !== 'binary')
       if (needsStats && actual && actual.ok && actual.baseAnchor) {
         const paths = rows.map(r => (r && r.path ? toPosix(r.path) : '')).filter(Boolean)
-        const stats = collectNumstatByPath(cwd, paths, { baseRef: actual.baseAnchor })
+        // 审查 C-F04：补采执行根走共享 resolveDiffRoot（form=worktree 时必须对 worktree 跑，
+        // 与主链路 :629/:636 同源配对——直用 cwd 会基点×根错位）
+        const stats = collectNumstatByPath(resolveDiffRoot(sb, changeName, actual.form, cwd), paths, { baseRef: actual.baseAnchor })
         let recovered = 0
         rows = rows.map(r => {
           if (!r || !r.path || Number.isFinite(r.additions) || r.kind === 'binary') return r
@@ -591,6 +640,8 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
           excluded: snap.excluded && Array.isArray(snap.excluded.foreignDeclared)
             ? snap.excluded
             : { foreignDeclared: [] },
+          patchSha256: snap.patchSha256 || null,
+          patchStatus: snap.patchStatus || null,
           note: `${settleLabel}——execute --done 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：文件集封闭在 apply 时点，主仓后续新文件不进表；行数按锚 ${actual.baseAnchor.slice(0, 7)}→当前工作树 补采（同文件后续演进会计入）`,
         }
       }
@@ -606,6 +657,8 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
         excluded: snap.excluded && Array.isArray(snap.excluded.foreignDeclared)
           ? snap.excluded
           : { foreignDeclared: [] },
+        patchSha256: snap.patchSha256 || null,
+        patchStatus: snap.patchStatus || null,
         note: `${settleLabel}——execute --done 时点冻结快照${snap.savedAt ? '（' + String(snap.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘）' : ''}：范围封闭在 apply 时点，主仓后续改动不反映到本表；需要看当前工作区实时状态请跑 git status`,
       }
     }
@@ -715,7 +768,7 @@ async function computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, c
  *   excluded: { foreignDeclared: Array<{ file: string, sessions: string[] }> },
  *   note?: string|null }>}
  */
-export async function computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, collectPatch } = {}) {
+export async function computeChangeScopeAudit({ cwd, specBase, changeName, platformOpts, collectPatch, freshActual } = {}) {
   const empty = {
     mode: 'full-flow', ok: false, degradedReason: null, baseAnchor: null,
     totals: { files: 0, additions: 0, deletions: 0 },
@@ -746,6 +799,8 @@ export async function computeChangeScopeAudit({ cwd, specBase, changeName, platf
             ? rec.record.excluded
             : { foreignDeclared: [] },
           frozenPatchPath: rec.patchPath,
+          patchSha256: rec.record.patchSha256 || null,
+          patchStatus: rec.record.patchStatus || null,
           note: `quick 会话已收尾——记录态（quicklog/patches/${rec.qlId}，${rec.record.savedAt ? String(rec.record.savedAt).replace('T', ' ').slice(0, 19) + ' 落盘' : '--done 时点冻结'}）`,
         }
       }
@@ -755,7 +810,7 @@ export async function computeChangeScopeAudit({ cwd, specBase, changeName, platf
         degradedReason: `quick 会话 ${changeName} 不存在（guard 已清理且 quicklog/patches/ 无记录——会话未产生改动或早于记录机制）`,
       }
     }
-    return await computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, collectPatch })
+    return await computeFullFlowAudit({ cwd, specBase, changeName, platformOpts, collectPatch, freshActual })
   } catch (e) {
     // fail-soft 兜底（D-006 / 兼容策略）：注入点只打一行提示，不阻断阶段完成
     return {
@@ -789,16 +844,36 @@ export async function getFileDiff({ cwd, specBase, changeName, platformOpts, fil
     // —— 真·当时内容比对（quick-359a48f1）：已收尾变更优先冻结 patch 切片 ——
     // ① quick 记录态自带 frozenPatchPath；② full-flow 变更目录 scope-audit.patch。
     // patch 冻结在收尾时点，不含后续演进——实时锚 diff 只作 patch 缺失的兜底（口径标注）。
-    const frozenPatch = (result.frozenPatchPath
-        && (() => { try { return readFileSync(result.frozenPatchPath, 'utf8') } catch { return null } })())
-      || readFrozenPatch(resolveChangeDir(sb, changeName)?.dir || null)
-    if (frozenPatch) {
+    // A-F01：读取时按 json 记录的 patchSha256 校验，不匹配显式告警（防低级篡改）。
+    const patchRecord = result.frozenPatchPath
+      ? { path: result.frozenPatchPath, sha: result.patchSha256 || null }
+      : (() => { const d = resolveChangeDir(sb, changeName); return d ? { path: join(d.dir, 'scope-audit.patch'), sha: null } : null })()
+    let recordedSha = patchRecord ? patchRecord.sha : null
+    if (patchRecord && !recordedSha && result.rows) {
+      // json 里未直接带回 hash（记录态捷径不透传）→ 读 json 原文取（快照/quick 记录都存该字段）
+      try {
+        const snapRaw = JSON.parse(readFileSync(result.frozenPatchPath
+          ? result.frozenPatchPath.replace(/\.patch$/, '.json')
+          : join(resolveChangeDir(sb, changeName).dir, 'scope-audit.json'), 'utf8'))
+        recordedSha = snapRaw.patchSha256 || null
+      } catch { /* json 不可读 → 无 hash 可校验（null=不校验） */ }
+    }
+    const frozenPatch = (patchRecord
+        && (() => { try { return readFileSync(patchRecord.path, 'utf8') } catch { return null } })())
+    if (frozenPatch !== null && frozenPatch !== undefined && patchRecord) {
+      const integrity = verifyPatchIntegrity(recordedSha, frozenPatch)
+      if (integrity === false) {
+        return { ok: false, mode: result.mode, root: cwd, baseRef: null, anchorLabel: '冻结 patch', diff: null, note: '⚠️ 冻结 patch 与快照记录的 patchSha256 不匹配——记录可能被篡改，审计前人工核验（git 历史比对）' }
+      }
       const sliced = slicePatchForFile(frozenPatch, norm)
       if (sliced) {
         return { ok: true, mode: result.mode, root: cwd, baseRef: null, anchorLabel: '冻结 patch（收尾时点内容，无后续演进混入）', diff: sliced, note: null }
       }
       return { ok: true, mode: result.mode, root: cwd, baseRef: null, anchorLabel: '冻结 patch', diff: null, note: '该文件不在冻结 patch 内（窗口外文件）' }
     }
+    if (result.patchStatus === 'failed') {
+      return { ok: true, mode: result.mode, root: cwd, baseRef: null, anchorLabel: '冻结记录', diff: null, note: '冻结 patch 当时采集失败（非无改动）——退实时锚比对' }
+    }
 
     // 锚点解析（语义锚 head-uncommitted-window → 实际 baseRef 'HEAD'；无锚同兜底并标注）
     let baseRef = 'HEAD'

package/src/semantic-guard.js

@@ -0,0 +1,207 @@
+/**
+ * semantic-guard.js — quick 语义护栏聚合模块（change: 2026-09-11-cross-change-decision-guard，
+ * task-03，FR-03/FR-04，D-001@v1）：近因他者交付归因 + 断言重写检测 + advisory 渲染 + 总开关。
+ *
+ * 被 run/prompt.js（task-05，进场注入）与 run/quick-audit.js（task-06，--done 断言 WARNING）
+ * 两端消费。纯模块纪律：不 console（渲染返回字符串，输出留给消费端）、不写盘、
+ * 不 import run/ 下模块（避免与 task-05/06 循环依赖）。
+ *
+ * git 交互一律走 git-helper 的 safeGit（数组参数不经 shell，Windows 路径安全）；失败静默
+ * 降级空结果不抛（acceptance：git 不可用 → 全部降级空结果）。
+ */
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { safeGit } from './git-helper.js'
+import { matchDecisionsByFiles } from './knowledge-match.js'
+
+/** 路径反斜杠归一 POSIX（Windows 调用方传 \ 分隔时不丢匹配；与 matchDecisionsByFiles 双侧归一口径一致） */
+function toPosix(p) {
+  return String(p || '').trim().replace(/\\/g, '/')
+}
+
+// ───────────────────────── 交付归因（FR-03） ─────────────────────────
+
+/** 提交信息里的完整变更名标记：init 生成的 change 目录名形态（2026-09-11-cross-change-decision-guard） */
+const CHANGE_NAME_RE = /\d{4}-\d{2}-\d{2}-[a-z0-9][a-z0-9-]*/g
+/** quicklog 条目 ID 标记：ql-YYYYMMDD-NNN-xxxx（quick 会话提交信息的归因键） */
+const QL_ID_RE = /ql-\d{8}-\d{3}-[a-z0-9]{4}/g
+
+/** 单条提交信息 → 两类标记列表（按出现位置排序；两类正则无交集，ql-ID 的日期段无连字符） */
+function extractChangeMarkers(subject) {
+  const found = []
+  for (const re of [CHANGE_NAME_RE, QL_ID_RE]) {
+    for (const m of subject.matchAll(re)) found.push({ token: m[0], at: m.index })
+  }
+  return found.sort((a, b) => a.at - b.at).map(f => f.token)
+}
+
+/**
+ * 近因他者交付归因：每文件查最近 days 天提交信息（--format=%s，仅 subject），解析变更名 /
+ * ql-ID 两类标记，取最新一条非 currentChange 标记 → { [file]: changeName }。
+ * git log 输出行为提交 subject，无 porcelain 首行前导空格语义（git-helper.js:88 的
+ * trim 坑不影响此处），safeGit 默认 trim 安全。
+ * @param {{ cwd?: string, files?: string[], currentChange?: string, days?: number }} opts
+ * @returns {{ [file]: string }} 键 = POSIX 归一路径；无标记 / 仅本变更标记 / git 失败 /
+ *   第 20 个之后的文件 → 不记
+ */
+export function collectRecentForeignDelivery({ cwd, files, currentChange, days = 7 } = {}) {
+  const result = {}
+  if (!cwd || !Array.isArray(files)) return result
+  const list = files.map(toPosix).filter(Boolean).slice(0, 20)
+  for (const file of list) {
+    const r = safeGit(cwd, ['log', `--since=${days}.days`, '--format=%s', '--', file])
+    if (r.error || !r.value) continue
+    // git log 新→旧：逐提交找第一条非 currentChange 标记，命中即止（取最新他者标记）
+    for (const subject of r.value.split('\n')) {
+      const foreign = extractChangeMarkers(subject).find(m => m !== currentChange)
+      if (foreign) {
+        result[file] = foreign
+        break
+      }
+    }
+  }
+  return result
+}
+
+// ───────────────────────── 断言重写检测（FR-04） ─────────────────────────
+
+/** 删除侧断言 token：expect( / assert / t.equal / toBe / toEqual / strictEqual / should. */
+const ASSERTION_TOKEN_RE = /expect\(|assert|t\.equal|toBe|toEqual|strictEqual|should\./
+
+/** 测试文件判定：test/ 前缀 或 *.test.* / *_test.* 命名（路径先 POSIX 归一） */
+function isTestFilePath(p) {
+  return p.startsWith('test/') || /\.test\./.test(p) || /_test\./.test(p)
+}
+
+/**
+ * 断言重写检测：测试文件跑 git diff HEAD -U0（HEAD 口径非 index——quick step3 先 git add
+ * 暂存的时序下裸 diff 恒空转，坑 Grill X-001），hunk 删除侧（- 行）含断言 token → 命中；
+ * 纯新增 hunk（无 - 行）不算；样例行封顶 5/文件。
+ * @param {{ cwd?: string, files?: string[] }} opts
+ * @returns {{ [file]: string[] }} 键 = POSIX 归一测试文件路径，值 = 删除侧含 token 的原行
+ *   （去 - 前缀）；非测试文件不查；无命中 / git 失败 → 不记
+ */
+export function detectAssertionRewrites({ cwd, files } = {}) {
+  const result = {}
+  if (!cwd || !Array.isArray(files)) return result
+  for (const raw of files) {
+    const file = toPosix(raw)
+    if (!file || !isTestFilePath(file)) continue
+    const r = safeGit(cwd, ['diff', 'HEAD', '-U0', '--', file])
+    if (r.error || !r.value) continue
+    const samples = []
+    let inHunk = false
+    let deletedLines = []
+    const flushHunk = () => {
+      if (!inHunk || deletedLines.length === 0) return // 纯新增 hunk（无 - 行）不算
+      for (const line of deletedLines) {
+        if (samples.length >= 5) break
+        if (ASSERTION_TOKEN_RE.test(line)) samples.push(line)
+      }
+    }
+    for (const line of r.value.split('\n')) {
+      if (line.startsWith('@@')) {
+        flushHunk()
+        inHunk = true
+        deletedLines = []
+        continue
+      }
+      if (!inHunk) continue // 文件头（diff --git / index / --- / +++）不进 hunk 统计
+      if (line.startsWith('-')) deletedLines.push(line.slice(1)) // + 行与 "\ No newline" 行跳过
+    }
+    flushHunk()
+    if (samples.length > 0) result[file] = samples
+  }
+  return result
+}
+
+// ───────────────────────── advisory 渲染（FR-03/FR-04 组合） ─────────────────────────
+
+/**
+ * advisory 文本段渲染：决策命中（matchDecisionsByFiles，knowledge 目录 = specBase/knowledge，
+ * task-02 契约）+ 交付归因（collectRecentForeignDelivery 默认 7 天窗）组合成注入文本，
+ * 供 task-05 进场注入 / task-06 --done WARNING 拼接；两类均零命中 → ''（不留空段）。
+ * @param {{ specBase?: string, cwd?: string, candidateFiles?: string[], currentChange?: string }} opts
+ * @returns {string}
+ */
+export function renderSemanticGuardBlock({ specBase, cwd, candidateFiles, currentChange } = {}) {
+  if (!Array.isArray(candidateFiles) || candidateFiles.length === 0) return ''
+  const files = [...new Set(candidateFiles.map(toPosix).filter(Boolean))]
+  if (files.length === 0) return ''
+  const decisions = specBase
+    ? matchDecisionsByFiles(join(specBase, 'knowledge'), files)
+    : {}
+  const delivery = cwd
+    ? collectRecentForeignDelivery({ cwd, files, currentChange })
+    : {}
+  const decisionFiles = files.filter(f => Array.isArray(decisions[f]) && decisions[f].length > 0)
+  const deliveryFiles = files.filter(f => delivery[f])
+  if (decisionFiles.length === 0 && deliveryFiles.length === 0) return ''
+  const lines = ['【语义护栏】改动文件触及既有决策 / 近期他者交付，动手前请对照：']
+  if (decisionFiles.length > 0) {
+    lines.push(`■ 决策库命中（${decisionFiles.length} 文件）`)
+    for (const f of decisionFiles) {
+      for (const hit of decisions[f]) {
+        const rejected = hit.status === 'rejected'
+        lines.push(`  - ${f} → ${hit.id} ${hit.title}［${rejected ? 'rejected，已否决，勿复潮' : hit.status || 'unknown'}］`)
+        lines.push(`      理由：${hit.reason || '（未记录）'}`)
+        if (hit.file) lines.push(`      详见：knowledge/${hit.file}`)
+      }
+    }
+  }
+  if (deliveryFiles.length > 0) {
+    lines.push('■ 近 7 天他者交付归因（最后交付的非本变更标记）')
+    for (const f of deliveryFiles) lines.push(`  - ${f} ← ${delivery[f]}`)
+  }
+  return lines.join('\n')
+}
+
+// ───────────────────────── 总开关（D-001@v1） ─────────────────────────
+
+/** YAML 布尔宽松解析：仅显式 false（含引号形态）为关，其余值一律 true（fail-open，先例 friction-tally R-05） */
+function parseEnabledValue(raw) {
+  const v = String(raw || '').trim().replace(/^['"]|['"]$/g, '')
+  return v.toLowerCase() !== 'false'
+}
+
+/**
+ * 读 specBase/local.yaml 的 semantic_guard.enabled 总开关（D-001@v1）：默认 true；
+ * 缺键 / 文件缺失 / 解析异常 → true（fail-open——配置读取异常不该把护栏误判为关）。
+ * 轻量行式解析不引 yaml 依赖（先例 friction-tally readFrictionHintEnabled 同款形态），
+ * 兼容嵌套（semantic_guard:\n  enabled: false）与 flat（semantic_guard.enabled: false）；
+ * 行尾先归一（Windows CRLF 残留致行式正则整体失配）。
+ * @param {string} specBase - spec 根（local.yaml 所在目录）
+ * @returns {boolean}
+ */
+export function readSemanticGuardEnabled(specBase) {
+  try {
+    const yamlPath = join(specBase, 'local.yaml')
+    if (!existsSync(yamlPath)) return true
+    const text = String(readFileSync(yamlPath, 'utf8')).replace(/\r\n?/g, '\n')
+    let inSection = false
+    let sectionIndent = -1
+    for (const line of text.split('\n')) {
+      // flat 形态优先：键名带点，不与嵌套段头冲突
+      const flat = line.match(/^\s*semantic_guard\.enabled\s*:\s*(.*?)\s*(?:#.*)?$/)
+      if (flat) return parseEnabledValue(flat[1])
+      const section = line.match(/^(\s*)semantic_guard\s*:\s*(?:#.*)?$/)
+      if (section) {
+        inSection = true
+        sectionIndent = section[1].length
+        continue
+      }
+      if (!inSection) continue
+      if (line.trim() === '' || line.trim().startsWith('#')) continue
+      // 缩进回落到段头层级（或更浅）= semantic_guard 段结束，之后的 enabled 不属于它
+      if (/^\s*/.exec(line)[0].length <= sectionIndent) {
+        inSection = false
+        continue
+      }
+      const kv = line.match(/^\s*enabled\s*:\s*(.*?)\s*(?:#.*)?$/)
+      if (kv) return parseEnabledValue(kv[1])
+    }
+    return true
+  } catch {
+    return true
+  }
+}

package/src/sillyhub-mcp/client.js

@@ -282,9 +282,14 @@ export class SillyHubMcpClient {
     }
 
     if (!res.ok) {
+      // 401 状态留痕（2026-09-11 用户实测反馈：token 失效被 probe 报成 daemon-unreachable，
+      // 误导排障方向——吊销/过期的 shmcp_ 是「重连再配对」能解的，不是 daemon 的问题）。
+      // getLastInitStatus() 供 probeSillyHub 类型化 reason；成功/其他失败置 null（不误判旧状态）。
+      this._lastInitHttpStatus = res.status;
       if (!quiet) console.warn(`[sillyhub-mcp] initialize → HTTP ${res.status}`);
       return false;
     }
+    this._lastInitHttpStatus = null;
 
     // 优先取 header mcp-session-id（FastMCP 实测返回）；缺失再查 body _meta.sessionId。
     // ⚠️ 无论 header 是否有 session，都必须读完 body（消费 SSE 流）——FastMCP 在
@@ -391,6 +396,15 @@ export class SillyHubMcpClient {
     return result !== null;
   }
 
+  /**
+   * 最近一次 initialize 握手的 HTTP 状态码（null = 无记录/成功/非 HTTP 失败）。
+   * 消费方：probeSillyHub 的 token 失效类型化（401 → reason='mcp-token-invalid'，
+   * 区别于 daemon-unreachable——2026-09-11 用户实测：吊销 token 被误报 daemon 不可达）。
+   */
+  getLastInitStatus() {
+    return this._lastInitHttpStatus ?? null;
+  }
+
   /**
    * 列出 daemon 暴露的 MCP tools（JSON-RPC `tools/list`，task-11 路径A 探测用）。
    *