sillyspec 3.28.6 → 3.28.8

package/src/stages/plan-postcheck.js

@@ -840,10 +840,21 @@ export function validateTaskCommands(changeDir, projectRoot, modules = null) {
 
 /**
  * design §6 按仓分段段头识别（D-014）：`## <repo> 仓变更`（如 `## sillyspec 仓变更`）。
- * 段头为 h2，repo 名取段头首 token（去空白/编号前缀）。容忍可选编号前缀与尾随空白/冒号。
+ * 段头为 h2/h3，repo 名取段头首 token（去空白/编号前缀）。容忍可选编号前缀、（…）备注后缀
+ * （`（跨仓，X1-X4）` 等，全/半角括号均可）与尾随空白/冒号——后缀不容忍时（用户实证
+ * 2026-08-29）`### sillyspec 仓变更（跨仓，X1-X4）` 整段判 main、跨仓文件全量误报未覆盖。
  * 不命中（非仓变更段头）→ null。
  */
-const REPO_SECTION_HEADER_RE = /^#{2,3}\s+(?:\d+[.)]\s*)?([A-Za-z0-9_.\-]+)\s*仓变更\s*[:：]?\s*$/
+const REPO_SECTION_HEADER_RE = /^#{2,3}\s+(?:\d+[.)]\s*)?([A-Za-z0-9_.\-]+)\s*仓变更(?:\s*[（(][^（）()]*[)）])?\s*[:：]?\s*$/
+
+/**
+ * 疑似段头宽匹配：标题行含「<token> 仓变更」字样（token 与仓变更间有空白）。
+ * 宽匹配命中而严格式（REPO_SECTION_HEADER_RE）不命中 = 段头意图明确但格式解析不了
+ * （repo-key 含中文等非法字符 / 仓变更后接自由文本）。此时该段文件会被错记到上一段仓
+ * （或 main）→ 覆盖对账整段错位，validateDesignFileCoverage 据此点名报错，
+ * 不让用户对着「未覆盖」清单反推是段头问题。
+ */
+const REPO_SECTION_HEADER_LOOSE_RE = /^#{2,3}\s+(?:\d+[.)]\s*)?\S+\s+仓变更/
 
 /**
  * design §6 文件清单章节标题（与 change-list.js FILE_LIST_SECTION_RE 同源，避免 import 私有常量）。
@@ -867,19 +878,20 @@ const FILE_LIST_SECTION_RE = /^#{2,3}\s*(?:\d+[.)]\s*)?(文件变更清单|变
  *   外加 _hasSegmentHeader 标记（调用方据此决定是否走分段对账路径）
  *
  * @param {string} designPath - design.md 绝对路径
- * @returns {{ byRepo: Map<string, Set<string>>, hasSegmentHeader: boolean, allFiles: string[] }}
+ * @returns {{ byRepo: Map<string, Set<string>>, hasSegmentHeader: boolean, allFiles: string[], malformedHeaders: string[] }}
  */
 function parseDesignCoverageByRepo(designPath) {
   const byRepo = new Map()
   const allFiles = []
+  const malformedHeaders = []
   if (!designPath || !existsSync(designPath)) {
-    return { byRepo, hasSegmentHeader: false, allFiles }
+    return { byRepo, hasSegmentHeader: false, allFiles, malformedHeaders }
   }
   const content = readFileSync(designPath, 'utf8')
 
   const sectionMatch = content.match(FILE_LIST_SECTION_RE)
   if (!sectionMatch) {
-    return { byRepo, hasSegmentHeader: false, allFiles }
+    return { byRepo, hasSegmentHeader: false, allFiles, malformedHeaders }
   }
 
   // 主章节起点（match index）→ 扫描到下一个非段头的 `## ` 标题或文件末尾。
@@ -891,10 +903,14 @@ function parseDesignCoverageByRepo(designPath) {
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i]
     if (i > 0 && /^##\s/.test(line) && !REPO_SECTION_HEADER_RE.test(line)) {
-      // 遇到非段头的 h2 标题（如 `## 7. 接口定义`）→ 主章节结束
+      // 遇到非段头的 h2 标题（如 `## 7. 接口定义`）→ 主章节结束。
+      // 但若它疑似仓变更段头（宽匹配命中），先记格式错误再结束——静默截断会让
+      // 该段文件整段脱离对账基准，比报错更危险。
+      if (REPO_SECTION_HEADER_LOOSE_RE.test(line)) malformedHeaders.push(line.trim())
       break
     }
     if (REPO_SECTION_HEADER_RE.test(line)) hasSegmentHeader = true
+    else if (REPO_SECTION_HEADER_LOOSE_RE.test(line)) malformedHeaders.push(line.trim())
     sectionLines.push(line)
   }
 
@@ -905,7 +921,7 @@ function parseDesignCoverageByRepo(designPath) {
     const main = new Set(parseFileChangeList(designPath, { keepSillyspecDocs: true }))
     if (main.size > 0) byRepo.set('main', main)
     for (const p of main) allFiles.push(p)
-    return { byRepo, hasSegmentHeader: false, allFiles }
+    return { byRepo, hasSegmentHeader: false, allFiles, malformedHeaders }
   }
 
   // 有段头 → 按 repo 切片，每段构造临时 design 调 parseFileChangeList
@@ -951,7 +967,7 @@ function parseDesignCoverageByRepo(designPath) {
     rmSync(tmpDir, { recursive: true, force: true })
   }
 
-  return { byRepo, hasSegmentHeader: true, allFiles }
+  return { byRepo, hasSegmentHeader: true, allFiles, malformedHeaders }
 }
 
 /**
@@ -996,9 +1012,16 @@ export function validateDesignFileCoverage(changeDir) {
   }
 
   // 按仓分段解析 design §6（约束③）：段头 `## <repo> 仓变更` → 段内路径归该 repo；无段头 → 全 main
-  const { byRepo: designByRepo, hasSegmentHeader, allFiles: designFiles } = parseDesignCoverageByRepo(designPath)
+  const {
+    byRepo: designByRepo, hasSegmentHeader, allFiles: designFiles, malformedHeaders,
+  } = parseDesignCoverageByRepo(designPath)
   // 两种断裂文案(缺清单章节 / 文件未覆盖)从 manifest 同源(plan.design-file-coverage.data)。
   const dcRule = getRule('plan.design-file-coverage')
+  // 疑似仓变更段头但格式解析不了 → 点名报错（manifest 同源文案）。不拦的话该段文件被错记
+  // 到别的仓，下方未覆盖对账整段错位，报错又不指向段头本身（用户实证 2026-08-29：排查靠猜）。
+  for (const h of malformedHeaders) {
+    errors.push(dcRule.data.messageMalformedHeader.replaceAll('${line}', h))
+  }
   if (designFiles.length === 0) {
     // 走到 plan-postcheck 说明已生成 task 卡片（light/full），brainstorm 模板规定清单必填。
     // 无清单 = design↔execute 偏差温床（覆盖对账无从对起），阻断，不让它静默放过。
@@ -1047,6 +1070,13 @@ export function validateDesignFileCoverage(changeDir) {
   return { ok: errors.length === 0, errors, warnings, designFiles, uncovered }
 }
 
+// acceptance 标识符 grep 停用词：工具域/格式名词——acceptance 行文高频出现但不是代码实体，
+// 不排除会给几乎每张卡稳定制造一条误报（宁漏不噪，漏一条提示的代价远低于满屏噪音淹没人）。
+const ACCEPT_IDENT_STOPWORDS = new Set([
+  'snake_case', 'camelCase', 'kebab_case', // 格式名词（acceptance 常写「输出 snake_case 格式」）
+  'allowed_paths', 'related_tests', 'depends_on', 'expects_from', 'title_zh', // TaskCard 字段名
+])
+
 /**
  * 流程产物前缀（target_files 不该声明的路径域）。
  * 与 worktree-apply filterDeliverableFiles 同口径硬编码——不 import 复用是因为
@@ -1189,6 +1219,16 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
   const allTaskIds = []
   const depMap = new Map()
 
+  // acceptance grep 降噪依据：design.md 全文——标识符已在 design 声明 = 本次计划要新增的
+  // 字段/函数（此刻自然不在源码里），不是噪音（用户实证 2026-08-29：15 卡 20+ 条 warning
+  // 全是这类误报）。无 design.md（none/light）→ 空串退化为纯源码 grep。
+  let designText = ''
+  try {
+    designText = readFileSync(pJoin(changeDir, 'design.md'), 'utf8')
+  } catch {
+    // design.md 不存在 → 跳过该降噪门，行为退化为只有源码 grep
+  }
+
   for (const file of taskFiles) {
     const content = readFileSync(pJoin(tasksDir, file), 'utf8')
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
@@ -1274,8 +1314,11 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
 
     // 6. acceptance best-effort 字段 grep（D-05 软约束，warning 不阻断）
     // 从 acceptance 文本提取 snake_case/camelCase 标识符，grep allowed_paths 指向的源文件；
-    // 找不到 → warning（给 LLM 审查提线索，不阻断 execute）。宁漏不噪：只取 snake/camel，
-    // 正则天然避开命令（无 _ 或大写）/路径（无 /）/中文；glob allowed_path / 目录 / 不存在文件一律跳过。
+    // 找不到 → warning（给 LLM 审查提线索，不阻断 execute）。宁漏不噪，三道降噪门：
+    // ① 停用词（格式名词/TaskCard 字段名，ACCEPT_IDENT_STOPWORDS）；
+    // ② design.md 已声明的标识符跳过——本次计划新增的字段/函数此刻不在源码里是正常的；
+    // ③ 正则天然避开命令（无 _ 或大写）/路径（无 /）/中文；glob allowed_path / 目录 /
+    //    不存在文件一律跳过，且至少读到一个源文件才比对（防全读不到 → 全标识符误报）。
     if (projectRoot && hasAcceptance && allowedPaths.length > 0) {
       let acceptanceText = ''
       try {
@@ -1301,8 +1344,10 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
           // 至少读到一个源文件才比对，避免「全没读到 → 全部标识符误报」噪声
           if (readableFiles.length > 0) {
             for (const ident of idents) {
+              if (ACCEPT_IDENT_STOPWORDS.has(ident)) continue
+              if (designText.includes(ident)) continue // design 已声明 → 本次计划新增，非噪音
               if (!readableFiles.some(c => c.includes(ident))) {
-                warnings.push(`${taskId}: acceptance 提到 ${ident} 但 allowed_paths 源文件未命中`)
+                warnings.push(`${taskId}: acceptance 提到 ${ident} 但 allowed_paths 源文件与 design.md 均未命中`)
               }
             }
           }

package/src/sync.js

@@ -12,6 +12,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlink
 import { createHash } from 'crypto';
 import { writeAtomicSync } from './fs-atomic.js';
 import { join, dirname, basename, isAbsolute, relative } from 'path';
+import { homedir } from 'os';
 import { resolvePlatformSpecDir } from './progress.js';
 import { safeGit } from './git-helper.js';
 import { openDatabase } from './db-engine.js';
@@ -534,7 +535,20 @@ export class SyncManager {
    * 不删后两者则"disconnect 后恢复本地模式"不可达（指针健在时 resolvePlatformSpecDir
    * 仍解析平台 specRoot；声明健在时指针缺失会 fail-closed）。
    */
