sillyspec 3.25.3 → 3.25.5

package/src/verify-postcheck.js

@@ -211,11 +211,115 @@ export function aggregateStatus(results) {
   return 'failed'
 }
 
+/**
+ * 从 local.yaml 提取 known_failures 声明（预存失败豁免清单，坑 verify-worktree-... 修复方向 2）。
+ * 支持块式与流式两种写法：
+ *   known_failures:
+ *     - "tests/test_ppm.py::test_legacy"
+ *     - app/modules/plan/test_old
+ *   或  known_failures: [a, b]
+ * 每条作为子串（大小写不敏感）匹配测试输出中的失败行。
+ *
+ * @param {string} yamlText
+ * @returns {string[]} 模式列表；无声明返回 []
+ */
+export function extractKnownFailures(yamlText) {
+  if (!yamlText) return []
+  const inline = yamlText.match(/^known_failures:\s*\[([^\]]*)\]\s*(?:#.*)?$/m)
+  if (inline) {
+    return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
+  }
+  const block = yamlText.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?)+)/m)
+  if (block) {
+    return (block[1].match(/^[ \t]+-[ \t]+(.+)/gm) || [])
+      .map(s => s.replace(/^[ \t]+-[ \t]+/, '').trim().replace(/^['"]|['"]$/g, '').replace(/#.*$/, '').trim())
+      .filter(Boolean)
+  }
+  return []
+}
+
+// 单条失败行标记（跨 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
+
+/**
+ * 把测试输出按行筛出「失败行」，再按 known_failures 模式分为已豁免 / 未豁免。
+ * @param {string} output
+ * @param {string[]} knownFailures 子串模式列表（大小写不敏感）
+ * @returns {{ failureLines: string[], exempted: string[], remaining: string[] }}
+ */
+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))
+  const pats = (knownFailures || []).map(p => String(p).toLowerCase()).filter(Boolean)
+  const exempted = []
+  const remaining = []
+  for (const l of failureLines) {
+    const ll = l.toLowerCase()
+    if (pats.some(p => ll.includes(p))) exempted.push(l)
+    else remaining.push(l)
+  }
+  return { failureLines, exempted, remaining }
+}
+
+/**
+ * 结合 known_failures 判定单次测试运行的状态（fail-safe）。
+ *   - exitCode 0 → passed
+ *   - exitCode≠0 且无 known_failures → failed（原行为）
+ *   - exitCode≠0 且有 known_failures：
+ *       检测到失败行且全部命中豁免 → passed（披露：请人工复核清单是否过宽）
+ *       有未豁免失败行 / 检测不到失败行（保守）→ failed
+ * fail-safe：检测不到失败行绝不自动 pass（避免解析盲区导致假 PASS）。
+ *
+ * @returns {{ status: 'passed'|'failed', reason: string|null, exemptedCount: number }}
+ */
+export function judgeWithKnownFailures(exitCode, output, baseReason, knownFailures) {
+  if (exitCode === 0) return { status: 'passed', reason: baseReason, exemptedCount: 0 }
+  if (!knownFailures || knownFailures.length === 0) {
+    return { status: 'failed', reason: baseReason, exemptedCount: 0 }
+  }
+  const { failureLines, exempted, remaining } = partitionFailures(output, knownFailures)
+  if (failureLines.length > 0 && remaining.length === 0) {
+    return {
+      status: 'passed',
+      reason: `全部 ${failureLines.length} 个失败行命中 known_failures 已豁免（${exempted.length} 条）— 请人工复核豁免清单是否过宽`,
+      exemptedCount: exempted.length,
+    }
+  }
+  const detail = remaining.length > 0
+    ? `${remaining.length} 个失败行未命中 known_failures`
+    : '失败输出未检测到可豁免的失败行（保守判 fail）'
+  return {
+    status: 'failed',
+    reason: baseReason ? `${baseReason}（${detail}）` : detail,
+    exemptedCount: exempted.length,
+  }
+}
+
+/**
+ * 决定 verify 实测的执行动作（纯函数，便于测试；坑 verify-worktree-... 修复方向 3）。
+ *   - module + 命中模块  → 'module-subset'
+ *   - module + 0 命中    → 'module-zero-hit-skip'（不静默回退注定超时/预存失败的全量）
+ *   - 其余（full / module 无块 / module git 不可用 hitCount=-1）→ 'full'
+ * @returns {'module-subset'|'module-zero-hit-skip'|'full'}
+ */
+export function decideVerifyTestAction({ strategy, modulesPresent, hitCount }) {
+  if (strategy === 'module' && modulesPresent) {
+    if (hitCount > 0) return 'module-subset'
+    if (hitCount === 0) return 'module-zero-hit-skip'
+    return 'full' // hitCount === -1（git 不可用）→ 落全量兜底
+  }
+  return 'full'
+}
+
 /**
  * 跑单个模块的 test 命令（串行调用方逐个调用）。
  * @returns {{name, status:'passed'|'failed', command, exitCode, durationMs, outputTail, reason}}
  */
