sillyspec 3.27.9 → 3.27.11

package/.claude/skills/sillyspec-execute/SKILL.md

@@ -92,7 +92,7 @@ execute 完成时，每个 task 必须有 `review.json` 且 verdict 通过，否
 
 > 🔧 **mechanics 字段不要手算**：`schemaVersion`/`task`/`base`/`head`/`changedFiles`(/跨仓 `repo`) 全部可由 CLI 从 git + task 卡推导。子代理/你只需写**语义字段**（`specVerdict`/`qualityVerdict`/`reviewerNotes`/`requiredEvidence`），mechanics 字段可以瞎填占位（如 `"base": "TODO"`），写完跑 `sillyspec backfill-reviews --change <变更名> --adopt` 一键重算代填（verdict 原样保留）。gate 拦下 mechanics 错误时也跑同一条命令修复。
 
-- 后端 router task 另需产出 API 端点清单：`sillyspec endpoints extract --change <变更名> --task <task-NN>`（CLI 静态扫描 FastAPI/Express/Spring 路由装饰器生成 endpoints.json，verify 探针 5 消费；扫描面默认取 task 卡 allowed_paths ∪ design 清单，也可 `--dir`/`--files` 显式指定）。勿手扫装饰器手写——易漏 endpoint。
+- 后端 router task 另需产出 API 端点清单：`sillyspec endpoints extract --change <变更名> --all-tasks`（聚合逐 task 卡 allowed_paths 提取，与 verify 探针 5 聚合对账口径一致；单 task 可 `--task task-NN`，也可 `--dir`/`--files` 显式指定）。勿手扫装饰器手写——易漏 endpoint；勿只提单 task——局部端点集对账放大假 missing。
 
 ### Stage Review Gate（execute 末尾的 acceptance review.json）
 

package/.npmrc-temp

@@ -0,0 +1 @@
+//registry.npmjs.org/:_authToken=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

package/package.json

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

package/src/commit-suggest.js

@@ -71,6 +71,28 @@ function classifyStagePath(p) {
   return null
 }
 
+/**
+ * 暂存区快照（坑 same-main-staging-pollution，2026-08-28 用户实证：同 main 两个活跃会话
+ * 共享同一暂存区，A 的 commit 把 B 暂存的文件扫入——本轮竞态事故根因，无任何防护）。
+ * 防护 = 提交前可见：commit 提示里带 `git diff --cached --name-only` 快照 + 他者文件告警。
+ * @param {{ cwd: string, ownFiles?: string[]|null }} opts
+ *   ownFiles：本会话/本变更的精确文件集（apply-pathspec 等）；提供时对快照做差集，
+ *   不在集内的暂存文件 = 他者会话暂存（告警对象）。null/空数组 = 只出快照不做归属判定。
+ * @returns {{ available: boolean, staged: string[], foreign: string[] }}
+ *   available=false：git 不可用/非仓库（调用方静默跳过，不误报）。
+ */
+export function collectStagedArea({ cwd, ownFiles = null }) {
+  const raw = gitQuiet(cwd, ['diff', '--cached', '--name-only'])
+  if (raw === null) return { available: false, staged: [], foreign: [] }
+  const staged = raw.split('\n').filter(Boolean).map(f => f.replace(/\\/g, '/'))
+  let foreign = []
+  if (Array.isArray(ownFiles) && ownFiles.length > 0) {
+    const own = new Set(ownFiles.map(f => String(f).replace(/\\/g, '/')))
+    foreign = staged.filter(f => !own.has(f))
+  }
+  return { available: true, staged, foreign }
+}
+
 /**
  * 收集提交上下文并生成建议 message。
  * @param {{ cwd: string, specDir?: string|null }} opts

package/src/contract-matrix.js

@@ -392,10 +392,13 @@ export function _readWorktreeMeta(specBase, scanRoot, changeName) {
 
 /**
  * 取本变更 diff 文件集（parity 前端调用收窄用，坑 probe5-fullrepo-frontend-noise）。
- * 优先 worktree meta 锚点 diff（与 verify 同源）；无 meta 退主仓 git diff HEAD。
+ * 优先 worktree meta 锚点 diff（与 verify 同源）；无 meta 退主仓 git diff HEAD；
+ * 两者皆空再退 apply-pathspec-<change>.txt（apply 落盘的精确清单）。
+ * 兜底链每级都空才返回 null/[]（调用方回退全仓——坑 probe5-single-task-artifact-scope，
+ * 2026-08-28 实证：apply+commit/cleanup 后 diff 为空 → 全仓调用 × 局部端点 = 150 条假 missing）。
  * @returns {string[]|null}
  */
