sillyspec 3.28.7 → 3.28.8

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 正式应用（主干已提交推进时自动三路合并）

package/src/worktree-cross.js

@@ -198,23 +198,16 @@ export function ensureCrossWorktrees({ cwd, changeName, specBase }) {
     };
     writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
 
-    // dirty baseline overlay：跨仓主工作副本在途改动 → worktree baseline（借主仓同款实现，
-    // 只用其参数化逻辑，不用实例路径状态）
-    try {
-      const wmHelper = new WorktreeManager({ cwd: repoRoot });
-      const baselineResult = wmHelper._overlayBaseline(repoRoot, worktreePath);
-      meta.baselineFiles = baselineResult.files;
-      meta.baselineHash = baselineResult.baselineHash;
-      if (baselineResult.files.length > 0) {
-        meta.baselineCommit = wmHelper._createBaselineCheckpoint(worktreePath, `${changeName}--${key}`, baselineResult.files);
-      }
-      if (baselineResult.errors && baselineResult.errors.length > 0) {
-        console.warn(`⚠️ 跨仓 ${key} baseline overlay 部分失败（${baselineResult.errors.join('; ')}）——在途改动未全量进 baseline，apply 前请人工核对跨仓主工作副本`);
-      }
-      writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
-    } catch (e) {
-      console.warn(`⚠️ 跨仓 ${key} baseline overlay 失败（${e.message}）——跨仓主工作副本如有在途改动，worktree 不含它们`);
-    }
+    // 跨仓仓跳过 dirty baseline overlay + checkpoint（坑 cross-baseline-checkpoint-foreign-files，
+    // 2026-09-12 驾驭第十三批②，用户实证：跨仓主副本在途的外来文件——并行会话的 2 个 pptx +
+    // meta.json——被 checkpoint 带进跨仓分支，污染 apply 锚点对账被迫 cherry-pick 重建）：
+    // 跨仓模型 = 子代理直接 commit 跨仓分支（NG-3），跨仓主副本的 WIP 不属于本变更隔离面，
+    // 不该被固化进分支。meta.baselineFiles=[] 显式记录「无 checkpoint」，apply 侧以 baseHash
+    // （跨仓仓 HEAD）为锚。
+    meta.baselineFiles = [];
+    meta.baselineHash = baseHash;
+    console.log(`ℹ️ 跨仓 ${key}: 跳过 dirty baseline checkpoint（跨仓主副本在途改动不进本变更分支——含并行会话外来文件时防污染；锚点 = 跨仓仓 HEAD ${String(baseHash).slice(0, 8)}）`);
+    writeAtomicSync(join(worktreePath, META_FILE), JSON.stringify(meta, null, 2) + '\n');
 
     // deps 供给：specBase 传 null —— sniff worktree 自身（主仓 local.yaml 的 project.type/install
     // 描述的是主仓，跨仓仓类型常不同，如实测 maven 主仓 + nodejs 前端仓，沿用会把 mvn 命令
@@ -284,7 +277,8 @@ export function cleanupCrossWorktrees({ cwd, changeName, specBase, force = false
       git(repoRoot, ['worktree', 'remove', '--force', wtPath], { timeout: 60000 });
     } catch {
       // remove 失败（脏文件/锁）：解链后安全删目录 + prune 注册
-      try { safeRemoveWorktreeDir(wtPath, meta) } catch (e) { residual.push(`目录残留 ${wtPath}: ${e.message}`) }
+      // allowCross:true——本函数就是跨仓清理的显式路径（主仓守卫放行；见 safeRemoveWorktreeDir 注释）
+      try { safeRemoveWorktreeDir(wtPath, meta, { allowCross: true }) } catch (e) { residual.push(`目录残留 ${wtPath}: ${e.message}`) }
       try { gitQuiet(repoRoot, ['worktree', 'prune'], { timeout: 30000 }) } catch { residual.push(`git worktree prune 失败（${repoRoot}）`) }
     }
     details.push(`分支 ${meta.branch} 保留作 review 锚点（确认无需回溯后可 git -C ${repoRoot} branch -D ${meta.branch}）`);