-function runOneModule(name, testCommand, cwd) {
+function runOneModule(name, testCommand, cwd, knownFailures = []) {
   const startedAt = Date.now()
   let exitCode = 0
   let output = ''
@@ -237,26 +341,27 @@ function runOneModule(name, testCommand, cwd) {
   }
   const durationMs = Date.now() - startedAt
   const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
+  const judged = judgeWithKnownFailures(exitCode, output, reason, knownFailures)
   return {
     name,
-    status: exitCode === 0 ? 'passed' : 'failed',
+    status: judged.status,
     command: testCommand,
     exitCode,
     durationMs,
     outputTail,
-    reason,
+    reason: judged.reason,
+    exemptedCount: judged.exemptedCount,
   }
 }
 
 /**
- * 取 git 变更文件列表（worktree unstaged + staged，相对仓库根）。
- * 务实策略：先取 unstaged working tree 改动（`git diff --name-only HEAD`），
- * 它同时覆盖已暂存与未暂存改动（相对 HEAD），最适合 worktree 内尚未 commit 的场景。
- * git 不可用 / 非仓库 → 返回 null（调用方 fallback）。
+ * 在指定 cwd 跑 `git diff --name-only <refSpec>`，返回相对仓库根的文件列表。
+ * git 不可用 / 非仓库 / ref 无效 → 返回 null（调用方 fallback）。
  */
-function gitChangedFiles(cwd) {
+function runGitDiffNameOnly(cwd, refSpec) {
   try {
-    const out = execSync('git diff --name-only HEAD', {
+    const cmd = refSpec ? `git diff --name-only ${refSpec}` : 'git diff --name-only'
+    const out = execSync(cmd, {
       cwd,
       encoding: 'utf8',
       timeout: 30 * 1000,
@@ -264,19 +369,60 @@ function gitChangedFiles(cwd) {
     })
     return out.split('\n').map(l => l.trim()).filter(Boolean)
   } catch {
-    // HEAD 不存在（空仓库）或 git 不可用 → 尝试纯 unstaged
-    try {
-      const out = execSync('git diff --name-only', {
-        cwd,
-        encoding: 'utf8',
-        timeout: 30 * 1000,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      })
-      return out.split('\n').map(l => l.trim()).filter(Boolean)
-    } catch {
-      return null
+    return null
+  }
+}
+
+/**
+ * 取主工作区 git 变更文件列表（unstaged + staged，相对仓库根）。
+ * `git diff --name-only HEAD` 同时覆盖已暂存与未暂存改动（相对 HEAD），
+ * 最适合 brownfield（apply 后未 commit / in-place 改动）场景。
+ * git 不可用 / 非仓库 → 返回 null（调用方 fallback）。
+ *
+ * 注意：worktree 隔离模式下主仓只剩 .sillyspec/ 文档改动、代码在 worktree，
+ * 本函数看不到——runVerifyTestCheck 用 resolveVerifyChangedFiles 统一处理。
+ */
+function gitChangedFiles(cwd) {
+  const head = runGitDiffNameOnly(cwd, 'HEAD')
+  if (head !== null) return head
+  // HEAD 不存在（空仓库）或 git 不可用 → 尝试纯 unstaged
+  return runGitDiffNameOnly(cwd, '')
+}
+
+/**
+ * 解析 verify 对账用的变更文件集（worktree-aware）。
+ *
+ * worktree 隔离模式下 execute 的代码改动落在 worktree，主仓工作区只剩
+ * .sillyspec/ 文档改动。若仍用主仓 `git diff --name-only HEAD`，hitCount=0
+ * → 回退注定超时且含预存失败的全量 commands.test → verify 完成被阻断
+ * （坑 verify-worktree-mode-test-reconciliation-fallback-full）。
+ *
+ * 判定（与 checkExecuteCodeEvidence / task-review 同源，meta.json 为权威）：
+ *   1. change 有 worktree meta 且 baseHash 存在 → 在 worktree（或 in-place 的 cwd）
+ *      跑 `git diff --name-only <baseHash>..HEAD` 取真实代码改动集
+ *   2. 无 worktree meta / diff 异常 → 主仓 `git diff --name-only HEAD`（brownfield 原行为）
+ *
+ * @param {string} cwd - 项目根目录（主仓）
+ * @param {string|null} changeName
+ * @returns {string[]|null} 变更文件列表；git 不可用返回 null（调用方按 hitCount=-1 处理）
+ */
+export function resolveVerifyChangedFiles(cwd, changeName) {
+  if (changeName) {
+    const metaPath = join(cwd, '.sillyspec', '.runtime', 'worktrees', changeName, 'meta.json')
+    if (existsSync(metaPath)) {
+      let meta = null
+      try { meta = JSON.parse(readFileSync(metaPath, 'utf8')) } catch {}
+      if (meta?.baseHash) {
+        const gitDir = (meta.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath))
+          ? meta.worktreePath
+          : cwd
+        const files = runGitDiffNameOnly(gitDir, `${meta.baseHash}..HEAD`)
+        if (files !== null) return files
+        // worktree diff 异常 → 落主仓兜底（保持与原 gitChangedFiles 相同的 null 语义）
+      }
     }
   }
+  return gitChangedFiles(cwd)
 }
 
 /**
@@ -301,41 +447,57 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null }) {
   const yamlText = existsSync(localYamlPath) ? readFileSync(localYamlPath, 'utf8') : null
 
   const strategy = extractTestStrategy(yamlText)
+  const knownFailures = extractKnownFailures(yamlText)
 
-  // —— 模块子集路径（test_strategy: module）——
-  // 算出 modulesPresent / hitCount 供 fallback hint 判定（computeFullFallbackReason）；
-  // 命中即走子集。gitChangedFiles 返回 null 表示 git 不可用 → hitCount=-1（与 0 命中区分）。
+  // —— 模块子集路径（test_strategy: module）：算 modulesPresent / hitCount / hits ——
+  // resolveVerifyChangedFiles 返回 null 表示 git 不可用 → hitCount=-1（与 0 命中区分）。
   let modulesPresent = false
   let hitCount = 0
+  let hits = []
   if (strategy === 'module') {
     const modules = extractModules(yamlText)
     if (modules) {
       modulesPresent = true
-      const changedFiles = gitChangedFiles(cwd)
+      const changedFiles = resolveVerifyChangedFiles(cwd, changeName)
       if (changedFiles === null) {
         hitCount = -1 // git 不可用 / 非仓库
       } else {
-        const hits = pickHitModules(changedFiles, modules)
+        hits = pickHitModules(changedFiles, modules)
         hitCount = hits.length
-        if (hitCount > 0) {
-          return runModuleSubset({ cwd, specBase, changeName, hits })
-        }
-        // 有 modules 配置但无命中 → fallback commands.test（D-002@v1 向后兼容）
       }
     }
-    // test_strategy:module 但无 modules 配置 → fallback commands.test（brownfield 友好）
   }
 
-  // —— 全量路径（默认 full / fallback）——
+  const action = decideVerifyTestAction({ strategy, modulesPresent, hitCount })
+  if (action === 'module-subset') {
+    return runModuleSubset({ cwd, specBase, changeName, hits, knownFailures })
+  }
+  if (action === 'module-zero-hit-skip') {
+    // module 模式 0 命中：不静默回退注定超时/含预存失败的全量（坑 verify-worktree-... 修复方向 3）。
+    // 据 verify-result.md 自报告判定；想跑全量请显式设 test_strategy: full。
+    return {
+      status: 'skipped',
+      command: null,
+      exitCode: null,
+      durationMs: null,
+      outputTail: null,
+      reason: 'test_strategy: module 但本次变更未命中任何已配置 modules（0 命中）。为避免回退到注定超时/含预存失败的全量 commands.test，CLI 未自动跑全量——据 verify-result.md 自报告判定测试。若需全量覆盖，显式设 test_strategy: full。',
+      resultPath: null,
+      mode: 'module-zero-hit',
+      fallbackReason: null,
+    }
+  }
+
+  // —— 全量路径（full / module 无块 / module git 不可用）——
   // fallbackReason 非 null 表示本次全量是"非显式"的（缺省/配置不全/未命中），需明示。
   const fallbackReason = computeFullFallbackReason({ strategy, modulesPresent, hitCount })
-  return runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason })
+  return runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason, knownFailures })
 }
 
 /**
  * 全量跑 commands.test（现有逻辑，brownfield 行为不变）。
  */
-function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason = null }) {
+function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason = null, knownFailures = [] }) {
   const command = extractTestCommand(yamlText)
 
   if (!command) {
@@ -376,16 +538,18 @@ function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fa
   const durationMs = Date.now() - startedAt
   const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
 
+  const judged = judgeWithKnownFailures(exitCode, output, reason, knownFailures)
   const result = {
-    status: exitCode === 0 ? 'passed' : 'failed',
+    status: judged.status,
     command,
     exitCode,
     durationMs,
     outputTail,
-    reason,
+    reason: judged.reason,
     resultPath: null,
     mode: 'full',
     fallbackReason,
+    exemptedCount: judged.exemptedCount,
   }
 
   writeRunResult({ specBase, changeName, result, extra: fallbackReason ? { fallback_reason: fallbackReason } : {} })
@@ -396,9 +560,9 @@ function runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fa
  * 串行跑命中的模块子集，聚合结果。
  * 返回 shape 与 runFullCommand 一致（status/command/exitCode/durationMs/outputTail/reason/resultPath）。
  */
-function runModuleSubset({ cwd, specBase, changeName, hits }) {
+function runModuleSubset({ cwd, specBase, changeName, hits, knownFailures = [] }) {
   const subsetStartedAt = Date.now()
-  const perModule = hits.map(h => runOneModule(h.name, h.test, cwd))
+  const perModule = hits.map(h => runOneModule(h.name, h.test, cwd, knownFailures))
   const status = aggregateStatus(perModule)
 
   const command = `module[${hits.map(h => h.name).join(',')}]`
@@ -423,6 +587,7 @@ function runModuleSubset({ cwd, specBase, changeName, hits }) {
     resultPath: null,
     mode: 'module-subset',
     fallbackReason: null,
+    exemptedCount: perModule.reduce((n, r) => n + (r.exemptedCount || 0), 0),
   }
 
   writeRunResult({
@@ -479,7 +644,12 @@ export function printVerifyTestCheck(result) {
     return
   }
   if (result.status === 'passed') {
-    console.log(`\n✅ Verify 实测通过：\`${result.command}\` 退出码 0（${(result.durationMs / 1000).toFixed(1)}s）`)
+    if (result.exemptedCount > 0) {
+      console.log(`\n✅ Verify 实测通过（含 ${result.exemptedCount} 个 known_failures 豁免）：\`${result.command}\` — ${result.reason}`)
+      console.warn('   ⚠️  本次 PASS 依赖 known_failures 豁免清单——请人工复核清单是否过宽（避免误豁免本变更引入的真实失败）。')
+    } else {
+      console.log(`\n✅ Verify 实测通过：\`${result.command}\` 退出码 0（${(result.durationMs / 1000).toFixed(1)}s）`)
+    }
   } else {
     console.error(`\n❌ Verify 实测失败：\`${result.command}\` — ${result.reason}`)
     if (result.outputTail) {

package/src/worktree-apply.js

@@ -18,7 +18,7 @@ import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 import { createHash } from 'crypto';
 import { WorktreeManager } from './worktree.js';
-import { parseFileChangeList } from './change-list.js';
+import { parseFileChangeList, pathMatches } from './change-list.js';
 
 const CHANGES_REL = '.sillyspec/changes';
 
@@ -48,6 +48,20 @@ export function filterDeliverableFiles(files) {
   return files.filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json');
 }
 
+/**
+ * 校验变更文件是否都在 design.md 清单内——容差匹配（与 plan-postcheck validateDesignFileCoverage
+ * 同语义）：design 清单写 glob（双星通配）或目录前缀（如 src/ 子树）也能覆盖 git diff 出的具体路径，
+ * 避免「plan 阶段放过、apply 阶段卡死」逼用户回去补字面文件名。
+ *
+ * @param {string[]} changedFiles  git diff 出的具体变更路径
+ * @param {Set<string>} allowSet   design.md 清单项（可能含 glob / 目录前缀）
+ * @returns {string[]} 不被任何清单项覆盖的文件（违规项，apply 将据此 BLOCK）
+ */
+export function classifyAllowListViolations(changedFiles, allowSet) {
+  const allow = [...allowSet];
+  return changedFiles.filter(f => !allow.some(ap => pathMatches(f, ap)));
+}
+
 /**
  * 批量获取多个文件在某个 treeish 中的 blob hash（一次 git ls-tree 替代 N 次 rev-parse）。
  *
@@ -170,29 +184,30 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
 
   // --- 4. 校验：变更文件 ⊆ 清单（无清单则跳过）---
   if (hasAllowList) {
-    for (const f of changedFiles) {
-      if (!allowSet.has(f)) {
-        result.extraFiles.push(f);
-      }
-    }
-    if (result.extraFiles.length > 0) {
+    const violations = classifyAllowListViolations(changedFiles, allowSet);
+    if (violations.length > 0) {
+      result.extraFiles.push(...violations);
       result.errors.push(
-        `文件清单校验失败：以下变更文件不在 design.md 清单中：\n  ${result.extraFiles.join('\n  ')}`
+        `文件清单校验失败：以下变更文件不在 design.md 清单中：\n  ${violations.join('\n  ')}`
       );
       return result;
     }
   }
 
-  // --- 4.5 校验：主工作区 baseline 是否变化（防 execute 期间主工作区被修改）---
-  // 注意：必须和 computeBaselineHash (worktree.js) 使用相同的排除规则。
+  // --- 4.6 显式 --merge：用户显式选择 git merge 兜底（主干已提交推进重叠时的三方合并） ---
+  // 触发点从「4.5 baseline 漂移自动降级」改为「用户显式 --merge flag」（D-001 保留，触发方式变化）。
+  // 用 --merge 时跳过未提交 dirty 拦截——merge 同样要求工作区相对干净，此处仅提示风险，真正失败由 applyByMerge 报告。
+  if (merge && !checkOnly) {
+    return applyByMerge(result, changeName, projectRoot, wm);
+  }
+
+  // --- 4.5 校验：主工作区是否有「未提交」脏改动（未提交 dirty 是 git apply --3way 危险区，必须拦）---
+  // 分工：4.5（整树 baselineHash）+ 5a（脏∩changedFiles）挡「未提交」dirty；5b 管「已提交」HEAD 分叉（已放宽，见下）。
+  // 实测：主干未提交 dirty 时，git apply --3way 报 `does not match index` 且行为不一致（可能报错/可能半应用，
+  // 哪怕脏文件与 patch 不重叠）——这是 git 硬约束，故此处友好拦截，引导用户先 commit/stash。
   // 排除非交付物的元数据/文档 churn（execute 自身改的 + 多操作者常改的 agent 指引/文档），
   // 否则别人改 CLAUDE.md/docs/.claude → 整树 hash 变 → apply 误阻断（多操作者仓库高频踩坑）。
-  // 安全：放过它们不丢真冲突——下方 step5a(未提交∩changedFiles)+step5b(HEAD blob) 对交付文件
-  // 做精确 per-file 校验，不读这里的 exclude。
-  //   - .sillyspec/：plan/design 蓝图 + runtime 产物
-  //   - .claude/：agent 配置/skills/CLAUDE.md
-  //   - docs/：文档（deliverable 文档冲突由 step5a/5b 兜底）
-  //   - CLAUDE.md：根 agent 指引
+  // 注意：必须和 computeBaselineHash (worktree.js) 使用相同的排除规则。
   if (meta.baselineHash) {
     const exclude = '-- . ":(exclude).sillyspec/" ":(exclude).claude/" ":(exclude)docs/" ":(exclude)CLAUDE.md"';
     const staged = gitQuiet(projectRoot, `diff --cached ${exclude}`) || '';
@@ -201,13 +216,15 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     const raw = `staged:${staged}\nunstaged:${unstaged}\nuntracked:${untracked}`;
     const currentHash = createHash('sha256').update(raw).digest('hex').slice(0, 16);
     if (currentHash !== meta.baselineHash) {
-      if (merge && !checkOnly) {
-        // baseline 漂移 + --merge 降级（D-001）：跳过步骤 5-7（patch 路径），走 git merge
-        return applyByMerge(result, changeName, projectRoot, wm);
-      }
+      // 未提交 dirty 拦截：列脏文件 + 指引先 commit/stash（git --3way 对 dirty 工作区不稳，merge 同理，故不再提 --merge）
+      const dirtyFiles = [...new Set(
+        ((gitQuiet(projectRoot, 'diff --name-only HEAD') || '').split('\n').filter(Boolean))
+          .concat((gitQuiet(projectRoot, 'ls-files --others --exclude-standard') || '').split('\n').filter(Boolean))
+      )].filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json');
       result.errors.push(
-        `主工作区 baseline 已变化（execute 前后不一致），不能直接 apply task.patch。\n` +
-        `建议：重新创建 worktree，或用 --merge 降级（git merge sillyspec/${changeName} 替代 patch，会引入合并提交）。\n` +
+        `主工作区有未提交的改动（execute 前后 baseline 不一致），git apply 无法安全应用。\n` +
+        (dirtyFiles.length > 0 ? `未提交文件：\n  ${dirtyFiles.join('\n  ')}\n` : '') +
+        `请先提交或暂存这些改动，再重新 apply：\n  git add -A && git commit -m "..."   或   git stash\n` +
         `execute 前 baseline: ${meta.baselineHash}\n` +
         `当前 baseline: ${currentHash}`
       );
@@ -233,6 +250,10 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   // 5b. 对比 worktree 的 baseHash 和主工作区 HEAD 中每个清单文件的 blob hash
   // 批量化：两次 ls-tree（worktree 的 baseHash + 主仓库 HEAD）各建一张 path→hash Map，
   // 替代 per-file getFileBlobHash × 2（原 2N spawn → 固定 2）。语义等价见 getBlobHashMap。
+  // 放宽（2026-07）：blob 不一致不再 BLOCKED——它意味着主干「已提交」推进改了同文件，
+  // 而 git apply --3way 能自动三路合并这种场景（不同区域直接合，同区域留冲突标记）。
+  // 故仅记录为风险提示（hashMismatchFiles → assess WARNING / summary 展示），放行交 step7 --3way 实测。
+  // 真重叠时 --3way 冲突，由 step7 回滚并提示 --merge 兜底。
   const targetFiles = hasAllowList ? [...allowSet] : changedFiles;
   const wtHashMap = getBlobHashMap(worktreePath, baseHash, targetFiles);
   const mainHashMap = getBlobHashMap(projectRoot, 'HEAD', targetFiles);
@@ -244,17 +265,10 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     if (wtBlob === null && mainBlob === null) continue;
     // 两者一致 → OK
     if (wtBlob === mainBlob) continue;
-    // 不一致 → 主工作区已被修改
+    // 不一致 → 主干已提交推进改了此文件，记风险提示（不拦截，交 --3way）
     result.hashMismatchFiles.push(f);
   }
 
-  if (result.hashMismatchFiles.length > 0) {
-    result.errors.push(
-      `base hash 不一致：以下文件在主工作区已被修改：\n  ${result.hashMismatchFiles.join('\n  ')}`
-    );
-    return result;
-  }
-
   // --- 6. checkOnly 模式：到此返回 ---
   if (checkOnly) {
     result.ok = true;
@@ -323,19 +337,33 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
 
     writeFileSync(patchPath, patchContent);
 
-    // apply --check 预检
-    try {
-      git(projectRoot, `apply --check ${patchPath}`);
-    } catch (e) {
-      result.errors.push(`patch 预检失败: ${e.message}`);
-      return result;
-    }
+    // apply --check 预检失败不再拦截（--check 只测 clean apply，--3way 能处理 clean apply 失败的
+    // 三路合并场景——主干已提交推进时 --check 恒失败但 --3way 可合）。故跳过 --check，直接试 --3way。
+
+    // 回滚准备：记录 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;
+    });
+    const newPatchFiles = patchFiles.filter(f => !trackedPatchFiles.includes(f));
 
-    // apply --3way 正式应用
+    // apply --3way 正式应用（主干已提交推进时自动三路合并）
     try {
       git(projectRoot, `apply --3way ${patchPath}`);
     } catch (e) {
-      result.errors.push(`patch apply 失败: ${e.message}`);
+      // --3way 冲突（exit 1，工作区已留冲突标记）：回滚到 apply 前干净状态，不留半成品
+      const rollback = rollbackApply(projectRoot, trackedPatchFiles, newPatchFiles);
+      result.errors.push(
+        `apply --3way 冲突：以下文件与主干「已提交」推进重叠，无法自动合并：\n` +
+        `  ${rollback.conflicts.length > 0 ? rollback.conflicts.join('\n  ') : '(未能获取冲突文件列表)'}\n` +
+        `已回滚工作区到 apply 前状态（无半成品冲突标记）。\n` +
+        `可选：用 --merge 自动三方合并兜底（git merge sillyspec/${changeName}，会引入合并提交）：\n` +
+        `  sillyspec worktree apply ${changeName} --merge\n` +
+        `或手动解决后重试。`
+      );
+      if (rollback.error) result.warnings = (result.warnings || []).concat([`回滚警告: ${rollback.error}`]);
       return result;
     }
 
@@ -360,6 +388,40 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   return result;
 }
 
+/**
+ * 回滚 --3way 冲突后的工作区到 apply 前状态（不留半成品冲突标记）。
+ * tracked 文件：git checkout -- <f> 还原 HEAD 版（清除冲突标记）。
+ * 新文件（apply 前不存在）：删除（--3way 可能部分创建）。
+ * @param {string} projectRoot
+ * @param {string[]} trackedFiles 主仓库 HEAD 已存在、patch 触及的文件
+ * @param {string[]} newFiles apply 前不存在、patch 可能新建的文件
+ * @returns {{ conflicts: string[], error: string|null }} conflicts=冲突文件列表
+ */
+function rollbackApply(projectRoot, trackedFiles, newFiles) {
+  let error = null;
+  // 冲突文件：git status 里带冲突标记（UU/AA 等）的文件
+  let conflicts = [];
+  try {
+    const unmerged = gitQuiet(projectRoot, 'diff --name-only --diff-filter=U') || '';
+    conflicts = unmerged.split('\n').filter(Boolean);
+  } catch {}
+  // 回滚 tracked 文件到 HEAD（强制从 HEAD 还原——--3way 冲突标记同时污染工作区和 index，
+  // `checkout -- f` 从 index 还原会拿到冲突版，必须 `checkout HEAD -- f` 才能还原干净）
+  for (const f of trackedFiles) {
+    try { gitQuiet(projectRoot, `checkout HEAD -- ${f}`); } catch (e) { error = (error ? error + '; ' : '') + `checkout ${f}: ${e.message}`; }
+  }
+  // 删除 --3way 可能新建的文件（apply 前不存在）
+  for (const f of newFiles) {
+    try {
+      const p = join(projectRoot, f);
+      if (existsSync(p)) unlinkSync(p);
+    } catch (e) { error = (error ? error + '; ' : '') + `delete ${f}: ${e.message}`; }
+  }
+  // 兜底：若 index 处于 unmerged 状态，重置 index（不影响工作区已还原的文件）
+  try { gitQuiet(projectRoot, 'reset --quiet'); } catch {}
+  return { conflicts, error };
+}
+
 /**
  * baseline 漂移时的 merge 降级路径（D-001）。
  *