-function _resolveDiffFilesForParity(specBase, scanRoot, changeName) {
+function _resolveDiffFilesForParity(specBase, scanRoot, changeName, runtimeRoot) {
   try {
     const wt = _readWorktreeMeta(specBase, scanRoot, changeName)
     if (wt) {
@@ -429,7 +432,20 @@ function _resolveDiffFilesForParity(specBase, scanRoot, changeName) {
     if (foreign.length > 0) {
       console.warn(`⚠️ parity 对账已排除 ${foreign.length} 个并行会话声明的文件（${foreign.slice(0, 5).map(x => x.file).join(', ')}${foreign.length > 5 ? ' 等' : ''}）`)
     }
-    return own
+    if (own.length > 0) return own
+    // 主仓 diff 空（apply 后已 commit / cleanup 完毕）→ apply-pathspec 兜底：apply 成功时落盘的
+    // 本变更精确文件清单（与 gates 归因提示②同源）。仍拿不到才回 null（调用方退全仓）。
+    try {
+      const pathspecFile = join(runtimeRoot || join(specBase, '.runtime'), `apply-pathspec-${changeName}.txt`)
+      if (existsSync(pathspecFile)) {
+        const fromPathspec = readFileSync(pathspecFile, 'utf8').split('\n').map(l => l.trim()).filter(Boolean)
+        if (fromPathspec.length > 0) {
+          console.log(`ℹ️ parity 前端范围用 apply-pathspec 兜底（主仓 diff 为空，${fromPathspec.length} 文件）`)
+          return fromPathspec
+        }
+      }
+    } catch { /* 兜底失败 → null 交调用方全仓 */ }
+    return null
   } catch { return null }
 }
 
@@ -526,7 +542,7 @@ export function verifyApiParity(specBase, scanRoot, runtimeRoot, changeName = nu
   const frontendRootLabel = frontendRoot === scanRoot ? 'scan-root' : 'worktree'
   if (changeName) {
     try {
-      const changed = _resolveDiffFilesForParity(specBase, scanRoot, changeName)
+      const changed = _resolveDiffFilesForParity(specBase, scanRoot, changeName, runtimeRoot)
       if (changed && changed.length > 0) {
         const changedSet = new Set(changed.map(f => f.replace(/\\/g, '/')))
         frontendCalls = scanFrontendApiCalls(frontendRoot).filter(c => {

package/src/decision-distill.js

@@ -22,7 +22,7 @@
  * 零输出：无 decisions.md 或无入选条目 → skipped 带原因，不写任何文件、不动 INDEX。
  */
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 
 /** FR-02：有实现影响的五类 type（scope 与未知 type 的 confirmed/accepted 不入选） */
 const IMPLEMENTED_TYPES = new Set(['architecture', 'compatibility', 'boundary', 'definition', 'process'])
@@ -244,10 +244,14 @@ function newDomainPreamble(domain) {
   ]
 }
 
-/** 单条目段落渲染（design 接口定义的条目格式，逐字对齐：状态/锚点/最近确认/理由 + rejected 专属两行） */
-function renderBlockLines(entry, headHash, supersedesNote) {
+/** 单条目段落渲染（design 接口定义的条目格式，逐字对齐：状态/锚点/最近确认/理由 + rejected 专属两行）。
+ * 变更：行（2026-08-28，坑 distill-cross-change-supersede）：D-xxx 编号是变更内局部序号，
+ * 跨变更同号（两个 D-002）互不相干——条目必须携带变更名限定，消费方（knowledge-match/
+ * docs-check 的字段行解析）只认各自标签，新增字段行是增量安全。 */
+function renderBlockLines(entry, headHash, supersedesNote, changeName) {
   const lines = [`## ${entry.id} ${oneLine(entry.title)}`.replace(/\s+$/, '')]
   lines.push(`状态：${entry.selected}`)
+  if (changeName) lines.push(`变更：${oneLine(changeName)}`)
   lines.push(`锚点：${oneLine(entry.anchor) || NOT_RECORDED}`)
   lines.push(`最近确认：${oneLine(headHash) || NOT_RECORDED}`)
   lines.push(`理由：${oneLine(entry.answer || entry.normalizedRequirement || entry.question)}`)
@@ -259,7 +263,9 @@ function renderBlockLines(entry, headHash, supersedesNote) {
   return lines
 }
 
-/** 知识文件切段：preamble 行 + D-xxx@vN 条目段（段边界 = 下一 `## D-` 头） */
+/** 知识文件切段：preamble 行 + D-xxx@vN 条目段（段边界 = 下一 `## D-` 头）。
+ * 段的变更归属取段内 `变更：<name>` 行；无该行的历史条目 → change=null（legacy：
+ * 升级前落库的条目，不参与新条目的同号匹配/supersede——只共存不误删）。 */
 function splitKnowledgeSections(content) {
   const sections = []
   const preamble = []
@@ -275,7 +281,11 @@ function splitKnowledgeSections(content) {
     else preamble.push(line)
   }
   if (cur) sections.push(cur)
-  for (const s of sections) s.id = `${s.number}@v${s.version}`
+  for (const s of sections) {
+    s.id = `${s.number}@v${s.version}`
+    const cm = s.lines.find(l => /^变更[：:]/.test(l))
+    s.change = cm ? cm.replace(/^变更[：:]\s*/, '').trim() || null : null
+  }
   return { preamble, sections }
 }
 
@@ -293,15 +303,20 @@ function joinKnowledgeFile(preamble, sections) {
 
 /**
  * 单条目写入一个域文件的段落集（就地修改 sections）。
- * @returns {{ action: 'append'|'update'|'supersede' }|null} null = 高版本已落库，迟到低版本不降级。
+ * 坑 distill-cross-change-supersede（2026-08-28 用户实证：跨变更同号 D-002 在 knowledge
+ * 里互相 supersede）：幂等键从「号」改为「号+变更」——同号匹配、版本守卫、旧版本段清除
+ * 全部限定在 entry.change 内；他者变更的同号段不参与（共存）。legacy 段（change=null，
+ * 升级前落库）不与任何新条目互认，只共存不误删。
+ * @returns {{ action: 'append'|'update'|'supersede' }|null} null = 同变更同号高版本已落库，迟到低版本不降级。
  */
 function applyEntryToSections(sections, entry, headHash) {
-  const sameNumber = sections.filter(s => s.number === entry.number)
+  const change = entry.change || null
+  const sameNumber = sections.filter(s => s.number === entry.number && (s.change || null) === change)
   if (sameNumber.some(s => s.version > entry.version)) return null
   let action
   let supersedesNote = oneLine(entry.supersedes) || null
   if (sameNumber.length === 0) {
-    sections.push({ number: entry.number, version: entry.version, id: entry.id, title: entry.title, lines: renderBlockLines(entry, headHash, supersedesNote) })
+    sections.push({ number: entry.number, version: entry.version, id: entry.id, title: entry.title, change, lines: renderBlockLines(entry, headHash, supersedesNote, change || undefined) })
     action = 'append'
   } else {
     const same = sameNumber.find(s => s.version === entry.version)
@@ -309,10 +324,10 @@ function applyEntryToSections(sections, entry, headHash) {
     if (!same && !supersedesNote) supersedesNote = `${slot.number}@v${slot.version}`
     slot.version = entry.version
     slot.title = entry.title
-    slot.lines = renderBlockLines(entry, headHash, supersedesNote)
-    // 同号旧版本段（< 新版本）就地清除——同文件内同号只留一个段
+    slot.lines = renderBlockLines(entry, headHash, supersedesNote, change || undefined)
+    // 同变更同号旧版本段（< 新版本）就地清除——同文件内同变更同号只留一个段
     for (let i = sections.length - 1; i >= 0; i--) {
-      if (sections[i].number === entry.number && sections[i] !== slot) sections.splice(i, 1)
+      if (sections[i].number === entry.number && (sections[i].change || null) === change && sections[i] !== slot) sections.splice(i, 1)
     }
     action = same ? 'update' : 'supersede'
   }
@@ -412,6 +427,9 @@ function syncIndexRoutingLines(knowledgeRoot) {
  *   缺否决理由/复潮条件被拦下（该条目未写盘，其余条目照常提炼）。
  */
 export function distillIntoKnowledge(changeDir, knowledgeRoot, headHash, moduleIndex = null) {
+  // 变更名限定（坑 distill-cross-change-supersede）：条目幂等键 = 号+变更。changeDir 末段
+  // 即变更名（changes/<name> 与 archive 后的 changes/archive/<name> 同为 <name>）。
+  const changeName = basename(changeDir)
   const parsed = parseDecisions(changeDir)
   if (parsed.missing) {
     return { written: [], skipped: `decisions.md 不存在（${join(changeDir, 'decisions.md')}），零输出`, needsWait: null }
@@ -450,7 +468,7 @@ export function distillIntoKnowledge(changeDir, knowledgeRoot, headHash, moduleI
   const taken = new Set()
   for (const e of distillable) {
     const keep = highestByNumber.get(e.number)
-    if (keep && !taken.has(e.number)) { taken.add(e.number); batch.push(keep) }
+    if (keep && !taken.has(e.number)) { taken.add(e.number); keep.change = changeName; batch.push(keep) }
   }
 
   const decisionsDir = join(knowledgeRoot, 'decisions')
@@ -489,7 +507,8 @@ export function distillIntoKnowledge(changeDir, knowledgeRoot, headHash, moduleI
     }
   }
 
-  // 跨文件清理：同号 ≤ 新版本的旧段散落其他域文件时移除（同号全局只留最高版本/目标文件）
+  // 跨文件清理：同变更同号 ≤ 新版本的旧段散落其他域文件时移除（同变更同号全局只留最高
+  // 版本/目标文件）；他者变更的同号段不参与（共存，坑 distill-cross-change-supersede）
   let onDisk = []
   try { onDisk = readdirSync(decisionsDir).filter(f => f.endsWith('.md')).map(f => f.replace(/\.md$/, '')) } catch { /* 刚创建，走 store */ }
   const allDomains = [...new Set([...onDisk, ...store.keys()])]
@@ -498,7 +517,7 @@ export function distillIntoKnowledge(changeDir, knowledgeRoot, headHash, moduleI
     for (const d of allDomains) {
       if (targets.has(d)) continue
       const st = loadDomain(d)
-      const removed = st.sections.filter(s => s.number === entry.number && s.version <= entry.version)
+      const removed = st.sections.filter(s => s.number === entry.number && s.version <= entry.version && (s.change || null) === (entry.change || null))
       if (removed.length === 0) continue
       st.sections = st.sections.filter(s => !removed.includes(s))
       st.dirty = true

package/src/docs-check.js

@@ -630,10 +630,20 @@ function extractKnownFailureKeys(yamlText) {
   if (inline) {
     return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
   }
-  const block = yaml.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?)+)/m)
+  // 坑 verify-known-failures-comment-line-truncation 同款（与 verify-postcheck.extractKnownFailures
+  // 口径互指对齐）：块内注释行/空行打断连续列表项捕获链 → 注释后的键静默丢失。块定义放行
+  // 注释行与空行；提取侧只认 - 项行；行尾注释须 # 前有空白（裸 # 不截）；引号值原样保留。
+  const block = yaml.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?|[ \t]*#[^\n]*\n?|[ \t]*\n)+)/m)
   if (block) {
     return (block[1].match(/^[ \t]+-[ \t]+(.+)/gm) || [])
-      .map(s => s.replace(/^[ \t]+-[ \t]+/, '').trim().replace(/^['"]|['"]$/g, '').replace(/#.*$/, '').trim())
+      .map(s => {
+        const item = s.replace(/^[ \t]+-[ \t]+/, '').trim()
+        const full = item.match(/^(['"])(.*)\1$/)
+        if (full) return full[2]
+        const stripped = item.replace(/[ \t]+#.*$/, '').trim()
+        const q2 = stripped.match(/^(['"])(.*)\1$/)
+        return q2 ? q2[2] : stripped
+      })
       .filter(Boolean)
   }
   return []

package/src/facade-hint.js

@@ -0,0 +1,170 @@
+/**
+ * facade-hint.js — plan 门「透传必经文件」候选探测（advisory）。
+ *
+ * 坑 plan-facade-files-manual-backfill（2026-08-28 用户实证 ×2）：facade 文件（如
+ * daemon/service.py——新端点/新模块必须在它里面挂载/转发才对外生效）不进 design §6 /
+ * TaskCard allowed_paths，执行期子代理按现实改它 → apply Gate1 拦截 → 人工回补
+ * allowed_paths 两轮。本模块在 plan 完成时做静态引用扫描，把候选透传/聚合文件提前
+ * 亮给 agent（warning 不阻断）：判定是语义，agent 拍板补不补。
+ *
+ * 两个信号（语言覆盖 py/js/ts/mjs/cjs/jsx/tsx/java 的 import/require 静态文本匹配）：
+ *   - direct：仓内文件 import 了 allowed_paths 里的模块（改被 facade 引用的模块，
+ *     facade 常需同步改——转发签名/挂载点）；
+ *   - aggregate：仓内文件 import 了该模块同目录下 ≥2 个模块（聚合器/注册表形态，
+ *     新增同目录模块几乎必然要在此登记——service.py 挂 router 即此形态）。
+ *
+ * 启发式 → 恒 advisory：候选只列不改，由 agent 判定补 allowed_paths / design §6，
+ * 或确认无关忽略。性能护栏：allowed 条目 > 100 或仓内源码文件 > 5000 时静默跳过。
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs'
+import { join, dirname, basename, extname, resolve } from 'path'
+
+const SOURCE_EXTS = new Set(['.py', '.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs', '.java'])
+const SKIP_DIRS = new Set([
+  '.git', 'node_modules', 'dist', 'build', 'out', '.next', '__pycache__',
+  '.venv', 'venv', 'env', '.sillyspec', '.worktrees', '.claude', '.runtime',
+  'coverage', 'target', '.idea', '.vscode',
+])
+const MAX_ALLOWED_ENTRIES = 100
+const MAX_REPO_FILES = 5000
+const MAX_FILE_BYTES = 512 * 1024
+
+const toPosix = (p) => String(p).replace(/\\/g, '/')
+
+/** 递归收集仓内源码文件（posix 相对路径），带总量护栏。 */
+function walkSourceFiles(root, out = []) {
+  if (out.length > MAX_REPO_FILES) return out
+  let names
+  try { names = readdirSync(root) } catch { return out }
+  for (const name of names) {
+    if (SKIP_DIRS.has(name)) continue
+    const abs = join(root, name)
+    let st
+    try { st = statSync(abs) } catch { continue }
+    if (st.isDirectory()) walkSourceFiles(abs, out)
+    else if (st.isFile() && SOURCE_EXTS.has(extname(name).toLowerCase()) && st.size <= MAX_FILE_BYTES) {
+      out.push(toPosix(join(root, name)))
+      if (out.length > MAX_REPO_FILES) return out
+    }
+  }
+  return out
+}
+
+/** 从源码文本提取 import/require 说明符（py dotted + js/ts path-ish）。 */
+export function extractImportSpecifiers(text, ext) {
+  const specs = new Set()
+  if (ext === '.py') {
+    // from X import a, b → 记 pkg 本身 + 逐名拼 'X.a'/'X.b'（前者保 from X.y import sym 的
+    // 直接引用形态，后者保 service.py 聚合挂载形态：from daemon.routers import users, orders）
+    for (const m of text.matchAll(/\bfrom\s+([.\w]+)\s+import\s+([^\n#]+)/g)) {
+      specs.add(m[1])
+      const names = m[2].split(',')
+        .map(s => s.trim().split(/\s+as\s+/i)[0].trim())
+        .filter(n => /^\w+$/.test(n))
+      for (const n of names) specs.add(`${m[1]}.${n}`)
+    }
+    for (const m of text.matchAll(/(?:^|\n)\s*import\s+([\w.]+)/g)) specs.add(m[1])
+  } else if (ext === '.java') {
+    for (const m of text.matchAll(/\bimport\s+([\w.]+)\s*;/g)) specs.add(m[1])
+  } else {
+    for (const m of text.matchAll(/(?:from\s+|require\(\s*|import\(\s*)['"]([^'"]+)['"]/g)) specs.add(m[1])
+  }
+  return [...specs]
+}
+
+/** 说明符是否指向模块名 mod（`m` / `pkg.m` / `./m` / `../d/m` 等尾部命中形态）。 */
+export function specRefsModule(spec, mod) {
+  if (!spec || !mod) return false
+  if (spec === mod) return true
+  return spec.endsWith('.' + mod) || spec.endsWith('/' + mod)
+}
+
+/**
+ * 探测 allowed_paths 之外的 facade/聚合候选文件。
+ *
+ * @param {{ cwd: string, allowedPaths: string[] }} opts
+ * @returns {{ skipped: boolean, reason: string|null, candidates: Array<{file: string, via: string[]}> }}
+ */
+export function findFacadeCandidates({ cwd, allowedPaths }) {
+  const root = cwd || process.cwd()
+  const allowed = (allowedPaths || []).map(toPosix).filter(p => !p.includes('*'))
+  if (allowed.length === 0) return { skipped: true, reason: 'no-allowed-paths', candidates: [] }
+  if (allowed.length > MAX_ALLOWED_ENTRIES) return { skipped: true, reason: 'allowed-too-many', candidates: [] }
+
+  const files = walkSourceFiles(root)
+  if (files.length > MAX_REPO_FILES) return { skipped: true, reason: 'repo-too-large', candidates: [] }
+
+  const allowedSet = new Set(allowed)
+  const isAllowed = (abs) => allowed.some(a => abs === a || abs.endsWith('/' + a) || a.endsWith('/' + abs) || abs.replace(/\.[^.]+$/, '') === a.replace(/\.[^.]+$/, ''))
+
+  // 目录 → 该目录下模块名索引（聚合信号用：R import 同目录 ≥2 模块 = 聚合器）
+  const dirModules = new Map()
+  for (const f of files) {
+    const d = dirname(f)
+    if (!dirModules.has(d)) dirModules.set(d, new Set())
+    dirModules.get(d).add(basename(f, extname(f)))
+  }
+
+  // 预读一遍源码 import（file → specs），两信号共用
+  const fileSpecs = []
+  for (const f of files) {
+    if (isAllowed(f)) continue
+    let text
+    try { text = readFileSync(f, 'utf8') } catch { continue }
+    fileSpecs.push({ file: f, specs: extractImportSpecifiers(text, extname(f).toLowerCase()) })
+  }
+
+  // 逐 allowed 文件探测 direct + aggregate 命中
+  const byFile = new Map()
+  for (const p of allowed) {
+    const mod = basename(p, extname(p))
+    // allowed 是相对仓根路径，目录索引键是绝对路径（walk 产物）——resolve 对齐再查
+    const dirKey = toPosix(resolve(root, dirname(p)))
+    const dirLabel = toPosix(dirname(p))
+    const dirModSet = dirModules.get(dirKey) || new Set()
+    for (const { file, specs } of fileSpecs) {
+      const via = []
+      if (specs.some(s => specRefsModule(s, mod))) via.push(`direct import of ${mod}`)
+      // aggregate：R 引用 mod 同目录 ≥2 个不同仓内模块（mod 自身可不在——新增模块形态）
+      const hitMods = new Set()
+      for (const s of specs) {
+        for (const b of dirModSet) {
+          if (specRefsModule(s, b)) { hitMods.add(b); break }
+        }
+      }
+      if (hitMods.size >= 2) via.push(`aggregates ≥2 modules of ${dirLabel === '.' ? './' : dirLabel + '/'}`)
+      if (via.length === 0) continue
+      const existing = byFile.get(file) || []
+      for (const v of via) if (!existing.includes(v)) existing.push(v)
+      byFile.set(file, existing)
+    }
+  }
+  const candidates = [...byFile.entries()]
+    .map(([file, via]) => ({ file: toPosix(file), via }))
+    .sort((a, b) => a.file.localeCompare(b.file))
+  return { skipped: false, reason: null, candidates }
+}
+
+/**
+ * plan 门消费入口：探测 + 打印（advisory，不阻断）。allowed 集与 apply Gate1 同源
+ * （resolveApplyAllowSet 的主仓切片），确保「预检亮出的候选」与「执行期会拦的门」
+ * 用同一份清单口径。
+ */
+export function warnFacadeCandidateFiles({ cwd, changeName, allowSet }) {
+  try {
+    const r = findFacadeCandidates({ cwd, allowedPaths: [...(allowSet || [])] })
+    if (r.skipped || r.candidates.length === 0) return r
+    console.warn(`\n⚠️  plan 预检：${r.candidates.length} 个 allowed_paths 外的「透传/聚合」候选文件（advisory，不阻断）：`)
+    for (const c of r.candidates.slice(0, 10)) {
+      console.warn(`   - ${c.file}（${[...new Set(c.via)].join('; ')}）`)
+    }
+    if (r.candidates.length > 10) console.warn(`   …还有 ${r.candidates.length - 10} 个`)
+    console.warn('   若属「透传必经文件」（facade 转发/路由挂载/注册登记——改 allowed 模块必须同步改它才生效）：')
+    console.warn('   现在补进对应 TaskCard allowed_paths 或 design §6 清单，避免执行期 apply Gate1 拦截后手工回补；')
+    console.warn('   确认无关则忽略。执行期有据越界另有出口（review.json 声明 changedFiles，apply 有审计放行）。')
+    return r
+  } catch (e) {
+    console.warn(`⚠️  facade 候选探测失败（advisory 跳过）: ${e.message}`)
+    return { skipped: true, reason: 'error', candidates: [] }
+  }
+}

package/src/index.js

@@ -98,7 +98,7 @@ SillySpec CLI — 规范驱动开发工具包
   sillyspec commit [--json]                 智能提交建议：收集 QUICKLOG/已勾 task/阶段产出语义，生成建议 message（只建议不执行）
   sillyspec verify-probes --change <name> [--init]  verify 机械探针（TODO 标记/测试覆盖/API 对账/删除对账）；--init 生成 verify-result.md 骨架
   sillyspec module-impact --change <name>       生成 module-impact.md 骨架（文件×模块归属按 module-map 预填 + 未匹配清单）
-  sillyspec endpoints extract --change <name> [--task task-NN] [--dir <dir>|--files <a.py,b.js>]  静态扫描路由装饰器生成 endpoints.json
+  sillyspec endpoints extract --change <name> [--task task-NN | --all-tasks] [--dir <dir>|--files <a.py,b.js>]  静态扫描路由装饰器生成 endpoints.json
   sillyspec scan-fix-headers [--project <名>]   scan 文档补 author/created_at header（幂等）
   sillyspec plan-adopt-waves --change <名> [--dry-run]   plan.md Wave 段一键重排为 depends_on 拓扑分组（同步任务总表 W 列，幂等）
   sillyspec workspace add <名> <路径> [--role] [--repo] | remove <名> | status   多项目工作区登记与状态探测
@@ -743,6 +743,20 @@ async function main() {
       }
       console.log(`📦 待提交变更（${cc.changedCount} 个文件${cc.untrackedCount > 0 ? `，其中未跟踪 ${cc.untrackedCount} 个` : ''}；上方 stat 仅列已跟踪文件的改动）`);
       if (cc.stat) console.log(cc.stat.split('\n').map(l => '   ' + l).join('\n'));
+      // 暂存区快照（坑 same-main-staging-pollution，2026-08-28 实证：同 main 双会话共享暂存区，
+      // A 的 commit 扫入 B 暂存的文件）：git commit 只含暂存内容——提交前把快照亮出来供核对。
+      {
+        const { collectStagedArea } = await import('./commit-suggest.js');
+        const staged = collectStagedArea({ cwd: dir });
+        if (staged.available && staged.staged.length > 0) {
+          console.log(`\n📌 暂存区快照（git diff --cached --name-only，你的下一次 git commit 将恰好含这 ${staged.staged.length} 个文件）：`);
+          for (const f of staged.staged.slice(0, 15)) console.log(`   - ${f}`);
+          if (staged.staged.length > 15) console.log(`   … 共 ${staged.staged.length} 个`);
+          console.log(`   ⚠️ 同 main 并行会话共享同一暂存区——快照里非本会话的文件请先 git restore --staged <file> 剔除，否则会被你的 commit 扫入`);
+        } else if (staged.available) {
+          console.log(`\n📌 暂存区为空（git commit 前需先 git add；用 pathspec 级 add 防扫入无关文件）`);
+        }
+      }
       if (cc.quickEntries.length > 0) {
         console.log(`\n📝 QUICKLOG（上次提交 ${cc.lastCommitTime || '（无）'} 之后 ${cc.quickEntries.length} 条）：`);
         for (const q of cc.quickEntries) {
@@ -892,15 +906,19 @@ async function main() {
       // 此前靠 agent 手扫装饰器手写（易漏 endpoint）。CLI 复用 endpoint-extractor 全套提取器
       // （FastAPI @router.* / Express router.* / Spring @*Mapping）静态扫描生成，
       // verify 探针 5（verifyApiParity）直接消费该产物。
+      // --all-tasks（坑 probe5-single-task-artifact-scope，2026-08-28 实证：单 task 产物对账
+      // 产生大量假 missing）：聚合模式——逐 task 卡提取，各自落 contract-artifacts/<change>/<task>/，
+      // 与 verifyApiParity 的聚合读侧（contract-artifacts/<change>/*/endpoints.json 全量并集）对齐。
       const epSub = filteredArgs[1];
       if (epSub !== 'extract') {
-        console.error('用法: sillyspec endpoints extract --change <name> [--task task-NN] [--dir <backendRoot> | --files <a.py,b.js...>] [--spec-dir <path>]\n  静态扫描后端路由装饰器生成 endpoints.json（FastAPI/Express/Spring）；verify 探针 5 消费');
+        console.error('用法: sillyspec endpoints extract --change <name> [--task task-NN | --all-tasks] [--dir <backendRoot> | --files <a.py,b.js...>] [--spec-dir <path>]\n  静态扫描后端路由装饰器生成 endpoints.json（FastAPI/Express/Spring）；verify 探针 5 消费。\n  --all-tasks：聚合逐 task 卡 allowed_paths 各自提取（对账口径与探针 5 聚合读侧一致，推荐）');
         process.exit(2);
       }
       const epChangeIdx = args.indexOf('--change');
       const epChange = epChangeIdx >= 0 && args[epChangeIdx + 1] ? args[epChangeIdx + 1] : null;
       const epTaskIdx = args.indexOf('--task');
       const epTask = epTaskIdx >= 0 && args[epTaskIdx + 1] ? args[epTaskIdx + 1] : null;
+      const epAllTasks = args.includes('--all-tasks');
       const epDirIdx = args.indexOf('--dir');
       const epDir = epDirIdx >= 0 && args[epDirIdx + 1] ? args[epDirIdx + 1] : null;
       const epFilesIdx = args.indexOf('--files');
@@ -909,6 +927,10 @@ async function main() {
         console.error('❌ 缺 --change <变更名>');
         process.exit(2);
       }
+      if (epAllTasks && (epTask || epDir || epFilesRaw)) {
+        console.error('❌ --all-tasks 与 --task/--dir/--files 互斥（聚合模式逐 task 卡自动取 allowed_paths）');
+        process.exit(2);
+      }
       assertSafeChangeName(epChange, '--change 变更名');
       const { extractFastApiEndpoints, extractExpressEndpoints, extractSpringEndpoints, scanBackendEndpoints } = await import('./endpoint-extractor.js');
       const endpoints = [];
@@ -928,10 +950,56 @@ async function main() {
           else if (ext === '.java') endpoints.push(...extractSpringEndpoints(abs))
         } catch { /* 单文件解析失败不阻断整体 */ }
       }
+      // 单 task 产物写盘（taskName 归属目录）；返回提取数
+      const epRuntimeRoot = (await import('./run/shared.js')).resolveRuntimeRoot({ specRoot: specDir }, epSpecBase);
+      const writeArtifact = (taskName, eps) => {
+        const artifact = {
+          generated_at: new Date().toISOString().slice(0, 19).replace('T', ' '),
+          generator: 'sillyspec endpoints extract',
+          endpoints: eps.map(e => ({ method: e.method, path: e.path, source: e.source })),
+        }
+        const epOutDir = join(epRuntimeRoot, 'contract-artifacts', epChange, taskName);
+        mkdirSync(epOutDir, { recursive: true });
+        const epOutPath = join(epOutDir, 'endpoints.json');
+        writeFileSync(epOutPath, JSON.stringify(artifact, null, 2) + '\n');
+        return epOutPath;
+      }
       if (epDir) {
-        endpoints.push(...scanBackendEndpoints(resolve(epDir)))
+        endpoints.push(...scanBackendEndpoints(resolve(epDir)));
       } else if (epFilesRaw) {
         for (const f of epFilesRaw.split(',').map(s => s.trim()).filter(Boolean)) collectFile(f)
+      } else if (epAllTasks) {
+        // 聚合模式：逐 task 卡 allowed_paths 提取，各自落产物目录（对齐 verifyApiParity 聚合读侧）
+        const { parseAllowedPaths } = await import('./stages/plan-postcheck.js')
+        const tasksDir = join(epChangeDir, 'tasks')
+        const taskCards = existsSync(tasksDir)
+          ? readdirSync(tasksDir).filter(f => /^task-[\w.-]+\.md$/.test(f)).sort()
+          : []
+        if (taskCards.length === 0) {
+          console.error(`❌ --all-tasks 无 task 卡（${tasksDir} 不存在或无 task-*.md）——先跑 plan 生成 TaskCard`);
+          process.exit(1);
+        }
+        let total = 0
+        for (const card of taskCards) {
+          const taskName = card.replace(/\.md$/, '')
+          const eps = []
+          const perFile = (f) => {
+            const abs = resolve(f)
+            if (!existsSync(abs)) return
+            const ext = extname(abs).toLowerCase()
+            try {
+              if (ext === '.py') eps.push(...extractFastApiEndpoints(abs))
+              else if (ext === '.js' || ext === '.ts') eps.push(...extractExpressEndpoints(abs))
+              else if (ext === '.java') eps.push(...extractSpringEndpoints(abs))
+            } catch { /* 单文件解析失败不阻断整体 */ }
+          }
+          for (const p of parseAllowedPaths(readFileSync(join(tasksDir, card), 'utf8'))) perFile(p)
+          const outPath = writeArtifact(taskName, eps)
+          total += eps.length
+          console.log(`ℹ️  ${taskName}: ${eps.length} 个端点 → ${outPath}`)
+        }
+        console.log(`✅ 聚合提取完成：${taskCards.length} 个 task 卡共 ${total} 个端点（探针 5 对账时全量并集消费）`);
+        break;
       } else {
         // 默认扫描面：task 卡 allowed_paths ∪ design §6 清单里的具体源码文件
         const { parseFileChangeListDetailed } = await import('./change-list.js')
@@ -957,22 +1025,13 @@ async function main() {
           collectFile(p)
         }
         if (candidates.size === 0) {
-          console.error('❌ 无扫描面：--task 卡无 allowed_paths 且 design.md 无具体文件清单——显式传 --dir <backendRoot> 或 --files <a.py,b.js>');
+          console.error('❌ 无扫描面：--task 卡无 allowed_paths 且 design.md 无具体文件清单——显式传 --dir <backendRoot> 或 --files <a.py,b.js>，或用 --all-tasks 聚合逐卡提取');
           process.exit(1);
         }
         console.log(`ℹ️  扫描 ${scanned}/${candidates.size} 个清单文件（不存在的跳过）`);
       }
-      const artifact = {
-        generated_at: new Date().toISOString().slice(0, 19).replace('T', ' '),
-        generator: 'sillyspec endpoints extract',
-        endpoints: endpoints.map(e => ({ method: e.method, path: e.path, source: e.source })),
-      }
-      const epRuntimeRoot = (await import('./run/shared.js')).resolveRuntimeRoot({ specRoot: specDir }, epSpecBase);
-      const epOutDir = join(epRuntimeRoot, 'contract-artifacts', epChange, epTask || 'scan');
-      mkdirSync(epOutDir, { recursive: true });
-      const epOutPath = join(epOutDir, 'endpoints.json');
-      writeFileSync(epOutPath, JSON.stringify(artifact, null, 2) + '\n');
-      console.log(`✅ 提取 ${endpoints.length} 个端点 → ${epOutPath}`);
+      const outPath = writeArtifact(epTask || 'scan', endpoints);
+      console.log(`✅ 提取 ${endpoints.length} 个端点 → ${outPath}`);
       console.log(`   verify 阶段探针 5（API 契约对账）自动消费该产物；FastAPI/Express/Spring 装饰器均支持。`);
       break;
     }
@@ -1719,6 +1778,20 @@ SillySpec worktree — git worktree 隔离管理
                 console.log(`   git add --pathspec-from-file="${result.pathspecFile}"`);
               }
               console.log(`   （完整清单 ${result.commitPathspec.length} 个文件已存 ${result.pathspecFile}，可 --pathspec-from-file 复用）`);
+              // 他者暂存差集（坑 same-main-staging-pollution）：暂存区已有非本变更文件时，
+              // 普通 git commit 会把它们一并扫入——提交前亮出来。pathspec 级 commit
+              // （git commit -m <msg> -- <paths>）只提交指定路径、不动他者暂存，双出口都给。
+              try {
+                const { collectStagedArea } = await import('./commit-suggest.js');
+                const stagedNow = collectStagedArea({ cwd: dir, ownFiles: result.commitPathspec });
+                if (stagedNow.available && stagedNow.foreign.length > 0) {
+                  console.warn(`\n⚠️  暂存区已有 ${stagedNow.foreign.length} 个非本变更文件（很可能为他者并行会话暂存，普通 git commit 会扫入）：`);
+                  for (const f of stagedNow.foreign.slice(0, 10)) console.warn(`   - ${f}`);
+                  if (stagedNow.foreign.length > 10) console.warn(`   … 共 ${stagedNow.foreign.length} 个`);
+                  console.warn(`   推荐用 pathspec 级 commit（不动他者暂存）：git commit -m "<msg>" --pathspec-from-file="${result.pathspecFile}"`);
+                  console.warn(`   或先剔除：git restore --staged -- <文件>（工作区内容不丢，对方可重新 add）`);
+                }
+              } catch { /* 暂存区快照失败不影响 apply 结果展示 */ }
             }
           }
           if (result.warnings && result.warnings.length > 0) {

package/src/run/command.js

@@ -75,6 +75,38 @@ export function detectSpaceSeparatedFiles(flags) {
   return suspects
 }
 
+/**
+ * 检测 prose 参数值是否疑似被 Git Bash(MSYS) 路径转换污染（坑 quick-req-msys-path-mangling）。
+ *
+ * MSYS2 对以 / 开头的命令行参数做 POSIX→Windows 自动转换：--req "/sessions 页修复" 到达
+ * CLI 时已是 "<Git 安装目录>/sessions 页修复"（如 E:/Software/Git/sessions 页修复），无感
+ * 写入 QUICKLOG 标题与「需求：」行（该标题也是平台「快速修复」列表展示标题）。启发式：
+ * 盘符绝对路径开头 + 紧随空白与中文正文——人写的 Windows 路径引用不会以「盘符路径+中文
+ * 句子」形态开头；纯英文正文检不出（v1 取零误报优先，本仓主流为中文文案）。
+ *
+ * 纯函数：无副作用，供 command.js 解析层告警 + 单测复用。只告警不阻断——无法确定性区分
+ * 误报（合法值确可能以盘符路径开头），由 agent 看到 stderr 告警后自查重发。
+ * @param {string|null} v 待检值
+ * @returns {boolean} 疑似污染返回 true
+ */
+export function looksLikeMsysMangledPath(v) {
+  if (typeof v !== 'string' || v.length === 0) return false
+  const m = v.match(/^[A-Za-z]:[\\/]\S+/) // 盘符绝对路径 token（吃到首个空白）
+  if (!m) return false
+  const rest = v.slice(m[0].length)
+  return /^\s/.test(rest) && /[\u4e00-\u9fff]/.test(rest)
+}
+
+/**
+ * MSYS 污染告警出口：命中嗅探时向 stderr 打 flag 名 + 值前缀 + 修复指引（不阻断）。
+ */
+function warnMsysMangledFlag(flag, value) {
+  if (!looksLikeMsysMangledPath(value)) return
+  console.error(`⚠️ ${flag} 的值疑似被 Git Bash(MSYS) 路径转换污染：「${value.slice(0, 60)}${value.length > 60 ? '…' : ''}」`)
+  console.error('   以 / 开头的文案在 Git Bash 下会被展开成 <Git 安装目录>/… 绝对路径后才传入 CLI。')
+  console.error('   非本意 → 去掉前导 / 或改写表述后重发本命令；确需原样 → 命令前加 MSYS_NO_PATHCONV=1。')
+}
+
 /**
  * 从 progress 或变更目录推导变更名
  */
@@ -473,6 +505,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
   let outputText = null
   const outputValue = getFlagValue('--output')
   if (outputValue !== null) outputText = outputValue
+  warnMsysMangledFlag('--output', outputValue)
 
   // 解析 quick 末步四字段参数（2026-08-21 agent-手工产出审计第二批 F6）：--req/--cause/
   // --solution/--result 各传一项，CLI 合成单行四字段 outputText（quicklog 落盘侧
@@ -492,6 +525,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
         console.error(`❌ quick 末步四字段参数缺项：${missing.join(' ')}（--req/--cause/--solution/--result 必须全给，或缺字段 --done 会被拒）`);
         process.exit(2)
       }
+      for (const [f] of FOUR) warnMsysMangledFlag(f, getFlagValue(f))
       outputText = FOUR.map(([f, label]) => `${label}${getFlagValue(f)}`).join(' ')
     }
   }
@@ -514,6 +548,7 @@ export async function runCommand(args, cwd, specDir = null, opts = {}) {
       break
     }
   }
+  warnMsysMangledFlag('--input', inputText)
 
   // 解析 --linked-changes <a,b|none>（quick 专用：显式声明关联变更，CI/脚本友好）
   // 与 --change 解耦：--linked-changes 语义清晰（关联变更），不与「指定变更名」混淆。

package/src/run/complete-handlers.js

@@ -1365,6 +1365,20 @@ export async function handleExecuteWorktreeCleanup({ stageName, changeName, cwd
             console.log(`   下一步: sillyspec worktree apply ${changeName}`);
           } else {
             console.log(`🔗 Worktree: ${cleanResult.result.result}`);
+            // 正当清理回执（坑 deps-gate-cleanup-order，2026-08-28 实证：cleanup 后重试 --done 被
+            // deps 门拦「worktree 不可用」，逼 doctor --align-execute-progress 手工对齐）：execute 完成时的
+            // 正当清理（无未应用变更）落 durable 标记，enforceDepsGate 读它区分「正当收尾」与「意外丢失」。
+            // apply 路径不写——apply-pathspec-<change>.txt 已是既定 apply 凭据，双标记冗余。
+            if (['cleaned', 'force-cleaned', 'partial'].includes(cleanResult.result.result)) {
+              try {
+                const runtimeDir = join(cwd, '.sillyspec', '.runtime');
+                mkdirSync(runtimeDir, { recursive: true });
+                writeFileSync(join(runtimeDir, `execute-cleanup-${changeName}.json`), JSON.stringify({
+                  change: changeName, cleanedAt: new Date().toISOString(),
+                  reason: 'execute-completed-no-unapplied-changes',
+                }, null, 2) + '\n', 'utf8');
+              } catch { /* 回执失败只损失 deps 门的放行判据，不影响 cleanup 结果 */ }
+            }
             if (cleanResult.result.residual?.length > 0) {
               console.warn(`   ⚠️ 清理残留: ${cleanResult.result.residual.join('; ')}`);
               console.warn(`   手动处理: sillyspec worktree cleanup ${changeName} --force`);

package/src/run/gates.js

@@ -363,6 +363,23 @@ export async function enforceDepsGate(stageName, cwd, changeName, step, steps, c
   try {
     worktreeGone = !!(wm && changeName) && !existsSync(wm.getWorktreePath(changeName))
   } catch {}
+  // ── 正当收尾放行（坑 deps-gate-cleanup-order，2026-08-28 实证：apply 后 / execute 空变更
+  // cleanup 后重试 --done，被本门拦「worktree 不可用」逼 doctor --align-execute-progress 手工
+  // 对齐——顺序矛盾：cleanup 是流程自己做的收尾，门却当意外丢失拦）。两凭据二选一：
+  //   - apply-pathspec-<change>.txt：applyWorktree 成功后落盘（apply 后自动 cleanup 删 meta）；
+  //   - execute-cleanup-<change>.json：handleExecuteWorktreeCleanup 正当清理回执。
+  // 有凭据 = 隔离期已正当结束（交付已落主仓或本无交付），deps 能力要求不再适用 → 放行。
+  if (worktreeGone && changeName) {
+    try {
+      const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
+      const legitimatelyEnded = existsSync(join(runtimeRoot, `apply-pathspec-${changeName}.txt`))
+        || existsSync(join(runtimeRoot, `execute-cleanup-${changeName}.json`))
+      if (legitimatelyEnded) {
+        console.log('ℹ️  worktree 已在 apply/execute 收尾时正当清理（凭据在 .runtime），deps 门放行')
+        return true
+      }
+    } catch { /* 凭据读取失败 → 维持原判定 */ }
+  }
   // ── fail-loud 块（Phase 3，D-005@v1：仅改拒绝侧 stderr）──
   console.error('❌ ── deps 门控阻断（本次 --done 未完成，进度未推进）──')
   if (worktreeGone) {
@@ -559,6 +576,19 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     }
   }
 
+  // plan 门 facade 候选预检（坑 plan-facade-files-manual-backfill，2026-08-28 用户实证 ×2：
+  // daemon/service.py 类「透传必经文件」不在 allowed_paths → 执行期 apply Gate1 拦截 →
+  // 手工回补两轮）。allowed 集与 Gate1 同源（resolveApplyAllowSet 主仓切片），
+  // 静态引用/聚合扫描亮候选，advisory 不阻断。
+  if (stageName === 'plan' && changeName) {
+    try {
+      const { resolveApplyAllowSet } = await import('../worktree-apply.js')
+      const { warnFacadeCandidateFiles } = await import('../facade-hint.js')
+      const allowMap = resolveApplyAllowSet(cwd, changeName)
+      warnFacadeCandidateFiles({ cwd, changeName, allowSet: allowMap.get('main') })
+    } catch { /* 预检失败不阻断 plan 完成 */ }
+  }
+
   // verify 产物校验通过 + 结论非 FAIL（否则上面已阻断）。
   // 再由 CLI 亲自执行 local.yaml 的测试命令，与 verify-result.md 的自报告对账：
   // 自报告 PASS 但实测失败 → 阻断（防止"文案通过"绕过验证）。
@@ -576,16 +606,23 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
         const { collectForeignDeclaredFiles } = await import('../verify-postcheck.js')
         const { gitQuiet } = await import('../git-helper.js')
         const foreignMap = collectForeignDeclaredFiles(cwd, changeName, { specBase, runtimeRoot: resolveRuntimeRoot(platformOpts, specBase) })
+        // dirty 集提前算好：归因提示①（他者在途）与②（生成产物旧基线）共用
+        const dirty = (gitQuiet(cwd, ['diff', '--name-only', 'HEAD']) || '')
+          .split('\n').filter(Boolean).map(f => f.replace(/\\/g, '/'))
+        const dirtySet = new Set(dirty)
         if (foreignMap.size > 0) {
-          const dirty = (gitQuiet(cwd, ['diff', '--name-only', 'HEAD']) || '')
-            .split('\n').filter(Boolean).map(f => f.replace(/\\/g, '/'))
           const hitForeign = dirty.filter(f => foreignMap.has(f))
           if (hitForeign.length > 0) {
             console.error(`   ℹ️ 归因提示：主仓检出 ${hitForeign.length} 个并行会话声明的在途文件（${hitForeign.slice(0, 5).join(', ')}${hitForeign.length > 5 ? ' 等' : ''}）——实测失败可能混入他者 WIP 而非本变更问题。待其提交/收尾后复验，仍失败才是本变更的。`)
           }
         }
         // 第二判据（坑 derived-artifact-stale-baseline）：本变更 apply 的文件（apply-pathspec 落盘）
-        // 与主仓近期提交重叠——本变更旧基线的生成产物可能覆盖了已合入内容，先在新基线重跑生成命令再复验
+        // 与主仓近期提交重叠——本变更旧基线的生成产物可能覆盖了已合入内容，先在新基线重跑生成命令再复验。
+        // 坑 verify-attr2-foreign-wip-misdirection（2026-08-28 实证）：并行会话在途/近期收尾文件
+        // 让重叠集虚高（51 文件），每轮误导 agent 重跑 gen:types，实际失败源是他者 WIP。两道过滤：
+        //   - 必须 dirty：apply 落盘的旧内容此刻物理在场（verify gate 时本变更未提交，旧基线覆盖
+        //     必然表现为对 HEAD 的修改）——内容与 HEAD 一致时重跑生成命令改变不了本轮实测；
+        //   - 剔除他者声明集：那是归因提示①的领地（待其收尾后复验），不是生成产物过期。
         try {
           const pathspecFile = join(resolveRuntimeRoot(platformOpts, specBase), `apply-pathspec-${changeName}.txt`)
           if (changeName && existsSync(pathspecFile)) {
@@ -594,8 +631,9 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
               const recent = (gitQuiet(cwd, ['log', '-n', '10', '--name-only', '--pretty=format:']) || '')
                 .split('\n').map(l => l.trim().replace(/\\/g, '/')).filter(Boolean)
               const overlap = [...new Set(recent)].filter(f => ownFiles.has(f))
-              if (overlap.length > 0) {
-                console.error(`   ℹ️ 归因提示②：本变更有 ${overlap.length} 个文件与主仓最近 10 条提交重叠（${overlap.slice(0, 5).join(', ')}${overlap.length > 5 ? ' 等' : ''}）——若为生成产物（api-types 等），本变更可能在旧基线生成并覆盖了已合入内容；先在新基线重跑生成命令（如 gen:types）再复验。`)
+              const actionable = filterStaleBaselineOverlap(overlap, dirtySet, foreignMap)
+              if (actionable.length > 0) {
+                console.error(`   ℹ️ 归因提示②：本变更有 ${actionable.length} 个文件与主仓最近 10 条提交重叠且旧内容仍在工作区（${actionable.slice(0, 5).join(', ')}${actionable.length > 5 ? ' 等' : ''}）——若为生成产物（api-types 等），本变更可能在旧基线生成并覆盖了已合入内容；先在新基线重跑生成命令（如 gen:types）再复验。（重叠共 ${overlap.length} 个，其余未在工作区改动或属他者会话在途文件，已归提示①/无需处理）`)
               }
             }
           }
@@ -1112,6 +1150,25 @@ export async function completeStageGates({ stageName, cwd, changeName, platformO
 }
 
 
+/**
+ * 归因提示②（生成产物旧基线覆盖）的重叠集过滤（坑 verify-attr2-foreign-wip-misdirection）。
+ *
+ * 原始重叠 = 本变更 apply-pathspec ∩ 主仓最近提交。并行会话场景下该集合被在途/刚收尾的
+ * 他者文件虚高，逐轮误导 agent 重跑生成命令。只保留两个必要条件都成立的文件：
+ *   - dirty（此刻对 HEAD 有改动）：verify gate 时本变更未提交，旧基线覆盖必然物理在场；
+ *     内容与 HEAD 一致时重跑生成命令改变不了本轮实测。
+ *   - 非他者声明集（collectForeignDeclaredFiles）：他者在途文件归归因提示①（待其收尾
+ *     复验），不是生成产物过期。
+ *
+ * @param {string[]} overlap 原始重叠文件（POSIX 路径）
+ * @param {Set<string>} dirtySet 主仓当前对 HEAD 的改动集
+ * @param {Set<string>|Map} foreignDeclared 他者会话声明集（Map 亦可用 has 判定）
+ * @returns {string[]} 可行动子集（空 = 不出提示②，避免误导）
+ */
+export function filterStaleBaselineOverlap(overlap, dirtySet, foreignDeclared) {
+  return (overlap || []).filter(f => dirtySet?.has(f) && !(foreignDeclared?.has(f)))
+}
+
 /**
  * verify 服务进程回收（verify --done 收尾调用）。
  *

package/src/run/shared.js

@@ -813,6 +813,54 @@ export function isQuickMetadata(p, linkedChanges = []) {
   return false
 }
 
+// 危险文件清单（auditQuickCompletion 危险门与 predictProtectedQuickFiles 预告共用单一真相源）。
+// SillySpec 核心流程代码。W6 重构后 src/run.js（23 行 barrel）/ src/progress.js（facade）
+// 把真正逻辑下沉到 src/run/、src/progress/ 子目录——旧的精确文件名匹配
+// （file === 'src/run.js'）命中不到 src/run/command.js（. 与 / 不可混同），致危险文件门
+// 静默失效。改用「目录前缀（带尾斜杠，startsWith 不会误伤 src/runtime-* 等同名前缀）+
+// barrel/facade 本体精确名」双重覆盖。重构 src/ 模块时须同步本清单（multi-agent-review Q5）。
+const QUICK_DANGEROUS_PATTERNS = [
+  'package.json',
+  'package-lock.json',
+  'yarn.lock',
+  'pnpm-lock.yaml',
+  '.eslintrc',
+  'tsconfig.json',
+  'src/run.js',
+  'src/run/',
+  'src/progress.js',
+  'src/progress/',
+  'src/db.js',
+  'src/stage-contract.js',
+  'src/stage-contract-spec.js',
+  'src/worktree.js',
+  'src/worktree-apply.js',
+  'src/hooks/',
+]
+
+/**
+ * 预告：--files 声明中哪些文件会在 --done 审计被危险/基线门拦截（坑 quick-protected-late-hint，
+ * 2026-08-28 用户实证：scan 类文档 ARCHITECTURE/CONCERNS 属受保护基线，--files 声明了照样拦、
+ * 必须 --force-baseline——设计合理但提示太晚，要等审计轮才发现，白跑一轮往返）。
+ * 判定与 auditQuickCompletion 危险门逐字同口径（isQuickMetadata 豁免 + 关联变更目录退栈 +
+ * DANGEROUS_PATTERNS 前缀/精确匹配），forceBaseline 已带 → 无预告。
+ * @param {string[]} files 声明文件（--files）
+ * @param {{ linkedChanges?: string[], forceBaseline?: boolean }} opts
+ * @returns {string[]} 将被拦截的声明文件子集
+ */
+export function predictProtectedQuickFiles(files, { linkedChanges = [], forceBaseline = false } = {}) {
+  if (forceBaseline) return []
+  const linked = (Array.isArray(linkedChanges) ? linkedChanges : []).map(c => String(c).replace(/\\/g, '/'))
+  const isUnderLinkedChange = (f) => linked.some(lc => f.startsWith(`.sillyspec/changes/${lc}/`))
+  return (files || [])
+    .filter(Boolean)
+    .map(f => String(f).replace(/\\/g, '/'))
+    .filter(f => {
+      if (f.startsWith('.sillyspec/') && !isQuickMetadata(f, linked) && !isUnderLinkedChange(f)) return true
+      return QUICK_DANGEROUS_PATTERNS.some(p => p === f || f.startsWith(p))
+    })
+}
+
 /**
  * quick 完成审计：对比 baseline 与实际变更。
  * @returns {{ status: 'safe'|'warning'|'blocked', reasons: string[], changedFiles: string[], newFiles: string[], deletedFiles: string[], baselineHit: string[], stagedTotal: number, attributedFiles: string[], undeclaredFiles: string[], foreignSessionDeclared: Array<{file: string, sessions: string[]}> }}
@@ -990,29 +1038,7 @@ export async function auditQuickCompletion(cwd, guard, options = {}) {
       }
       return foreignDeclaredIndex.get(f) || null
     }
-    const DANGEROUS_PATTERNS = [
-      'package.json',
-      'package-lock.json',
-      'yarn.lock',
-      'pnpm-lock.yaml',
-      '.eslintrc',
-      'tsconfig.json',
-      // SillySpec 核心流程代码。W6 重构后 src/run.js（23 行 barrel）/ src/progress.js（facade）
-      // 把真正逻辑下沉到 src/run/、src/progress/ 子目录——旧的精确文件名匹配
-      // （file === 'src/run.js'）命中不到 src/run/command.js（. 与 / 不可混同），致危险文件门
-      // 静默失效。改用「目录前缀（带尾斜杠，startsWith 不会误伤 src/runtime-* 等同名前缀）+
-      // barrel/facade 本体精确名」双重覆盖。重构 src/ 模块时须同步本清单（multi-agent-review Q5）。
-      'src/run.js',
-      'src/run/',
-      'src/progress.js',
-      'src/progress/',
-      'src/db.js',
-      'src/stage-contract.js',
-      'src/stage-contract-spec.js',
-      'src/worktree.js',
-      'src/worktree-apply.js',
-      'src/hooks/',
-    ]
+    const DANGEROUS_PATTERNS = QUICK_DANGEROUS_PATTERNS
 
     for (const entry of currentEntries) {
       // porcelain 两字符状态码（X=暂存区 Y=工作区）不能先 trim：' D'.trim()==='D' 使第二分支恒假、

package/src/run/stage.js

@@ -19,7 +19,7 @@
 import { join, dirname } from 'node:path'
 import { existsSync, readdirSync, readFileSync, mkdirSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
-import { resolveSpecDir, resolveChangeDir, resolveRuntimeRoot, resolveQuickSessionsDir, triggerSync, safeGit, parsePorcelainPath, formatWaitOptions, checkApproval, getStageSteps, warnApprovalUnknown } from './shared.js'
+import { resolveSpecDir, resolveChangeDir, resolveRuntimeRoot, resolveQuickSessionsDir, triggerSync, safeGit, parsePorcelainPath, formatWaitOptions, checkApproval, getStageSteps, warnApprovalUnknown, predictProtectedQuickFiles } from './shared.js'
 import { computeScanProfile, applyScanProfileSteps, executeScanPreflight, executeScanPostcheck } from './scan-profile.js'
 import { outputStep, collectStageWaitHistory } from './prompt.js'
 import { allocateQuicklogEntry, deriveTitleFromLinkedChange, sanitizeDesc } from '../quicklog.js'
@@ -328,6 +328,15 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
   // （D-003@v1：顶层 quickGuard 不跨进程持久化；agent 在 step 间用 `run quick` 取下一步
   // prompt 时每个新进程都进此块，按文件判幂等才不会重复分配 ql-ID / 重复写条目）。
   if (stageName === 'quick') {
+    // 受保护文件预告打印（坑 quick-protected-late-hint，2026-08-28 用户实证：scan 类文档
+    // ARCHITECTURE/CONCERNS 属受保护基线，--files 声明了照样拦、必须 --force-baseline——
+    // 设计合理但提示太晚。step1 即预告哪些声明文件会触发拦截，省一轮跑到 --done 才发现的往返）
+    const warnProtectedQuickFiles = (protectedFiles) => {
+      console.warn(`⚠️ 声明文件中 ${protectedFiles.length} 个属受保护/危险范围，--done 审计将拦截（--files 只声明归属，不解锁拦截）：`)
+      for (const f of protectedFiles) console.warn(`   - ${f}`)
+      console.warn(`   确认要改这类文件：本会话收尾带 --force-baseline（sillyspec run quick --done --force-baseline ...）；`)
+      console.warn(`   属误判或不该由本会话改：换出 --files 声明，或走完整流程（execute 有 review 把关）。`)
+    }
     // quick-sessions 目录经 resolveQuickSessionsDir 单一解析（multi-agent-review Q4）：
     // 平台模式 runtimeRoot 与 specBase/.runtime 不同时，写/读须对齐，否则 guard 写一处、收尾读另一处。
     const sessionGuardDir = join(resolveQuickSessionsDir(platformOpts, specBase), changeName)
@@ -348,6 +357,13 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
         const known = new Set(progress.quickGuard.allowedFiles || [])
         const added = resumeFiles.filter(f => !known.has(f))
         if (added.length > 0) {
+          // 受保护文件预告（坑 quick-protected-late-hint）：追加声明若含审计将拦的文件，
+          // 追加时即点破（省一轮跑到 --done 才发现）。--files 只声明归属，不解锁拦截。
+          const protectedPreview = predictProtectedQuickFiles(added, {
+            linkedChanges: progress.quickGuard.linkedChanges || [],
+            forceBaseline: quickOpts?.isForceBaseline || false,
+          })
+          if (protectedPreview.length > 0) warnProtectedQuickFiles(protectedPreview)
           progress.quickGuard.allowedFiles = [...(progress.quickGuard.allowedFiles || []), ...added]
           progress.quickGuard.allowedFilesHash = { ...(progress.quickGuard.allowedFilesHash || {}) }
           for (const f of added) {
@@ -385,6 +401,10 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
         const allowDelete = quickOpts?.isAllowDelete || false
         const forceBaseline = quickOpts?.isForceBaseline || false
         const linkedChanges = Array.isArray(quickOpts?.linkedChanges) ? quickOpts.linkedChanges : []
+        // 受保护文件预告（坑 quick-protected-late-hint）：会话起步（step1）即点破，
+        // 判定与 --done 审计危险门同口径（predictProtectedQuickFiles）
+        const protectedPreview = predictProtectedQuickFiles(allowedFiles, { linkedChanges, forceBaseline })
+        if (protectedPreview.length > 0) warnProtectedQuickFiles(protectedPreview)
         // CLI 接管：分配 ql-ID + 写 QUICKLOG「进行中」条目 + 关联 tasks.md（持锁、当天唯一）
         const gitUser = safeGit(cwd, ['config', 'user.name']).value || 'unknown'
         // 标题回退：启动 quick 不带 --input 时，从关联变更的 proposal/design 提取语义标题，

package/src/spec-sync.js

@@ -8,6 +8,11 @@
  *
  * 复用 daemon 已验证的排除口径（UPLOAD_EXCLUDE_TOP_BASE / UPLOAD_PRUNE_NAMES_BASE），
  * 与 daemon 共用同一套清单语义（base_version 乐观锁、conflict 提示但不阻塞）。
+ *
+ * 并行会话 fail-closed 护栏（computeSpecOps 空树/changes 整删守卫 + filterStaleUpdates
+ * 旧副本回推守卫）：共享同一平台工作空间的多会话/多机场景下，错锚或滞后本地的破坏性
+ * ops（整删 changes/、旧版内容回推）在发出前拦下——服务器侧一旦被破坏会经同步链路
+ * 落地回各端本地（2026-08-26/27 两次实证）。
  */
 
 import { createHash } from 'crypto';
@@ -140,6 +145,20 @@ export function computeSpecOps(serverManifest, localFiles) {
     return [];
   }
 
+  // 并行会话护栏（坑 spec-sync-parallel-changes-wipe，2026-08-26/27 两次实证：平台同步
+  // 删整个 changes 目录）：本地树非空但 changes/ 子树一个文件都没有、服务器却有——
+  // 几乎必然是错锚/新机未先落地，而非用户真删光了所有变更（archive 是移动不是清空）。
+  // 放行即服务器 changes/ 整树清空，再经 daemon/对端同步落地回本地（破坏本地）。
+  // 逐个变更目录的合法删除不受影响（本地仍有其他 changes/ 文件时不触发本护栏）。
+  const serverChanges = serverPaths.filter((p) => p.startsWith('changes/'));
+  const localChanges = localFiles.filter((f) => f.path.startsWith('changes/'));
+  if (localFiles.length > 0 && serverChanges.length > 0 && localChanges.length === 0) {
+    console.warn(
+      `[spec-sync] 本地 spec 树无 changes/ 文件但服务器有 ${serverChanges.length} 个，跳过同步（防并行会话/错锚整删 changes/；请检查 spec 目录锚点，新环境先完成平台侧文件落地）`
+    );
+    return [];
+  }
+
   // rename 检测：旧路径（服务器有、本地无）↔ 新路径（本地有、服务器无）hash 相同
   const renames = [];
   const consumedNew = new Set();
@@ -248,6 +267,62 @@ function collectChangeDir(dirs, p) {
   }
 }
 
+/**
+ * 过滤「旧副本回推」型 update op（坑 spec-sync-parallel-stale-overwrite，2026-08-26/27
+ * 两次实证：平台同步把本地文件覆盖回旧版）。
+ *
+ * 判据：本地文件 mtime 早于上次成功同步（mtime + 1s 缓冲）= 该文件自上次同步后本地从未
+ * 改动——此刻服务器 hash 却不同，只可能是他者会话/他机推进了服务器内容。本地这份是旧
+ * 副本，照推 update 就是把服务器内容回退到旧版（再经 daemon/对端落地破坏各端本地）。
+ * 本地改过的文件（mtime 晚于上次同步）不受影响，正常 last-writer-wins。
+ *
+ * 被滤掉的文件如确需以本地为准覆盖服务器：本地重存（touch/再编辑）后重推。
+ *
+ * @param {Array} ops computeSpecOps 产物
+ * @param {Array} localFiles hashFiles 产物（含 mtime，Unix 秒）
+ * @param {number|null} lastSyncTs 上次成功同步完成时刻（ms）；null/0 → 不过滤
+ * @returns {{ ops: Array, stale: string[] }} 过滤后 ops + 被拦下的路径
+ */
+export function filterStaleUpdates(ops, localFiles, lastSyncTs) {
+  if (!lastSyncTs || !Array.isArray(ops) || ops.length === 0) {
+    return { ops, stale: [] };
+  }
+  const mtimeByPath = new Map(localFiles.map((f) => [f.path, f.mtime]));
+  const stale = [];
+  const kept = [];
+  for (const op of ops) {
+    if (op.op === 'update') {
+      const mtime = mtimeByPath.get(op.path);
+      if (mtime !== undefined && mtime * 1000 + 1000 <= lastSyncTs) {
+        stale.push(op.path);
+        continue;
+      }
+    }
+    kept.push(op);
+  }
+  return { ops: kept, stale };
+}
+
+// 上次成功同步标记（本地 .runtime 下，walk 排除不上传）：filterStaleUpdates 的时间锚。
+const LAST_SUCCESS_MARKER = 'spec-sync-last-success.json';
+
+function readLastSyncTs(specRoot) {
+  try {
+    const raw = readFileSync(join(specRoot, '.runtime', LAST_SUCCESS_MARKER), 'utf8');
+    const ts = JSON.parse(raw).ts;
+    return Number.isFinite(ts) ? ts : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeLastSyncTs(specRoot) {
+  try {
+    mkdirSync(join(specRoot, '.runtime'), { recursive: true });
+    writeFileSync(join(specRoot, '.runtime', LAST_SUCCESS_MARKER), JSON.stringify({ ts: Date.now() }) + '\n', 'utf8');
+  } catch { /* 标记失败只损失下次的防回推过滤，不影响本次同步结果 */ }
+}
+
 /**
  * 同步本地 .sillyspec 树到平台（CLI 直跑增量同步入口）。
  *
@@ -292,7 +367,17 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
   // 2. walk/hash/diff
   const entries = walkSpecTree(specRoot);
   const localFiles = hashFiles(entries);
-  const ops = computeSpecOps(serverManifest, localFiles);
+  let ops = computeSpecOps(serverManifest, localFiles);
+
+  // 旧副本回推防护（并行会话一致性）：上次同步后本地从未改动的文件不回推覆盖服务器新内容
+  const lastSyncTs = readLastSyncTs(specRoot);
+  const filtered = filterStaleUpdates(ops, localFiles, lastSyncTs);
+  if (filtered.stale.length > 0) {
+    console.warn(
+      `[spec-sync] 拦下 ${filtered.stale.length} 个旧副本回推（本地自上次同步未改动而服务器已前进，如确需以本地为准：重存后重推）: ${filtered.stale.slice(0, 5).join(', ')}${filtered.stale.length > 5 ? ' 等' : ''}`
+    );
+  }
+  ops = filtered.ops;
 
   if (ops.length === 0) {
     debugLog(`[spec-sync] 无差异，跳过同步: ${changeName}`);
@@ -342,6 +427,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       return { synced: 0, conflict: true, serverVersions, conflictPath };
     }
     console.log(`[spec-sync] 已同步 ${ops.length} 个文件变更: ${changeName}`);
+    writeLastSyncTs(specRoot);
     return { synced: ops.length };
   } catch (err) {
     console.warn(`[spec-sync] 同步异常（文件树本次未同步，下次自动重试）: ${changeName}: ${err.message}`);
@@ -354,5 +440,6 @@ export default {
   hashFiles,
   computeSpecOps,
   extractChangeDirs,
+  filterStaleUpdates,
   syncSpecTree,
 };

package/src/stages/execute.js

@@ -1265,10 +1265,11 @@ task-XX 对应：{SPEC_ROOT}/.runtime/execute-runs/{EXECUTE_RUN_ID}/tasks/task-X
 
 ### 完成后
 1. 为每个后端 router task 生成 API 端点 artifact——**用 CLI 命令，勿手扫装饰器手写（易漏 endpoint）**：
-   - 逐 task 运行：sillyspec endpoints extract --change <change> --task <task-NN>（<change> = 当前变更名）
+   - 聚合一次跑全：sillyspec endpoints extract --change <change> --all-tasks（逐 task 卡 allowed_paths 各自提取落盘，<change> = 当前变更名；与 verify 探针 5 聚合对账口径一致）
    - CLI 静态扫描变更文件（FastAPI @router.* / Express router.* / Spring @*Mapping）生成
      {SPEC_ROOT}/.runtime/contract-artifacts/<task-name>/endpoints.json
    - 格式: { "task": "task-XX", "type": "backend_endpoints", "endpoints": [{ "method": "GET", "path": "/api/ppm/xxx" }] }（CLI 已按此格式写好，verify 探针 5 直接消费）
+   - 只提单 task（--task task-NN）会让探针 5 用局部端点集对账放大假 missing——多 task 变更必用 --all-tasks
 `
 }
 

package/src/verify-postcheck.js

@@ -579,10 +579,21 @@ export function extractKnownFailures(yamlText) {
   if (inline) {
     return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
   }
-  const block = yaml.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?)+)/m)
+  // 坑 verify-known-failures-comment-line-truncation（2026-08-28 连续踩两次）：块内注释行/空行
+  // 打断「连续列表项」的捕获链 → 只取到注释前的项，注释后的项静默丢失 → 清单残缺、
+  // verify 实测 remaining>0 假红。块定义放行注释行与空行（提取侧本就只认 `- ` 项行，
+  // 吸收进块的注释不影响结果）。
+  const block = yaml.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?|[ \t]*#[^\n]*\n?|[ \t]*\n)+)/m)
   if (block) {
     return (block[1].match(/^[ \t]+-[ \t]+(.+)/gm) || [])
-      .map(s => s.replace(/^[ \t]+-[ \t]+/, '').trim().replace(/^['"]|['"]$/g, '').replace(/#.*$/, '').trim())
+      .map(s => {
+        const item = s.replace(/^[ \t]+-[ \t]+/, '').trim()
+        const full = item.match(/^(['"])(.*)\1$/)
+        if (full) return full[2] // 整体引号值原样保留（内部 # 不是注释）
+        const stripped = item.replace(/[ \t]+#.*$/, '').trim() // 行尾注释须 # 前有空白（YAML 语义），裸 # 不截
+        const q2 = stripped.match(/^(['"])(.*)\1$/)
+        return q2 ? q2[2] : stripped
+      })
       .filter(Boolean)
   }
   return []
@@ -591,9 +602,25 @@ export function extractKnownFailures(yamlText) {
 // 单条失败行标记（跨 pytest/jest/vitest/go/generic）。大小写不敏感。
 // 刻意用 FAIL/FAILED + 配合 SUMMARY_LINE_RE 排除汇总行：否则 pytest/jest 的
 // "N failed" 汇总会被误判为「需豁免的失败行」→ 永远 remaining>0 → known_failures 失效。
-const PER_TEST_FAIL_RE = /(FAILED|\bFAIL\b|✕|✗|✘|panic\s*:|assertionerror|traceback|---\s*fail|error:|exception)/i
-// 汇总/计数行（非单条失败）：pytest === 框、jest "Tests:"、裸 "N failed/passed"、go "FAILED in Ns" 等。
-const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)\b|tests?\s*:|test\s+suites?\s*:|failed\s+in\s+\d)/i
+// ×(U+00D7) 是 vitest 失败行的实际前缀标记（✕✗✘ 是 jest/mocha 形态）。
+const PER_TEST_FAIL_RE = /(FAILED|\bFAIL\b|✕|✗|✘|×|panic\s*:|assertionerror|traceback|---\s*fail|error:|exception)/i
+// 汇总/计数行（非单条失败）：pytest === 框、jest "Tests:"、vitest "Test Files  N failed"/"Tests  N failed | M passed"
+// （无冒号形态）、裸 "N failed/passed"、go "FAILED in Ns"、pnpm "ELIFECYCLE Test failed" 退出横幅等。
+const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)\b|tests?\s*:|test\s+suites?\s*:|^\s*(?:test\s+files|tests?)\s+\d|failed\s+in\s+\d|failed\s+tests\s+\d|elifecycle)/i
+// 控制台捕获噪声行（非失败信号）：vitest 把测试内 console 输出捕获为
+// `stderr | <file> > <测试名>` 横幅 + 后续内容行——挂在通过用例上的噪声里常含
+// error:/failed 字样（jsdom「Not implemented」警告、用例名本身带 failed 等），
+// 与失败信号（× 行 / FAIL 横幅 / 汇总计数）无关，全部剔除。
+const CONSOLE_CAPTURE_RE = /^\s*(?:stdout|stderr)\s*\|/
+const ENV_NOISE_RE = /not\s+implemented\s*:/i
+// 通过行（行首标记，剥 ANSI 后判定）：vitest/jest/mocha 的 ✓√✔ 前缀行 + jest 的 PASS 文件行。
+// 坑 verify-known-failures-pass-line-false-positive：FAILED/error:/exception 是子串匹配，
+// 通过行用例名恰含这些字样（如「✓ … 超时后 syncStatus=failed」）会被误判失败行——
+// 2710 用例套件 382 个"失败行"里 378 假阳性，known_failures 无法逐条枚举而实质失效。
+// 框架输出里通过行恒以通过标记开头、失败行恒以失败标记开头，行首判定即足以分离两类。
+const PASS_LINE_RE = /^\s*(?:[✓√✔]|PASS\b)/
+// ANSI 色码剥离（分类用）：TTY 捕获的输出里 ✓/× 前缀可能被色码包裹，行首锚定会失配。
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g
 
 /**
  * 把测试输出按行筛出「失败行」，再按 known_failures 模式分为已豁免 / 未豁免。
@@ -603,7 +630,15 @@ const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)
  */
 export function partitionFailures(output, knownFailures) {
   const lines = String(output || '').split(/\r?\n/)
-  const failureLines = lines.filter(l => PER_TEST_FAIL_RE.test(l) && !SUMMARY_LINE_RE.test(l))
+  // 分类在剥 ANSI 后的行上做，返回保留原文（remaining 展示给 agent 时不变形）
+  const failureLines = lines.filter(l => {
+    if (PASS_LINE_RE.test(l)) return false
+    const bare = l.replace(ANSI_RE, '')
+    if (PASS_LINE_RE.test(bare)) return false
+    if (CONSOLE_CAPTURE_RE.test(bare)) return false
+    if (ENV_NOISE_RE.test(bare)) return false
+    return PER_TEST_FAIL_RE.test(bare) && !SUMMARY_LINE_RE.test(bare)
+  })
   const pats = (knownFailures || []).map(p => String(p).toLowerCase()).filter(Boolean)
   const exempted = []
   const remaining = []
@@ -1528,6 +1563,12 @@ export function printVerifyParityCheck(result) {
     console.warn(`   - ${m.method} ${m.path}  ← ${m.consumerFile}:${m.consumerLine}`)
   }
   if (result.missingBackend.length > 20) console.warn(`   …还有 ${result.missingBackend.length - 20} 个`)
+  // 全仓口径告警（坑 probe5-single-task-artifact-scope，2026-08-28 实证：diff/apply 清单都不可得
+  // 时回退全仓，全仓调用 × 本变更局部端点 = 大量假 missing，agent 照单记 FAIL 误导归档判定）
+  if (/\[scope: full-repo\]/.test(result.summary || '')) {
+    console.warn('   ⚠️  本次 scope 为 full-repo（diff 与 apply-pathspec 均不可得时的兜底）——missing 大概率是口径错配噪音而非真实 contract gap。')
+    console.warn('      先收窄复跑：sillyspec verify-probes --change <变更名>（change-diff/apply-pathspec 口径）再判定。')
+  }
   console.warn('   提示：检查是否后端漏实现，或前端调用了尚未实现的端点。确认无误可在 design.md 标注豁免。')
 }
 

package/src/worktree-apply.js

@@ -1377,6 +1377,60 @@ function rollbackApply(projectRoot, trackedFiles, newFiles, rawStderr = '') {
  * @param {object} p.result - applyWorktree 的 result（预对齐信息写入 result.warnings，可追溯，约束④）
  * @returns {{ aligned: string[], commit: string|null }} aligned=本次对齐的文件（空数组=未对齐）
  */
+/**
+ * merge 前自动 commit worktree 未提交交付物（坑 apply-merge-uncommitted-noop，2026-08-28 实证：
+ * 子代理默认不 commit，分支 tip 只有 baseline checkpoint → git merge 空转「Already up to date」/
+ * --no-ff 空合并，交付零落地，落地校验报错后只能手工 cherry-pick/cp 补救）。
+ * 默认 patch 路径本就能吃未提交内容（git diff <base> 到工作区）；只有 --merge/降级 merge 路径
+ * 只看已提交——在此补上衔接。与 preAlignBaselineToMain 同款 pathspec commit（坑
+ * git-commit-sweeps-prestaged：不扫入其他 staged 改动）。
+ *
+ * best-effort：commit 失败只 warning，交由下方落地校验兜底报错（不劣于原行为）。
+ * @returns {{ committed: string[], skipped: boolean, shortHash: string|null }}
+ */
+function autoCommitWorktreeWip({ meta, result, changeName }) {
+  const out = { committed: [], skipped: true, shortHash: null };
+  const worktreePath = meta?.worktreePath;
+  if (!worktreePath || !existsSync(worktreePath)) return out;
+  if (meta.mode && meta.mode !== 'worktree') return out;
+
+  // 未提交交付物 = tracked-modified（vs HEAD）∪ untracked，过 filterDeliverableFiles（排 meta.json/.sillyspec）
+  let wip = [];
+  try {
+    const modRaw = gitQuiet(worktreePath, ['diff', '--name-only', 'HEAD']);
+    const untrackedRaw = gitQuiet(worktreePath, ['ls-files', '--others', '--exclude-standard']);
+    wip = filterDeliverableFiles([
+      ...new Set([...(modRaw || '').split('\n'), ...(untrackedRaw || '').split('\n')].filter(Boolean)),
+    ]);
+  } catch { return out; }
+  if (wip.length === 0) return out;
+
+  try {
+    git(worktreePath, ['add', '-A', '--', ...wip]);
+    try {
+      git(worktreePath, ['commit', '--no-verify', '-m',
+        `sillyspec: auto-commit worktree WIP (${wip.length} files, apply --merge)`, '--', ...wip]);
+    } catch {
+      // 仓级 git 身份缺失时 commit 拒绝——补 -c 身份重试一次（worktree 继承不到全局配置的形态）
+      git(worktreePath, ['-c', 'user.name=sillyspec', '-c', 'user.email=sillyspec@apply.local',
+        'commit', '--no-verify', '-m',
+        `sillyspec: auto-commit worktree WIP (${wip.length} files, apply --merge)`, '--', ...wip]);
+    }
+    out.committed = wip;
+    out.skipped = false;
+    out.shortHash = gitQuiet(worktreePath, ['rev-parse', '--short', 'HEAD']);
+    result.warnings = result.warnings || [];
+    result.warnings.push(
+      `worktree 有 ${wip.length} 个未提交交付文件（子代理未 commit），已在分支自动 commit` +
+      `${out.shortHash ? `（${out.shortHash}）` : ''} 再 merge：${wip.slice(0, 5).join(', ')}${wip.length > 5 ? ' 等' : ''}`
+    );
+  } catch (e) {
+    result.warnings = result.warnings || [];
+    result.warnings.push(`worktree WIP 自动 commit 失败（merge 可能空转，落地校验将报未落地）：${(e.message || '').split('\n')[0]}`);
+  }
+  return out;
+}
+
 function preAlignBaselineToMain({ meta, branch, projectRoot, result }) {
   const pushWarning = (msg) => {
     result.warnings = result.warnings || [];
@@ -1495,6 +1549,10 @@ export function applyByMerge(result, changeName, projectRoot, wm, opts = {}) {
   // --- merge 前预对齐（D-002@v1 / task-02）：baseline 并行旧文件对齐 main 版，消除 merge 冲突主因 ---
   preAlignBaselineToMain({ meta, branch, projectRoot, result });
 
+  // --- merge 前自动 commit 未提交交付物（坑 apply-merge-uncommitted-noop）：预对齐在前——
+  // 它跳过 dirty 文件（不覆盖 WIP）且只提交对齐集；WIP commit 在后，两者不混提交 ---
+  autoCommitWorktreeWip({ meta, result, changeName });
+
   try {
     git(projectRoot, ['merge', '--no-ff', branch], { timeout: 30000 });
   } catch (e) {

package/templates/prompts/verify-probes.md

@@ -26,7 +26,8 @@ grep -rl "<关键词>" <源码目录>/ --include="*.java" --include="*.js" --inc
 6. 任意 P0/P1 unresolved/blocking 决策标记为 FAIL blocker
 
 **探针 5 补充（CLI 已出对账表，你做诚实判定）**
-CLI 的 missing backend endpoint 是 advisory（不硬阻断归档）——但 contract gap 是真实集成缺陷，应诚实标 FAIL 并回 execute 补端点，勿因 CLI 不拦而放行。后端 router 的端点清单可用 `sillyspec endpoints extract --change <变更名> --task <task-NN>` 重新静态提取（勿手扫装饰器）。
+CLI 的 missing backend endpoint 是 advisory（不硬阻断归档）——但 contract gap 是真实集成缺陷，应诚实标 FAIL 并回 execute 补端点，勿因 CLI 不拦而放行。后端 router 的端点清单用 `sillyspec endpoints extract --change <变更名> --all-tasks` 聚合提取（逐 task 卡各自落产物，与对账聚合口径一致；勿手扫装饰器、勿只提单 task——单 task 产物对账会放大假 missing）。
+先看对账表 scope 标注：`change-diff`（含 apply-pathspec 兜底）口径可信；若显示 `full-repo`（diff 与 apply 清单都不可得时的兜底），missing 大概率是「全仓调用 × 本变更局部端点」的口径错配噪音——先收窄复跑（`sillyspec verify-probes --change <变更名>`）再判定，不要把口径噪音直接记成 contract gap。
 
 **探针 6 补充（CLI 已出三态判定，你做终审）**
 以 git 事实为准（真实 > 声明）；CLI 的三态（合规/高风险/未声明）是机械判定，是否构成 FAIL blocker 由你诚实判定，务必如实记录——静默删除代码是 verify 的最大盲区。