-  disconnect() {
+  disconnect(opts = {}) {
+    const { keepPointer = false } = opts
+    // 坑 platform-sync-progress-rollback-and-db-corruption 坑1③（2026-09-08 实证）：三清里的
+    // 指针/声明是 daemon 内嵌 CLI 的 specDir 解析依据——指针缺席期间 daemon 心跳读仓库
+    // .sillyspec（空）并把空状态推上平台，反而放大回滚。两道防线：
+    //   ① keepPointer（CLI `platform disconnect --keep-pointer`）：只清 local.yaml platform
+    //      段（自己 CLI 的同步断开），指针/声明保留给 daemon——回滚环恢复序列的正规化出口；
+    //   ② 默认三清前检测 daemon 主目录存在 → 醒目警告（在线 daemon 会失锚）。
+    const daemonHome = join(homedir(), '.sillyhub', 'daemon')
+    if (!keepPointer && existsSync(daemonHome)) {
+      console.warn(`⚠️ 检测到本机存在 SillyHub daemon（${daemonHome}）——三清将删除平台指针，daemon 内嵌 CLI 将失锚：`)
+      console.warn(`   指针缺席期间 daemon 心跳读仓库本地 .sillyspec（可能为空）并把空状态推上平台，会放大进度回滚。`)
+      console.warn(`   若只想断开自己 CLI 的同步（保留 daemon 锚点）：sillyspec platform disconnect --keep-pointer`)
+    }
     const p = join(this.cwd, LOCAL_YAML);
     if (existsSync(p)) {
       const text = readFileSync(p, 'utf8');
@@ -549,6 +563,10 @@ export class SyncManager {
         }
       }
     }
+    if (keepPointer) {
+      console.log('[sync] 已断开连接（--keep-pointer：仅清 local.yaml platform 段，指针与接管声明保留给 daemon 内嵌 CLI）');
+      return;
+    }
     // 三清之二/三：指针 + 接管声明（disconnect 是声明的唯一退出路径——design.md §5.4）。
     // HUB-12 有意不清 .sillyspec-platform-cleaned marker：它防的是「重新接入平台时 init
     // 重复做残留清理」——disconnect 后重连若清掉 marker，init 会对现在装着本地数据的
@@ -1723,7 +1741,51 @@ export class SyncManager {
     const cf = this.readConflictFile(changeName);
     const specCf = this.readSpecConflictFile(changeName);
     if (!cf && !specCf) {
-      return { ok: false, resolved: false, reason: `无可解决冲突: ${changeName}（无 sync-conflict / spec-sync-conflict 文件）` };
+      // 坑 platform-sync-progress-rollback-and-db-corruption 坑1②（2026-09-08 实证）：回滚环
+      // 中间态——冲突文件已被某次常规同步静默清除，但 DB 的 base_ts 仍落后，keep-local
+      // 找不到裁决目标被拒（「无可解决冲突」），恢复序列被迫走人肉 SQL。显式出口：keep-local
+      // 在无冲突文件时降级为「无冲突强推」——拉平台 last_pushed_at 推进 base_ts（与有冲突
+      // 路径同款 MAX/COALESCE 单调 SQL）+ 自动重推闭环，等价完成裁决意图。take-platform
+      // 依赖冲突文件里的 platform_progress 快照，无文件时仍拒绝（无可覆盖源）。
+      if (mode !== 'keep-local') {
+        return { ok: false, resolved: false, reason: `无可解决冲突: ${changeName}（无 sync-conflict / spec-sync-conflict 文件）` };
+      }
+      const platform = this._getPlatform();
+      if (!platform) {
+        return { ok: false, resolved: false, reason: `无可解决冲突且未连接平台: ${changeName}——keep-local 无冲突强推需拉平台 last_pushed_at` };
+      }
+      let pushedAt = null;
+      try {
+        const res = await fetchJson(
+          `${platform.url}/api/changes/${encodeURIComponent(changeName)}/progress`,
+          { headers: { Authorization: `Bearer ${platform.token}` } },
+        );
+        pushedAt = (res && res.last_pushed_at) || null;
+      } catch { /* 拉取失败按 null：仅跳过 base_ts 推进，重推仍可尝试 */ }
+      if (pushedAt) {
+        try {
+          const { ProgressManager } = await import('./progress.js');
+          const pm = new ProgressManager({ specDir: safePlatformSpecDir(this.cwd) });
+          const db = pm._ensureDB(this.cwd).getDb();
+          db.prepare('UPDATE changes SET last_synced_platform_ts = MAX(COALESCE(?, last_synced_platform_ts), COALESCE(last_synced_platform_ts, ?)) WHERE name = ?')
+            .run(pushedAt, pushedAt, changeName);
+        } catch (err) {
+          return { ok: false, resolved: false, reason: `无冲突 keep-local 推进 base_ts 失败: ${err.message}` };
+        }
+      }
+      let repush = null;
+      try {
+        repush = await this.sync(changeName, { fromResolve: true });
+      } catch (err) {
+        debugLog(`[sync] 无冲突 keep-local 重推异常: ${changeName}: ${err.message}`);
+      }
+      if (repush && repush.synced === 1) {
+        return { ok: true, resolved: true, mode: 'keep-local-noconflict', reason: '无冲突显式 keep-local：base_ts 已对齐平台最新，本地已重推——回滚环收敛出口' };
+      }
+      if (repush && repush.conflict) {
+        return { ok: true, resolved: true, mode: 'keep-local-noconflict', reason: '无冲突显式 keep-local：base_ts 已推进；重推被拒（平台刚又有更新，已落冲突文件）——再跑一次 resolve --keep-local 即可' };
+      }
+      return { ok: true, resolved: true, mode: 'keep-local-noconflict', reason: '无冲突显式 keep-local：base_ts ' + (pushedAt ? '已推进' : '未获取（平台拉取失败）') + '；重推未成功（未连接/网络），请手动 sillyspec platform sync --change ' + changeName };
     }
     const platformPushedAt = (cf && cf.platform_last_pushed_at) || null;
 
@@ -1954,8 +2016,8 @@ export async function connect(url, token, cwd) {
   return new SyncManager(cwd).connect(url, token);
 }
 
-export async function disconnect(cwd) {
-  return new SyncManager(cwd).disconnect();
+export async function disconnect(cwd, opts = {}) {
+  return new SyncManager(cwd).disconnect(opts);
 }
 
 export async function sync(changeName, cwd, opts) {

package/src/task-review.js

@@ -9,11 +9,12 @@
  */
 
 import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSync } from 'fs'
-import { join, resolve } from 'path'
+import { join, resolve, basename, dirname } from 'path'
 import { git, unquoteGitPath } from './git-helper.js'
 import { pathMatches } from './change-list.js'
 import { parseAllowedPaths, parseRepo, parseBaseCommit, parseHeadCommit } from './stages/plan-postcheck.js'
 import { resolveVerifyChangedFiles } from './verify-postcheck.js'
+import { splitOwnVsForeignDiffFiles } from './foreign-declared.js'
 import { WorktreeManager } from './worktree.js'
 import { resolveRuntimeRoot } from './run/shared.js'
 
@@ -30,6 +31,16 @@ import { resolveRuntimeRoot } from './run/shared.js'
 // 跨仓 task 写 review.json 可用 v2 带 repo 字段，单仓/旧 change 仍用 v1。后续可拆分 stage-review 专用
 // 常量，本期遵循 allowed_paths 约束不扩散到 stage-review.js。
 export const REVIEW_SCHEMA_VERSION = 1
+
+/**
+ * review.json 写入溯源戳（坑 review-json-mystery-overwrite，2026-09-12 驾驭第十七批①，
+ * 用户实证 task-04 review 被覆写成空壳、gate 报零改动伪造重写恢复——四个 writer 均有
+ * 覆盖守卫，无堆栈钉不死覆写者）：每次写入附 writtenBy（写入通道 + PID）+ writtenAt，
+ * emptyDiff 伪造 error 直显两字段——下次复现自曝身份，事后可归因。
+ */
+function reviewProvenanceStamp(channel) {
+  return { writtenBy: `${channel}#pid${process.pid}`, writtenAt: new Date().toISOString() }
+}
 const REVIEW_SCHEMA_VERSIONS_ACCEPTED = [1, 2]
 // repo 缺省值（review.repo / task 卡 repo 缺省时统一按 'main' 处理）。design §7.2 / §7.4。
 const DEFAULT_REPO_KEY = 'main'
@@ -493,7 +504,11 @@ export function validateTaskReviews(opts) {
       }
     }
     if (reviewGitDir) {
-      const evidence = verifyReviewGitEvidence(review, reviewGitDir, evidenceCache)
+      const evidence = verifyReviewGitEvidence(review, reviewGitDir, evidenceCache, {
+        mainGitDir: gitDir,
+        changeName: changeDir ? basename(changeDir) : null,
+        specBase: changeDir ? dirname(dirname(changeDir)) : null,
+      })
       for (const w of evidence.warnings) warnings.push(`${taskId}: ${w}`)
       if (!evidence.ok) {
         for (const err of evidence.errors) errors.push(`${taskId}: ${err}`)
@@ -515,7 +530,8 @@ export function validateTaskReviews(opts) {
           const scopeNote = Array.isArray(review.diffPaths) && review.diffPaths.length > 0
             ? `（diffPaths 路径限定切片为空——统一 commit 模式下 diffPaths 应为本 task 的 allowed_paths；task 确未实现请把 verdict 回 fail）`
             : ''
-          errors.push(`${taskId}: base..head（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}）无任何代码变更 — 评审了一个零改动的任务，review 疑似伪造${scopeNote}`)
+          const prov = (review.writtenBy || review.writtenAt) ? `［写入溯源：${review.writtenBy || '?'} @ ${review.writtenAt || '?'}］` : '［无写入溯源—— older writer 产物］'
+          errors.push(`${taskId}: base..head（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}）无任何代码变更 — 评审了一个零改动的任务，review 疑似伪造${scopeNote}${prov}`)
           continue
         }
       }
@@ -622,7 +638,7 @@ function parsePorcelainFiles(statusOut) {
  *   一次校验批：working-tree status 是快照语义，跨批复用会读到陈旧状态。
  * @returns {{ ok: boolean, emptyDiff: boolean, errors: string[], warnings: string[], unavailable: boolean }}
  */
-export function verifyReviewGitEvidence(review, gitDir, cache = null) {
+export function verifyReviewGitEvidence(review, gitDir, cache = null, opts = {}) {
   const errors = []
   const warnings = []
   const c = cache || (cache = {})
@@ -667,7 +683,7 @@ export function verifyReviewGitEvidence(review, gitDir, cache = null) {
       // 可执行指引（坑 review-head-real-commit-late，2026-08-22 实证：head 必须真实 commit 的
       // 要求撞门才知道——报错直接给操作序列：worktree 改动先 commit，取 HEAD 作 head）
       errors.push(`${field} "${hash}" 不是仓库中的真实 commit — review.json 疑似伪造。` +
-        `head/base 必须是 git rev-parse 可解析的 commit hash：worktree 内先 git add -A && git commit -m "<task>"，` +
+        `head/base 必须是 git rev-parse 可解析的 commit hash：worktree 内先 sillyspec wt-commit --change <变更名> -m "<task-NN>" -- <本 task 精确路径>（串行锁 + pathspec，防卷入并行兄弟 WIP；退路 git add -- <精确路径> && git commit，禁 add -A），` +
         `再取 git rev-parse HEAD 作 head（base 用 task 卡锡点或基线 commit）；不要填分支名/伪 hash/working-tree 描述`)
     }
   }
@@ -703,7 +719,22 @@ export function verifyReviewGitEvidence(review, gitDir, cache = null) {
       c.wtStatus.set(gitDir, wtStatus)
     }
     if (wtStatus && wtStatus.trim().length > 0) {
-      const wtFiles = parsePorcelainFiles(wtStatus)
+      let wtFiles = parsePorcelainFiles(wtStatus)
+      // 归属过滤（2026-09-12 审查批 A-①，坑 task-review-foreign-wip-blindspot）：主仓 in-place
+      // 模式下 wtStatus 含**全部**并行会话的未提交文件——他者 WIP 稀释 diffFiles 使 emptyDiff
+      // （零改动→伪造 ERROR）在共享仓永不触发、交叉比对更易混过。对齐 verify-postcheck
+      // resolveMainChangedFiles 的 splitOwnVsForeignDiffFiles 剔除口径（他者声明文件归他者）。
+      // 仅主仓 gitDir 过滤（跨仓/worktree 无主 specBase 声明源，行为不变）；无 opts 零回归。
+      if (wtFiles.length > 0 && opts.mainGitDir && opts.changeName
+          && resolve(gitDir) === resolve(opts.mainGitDir)) {
+        try {
+          const { own, foreign } = splitOwnVsForeignDiffFiles(gitDir, opts.changeName, wtFiles, { specBase: opts.specBase })
+          if (foreign.length > 0) {
+            wtFiles = own
+            warnings.push(`working-tree 并入已排除 ${foreign.length} 个并行会话声明的文件（${foreign.slice(0, 3).map(x => x.file).join(', ')}${foreign.length > 3 ? ' 等' : ''}）`)
+          }
+        } catch { /* 归属过滤失败退回全量并入（fail-open 与旧口径一致） */ }
+      }
       if (wtFiles.length > 0) diffFiles = diffFiles.concat(wtFiles)
       if (commitDiffFiles.length === 0) {
         warnings.push(`base..head 无 commit diff（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}），交叉对账并入 working-tree 未提交改动 ${wtFiles.length} 个文件 —— 按有效改动处理，不判零改动伪造`)
@@ -1321,6 +1352,7 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
           ';verdict=未评审（无归属 diff 兜底草稿，坑 task-review-draft-skip-leak）',
       }
       if (draftRepo) draft.repo = draftRepo
+      Object.assign(draft, reviewProvenanceStamp('generateTaskReviewDrafts:no-attribution'))
       // fail-open（对齐函数头契约 + execute-run-dir-fail-loud 测试锁定的「写失败返回统计不抛」）：
       // 无归属草稿写入失败（如 tasks/ 被普通文件占位 ENOTDIR）降级 skipped，不崩整个草稿生成
       try {
@@ -1352,6 +1384,7 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
       reviewerNotes: 'auto-generated draft from git diff ' + taskBase.slice(0, 8) + '..' + taskHead.slice(0, 8) + ';verdict=未评审（worktree execute 主 agent 实现模式兜底，坑2）',
     }
     if (draftRepo) draft.repo = draftRepo
+    Object.assign(draft, reviewProvenanceStamp('generateTaskReviewDrafts'))
     mkdirSync(reviewDir, { recursive: true })
     writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\n')
     generated++
@@ -1568,6 +1601,7 @@ export async function adoptTaskReviewMechanics({ changeName, cwd, platformOpts =
 
     try {
       if (mechanicsChanged || verdictTouched || evidenceFilled) {
+        Object.assign(merged, reviewProvenanceStamp('adoptTaskReviewMechanics'))
         writeFileSync(reviewPath, JSON.stringify(merged, null, 2) + '\n')
         adopted++
       } else {
@@ -1770,6 +1804,7 @@ export async function writeTaskReview({
     ...(requiredEvidence.filter(Boolean).length > 0 ? { requiredEvidence: requiredEvidence.filter(Boolean) } : {}),
     reviewerNotes: reviewerNotes || `written by sillyspec review write (${base.slice(0, 8)}..${head.slice(0, 8)})`,
   }
+  Object.assign(review, reviewProvenanceStamp('writeTaskReview' + (force ? ':force' : '')))
   const schemaResult = validateReviewSchema(review)
   if (!schemaResult.ok) {
     return { ok: false, errors: schemaResult.errors, warnings }

package/src/verify-facts-schema.js

@@ -42,8 +42,15 @@ export function classifyVerifiedFile(path) {
 /** 证据账 task 行：`- task-NN: <status> | verifiedFiles: a, b（豁免：…）`——占位 <待填：*> 不命中（fail-closed） */
 const EVIDENCE_LINE_RE = /^- (task-\d+):\s*(satisfied|missing|partial)\b([^\n]*)$/
 
-/** 回执行：`- claim: … | command: … | exit: 0 | log: path`——四字段行首锚定，占位不命中 */
-const RECEIPT_LINE_RE = /^- claim:\s*([^|]+)\|\s*command:\s*([^|]+)\|\s*exit:\s*(\d+)\s*\|\s*log:\s*([^\s|]+)/
+/**
+ * 回执行：`- claim: … | command: … | exit: 0 | log: path`——四字段行首锚定，占位不命中。
+ * 双宽度容收（坑 receipt-fullwidth-parse，2026-09-12 驾驭第十四批③，用户上一变更实证、
+ * 本次手动避开后要求修根：①分隔符同时认半角 | 与全角 ｜（中文输入法手写回执高频形态，
+ * 全角形态旧正则整行不命中 → 回执槽 0 条 → integration-critical 误报无绿回执）；
+ * ②log 字段 rest-of-line（旧 [^\s|+] 遇含空格/全角括号路径截断——`日志（第 1 次）.log`
+ * 被截成 `日志（第` → 「日志不存在」假红）；log 是末字段，行内若有 ｜/| 尾注取首段剥注。
+ */
+const RECEIPT_LINE_RE = /^- claim:\s*([^|｜\n]+)[|｜]\s*command:\s*([^|｜\n]+)[|｜]\s*exit:\s*(\d+)\s*[|｜]\s*log:\s*(.+)$/
 
 /**
  * 解析 verify-result.md 的两个受控槽段（D-001@v2 slot-backfill 录入界面）。
@@ -101,7 +108,7 @@ export function parseEvidenceSlots(mdText) {
         claim: m[1].trim(),
         command: m[2].trim(),
         exitCode: Number(m[3]),
-        logPath: m[4].trim().replace(/^`|`$/g, ''),
+        logPath: m[4].split(/[|｜]/)[0].trim().replace(/^`|`$/g, ''),
       })
     }
   }

package/src/verify-postcheck.js

@@ -88,7 +88,11 @@ export function extractTestCommand(yamlText) {
   if (quoted && quoted[1]) {
     return quoted[1].toLowerCase() === 'unavailable' ? null : quoted[1].trim()
   }
-  const bare = yamlText.match(/^\s*test:\s*([^\n#"']+?)\s*(?:#.*)?$/m)
+  // bare 值不得排除引号字符（坑 verify-bare-quote-miss，2026-09-12 审查批 B-③）：
+  // `test: cd "C:\proj" && npm test` 是合法 YAML 裸标量，旧 char class [^\n#"'] 对含引号值
+  // 整体不匹配 → 判「未配置」→ 实测硬门静默 skipped（fail-open）。全引号形态已被上方
+  // quoted 分支先行消费，此处的引号只可能是嵌在值中部的。同款修正在 extractLintCommand。
+  const bare = yamlText.match(/^\s*test:[ \t]*([^\n#]+?)[ \t]*(?:#.*)?$/m)
   if (bare && bare[1]) {
     const cmd = bare[1].trim()
     return cmd.toLowerCase() === 'unavailable' ? null : cmd
@@ -109,7 +113,7 @@ function extractLintCommand(yamlText) {
   if (quoted && quoted[1]) {
     return quoted[1].toLowerCase() === 'unavailable' ? null : quoted[1].trim()
   }
-  const bare = yamlText.match(/^\s*lint:\s*([^\n#"']+?)\s*(?:#.*)?$/m)
+  const bare = yamlText.match(/^\s*lint:[ \t]*([^\n#]+?)[ \t]*(?:#.*)?$/m)
   if (bare && bare[1]) {
     const cmd = bare[1].trim()
     return cmd.toLowerCase() === 'unavailable' ? null : cmd
@@ -154,7 +158,7 @@ function recordVerifyLintTally({ specBase, result }) {
  * advisory 起步：失败只打印不阻断（test 门已 fail-closed，lint 门观察期后再升级）。
  * 信任边界与 runVerifyTestCheck 一致：命令只来源于主仓 .sillyspec/local.yaml。
  */
-export function runVerifyLintCheck({ cwd, specBase }) {
+export function runVerifyLintCheck({ cwd, specBase, timeoutMs } = {}) {
   const localYamlPath = join(specBase, 'local.yaml')
   const yamlText = existsSync(localYamlPath) ? readFileSync(localYamlPath, 'utf8') : null
   const command = extractLintCommand(yamlText)
@@ -172,7 +176,9 @@ export function runVerifyLintCheck({ cwd, specBase }) {
     }
   }
 
-  const LINT_TIMEOUT_MS = Number(process.env.SILLYSPEC_LINT_TIMEOUT_MS) || 3 * 60 * 1000
+  // timeoutMs（2026-09-12 驾驭第十七批 dogfood）：门禁快照内 node_modules 经 junction I/O 较慢，
+  // 3min 默认预算实测被超时杀（180.1s 假败）——快照路径显式传 5min；优先级 显式参 > env > 默认
+  const LINT_TIMEOUT_MS = timeoutMs || Number(process.env.SILLYSPEC_LINT_TIMEOUT_MS) || 3 * 60 * 1000
   const startedAt = Date.now()
   let exitCode = 0
   let output = ''
@@ -577,7 +583,12 @@ export function extractModules(yamlText) {
  */
 function parseFlowValue(flowText, key) {
   // 键可能带引号也可能不带：path: "x" 或 "path": "x"
-  const re = new RegExp(String.raw`(?:^|[{,]\s*)"?${key}"?\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|(?:[^,}]+?))\s*(?=[,}]|$)`)
+  // bare 值的逗号终止是「下一键开始的逗号」而非任意逗号（坑 flow-value-comma-truncate，
+  // 2026-09-12 审查批 C-③）：`test: pytest -k a,b` 旧 [^,}]+? 在第一个逗号截断 → 实测跑
+  // 残损命令 `pytest -k a`（假红/碰巧假绿）。bare 分支与终止 lookahead 双侧同口径：只把
+  // 「后随键形态的逗号」当分隔符——消费侧负向前瞻排除它，终止侧正向前瞻要求它（或 } / 行尾）。
+  const sepComma = String.raw`,\s*"?[A-Za-z0-9_.\-]+"?\s*:`
+  const re = new RegExp(String.raw`(?:^|[{,]\s*)"?${key}"?\s*:\s*("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|(?:[^,}]|,(?!${sepComma.slice(1)}))+?)\s*(?=\}|${sepComma}|$)`)
   const m = flowText.match(re)
   if (!m) return null
   let v = m[1].trim()
@@ -666,7 +677,11 @@ export function extractKnownFailures(yamlText) {
   // CRLF 归一（坑 verify-modules-crlf-blanket-fallback）：块式正则的 `.+`/`\n?` 在 CRLF 行
   // 间失配，只捕获到第一条豁免项就停——归一后整块捕获恢复
   const yaml = normalizeLineEndings(yamlText)
-  const inline = yaml.match(/^known_failures:\s*\[([^\]]*)\]\s*(?:#.*)?$/m)
+  // inline 捕获组用贪婪 .*（坑 known-failures-inline-nested-bracket，2026-09-12 审查批 C-④）：
+  // 旧 [^\]]* 在值内首个 ] 停——豁免项是 glob/pytest id 可含 [] 字符类（tests/\[x\]::case），
+  // 旧版整表静默清空 → 预存失败全落 remaining 假红且难归因。贪婪 .* + 后随 \] 行尾锚，
+  // 吃到最后一个 ]（行尾注释里含 ] 的极端形态会被并入值，远优于静默清空）。
+  const inline = yaml.match(/^known_failures:\s*\[(.*)\]\s*(?:#.*)?$/m)
   if (inline) {
     return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
   }

package/src/verify-probes.js

@@ -121,9 +121,14 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
       probe1.globEntries.push(e.path)
       continue
     }
-    let abs = join(cwd, e.path)
+    // NEW: 待建前缀剥离（坑 probe1-new-prefix-miss，2026-09-12 驾驭第十七批③，用户实证
+    // 「NEW: 前缀文件已合入主仓」时 existsSync(join(cwd,'NEW:src/x')) 恒 miss 落 skippedFiles
+    // 留 ⚠️ 噪声）：design 清单的 NEW: 是「新建意图」标记，文件 apply 后已是无前缀实体——
+    // 探针按目标文件扫（与 pathMatches 比对侧剥除同源）。
+    const probePath = String(e.path).replace(/^NEW:\s*/, '')
+    let abs = join(cwd, probePath)
     if (!existsSync(abs)) {
-      const wtAbs = wtRoot ? join(wtRoot, e.path) : null
+      const wtAbs = wtRoot ? join(wtRoot, probePath) : null
       if (wtAbs && existsSync(wtAbs)) {
         abs = wtAbs
         probe1.worktreeHits++
@@ -136,7 +141,7 @@ export function runVerifyProbes({ cwd, changeName, specDir = null }) {
       const lines = readFileSync(abs, 'utf8').split('\n')
       lines.forEach((line, i) => {
         if (probe1.matches.length >= PROBE1_MAX_MATCHES) return
-        if (TODO_MARKER_RE.test(line)) probe1.matches.push({ file: e.path, line: i + 1, content: line.trim().slice(0, 160) })
+        if (TODO_MARKER_RE.test(line)) probe1.matches.push({ file: probePath, line: i + 1, content: line.trim().slice(0, 160) })
       })
     } catch {
       probe1.skippedFiles.push(e.path)

package/src/worktree-apply.js

@@ -131,9 +131,18 @@ export function mergeDirtyOverlapThreeWay({ projectRoot, worktreePath, baseHash
           if (code < 0) { conflicts.push(f); continue } // merge-file 本身不可用 → 原拦截
         }
         if (code === 0) {
+          // 覆写前备份主仓在途原文（2026-09-12 审查批 D-②）：合并写回发生在 apply 整体成败
+          // 判定之前——后续步骤（5a/7）失败返回时主仓已是合并版，而原文从未进任何 git 对象
+          // （也未 commit），不留备份即不可恢复。备份落 <projectRoot>/.sillyspec/.runtime/
+          // merge-backups/（运行时目录，doctor/hygiene 常规清理面，不污染工作区）。
+          try {
+            const backupDir = join(projectRoot, '.sillyspec', '.runtime', 'merge-backups')
+            mkdirSync(backupDir, { recursive: true })
+            writeFileSync(join(backupDir, `${Date.now()}-${f.replace(/[\\/]/g, '__')}`), mainRaw)
+          } catch { /* 备份失败不阻断合并（原文仍可经 rescue 出口重取，不静默弃救 */ }
           writeFileSync(join(projectRoot, f), outBuf)
           merged.push(f)
-          console.log(`🔀 EXCLUDE-DIRTY 三方合并成功（clean）: ${f}——主仓在途改动与 worktree 交付均已保留`)
+          console.log(`🔀 EXCLUDE-DIRTY 三方合并成功（clean）: ${f}——主仓在途改动与 worktree 交付均已保留（覆写前原文已备份至 .sillyspec/.runtime/merge-backups/）`)
         } else {
           conflicts.push(f)
         }
@@ -242,19 +251,39 @@ export function resolvePatchFiles(changedFiles, allowSet, hasAllowList) {
 function getBlobHashMap(cwd, treeish, files) {
   const map = new Map();
   if (files.length === 0) return map; // 空 pathspec 会让 ls-tree 列出整棵树，必须拦截
-  const raw = gitQuiet(cwd, ['ls-tree', treeish, '--', ...files]);
-  if (!raw) return map;
-  for (const line of raw.split('\n')) {
-    if (!line) continue;
-    const tabIdx = line.indexOf('\t');
-    if (tabIdx === -1) continue;
-    const filePath = line.slice(tabIdx + 1);
-    const hash = line.slice(0, tabIdx).split(' ')[2]; // "<mode> <type> <hash>"
-    if (hash) map.set(filePath, hash);
+  for (const batch of chunkPaths(files)) {
+    const raw = gitQuiet(cwd, ['ls-tree', treeish, '--', ...batch]);
+    if (!raw) continue
+    for (const line of raw.split('\n')) {
+      if (!line) continue;
+      const tabIdx = line.indexOf('\t');
+      if (tabIdx === -1) continue;
+      const filePath = line.slice(tabIdx + 1);
+      const hash = line.slice(0, tabIdx).split(' ')[2]; // "<mode> <type> <hash>"
+      if (hash) map.set(filePath, hash);
+    }
   }
   return map;
 }
 
+/**
+ * 按估算 argv 长度切批（2026-09-12 审查批 D-③）：Windows CreateProcess 命令行 32767 字符
+ * 上限——数百个长路径（Windows 深路径 160+ 字符 × 200 文件）全量展开时 spawn 直接失败，
+ * add/reset/diff 整体炸（hash-object 同病灶在 worktree.js，本文件先行收口）。保守 8000
+ * 字符/批，预留 git 参数与编码余量。返回至少一批（空输入返回单空批）。
+ */
+export function chunkPaths(paths, maxChars = 8000) {
+  const batches = [[]]
+  let len = 0
+  for (const p of paths) {
+    const l = String(p).length + 1
+    if (batches[batches.length - 1].length > 0 && len + l > maxChars) { batches.push([]); len = 0 }
+    batches[batches.length - 1].push(p)
+    len += l
+  }
+  return batches
+}
+
 /**
  * apply 的文件清单 = design §6 清单 ∪ plan TaskCard allowed_paths（execute 复盘 c）。
  *
@@ -676,14 +705,24 @@ function applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly = fal
       const untrackedPatchFiles = patchFiles.filter(f => !trackedFiles.includes(f));
       const patchParts = [];
       if (trackedFiles.length > 0) {
-        patchParts.push(git(cm.worktreePath, ['diff', '--binary', deliverableBase, '--', ...trackedFiles], { encoding: 'buffer', timeout: 60000 }));
+        // argv 分批（批 D-③）：数百长路径全量展开超 Windows 命令行上限；diff 输出按批拼接
+        // （各批均为完整 patch 文档，concat 对 git apply 合法）
+        for (const batch of chunkPaths(trackedFiles)) {
+          patchParts.push(git(cm.worktreePath, ['diff', '--binary', deliverableBase, '--', ...batch], { encoding: 'buffer', timeout: 60000 }));
+        }
       }
       if (untrackedPatchFiles.length > 0) {
-        git(cm.worktreePath, ['add', '--', ...untrackedPatchFiles]);
+        for (const batch of chunkPaths(untrackedPatchFiles)) {
+          git(cm.worktreePath, ['add', '--', ...batch]);
+        }
         try {
-          patchParts.push(git(cm.worktreePath, ['diff', '--binary', '--cached', '--', ...untrackedPatchFiles], { encoding: 'buffer', timeout: 60000 }));
+          for (const batch of chunkPaths(untrackedPatchFiles)) {
+            patchParts.push(git(cm.worktreePath, ['diff', '--binary', '--cached', '--', ...batch], { encoding: 'buffer', timeout: 60000 }));
+          }
         } finally {
-          gitQuiet(cm.worktreePath, ['reset', 'HEAD', '--', ...untrackedPatchFiles]);
+          for (const batch of chunkPaths(untrackedPatchFiles)) {
+            gitQuiet(cm.worktreePath, ['reset', 'HEAD', '--', ...batch]);
+          }
         }
       }
       const patchContent = Buffer.concat(patchParts);
@@ -1232,10 +1271,9 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
       // 回滚准备：记录 patch 涉及的 tracked 文件（--3way 冲突后需恢复 HEAD 版，不留半成品冲突标记）。
       // tracked 文件冲突 → git checkout -- <f> 还原；untracked 新建文件（--3way 不会对其冲突）不在回滚范围，
       // 但若 --3way 部分成功后冲突，已创建的新文件需删，故记录 untracked 集合。
-      const trackedPatchFiles = patchFiles.filter(f => {
-        // 该文件在主仓库 HEAD 存在 → 是 tracked（--3way 冲突时留标记需 checkout 还原）
-        return gitQuiet(projectRoot, ['cat-file', '-e', `HEAD:${f}`]) === null ? false : true;
-      });
+      // 批 D-③：per-file cat-file N+1 spawn 改单次 ls-tree blob 哈希表（同 :1188 既有口径复用）
+      const headBlobMap = getBlobHashMap(projectRoot, 'HEAD', patchFiles)
+      const trackedPatchFiles = patchFiles.filter(f => headBlobMap.has(f));
       const newPatchFiles = patchFiles.filter(f => !trackedPatchFiles.includes(f));
 
       // apply --3way 正式应用（主干已提交推进时自动三路合并）