sillyspec 3.28.8 → 3.28.10

package/src/worktree-apply.js

@@ -5,7 +5,7 @@
  * 1. 读取 meta.json 获取 baseHash
  * 2. git diff --name-only baseHash 获取 worktree 中所有变更文件
  * 3. 从 design.md 解析文件变更清单（无清单 = 允许所有）
- * 4. 校验：变更文件 ⊆ 清单
+ * 4. 校验：变更文件 ⊆ 清单（review 声明与 allow 面相交过滤，D-003：外来声明不并入放行面）
  * 5. 校验：主工作区文件 base hash 一致
  * 6. --check-only 模式只输出检查结果
  * 7. 非 checkOnly：生成 patch → apply --check → apply --3way
@@ -15,12 +15,15 @@
 import { existsSync, unlinkSync, writeFileSync, mkdtempSync, rmSync, readdirSync, readFileSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 import { tmpdir } from 'os';
+import { createHash } from 'crypto';
 import { WorktreeManager } from './worktree.js';
 import { getCrossWorktreeMeta, cleanupCrossWorktrees } from './worktree-cross.js';
 import { parseFileChangeList, parseFileChangeListDetailed, pathMatches } from './change-list.js';
 import { parseAllowedPaths, parseRepo } from './stages/plan-postcheck.js';
-import { git, gitQuiet } from './git-helper.js';
+import { git, gitQuiet, safeGit, unquoteGitPath } from './git-helper.js';
 import { resolveLatestExecuteRunId, resolveLatestExecuteRunIdWithTasks, readReview, normalizeRepoKey } from './task-review.js';
+import { collectActiveQuickGuardFiles } from './quicklog.js';
+import { detectCommittedDrift, formatCommittedDriftWarning } from './run/concurrent-detect.js';
 
 const CHANGES_REL = '.sillyspec/changes';
 
@@ -40,6 +43,40 @@ function consumeCleanupResult(cr, result) {
   return cr;
 }
 
+/**
+ * 工具/平台脚手架分类（scope-audit-cross-repo-blindness 改进点 1，2026-09-15）：
+ * CLI/平台自己写进仓的文件，不是本变更的交付改动。分硬排（filterDeliverableFiles
+ * 直接滤除）与软桶（classifyToolScaffold 打标、scope-audit 归入「工具/平台设施」
+ * 不占「计划外」）两档——区分依据是 apply 语义：filterDeliverableFiles 的滤除会让
+ * apply 不回放该文件（坑 apply-glob-manifest 静默丢失类），故只有「绝无交付语义、
+ * 回放反而有害」的进硬排；可能被 design 清单正当声明的（SKILL.md/CLAUDE.md 改写
+ * 本身是合法交付）只打标不滤除。
+ *
+ *   硬排（platform 设施，绝不交付）：
+ *     - .worktrees/：嵌套 worktree 目录（cp 回放会把整个 worktree 副本塞进主仓）
+ *     - .sillyspec-platform 系根标记文件（含 -cleaned / -managed / .json 变体）：平台元数据
+ *     - .sillyspec/knowledge/：CLI 自维护知识库（路由 INDEX 等，机器本地态）
+ *     - .sillyspec/local.yaml：机器本地配置（gitignore 约定；回放会覆盖主仓本地配置）
+ *   软桶（tool 脚手架，可能正当交付 → 只打标）：
+ *     - .claude/skills/（含 sillyspec-*）：CLI 自装 skill 脚手架
+ *     - CLAUDE.md：CLI/平台维护的 agent 指引
+ *     - attachments/：brainstorm 需求附件（docx/html/截图等流程产物）
+ * @param {string} f 仓库根相对路径（正斜杠）
+ * @returns {'platform'|'tool'|null}
+ */
+export function classifyToolScaffold(f) {
+  const p = String(f || '').replace(/\\/g, '/');
+  if (!p) return null;
+  if (p.startsWith('.worktrees/')
+    || /^\.sillyspec-platform(?:-cleaned|-managed)?(?:\.json)?$/.test(p)
+    || p.startsWith('.sillyspec/knowledge/')
+    || p === '.sillyspec/local.yaml') return 'platform';
+  if (p.startsWith('.claude/skills/')
+    || p === 'CLAUDE.md'
+    || p.startsWith('attachments/')) return 'tool';
+  return null;
+}
+
 /**
  * 过滤掉 worktree 基础设施文件（非交付物），让 apply 只关心真正的变更产出：
  *   - meta.json：worktree 元数据，baseline commit 中被跟踪、working-tree 被 CLI 改写
@@ -51,14 +88,19 @@ function consumeCleanupResult(cr, result) {
  *   - .sillyspec/.runtime/：运行时产物（进度库/锁/review 产物，非源码）。
  *   - .sillyspec/quicklog/：quicklog 条目（worktree 进度，非交付物）。
  *   保留 .sillyspec/docs/（dogfood 模块规范文档 = 交付物，apply 回主仓）。
- * 对 modified-tracked（git diff）与 untracked（ls-files --others）一视同仁。
+ *   - classifyToolScaffold 的 platform 档（.worktrees/、.sillyspec-platform 系根标记、
+ *     .sillyspec/knowledge/、.sillyspec/local.yaml）：工具/平台设施，绝无交付语义
+ *     （scope-audit-cross-repo-blindness 改进点 1——锚点窗口内 CLI 自装文件曾全量
+ *     落「计划外」；回放有害类直接硬排）。
+ *   对 modified-tracked（git diff）与 untracked（ls-files --others）一视同仁。
  */
 export function filterDeliverableFiles(files) {
   return files.filter(f =>
     !f.startsWith('.sillyspec/changes/') &&
     !f.startsWith('.sillyspec/.runtime/') &&
     !f.startsWith('.sillyspec/quicklog/') &&
-    f !== 'meta.json'
+    f !== 'meta.json' &&
+    classifyToolScaffold(f) !== 'platform'
   );
 }
 
@@ -151,7 +193,133 @@ export function mergeDirtyOverlapThreeWay({ projectRoot, worktreePath, baseHash
   } finally {
     try { rmSync(tmpDir, { recursive: true, force: true }) } catch {}
   }
-  return { merged, conflicts }
+  // 批末统一暂存（task-01 / FR-01 / D-001@v1 前半，2026-09-14-apply-conflict-hardening）：
+  // 本写回点曾是全链路唯一未暂存的自动写点——未暂存文件对主仓工作区级 git 操作
+  // （restore / clean / checkout）零免疫（§64 事故的实际缺口）。对全部 clean 写回文件
+  // 显式 pathspec git add（safeGit 数组形式不经 shell；chunkPaths 分批防 Windows argv
+  // 上限，批 D-③ 同款）。fail-open：add 失败不抛（合并成果保留），console.warn 留痕 +
+  // 返回 stagedOk:false——manifest 侧对该批文件自动回退 readFile+归一 approx 口径。
+  let stagedOk = true
+  if (merged.length > 0) {
+    for (const batch of chunkPaths(merged)) {
+      const r = safeGit(projectRoot, ['add', '--', ...batch])
+      if (r && r.error) {
+        stagedOk = false
+        console.warn(`⚠️ merge 写回批末 git add 失败（fail-open：${merged.length} 个合并文件成果保留，但未暂存对 git restore/clean 不免疫，请尽快人工 git add）：${String(r.error).split('\n')[0]}`)
+        break
+      }
+    }
+  }
+  return { merged, conflicts, stagedOk }
+}
+
+/**
+ * 字节级 CRLF→LF 归一（ql-20260915-001 修复①，mergeMismatchThreeWay 专用）。
+ *
+ * 动机：本仓 core.autocrlf=true（2026-09-15 实测），git checkout 出的 worktree 磁盘内容是
+ * CRLF、blob（git show 取出）是 LF——ours(blob LF) 与 theirs(disk CRLF) 混形喂 merge-file 会
+ * 逐行假冲突（每一行都呈现为两侧各改一次）。三输入统一 LF 域合并，写回后 git add 按
+ * autocrlf 属性归一回 blob 域（磁盘 LF 形态 git status 亦不报幻影改动）。
+ *
+ * 字节级替换（latin1 语义，不经 utf8 解码）保任意非 UTF-8 文本字节不被替换字符污染；含 NUL
+ * （二进制标志）返回 null——二进制不可文本合并，调用方按冲突处理。
+ *
+ * @param {Buffer} buf
+ * @returns {Buffer|null} 归一后内容；二进制返回 null
+ */
+function _toLfBuffer(buf) {
+  if (!buf || buf.length === 0) return buf
+  if (buf.indexOf(0) !== -1) return null // 二进制
+  if (buf.indexOf(Buffer.from('\r\n')) === -1) return buf
+  const out = []
+  for (let i = 0; i < buf.length; i++) {
+    if (buf[i] === 0x0d && i + 1 < buf.length && buf[i + 1] === 0x0a) { out.push(0x0a); i++ }
+    else out.push(buf[i])
+  }
+  return Buffer.from(out)
+}
+
+/**
+ * EXCLUDE-MISMATCH 前置自动三方合并（ql-20260915-001 修复①，坑 apply-archived-mismatch-no-merge：
+ * 2026-09-14 用户实证归档后补 apply 时主仓文件已被并行会话提交推进 → rescue EXCLUDE-MISMATCH
+ * 跳过不落地，被迫手工 cp + 锚点合并）。
+ *
+ * 与 mergeDirtyOverlapThreeWay 同实现形态，base/ours 取源不同：
+ *   - base = apply 锚点（baseHash 形参，调用方传 deliverableBase=baselineCommit||baseHash）blob
+ *   - **ours = 主仓 HEAD blob（已提交推进态，非脏读——mismatch 面主仓无未提交改动，
+ *     调用方已按 pre-stash dirty 集排除，HEAD 即主仓当前态）**
+ *   - theirs = worktree 文件内容（磁盘读，子代理未 commit 的交付）
+ *
+ * clean 合并才写回主仓（两侧增量都保留）+ 批末 git add（chunkPaths 分批）+ 调用方从
+ * changedFiles/hashMismatchFiles 剔除（patch 不再重放，防 staged 内容与 patch 预像互踩）；
+ * conflict / 异常 fail-soft 维持原路径（rescue EXCLUDE-MISMATCH 新文案 / step7 --3way 实测）。
+ * 覆写前备份主仓磁盘原文至 .sillyspec/.runtime/merge-backups/（与脏读版同一惯例）。
+ *
+ * @param {{ projectRoot: string, worktreePath: string, baseHash: string }} ctx
+ * @param {string[]} mismatchFiles mismatch ∩ changedFiles 且主仓无未提交改动的文件（仓库根相对路径）
+ * @returns {{ merged: string[], conflicts: string[], stagedOk: boolean }}
+ */
+export function mergeMismatchThreeWay({ projectRoot, worktreePath, baseHash }, mismatchFiles) {
+  const merged = []
+  const conflicts = []
+  const tmpDir = mkdtempSync(join(tmpdir(), 'sillyspec-3way-m-'))
+  try {
+    for (const f of mismatchFiles) {
+      try {
+        // ours/HEAD 缺失（主干侧删除等 modify/delete 形态）→ git show 抛错 → conflicts（fail-soft，
+        // 删除语义 merge-file 无法表达，交既有出口 --3way/--merge 裁决）
+        const baseRaw = git(projectRoot, ['show', `${baseHash}:${f}`], { encoding: 'buffer', timeout: 15000 })
+        const oursRaw = git(projectRoot, ['show', `HEAD:${f}`], { encoding: 'buffer', timeout: 15000 })
+        const wtRaw = readFileSync(join(worktreePath, f))
+        const baseN = _toLfBuffer(baseRaw)
+        const oursN = _toLfBuffer(oursRaw)
+        const theirsN = _toLfBuffer(wtRaw)
+        if (!baseN || !oursN || !theirsN) { conflicts.push(f); continue } // 二进制 → 原路径
+        const p = (tag) => join(tmpDir, `${tag}-${Math.random().toString(36).slice(2, 8)}`)
+        const baseP = p('base'); const oursP = p('ours'); const theirsP = p('theirs')
+        writeFileSync(baseP, baseN); writeFileSync(oursP, oursN); writeFileSync(theirsP, theirsN)
+        let outBuf, code = 0
+        try {
+          outBuf = git(projectRoot, ['merge-file', '-p', oursP, baseP, theirsP], { encoding: 'buffer', timeout: 15000 })
+        } catch (e) {
+          code = (typeof e.status === 'number') ? e.status : -1
+          outBuf = (e.stdout instanceof Buffer) ? e.stdout : Buffer.alloc(0)
+          if (code < 0) { conflicts.push(f); continue }
+        }
+        if (code === 0) {
+          // 覆写前备份主仓磁盘原文（merge-backups 惯例；ours=HEAD 理论可经 git show 重取，仍留备份保审计）
+          try {
+            const backupDir = join(projectRoot, '.sillyspec', '.runtime', 'merge-backups')
+            mkdirSync(backupDir, { recursive: true })
+            let pre = oursRaw
+            try { pre = readFileSync(join(projectRoot, f)) } catch { /* 磁盘缺文件用 HEAD 原文 */ }
+            writeFileSync(join(backupDir, `${Date.now()}-${f.replace(/[\\/]/g, '__')}`), pre)
+          } catch { /* 备份失败不阻断合并 */ }
+          writeFileSync(join(projectRoot, f), outBuf)
+          merged.push(f)
+          console.log(`🔀 EXCLUDE-MISMATCH 三方合并成功（clean）: ${f}——主仓已提交推进与 worktree 交付均已保留（覆写前原文已备份至 .sillyspec/.runtime/merge-backups/）`)
+        } else {
+          conflicts.push(f)
+        }
+      } catch { conflicts.push(f) }
+    }
+  } finally {
+    try { rmSync(tmpDir, { recursive: true, force: true }) } catch {}
+  }
+  // 批末统一暂存（与 mergeDirtyOverlapThreeWay 同款：safeGit 数组形式 + chunkPaths 分批，
+  // fail-open：add 失败不抛、stagedOk:false 供调用方 warning 提示人工补 add）
+  let stagedOk = true
+  if (merged.length > 0) {
+    for (const batch of chunkPaths(merged)) {
+      const r = safeGit(projectRoot, ['add', '--', ...batch])
+      if (r && r.error) {
+        stagedOk = false
+        console.warn(`⚠️ mismatch merge 写回批末 git add 失败（fail-open：${merged.length} 个合并文件成果保留，但未暂存对 git restore/clean 不免疫，请尽快人工 git add）：${String(r.error).split('\n')[0]}`)
+        break
+      }
+    }
+  }
+  return { merged, conflicts, stagedOk }
 }
 
 export function generateRescueCommands({ changedFiles, dirtyFiles, hashMismatchFiles, deletedFiles = [], worktreePath, projectRoot }) {
@@ -177,7 +345,9 @@ export function generateRescueCommands({ changedFiles, dirtyFiles, hashMismatchF
       continue;
     }
     if (mismatchSet.has(f)) {
-      warnings.push(`跳过 ${f}：EXCLUDE-MISMATCH（主干已提交推进该文件，cp 会回退他人改动；请先 commit main 未提交改动再正常 apply 走 --3way 合并）`);
+      // ql-20260915-001 修复①：文案更新——前置三方合并已尝试过（4.5b），此处剩的是合并冲突面，
+      // 给出两条实际出路（手动锚点合并 / 先 commit 后 --3way），不再误导「正常 apply 走 --3way」即可解
+      warnings.push(`跳过 ${f}：EXCLUDE-MISMATCH（主干已提交推进该文件，已尝试自动三方合并，冲突——手动锚点合并，或先 commit 主仓未提交改动后正常 apply 走 --3way）`);
       excludedCount++;
       continue;
     }
@@ -185,6 +355,15 @@ export function generateRescueCommands({ changedFiles, dirtyFiles, hashMismatchF
     cpFileCount++;
   }
 
+  // D-003@v1（task-01，2026-09-14-apply-conflict-hardening）：rescue 是人工落地路径，落地文件
+  // 不进 manifest 也不自动暂存——主仓工作区级 git 操作（restore/clean/checkout）可静默冲掉
+  // 未暂存落地（§64 事故实际路径）。commands 末尾追加一行「落地后立即 git add 锁定」指引
+  // （# 注释形态，整块复制粘贴仍是合法 shell；纯文案，commands/warnings 结构语义与
+  // cpFileCount/excludedCount 口径不变；commands 为空 = 无可落地文件，不加指引）。
+  if (commands.length > 0) {
+    commands.push(`# 全部执行后立即 git add -- <上方 cp 落地的各文件路径> 锁定暂存区（staged 对 git restore / git clean 免疫，防止并行会话的工作区级操作冲掉刚落地的文件；rm 删除的文件无需 add）`);
+  }
+
   return { commands, warnings, cpFileCount, excludedCount };
 }
 
@@ -284,6 +463,69 @@ export function chunkPaths(paths, maxChars = 8000) {
   return batches
 }
 
+/**
+ * no-op 文件检测（FR-02 / D-002@v1，坑② assess-noop-blocked）：判定候选文件中
+ * 「worktree 工作区内容 = 主仓 HEAD blob」者。execute 期主仓 HEAD 前进后，worktree 内
+ * 自救/重同步成主仓最新内容的文件对 baseline checkpoint diff 非空，apply 回主仓实为
+ * no-op，却被 assess 误判「变更文件超出 allowed_paths」BLOCKED——由 applyWorktree
+ * step 2 单点 choke point 调用（apply 与 assess checkOnly 复用同函数，自动同口径）。
+ *
+ * 比对：worktree 工作区 `git hash-object`（默认带 clean filter，与 tree blob 同口径）
+ * 按 argv 分批（chunkPaths，worktree.js _changesAlreadyOnMain 同型），批次输出按行序
+ * 拼接与候选索引对齐；主仓 HEAD blob 复用 getBlobHashMap（ls-tree）。路径对照键统一
+ * quotepath 剥引号（unquoteGitPath）+ 反斜杠归一正斜杠，仅用于比对不回写（changedFiles
+ * 路径字面保持现状口径，下游 pathMatches/gates/archive-delta 零改动）。
+ *
+ * fail-safe（D-002 故障面契约）：hash-object 某批失败 / 行数不齐 / 整段异常 → 该批
+ * （或全部）保守不剔，保留 changed——退回现状误报而非误放行。每调用现算不缓存（主仓
+ * HEAD 在 assess 与 apply 间可能推进，以各自当下事实为准）。
+ *
+ * @param {string} projectRoot 主仓根（HEAD blob 读取处）
+ * @param {string} worktreePath worktree 根（工作区 hash-object 执行处）
+ * @param {string[]} candidates 候选文件（调用方已保证 worktree 工作区存在——删除类天然出局）
+ * @returns {string[]} 判定为 no-op 的文件子集（candidates 原字面）；判定不可得时返回 []
+ */
+function detectNoOpFiles(projectRoot, worktreePath, candidates) {
+  try {
+    if (!candidates || candidates.length === 0) return [];
+    // 主仓 HEAD 树 blob map：路径不在 HEAD 树 → 不在 Map → 主仓无该路径的新文件天然非 no-op
+    const mainBlobs = getBlobHashMap(projectRoot, 'HEAD', candidates);
+    if (mainBlobs.size === 0) return [];
+    const pathKey = (p) => {
+      let s = String(p);
+      if (s.startsWith('"') && s.endsWith('"') && s.length >= 2) s = unquoteGitPath(s.slice(1, -1));
+      return s.replace(/\\/g, '/');
+    };
+    const mainBlobByKey = new Map();
+    for (const [p, h] of mainBlobs) mainBlobByKey.set(pathKey(p), h);
+    const present = candidates.filter(f => mainBlobByKey.has(pathKey(f)));
+    if (present.length === 0) return [];
+
+    // worktree 工作区 blob：hash-object 按 argv 顺序逐行输出；某批失败（文件被并发删/权限等）
+    // → 占位空串填充保批次间索引对齐（空串永不等于 blob hash → 该批各文件保守不剔）
+    const wtHashes = [];
+    for (const batch of chunkPaths(present)) {
+      const out = gitQuiet(worktreePath, ['hash-object', '--', ...batch], { timeout: 30000 });
+      const lines = out === null ? null : out.split('\n');
+      if (!lines || lines.length !== batch.length) {
+        console.warn(`⚠️  no-op 检测：hash-object 批失败/行数不齐，该批 ${batch.length} 个文件保守保留在 changedFiles`);
+        for (let i = 0; i < batch.length; i++) wtHashes.push('');
+        continue;
+      }
+      wtHashes.push(...lines);
+    }
+    const noopFiles = [];
+    for (let i = 0; i < present.length; i++) {
+      if (wtHashes[i] && wtHashes[i] === mainBlobByKey.get(pathKey(present[i]))) noopFiles.push(present[i]);
+    }
+    return noopFiles;
+  } catch (e) {
+    // 意外异常整体保守不剔（fail-safe：宁可误报 BLOCKED，不可误放行剔除）
+    console.warn(`⚠️  no-op 文件检测失败（保守保留 changedFiles）：${(e.message || '').split('\n')[0]}`);
+    return [];
+  }
+}
+
 /**
  * apply 的文件清单 = design §6 清单 ∪ plan TaskCard allowed_paths（execute 复盘 c）。
  *
@@ -374,14 +616,127 @@ function _silentPointerSpecRoot(projectRoot) {
   } catch { return null; }
 }
 
+/**
+ * apply 成功尾声写 apply-manifest.json（task-01 / FR-02 / D-001@v1 后半，
+ * 2026-09-14-apply-conflict-hardening）。
+ *
+ * 目的：apply 后交付文件在主仓被并行会话的工作区级 git 操作冲掉（新文件删除/修改回退）时
+ * 靠指纹可检测（doctor 漂移检查项消费，Wave 3）。CLI 全权写（agent 勿手改，verify-facts
+ * 同款契约）；rescue 人工落地文件不进 manifest（design 非目标边界）。
+ *
+ * 哈希口径（design 接口定义定案，AGENTS.md 规则 13 Windows 兼容）：**staged blob 内容**
+ * （git show :<path>，autocrlf 归一后的 LF 规范态）——写侧在 git add / apply --3way（隐含
+ * --index）之后取值，与 doctor 的 staged 态比对天然同基。文件未进暂存（如 merge 写回批末
+ * add 失败的 fail-open 面）→ 回退 readFile 后 CRLF→LF 归一计算（latin1 往返保字节），条目
+ * 加 approx:true 标记；staged 与磁盘皆无（apply 删除的文件——无内容可指纹）→ 不进 manifest。
+ *
+ * 落点：<changeDir>/apply-manifest.json（resolveActiveOrArchiveChangeDir 归档感知——与
+ * resolveApplyAllowSet 同源，归档后补 apply 的重放写在归档目录）。已存在则覆盖（重放 apply
+ * 以最新为准）。manifest 落 .sillyspec/changes/ 面 → filterDeliverableFiles 排除，不构成
+ * apply 交付物、不进自身 files。
+ *
+ * 本函数自身不 catch 写失败（交调用方 fail-open warning）；files 为空时跳过不写（无落盘面
+ * 的成功出口不产 manifest，doctor 按存在性跳过）。
+ *
+ * @param {{ projectRoot: string, specBase?: string, changeName: string, baseHash?: string, files: string[] }} args
+ *   specBase 缺省时与 resolveApplyAllowSet 同链回退（指针 specRoot > 本地 .sillyspec）；
+ *   baseHash 记 apply 锚点（deliverableBase 语义：baselineCommit || baseHash）
+ * @returns {{ written: boolean, file?: string, files: Array<{path:string, sha256:string, approx?:true}>, skipped?: string }}
+ */
+function writeApplyManifest({ projectRoot, specBase, changeName, baseHash, files }) {
+  const face = [...new Set((Array.isArray(files) ? files : []).filter(Boolean))];
+  if (face.length === 0) return { written: false, files: [], skipped: 'empty-files' };
+  const base = specBase || _silentPointerSpecRoot(projectRoot) || join(projectRoot, '.sillyspec');
+  const changeDir = resolveActiveOrArchiveChangeDir(base, changeName);
+  const entries = [];
+  for (const f of face) {
+    let sha256 = null;
+    let approx = false;
+    try {
+      // staged blob（LF 规范态）：encoding buffer 保二进制原样；不在 index（删除/未 add）→ 抛错走回退
+      const blob = git(projectRoot, ['show', `:${f}`], { encoding: 'buffer', timeout: 15000 });
+      sha256 = createHash('sha256').update(blob).digest('hex');
+    } catch {
+      try {
+        const raw = readFileSync(join(projectRoot, f));
+        // CRLF→LF 归一（latin1 往返保字节，防 utf8 解码破坏二进制内容）
+        const norm = Buffer.from(raw.toString('latin1').replace(/\r\n/g, '\n'), 'latin1');
+        sha256 = createHash('sha256').update(norm).digest('hex');
+        approx = true;
+      } catch { continue; } // staged 与磁盘皆无（apply 删除面）→ 无内容可指纹，不进 manifest
+    }
+    entries.push(approx ? { path: f, sha256, approx: true } : { path: f, sha256 });
+  }
+  const manifest = {
+    schemaVersion: 1,
+    change: changeName,
+    appliedAt: new Date().toISOString(),
+    baseHash: baseHash || null,
+    files: entries,
+  };
+  mkdirSync(changeDir, { recursive: true });
+  const manifestPath = join(changeDir, 'apply-manifest.json');
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+  return { written: true, file: manifestPath, files: entries };
+}
+
+/**
+ * 坑 mixed-baseline-drift-hint（ql-20260915-004）：apply 成功尾声混合基线 advisory。
+ *
+ * 主仓自本变更基点（baseHash）后的已提交推进若触及本变更相关文件（含 .test./.spec. 变体），
+ * worktree 快照内验证过的测试断言可能基于旧内容——apply 落地的是混合基线，提示 agent 合并态
+ * 复跑相关测试（非阻断，result.committedDrift 留痕）。head 缺省 HEAD：patch 路径自身交付
+ * staged 未提交，baseHash..HEAD 即纯他者推进面；merge 路径传 preMergeHead（merge 提交后
+ * HEAD 含自身交付，不剔会把「自己合自己」误报成他者推进）。fail-soft：异常零影响 apply。
+ */
+function annotateCommittedDrift(result, { projectRoot, baseHash, files, head }) {
+  try {
+    if (!baseHash || !files || files.length === 0) return;
+    const drift = detectCommittedDrift({ projectRoot, baseHash, touchedFiles: files, head });
+    if (drift && drift.drift) {
+      result.committedDrift = drift;
+      console.warn(formatCommittedDriftWarning(drift));
+    }
+  } catch { /* fail-soft：drift 检测异常不影响 apply 结果 */ }
+}
+
+/**
+ * guard 相交预检（task-02 / FR-03 / D-002@v1，内部函数）。
+ *
+ * 活跃 quick 会话 guard.allowedFiles 与本次 apply 实际落盘集求交集——非空说明本变更文件正被
+ * 并行 quick 会话声明在途改动，此刻 apply 会互冲（2026-09-14 实证事故：apply 交付文件被并行
+ * 会话工作区 git 操作冲掉）。交集口径：字符串等值（guard.allowedFiles 与 changedFiles 同为
+ * 仓库根相对路径）。无活跃会话/无声明/交集空 → blocked=false（零行为变化）。
+ *
+ * @param {{ activeGuards: Map<string, string[]>, applyFiles: string[], selfChange?: string }} p
+ *   - activeGuards：collectActiveQuickGuardFiles 产物（已按 excludeChange 排除自身）
+ *   - applyFiles：changedFiles∪newPatchFiles（result 实际字段口径）
+ *   - selfChange：防御性再排除（sessionId == 本次 changeName 不拦自身）
+ * @returns {{ overlaps: Array<{sessionId: string, file: string}>, blocked: boolean }}
+ */
+function checkGuardOverlap({ activeGuards, applyFiles, selfChange }) {
+  const overlaps = [];
+  const fileSet = new Set((applyFiles || []).filter(Boolean));
+  if (!activeGuards || fileSet.size === 0) return { overlaps, blocked: false };
+  for (const [sessionId, allowedFiles] of activeGuards) {
+    if (selfChange && sessionId === selfChange) continue;
+    for (const f of (allowedFiles || [])) {
+      if (fileSet.has(f)) overlaps.push({ sessionId, file: f });
+    }
+  }
+  return { overlaps, blocked: overlaps.length > 0 };
+}
+
 /**
  * 收集最新 execute run 各 task review.json 的 changedFiles 声明 → Map<repoKey, string[]>。
  *
  * 坑 apply-undeclared-deviation-block（2026-08-24 用户反馈四期③）：执行期有据越界文件
  * （facade 转发/名单测试）不在 design §6 也不在 allowed_paths，Gate1 拦 apply 只能回改
  * design.md。review.json changedFiles 是 reviewer 对实际改动的声明（Task Review Gate 的
- * verifyReviewGitEvidence 已交叉校验其与真实 git diff 相交），作为第三源并入 allow set——
- * 放行仅限「已声明且过证据校验」的文件，完全越界仍拦。口径与 complete-handlers 的
+ * verifyReviewGitEvidence 已交叉校验其与真实 git diff 相交）。D-003@v1 收紧（2026-09-14
+ * change-ownership-guards task-03）：声明只与 allow 面相交（pathMatches 容差）才计入，
+ * 不相交的外来声明剔除出放行面、进 violations 报告行——本函数仍是声明收集口（口径不变），
+ * 相交过滤在主仓 3b/跨仓清单校验两消费点执行。口径与 complete-handlers 的
  * collectExecuteChangedFiles 一致：change 戳归属 run、.sillyspec//meta.json 过滤、
  * review.repo 切片（跨仓声明不进 main 集）。读不到 run/review → 空 Map（fail-closed 回退旧行为）。
  *
@@ -510,9 +865,12 @@ function validateCrossRepoNoOp(ctx, projectRoot, changeName) {
  * 可清，wm.cleanup 只作用于主仓 worktree）。主仓 task 走原 A5 完整 apply 不动（GOAL-2 单仓零回归）。
  *
  * @param {string} changeName - 变更名
- * @param {{ cwd?: string, checkOnly?: boolean, merge?: boolean, ctx?: object }} opts
+ * @param {{ cwd?: string, checkOnly?: boolean, merge?: boolean, ctx?: object, force?: boolean, autoApply?: boolean }} opts
  *   - ctx：可选 MultiRepoContext（design §7.1）。缺省=单仓退化（仅主仓 apply，零行为变化，GOAL-2）。
  *     提供 ctx 且含跨仓 entry 时，触发跨仓 no-op 校验（校验 review.head 真实 + 不 cleanup 跨仓）。
+ *   - force（task-02 / FR-03）：guard 相交预检命中时显式放行并留痕 result.overlapForced（仅人工 CLI --force）。
+ *   - autoApply（task-02 / FR-03）：assess 自动入口置 true——相交命中软跳过（result.overlapSkipped + warning，
+ *     不抛错不落盘）；自动路径永不 force。
  * @returns {{
  *   ok: boolean,
  *   changedFiles: string[],
@@ -583,7 +941,7 @@ export async function withMainRepoLock(projectRoot, changeName, purpose, fn, opt
  *
  * 对有 worktree meta 的跨仓仓（worktree-cross.js 创建）执行与主仓 A5 同构的 patch 回落：
  *   deliverables（diff baselineCommit||baseHash + untracked，filterDeliverableFiles 排除基础设施）
- *   → 清单校验（resolveApplyAllowSet 按 repo 切片 ∪ review 声明切片）
+ *   → 清单校验（resolveApplyAllowSet 按 repo 切片 + review 声明相交过滤，D-003：不相交剔除）
  *   → 跨仓主工作副本 dirty 重叠拦截
  *   → patch（tracked diff + untracked add/diff --cached/reset，Buffer 防二进制损坏）
  *   → git apply --3way 回跨仓主工作副本；成功后 cleanup 该跨仓 worktree（分支保留作锚）。
@@ -623,7 +981,14 @@ function applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly = fal
         }
       }
       const untrackedRaw = gitQuiet(cm.worktreePath, ['ls-files', '--others', '--exclude-standard']) || '';
-      changedFiles = filterDeliverableFiles([...new Set([...statusFiles, ...untrackedRaw.split('\n').filter(Boolean)])]);
+      const allFiles = [...new Set([...statusFiles, ...untrackedRaw.split('\n').filter(Boolean)])];
+      changedFiles = filterDeliverableFiles(allFiles);
+      // 硬排可见性（scope-audit-cross-repo-blindness 改进点 1）：被滤除的平台设施文件列
+      // warning 不静默——apply 不回放它们；若某文件确为交付物（极少），人工落主仓。
+      const dropped = allFiles.filter(f => !changedFiles.includes(f) && classifyToolScaffold(f) === 'platform');
+      if (dropped.length > 0) {
+        out.warnings.push(`跨仓 ${repoKey}：${dropped.length} 个工具/平台设施文件未纳入 apply（${dropped.slice(0, 5).join(', ')}${dropped.length > 5 ? ' 等' : ''}）——非交付物不回放，确需交付请人工处理`);
+      }
     } catch (e) {
       out.errors.push(`跨仓 ${repoKey}：获取变更文件列表失败（${cm.worktreePath}）: ${e.message}`);
       continue;
@@ -641,24 +1006,45 @@ function applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly = fal
       continue;
     }
 
-    // 清单校验（per-repo 切片 + review 声明切片并入，与主仓 Gate1/3b 同语义）。
+    // 清单校验（per-repo 切片 + review 声明相交过滤，与主仓 Gate1/3b 同语义）。
     // specBase 显式传（平台模式 changes/ 在 specRoot；本地模式与旧硬编码同值零回归）。
+    // review 声明收紧（D-003@v1，2026-09-14-change-ownership-guards task-03）：声明文件须与
+    // allow 面（design 清单 ∪ 各 task target_files/allowed_paths ∪ linked-change 声明 =
+    // resolveApplyAllowSet 现有并集）相交（pathMatches 容差）才计入；不相交的外来声明剔除出
+    // 放行面、进 violations 报告行（「review 声明了越权文件」嫌疑标注），admission 增量归零。
     const allowMap = resolveApplyAllowSet(projectRoot, changeName, { specBase });
-    let allowSet = allowMap.get(repoKey) || new Set();
+    const allowSet = allowMap.get(repoKey) || new Set();
     const reviewDeclared = collectReviewDeclaredFiles(projectRoot, changeName, { runtimeRoot: join(specBase, '.runtime') }).get(repoKey);
-    if (reviewDeclared) {
-      const merged = new Set([...allowSet]);
+    const reviewForeign = [];
+    if (reviewDeclared && allowSet.size > 0) {
+      const face = [...allowSet];
       for (const f of reviewDeclared) {
-        if (![...merged].some(ap => pathMatches(f, ap))) merged.add(f);
+        if (!face.some(ap => pathMatches(f, ap))) reviewForeign.push(f);
       }
-      allowSet = merged;
+    }
+    if (reviewForeign.length > 0) {
+      out.warnings.push(
+        `跨仓 ${repoKey}：${reviewForeign.length} 个 review 声明文件不在 allow 面（design 清单/任务卡 allowed_paths/linked 声明），已剔除出放行面（review 声明了越权文件——嫌疑：review 失实或并行会话在途文件混入声明）：${reviewForeign.join(', ')}`
+      );
     }
     if (allowSet.size > 0) {
       const violations = classifyAllowListViolations(changedFiles, allowSet);
       if (violations.length > 0) {
-        out.errors.push(
-          `跨仓 ${repoKey}：文件清单校验失败——以下变更文件不在 design.md 清单、也不在该仓 task review.json changedFiles 声明中：\n  ${violations.join('\n  ')}`
-        );
+        const foreignSet = new Set(reviewForeign);
+        const foreignViolations = violations.filter(f => foreignSet.has(f));
+        const undeclaredViolations = violations.filter(f => !foreignSet.has(f));
+        const lines = [];
+        if (undeclaredViolations.length > 0) {
+          lines.push(
+            `跨仓 ${repoKey}：文件清单校验失败——以下变更文件不在 design.md 清单、也不在该仓 task review.json changedFiles 声明中：\n  ${undeclaredViolations.join('\n  ')}`
+          );
+        }
+        if (foreignViolations.length > 0) {
+          lines.push(
+            `跨仓 ${repoKey}：review 声明了越权文件——以下变更文件已被 review.json changedFiles 声明但不在 allow 面（design 清单/任务卡 allowed_paths/linked 声明），不予放行：\n  ${foreignViolations.join('\n  ')}\n（确属本变更交付：补进 design §6 清单或任务卡 allowed_paths 后重跑）`
+          );
+        }
+        out.errors.push(lines.join('\n'));
         if (!checkOnly) continue;
       }
     }
@@ -765,7 +1151,7 @@ function applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly = fal
   return out;
 }
 
-export function applyWorktree(changeName, { cwd, checkOnly = false, merge = false, base = 'merge-base', ctx = null, skipOverlap = false, stashDirty = false } = {}) {
+export function applyWorktree(changeName, { cwd, checkOnly = false, merge = false, base = 'merge-base', ctx = null, skipOverlap = false, stashDirty = false, force = false, autoApply = false } = {}) {
   const projectRoot = cwd || process.cwd();
   const wm = new WorktreeManager({ cwd: projectRoot });
   const meta = wm.getMeta(changeName);
@@ -882,7 +1268,41 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     // 排除 worktree 基础设施文件（meta.json / .sillyspec/，见 filterDeliverableFiles）。
     // 对 modified-tracked（statusFiles）与 untracked 一视同仁——否则 modified 的 meta.json
     // 会被误算入 changedFiles，触发 design.md 清单校验失败（assess 恒 BLOCKED）。
-    changedFiles = filterDeliverableFiles([...new Set([...statusFiles, ...untrackedFiles])]);
+    const allChangedRaw = [...new Set([...statusFiles, ...untrackedFiles])];
+    changedFiles = filterDeliverableFiles(allChangedRaw);
+
+    // no-op 文件剔除（FR-02 / D-002@v1）：主仓 HEAD 在 execute 期间前进后，worktree 内
+    // 「内容=主仓 HEAD」的自救/重同步文件对 deliverableBase diff 非空，apply 回主仓实为
+    // no-op，却被 assess 误判「变更文件超出 allowed_paths」BLOCKED。候选收窄：allChangedRaw
+    // 中 worktree 工作区存在者（existsSync，删除类天然出局）∩ 主仓 HEAD 树存在者（helper
+    // 内反查）；判定失败保守不剔。diff-size/Gate 判定消费的 changedFiles 自然跟随收窄，
+    // patch 面（resolvePatchFiles ⊆ changedFiles）同步不再回放该类文件。
+    const noopCandidates = allChangedRaw.filter(f => existsSync(join(worktreePath, f)));
+    const noopFiles = noopCandidates.length > 0 ? detectNoOpFiles(projectRoot, worktreePath, noopCandidates) : [];
+    // 只报实际从三集剔出的文件（候选含 filterDeliverableFiles 已硬排的平台设施时，
+    // 那部分本就不在 changedFiles，不计入告警面）
+    const changedSetForNoop = new Set([...changedFiles, ...deletedFiles, ...absentAfterMerge]);
+    const removedNoopFiles = noopFiles.filter(f => changedSetForNoop.has(f));
+    if (removedNoopFiles.length > 0) {
+      const noopSet = new Set(removedNoopFiles);
+      changedFiles = changedFiles.filter(f => !noopSet.has(f));
+      // 防御性剔除（候选已限工作区存在，正常不命中后两集；过滤保三集不变式）
+      for (let i = deletedFiles.length - 1; i >= 0; i--) if (noopSet.has(deletedFiles[i])) deletedFiles.splice(i, 1);
+      for (let i = absentAfterMerge.length - 1; i >= 0; i--) if (noopSet.has(absentAfterMerge[i])) absentAfterMerge.splice(i, 1);
+      result.warnings = result.warnings || [];
+      result.warnings.push(
+        `${removedNoopFiles.length} 个文件内容与主仓 HEAD 一致（apply 为 no-op，不计入 changedFiles）：${removedNoopFiles.slice(0, 5).join(', ')}${removedNoopFiles.length > 5 ? ' 等' : ''}`
+      );
+    }
+
+    // 硬排可见性（scope-audit-cross-repo-blindness 改进点 1）：平台设施被滤出不静默——
+    // apply 不回放它们（.worktrees//.sillyspec-platform*/knowledge/local.yaml）；确为交付物
+    // 的极少数场景（如刻意改 knowledge 模板）人工落主仓。
+    const droppedScaffold = allChangedRaw.filter(f => !changedFiles.includes(f) && classifyToolScaffold(f) === 'platform');
+    if (droppedScaffold.length > 0) {
+      result.warnings = result.warnings || [];
+      result.warnings.push(`${droppedScaffold.length} 个工具/平台设施文件未纳入 apply（${droppedScaffold.slice(0, 5).join(', ')}${droppedScaffold.length > 5 ? ' 等' : ''}）——非交付物不回放，确需交付请人工处理`);
+    }
   } catch (e) {
     result.errors.push(`获取变更文件列表失败: ${e.message}`);
     return result;
@@ -912,27 +1332,30 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   // （主仓 worktree diff 只含主仓文件，跨仓文件在跨仓仓不进主仓 worktree diff）。跨仓 allowed_paths
   // 仅作 Map 切片返回供上游用，主流程不消费（跨仓 apply=no-op，D-009）。
   const allowMap = resolveApplyAllowSet(projectRoot, changeName, { specBase: allowSpecBase });
-  // --- 3b. review.json 声明偏差文件并入（坑 apply-undeclared-deviation-block）---
-  // 第三源：reviewer 声明的 changedFiles（已过 Task Review Gate git 证据交叉校验）——执行期
-  // 有据越界（facade 转发/名单测试）不再逼回改 design.md。各 repo 切片各自并入；仅靠 review
-  // 放行的文件记审计 warning（result.reviewAdmittedFiles），完全越界文件仍拦（Gate1 在扩展后判）。
+  // --- 3b. review.json 声明偏差文件相交过滤（坑 apply-undeclared-deviation-block → D-003@v1 收紧，
+  // 2026-09-14-change-ownership-guards task-03 / FR-02）---
+  // 旧语义：reviewer 声明的 changedFiles 整体并入 allow set（声明即放行）——troubleshooting §65
+  // 事件②实证该通道无 allowed_paths 相交校验，11 个并行会话在途文件经 review 声明真实放行。
+  // 新语义（D-003 翻转）：review 声明只承认与 allow 面（design 清单 ∪ 各 task
+  // target_files/allowed_paths ∪ linked-change 声明 = resolveApplyAllowSet 现有并集）相交的文件
+  // （pathMatches 容差）；不相交的外来声明剔除出放行面、进 violations 报告行（「review 声明了
+  // 越权文件」嫌疑标注）——admission 增量归零，通道保留作审计报告位（外来声明显式列出）。
   const reviewDeclaredByRepo = collectReviewDeclaredFiles(projectRoot, changeName, { runtimeRoot: allowRuntimeRoot });
-  const reviewAdmittedFiles = [];
+  const reviewForeignMain = [];
   for (const [repoKey, files] of reviewDeclaredByRepo) {
     const repoSet = allowMap.get(repoKey);
-    if (!repoSet) continue; // 该 repo 无 design/任务卡清单（无清单=不校验），无需扩展
-    const existing = [...repoSet];
+    if (!repoSet || repoSet.size === 0) continue; // 该 repo 无 design/任务卡清单（无清单=不校验），无相交可判
+    const face = [...repoSet];
     for (const f of files) {
-      if (!existing.some(ap => pathMatches(f, ap))) {
-        repoSet.add(f);
-        if (repoKey === 'main') reviewAdmittedFiles.push(f);
+      if (!face.some(ap => pathMatches(f, ap))) {
+        if (repoKey === 'main') reviewForeignMain.push(f);
       }
     }
   }
-  if (reviewAdmittedFiles.length > 0) {
-    result.reviewAdmittedFiles = reviewAdmittedFiles;
+  if (reviewForeignMain.length > 0) {
+    result.reviewOverdeclaredFiles = reviewForeignMain;
     result.warnings = (result.warnings || []).concat([
-      `${reviewAdmittedFiles.length} 个变更文件不在 design.md/任务卡清单，但已被 task review.json changedFiles 声明（review 声明放行，已过 Task Review Gate git 证据校验；审计留痕）：${reviewAdmittedFiles.join(', ')}`
+      `${reviewForeignMain.length} 个 review 声明文件不在 allow 面（design 清单/任务卡 allowed_paths/linked 声明），已剔除出放行面（review 声明了越权文件——嫌疑：review 失实或并行会话在途文件混入声明）：${reviewForeignMain.join(', ')}；确属本变更交付请补进 design §6 清单或任务卡 allowed_paths`
     ]);
   }
   const allowSet = allowMap.get('main') || new Set();
@@ -972,16 +1395,90 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   if (hasAllowList) {
     const violations = classifyAllowListViolations(changedFiles, allowSet);
     if (violations.length > 0) {
+      // D-003：violation 分流——已被 review 声明但不在 allow 面（越权声明）与完全未声明分报，
+      // 前者带「review 声明了越权文件」嫌疑标注（外来声明剔除后的落地拦截报告行）。
+      const foreignSet = new Set(result.reviewOverdeclaredFiles || []);
+      const foreignViolations = violations.filter(f => foreignSet.has(f));
+      const undeclaredViolations = violations.filter(f => !foreignSet.has(f));
       result.extraFiles.push(...violations);
-      result.errors.push(
-        `文件清单校验失败：以下变更文件不在 design.md 清单、也不在 task review.json changedFiles 声明中：\n  ${violations.join('\n  ')}\n（若属执行期合理偏差：在 task review.json 的 changedFiles 声明，或在 design.md §6 清单补行）`
-      );
+      const errLines = [];
+      if (undeclaredViolations.length > 0) {
+        errLines.push(
+          `文件清单校验失败：以下变更文件不在 design.md 清单、也不在 task review.json changedFiles 声明中：\n  ${undeclaredViolations.join('\n  ')}\n（若属执行期合理偏差：在 design.md §6 清单或任务卡 allowed_paths 补行——review.json 的 changedFiles 声明已不再放行清单外文件，仅作审计对照）`
+        );
+      }
+      if (foreignViolations.length > 0) {
+        errLines.push(
+          `review 声明了越权文件：以下变更文件已被 task review.json changedFiles 声明，但不在 allow 面（design 清单/任务卡 allowed_paths/linked 声明）——嫌疑：review 失实或并行会话在途文件混入声明，不予放行：\n  ${foreignViolations.join('\n  ')}\n（确属本变更交付：补进 design.md §6 清单或任务卡 allowed_paths 后重跑）`
+        );
+      }
+      result.errors.push(errLines.join('\n'));
       // checkOnly（assess）模式不短路：继续跑 Gate3，收集所有道供一次报全（坑 worktree-execute-apply-friction 坑4）。
       // 真实 apply（checkOnly=false）仍短路，保安全。
       if (!checkOnly) return result;
     }
   }
 
+  // --- 4.3 guard 相交预检（task-02 / FR-03 / D-002@v1）：活跃 quick 会话 guard.allowedFiles ∩ 本次落盘集 ---
+  // 内嵌 applyWorktree 主流程：CLI apply（index.js apply 分支）与 assess 自动 apply（index.js assess
+  // 分支）全经此覆盖；真实 apply 由调用方 withMainRepoLock 包裹——判定与落盘同在锁内，无 TOCTOU。
+  // 位置在一切主仓写动作之前（4.4 stash / 4.5 合并写回 / 4.6 --merge / step7 patch / ENOBUFS 降级）。
+  // applyFiles=changedFiles∪newPatchFiles：newPatchFiles⊆patchFiles⊆changedFiles（resolvePatchFiles
+  // 是 changedFiles 的过滤），并集即 changedFiles∪patchFiles，此处显式两集合并忠于 result 实际字段口径。
+  // specBase/sessionsDir 复用上方 allowlist 同一解析链（allowSpecBase > 平台指针 > 本地），勿新造配置读取。
+  // checkOnly 只读零写盘 → 跳过（零行为变化）。无活跃会话/无声明/交集空 → 全段空转零路径变化。
+  if (!checkOnly) {
+    const guardSpecBase = allowSpecBase || _silentPointerSpecRoot(projectRoot) || join(projectRoot, '.sillyspec');
+    const guardSessionsDir = allowRuntimeRoot ? join(allowRuntimeRoot, 'quick-sessions') : undefined;
+    const activeGuards = collectActiveQuickGuardFiles(guardSpecBase, { excludeChange: changeName, sessionsDir: guardSessionsDir });
+    const guardApplyFiles = [...new Set([...changedFiles, ...resolvePatchFiles(changedFiles, allowSet, hasAllowList)])];
+    const guardCheck = checkGuardOverlap({ activeGuards, applyFiles: guardApplyFiles, selfChange: changeName });
+    if (guardCheck.blocked) {
+      const sessions = [...new Set(guardCheck.overlaps.map(o => o.sessionId))];
+      const files = [...new Set(guardCheck.overlaps.map(o => o.file))];
+      const pairLines = guardCheck.overlaps.map(o => `  [${o.sessionId}] ${o.file}`);
+      if (force) {
+        // 显式解锁：放行并留痕（审计可见——自动路径永不带 force，overlapForced 只可能来自人工 --force）
+        result.overlapForced = { sessions, files };
+        result.warnings = (result.warnings || []).concat([
+          `--force 越过 guard 相交预检：${guardCheck.overlaps.length} 个会话×文件对与活跃 quick 会话声明重叠——` +
+          pairLines.join('；') + `（对方会话在途改动可能被覆盖，overlapForced 留痕）`
+        ]);
+      } else if (autoApply) {
+        // 软跳过：无人值守不越权（不落地互冲）也不阻断审计流——不抛错，指引人工评估
+        result.overlapSkipped = true;
+        result.warnings = (result.warnings || []).concat([
+          `自动 apply 软跳过（未落盘）：${files.length} 个文件与活跃 quick 会话在途声明重叠——` +
+          pairLines.join('；') + `——请人工评估后显式 sillyspec worktree apply ${changeName}（确认无冲突），或等对方会话 --done 后重试`
+        ]);
+        return result; // 安全返回：result.ok 保持 false，主仓零写动作（本预检位于一切写动作之前）
+      } else {
+        // 人工 CLI 入口（fail-closed）：结构化错误含会话×文件对清单 + 串行化指引 + --force 提示
+        result.errors.push(
+          `guard 相交拦截：本次 apply 文件与 ${sessions.length} 个活跃 quick 会话的在途声明重叠（会话×文件对）：\n` +
+          pairLines.join('\n') +
+          `\n串行化指引：等对方会话 sillyspec run quick --done 完成（guard 目录随之清理）后重试；` +
+          `或确认无实际冲突后显式解锁：sillyspec worktree apply ${changeName} --force（overlapForced 留痕）`
+        );
+        return result; // index.js apply 分支对 result.errors 走 exit 1 展示
+      }
+    }
+  }
+
+  // ── ql-20260915-001 修复①：mismatch 前置合并的 dirty 排除集（4.4 stash 前取样）──
+  // 4.5b 的 EXCLUDE-MISMATCH 前置合并只碰「主仓无未提交改动」的 mismatch 文件——dirty∩mismatch
+  // 交 4.5 脏读合并处理（其 ours=主仓磁盘脏内容，已含已提交推进，语义更全）。排除集必须在
+  // 4.4 --stash-dirty 之前取样：stash 会把脏文件收走，事后取 diff 恒空，会把在途文件误判成
+  // 干净 mismatch 用 ours=HEAD 合并写回（stash 恢复时与合并写回互踩）。checkOnly 只读不合并，
+  // 无 mismatch 时零开销，均不取样。untracked 不可能是 mismatch（不在 HEAD，mainBlob=null
+  // 天然被合并函数的 ours=git show HEAD:f 失败挡住），此处只取 tracked-modified 口径即可。
+  let preStashDirtySet = null
+  if (!checkOnly && (result.hashMismatchFiles || []).length > 0) {
+    preStashDirtySet = new Set(
+      (gitQuiet(projectRoot, ['diff', '--name-only', 'HEAD']) || '').split('\n').filter(Boolean)
+    )
+  }
+
   // --- 4.4 --stash-dirty：主仓在途改动自动 stash（坑 apply-main-dirty-no-first-class， ---
   // 2026-08-24 用户反馈四期①：主仓并行在途改动下默认 / --skip-overlap（全重叠「无可应用子集」）/
   // --merge（git 拒在脏树启动合并）三路死锁，手工 stash→3way→pop 流程未内置。flag 显式 opt-in
@@ -1023,7 +1520,45 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     // 用 --merge 时跳过未提交 dirty 拦截——merge 同样要求工作区相对干净，此处仅提示风险，真正失败由 applyByMerge 报告。
     // keepConflicts:true——显式 --merge 冲突时保留现场供手工解决（不再直接 abort 丢上下文）。
     if (merge && !checkOnly) {
-      return applyByMerge(result, changeName, projectRoot, wm, { keepConflicts: true });
+      return applyByMerge(result, changeName, projectRoot, wm, { keepConflicts: true, specBase: allowSpecBase });
+    }
+
+    // --- 4.5b EXCLUDE-MISMATCH 前置三方合并（ql-20260915-001 修复①，坑 apply-archived-mismatch-no-merge，
+    // 2026-09-14 用户实证：归档后补 apply，主仓已被并行会话提交推进 → rescue EXCLUDE-MISMATCH 跳过
+    // 不落地，被迫手工 cp+锚点合并）---
+    // 对 hashMismatch ∩ changedFiles 且主仓无未提交改动（pre-stash dirty 集排除，dirty 面交 4.5
+    // 脏读合并）的文件逐个 merge-file：base=checkpoint（deliverableBase）blob、ours=主仓 HEAD blob、
+    // theirs=worktree 文件。clean → 写回主仓 + 批末 add + mergedMismatchFiles 留痕 + 从
+    // changedFiles/hashMismatchFiles/deletedFiles 剔除（后续 patch 不再重放——staged 合并内容若再进
+    // patch，apply --3way 对 staged≠HEAD 的文件报 does not match index）；conflict/异常 → 留原集走
+    // 既有出口（rescue EXCLUDE-MISMATCH 新文案 / step7 --3way 实测 / --merge 兜底）。
+    // checkOnly（assess 只读）零写盘不试合并；--merge 已在 4.6 早退不达此；位于 4.3 guard 预检
+    // （一切主仓写动作之前）与 Gate1 清单校验之后，越权文件不会被合并落地。
+    if (!checkOnly && (result.hashMismatchFiles || []).length > 0 && worktreePath && worktreePath !== projectRoot) {
+      const mismatchCandidates = result.hashMismatchFiles.filter(f =>
+        changedFiles.includes(f) && !(preStashDirtySet && preStashDirtySet.has(f)))
+      if (mismatchCandidates.length > 0) {
+        try {
+          const m3m = mergeMismatchThreeWay({ projectRoot, worktreePath, baseHash: deliverableBase }, mismatchCandidates)
+          if (m3m.merged.length > 0) {
+            result.mergedMismatchFiles = (result.mergedMismatchFiles || []).concat(m3m.merged)
+            if (m3m.stagedOk === false) {
+              result.warnings = (result.warnings || []).concat([
+                `EXCLUDE-MISMATCH 三方合并 ${m3m.merged.length} 个文件已写回主仓，但批末 git add 暂存失败（未暂存对 git restore / git clean 不免疫）——请尽快人工 git add -- <该批文件> 锁定`
+              ])
+            }
+            result.warnings = (result.warnings || []).concat([
+              `EXCLUDE-MISMATCH 前置三方合并：${m3m.merged.length} 个主干已推进文件 clean 合并已写回并暂存（主仓已提交推进与 worktree 交付均保留，覆写前原文备份于 .sillyspec/.runtime/merge-backups/）`
+            ])
+            const mergedMisSet = new Set(m3m.merged)
+            changedFiles = changedFiles.filter(f => !mergedMisSet.has(f))
+            result.changedFiles = changedFiles
+            result.deletedFiles = deletedFiles.filter(f => !mergedMisSet.has(f))
+            result.hashMismatchFiles = result.hashMismatchFiles.filter(f => !mergedMisSet.has(f))
+          }
+          // m3m.conflicts 面留在 result.hashMismatchFiles 原样（rescue 分类 / step7 --3way 既有路径）
+        } catch { /* 合并链路异常 → mismatch 集原样，走既有出口（fail-soft 不阻断 apply） */ }
+      }
     }
 
     // --- 4.5 校验：主工作区「未提交」脏文件是否与本次变更重叠（overlap-only 拦截）---
@@ -1052,10 +1587,14 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
       // hash 必变，若仍比对会永久死锁（须手改 meta.baselineHash）。改判「排除规则下当前是否有未提交 dirty」。
       const hasUncommittedDirty = staged !== '' || unstaged !== '' || untracked !== '';
       if (hasUncommittedDirty) {
+        // ql-20260915-001 修复①：4.5b 已合并写回并暂存的 mismatch 文件不出现在此脏清单——它们
+        // 是本次 apply 自己的产物（非他者无关脏文件），列进「无关未提交文件」警告会误导。
+        // 对 overlapDirty 无影响（合并文件已从 changedFiles 剔除，交集恒空）；集合空时为恒等过滤。
+        const mergedMisSet45 = new Set(result.mergedMismatchFiles || [])
         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');
+        )].filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json' && !mergedMisSet45.has(f));
         const overlapDirty = dirtyFiles.filter(f => changedFiles.includes(f));
         if (overlapDirty.length > 0) {
           // 自动三方合并（坑 apply-dirty-block-no-merge，2026-09-10 驾驭小结第六批③）：先对
@@ -1068,6 +1607,13 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
               const m3 = mergeDirtyOverlapThreeWay({ projectRoot, worktreePath, baseHash: deliverableBase }, overlapDirty);
               if (m3.merged.length > 0) {
                 result.mergedDirtyFiles = (result.mergedDirtyFiles || []).concat(m3.merged);
+                if (m3.stagedOk === false) {
+                  // 批末 git add fail-open 留痕（task-01 / FR-01）：写回成功但未暂存——result 面
+                  // 可见（console.warn 已在 mergeDirtyOverlapThreeWay 内打），提示人工补 add。
+                  result.warnings = (result.warnings || []).concat([
+                    `EXCLUDE-DIRTY 三方合并 ${m3.merged.length} 个文件已写回主仓，但批末 git add 暂存失败（未暂存对 git restore / git clean 不免疫）——请尽快人工 git add -- <该批文件> 锁定`
+                  ]);
+                }
                 const mergedSet = new Set(m3.merged);
                 changedFiles = changedFiles.filter(f => !mergedSet.has(f));
                 result.changedFiles = changedFiles;
@@ -1131,11 +1677,15 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
         } else {
           // 无关脏文件放行（只校验重叠文件）：--3way 若因 autocrlf 报 does not match index 会被
           // step7 catch 回滚（交集空前提下无损，见上注释），stash 后重试即可——不再硬挡 rescue 手动路径
-          result.warnings = (result.warnings || []).concat([
-            `主工作区有 ${dirtyFiles.length} 个与本次 apply 无关的未提交文件，已放行（只校验重叠文件）：` +
-            `${dirtyFiles.slice(0, 5).join(', ')}${dirtyFiles.length > 5 ? ' 等' : ''}` +
-            `——若 apply --3way 因 CRLF/autocrlf 报 does not match index，可 git stash 后重试`
-          ]);
+          // （ql-20260915-001 修复①：dirtyFiles 已剔除本次合并写回面，剔除后为空 = 探针命中的
+          // 全是本 apply 自身 staged 产物——不打「0 个无关文件」的空警告）
+          if (dirtyFiles.length > 0) {
+            result.warnings = (result.warnings || []).concat([
+              `主工作区有 ${dirtyFiles.length} 个与本次 apply 无关的未提交文件，已放行（只校验重叠文件）：` +
+              `${dirtyFiles.slice(0, 5).join(', ')}${dirtyFiles.length > 5 ? ' 等' : ''}` +
+              `——若 apply --3way 因 CRLF/autocrlf 报 does not match index，可 git stash 后重试`
+            ])
+          }
         }
       }
     }
@@ -1259,6 +1809,26 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
       if (patchContent.length === 0) {
         // patch 为空（清单中部分文件可能没实际变更）
         result.ok = true;
+        // apply-manifest（task-01 出口③变体）：4.5 三方合并全部消解重叠时，merge 写回面是
+        // 本出口唯一落盘面——manifest 仍须覆盖（写回批末 add 已先行，指纹取 staged 态）。
+        // ql-20260915-001 修复①：4.5b mismatch 前置合并同样可能消解全部 changedFiles（本出口
+        // 另一来源），合并面并入 manifest files。
+        const emptyPatchManifestFace = [...(result.mergedDirtyFiles || []), ...(result.mergedMismatchFiles || [])]
+        if (emptyPatchManifestFace.length > 0) {
+          try {
+            const mf = writeApplyManifest({
+              projectRoot, specBase: allowSpecBase, changeName,
+              baseHash: deliverableBase, files: emptyPatchManifestFace,
+            });
+            if (mf && mf.written) result.applyManifest = mf.file;
+          } catch (e) {
+            result.warnings = (result.warnings || []).concat([
+              `apply-manifest.json 写入失败（不影响 apply 结果；doctor 漂移检测将按无 manifest 跳过）: ${(e.message || '').split('\n')[0]}`
+            ]);
+          }
+        }
+        // 坑 mixed-baseline-drift-hint（ql-20260915-004）：三方合并消解型成功出口的混合基线提示
+        annotateCommittedDrift(result, { projectRoot, baseHash: deliverableBase, files: emptyPatchManifestFace });
         rmSync(tmpDir, { recursive: true, force: true });
         return result;
       }
@@ -1309,12 +1879,43 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
 
       result.ok = true;
 
+      // --- 7.2 apply 成功尾声写 apply-manifest.json（task-01 / FR-02 / D-001@v1 后半）---
+      // 三条成功出口之一（patch 主路径；含 4.5 三方合并写回后主流程继续至此的出口③）。指纹
+      // 口径 = staged blob（git show :<path> 的 LF 规范态——apply --3way 隐含 --index 已暂存，
+      // merge 写回批末 add 亦已先行）→ 与 doctor 漂移检测的 staged 态比对天然同基。files 面 =
+      // patch 实际落盘集 ∪ 4.5 三方合并写回集（mergeDirtyFiles 已从 changedFiles 剔除，须并回）；
+      // apply 删除的文件 staged/磁盘皆无，函数内自然跳过。fail-open：写失败不阻断 apply
+      // （warning 留痕）。已存在则覆盖（重放 apply 以最新为准）。锁内（调用方 withMainRepoLock）。
+      // manifestFace 提升到 try 外（坑 mixed-baseline-drift-hint ql-20260915-004：drift 提示
+      // 在 manifest 写点后消费同面，try 内 const 出块即失域）
+      const manifestFace = [...new Set([...patchFiles, ...(result.mergedDirtyFiles || []), ...(result.mergedMismatchFiles || [])])];
+      try {
+        // ql-20260915-001 修复①：mergedMismatchFiles（4.5b 前置合并写回面）与 mergedDirtyFiles
+        // 同为 staged 落盘集，一并进 manifest 指纹面与提交复用 pathspec（缺列 = doctor 漂移检测
+        // 盲区 + agent 按 pathspec 提交漏文件）
+        const mf = writeApplyManifest({
+          projectRoot, specBase: allowSpecBase, changeName,
+          baseHash: deliverableBase, files: manifestFace,
+        });
+        if (mf && mf.written) result.applyManifest = mf.file;
+      } catch (e) {
+        result.warnings = (result.warnings || []).concat([
+          `apply-manifest.json 写入失败（不影响 apply 结果；doctor 漂移检测将按无 manifest 跳过）: ${(e.message || '').split('\n')[0]}`
+        ]);
+      }
+
+      // 坑 mixed-baseline-drift-hint（ql-20260915-004）：patch 主路径成功出口的混合基线提示
+      //（自身交付 staged 未提交 → baseHash..HEAD 即纯他者推进面，精确/变体命中均为真信号）
+      annotateCommittedDrift(result, { projectRoot, baseHash: deliverableBase, files: manifestFace });
+
       // --- 7.5 提交复用 pathspec（坑 apply-commit-pathspec-sweep，2026-08-21 实证）---
       // apply 后主仓常混有无关未提交文件（他者会话/并行 quick），agent 习惯 `git add <目录>/`
       // 会把无关文件扫进暂存需手工剔除。落盘本变更精确 pathspec 供提交直接复用：
       // 文件 + result 字段（CLI 输出可照抄 git add -- … / 长清单用 --pathspec-from-file）。
       try {
-        const commitFiles = [...new Set(patchFiles)].sort().filter(Boolean);
+        // ql-20260915-001 修复①：提交复用 pathspec 补并两个三方合并写回面（均为 staged 落盘、
+        // 属本变更交付——缺列时 agent 按此 pathspec 提交会漏掉合并成果）
+        const commitFiles = [...new Set([...patchFiles, ...(result.mergedDirtyFiles || []), ...(result.mergedMismatchFiles || [])])].sort().filter(Boolean);
         result.commitPathspec = commitFiles;
         const runtimeRoot = join(projectRoot, '.sillyspec', '.runtime');
         mkdirSync(runtimeRoot, { recursive: true });
@@ -1361,7 +1962,7 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
         );
         try {
           // keepConflicts:false——自动降级路径无人善后冲突状态，维持 abort 回滚干净态
-          return applyByMerge(result, changeName, projectRoot, wm, { keepConflicts: false });
+          return applyByMerge(result, changeName, projectRoot, wm, { keepConflicts: false, specBase: allowSpecBase });
         } catch (mergeErr) {
           result.errors.push(`ENOBUFS 降级 merge 也失败: ${mergeErr.message}`);
           return result;
@@ -1715,8 +2316,11 @@ function preAlignBaselineToMain({ meta, branch, projectRoot, result }) {
 //     git add + git commit；或 git merge --abort 放弃）。worktree/分支/meta 本就保留。
 //   false（ENOBUFS 自动降级路径，默认）→ 维持 abort——自动降级无人善后冲突状态，回滚到
 //     干净态让用户显式重来更安全。
+// opts.specBase（task-01，2026-09-14-apply-conflict-hardening）：applyWorktree 调用方透传的
+//   spec 基准目录（平台模式 ctx.platformOpts.specRoot），成功尾声 writeApplyManifest 用；缺省
+//   时函数内同链回退（指针 specRoot > 本地 .sillyspec）——外部直接调用零必填。
 export function applyByMerge(result, changeName, projectRoot, wm, opts = {}) {
-  const { keepConflicts = false } = opts;
+  const { keepConflicts = false, specBase } = opts;
   const meta = wm.getMeta(changeName);
   const changedFiles = result.changedFiles || [];
   // 用 meta.branch（native-worktree 模式分支名可能不是 sillyspec/<change>），不硬编码。
@@ -1729,6 +2333,10 @@ export function applyByMerge(result, changeName, projectRoot, wm, opts = {}) {
   // 它跳过 dirty 文件（不覆盖 WIP）且只提交对齐集；WIP commit 在后，两者不混提交 ---
   autoCommitWorktreeWip({ meta, result, changeName });
 
+  // 坑 mixed-baseline-drift-hint（ql-20260915-004）：merge 前 HEAD = 纯他者推进面锚点——
+  // merge 提交后 HEAD 含自身交付，drift 检测须以 preMergeHead 为推进面终点（防自污染误报）
+  const preMergeHead = gitQuiet(projectRoot, ['rev-parse', 'HEAD']);
+
   try {
     git(projectRoot, ['merge', '--no-ff', branch], { timeout: 30000 });
   } catch (e) {
@@ -1793,6 +2401,32 @@ export function applyByMerge(result, changeName, projectRoot, wm, opts = {}) {
   }
 
   result.ok = true;
+  // apply 成功尾声写 apply-manifest.json（task-01 出口②：applyWorktree 显式 --merge 与
+  // ENOBUFS 自动降级两条提前 return 入口共用本成功出口）。merge 已 commit → staged 态 =
+  // HEAD = 合并内容，指纹口径（git show :<path> LF 规范态）与 patch 路径同基；files 面 =
+  // changedFiles（落地校验过的交付集）∪ mergedDirtyFiles（ENOBUFS 路径下 4.5 可能已写回）
+  // ∪ mergedMismatchFiles（ql-20260915-001 修复①：4.5b 前置合并写回面，同口径并入），
+  // merge 删除面 staged/磁盘皆无、函数内自然跳过。fail-open：写失败不阻断 merge（warning 留痕）。
+  // manifestFace 提升到 try 外（坑 mixed-baseline-drift-hint ql-20260915-004：drift 提示在
+  // manifest 写点后消费同面，try 内 const 出块即失域）
+  const manifestFace = [...new Set([...(result.changedFiles || []), ...(result.mergedDirtyFiles || []), ...(result.mergedMismatchFiles || [])])];
+  try {
+    const mf = writeApplyManifest({
+      projectRoot, specBase, changeName,
+      baseHash: meta.baselineCommit || meta.baseHash, files: manifestFace,
+    });
+    if (mf && mf.written) result.applyManifest = mf.file;
+  } catch (e) {
+    result.warnings = (result.warnings || []).concat([
+      `apply-manifest.json 写入失败（不影响 merge 结果；doctor 漂移检测将按无 manifest 跳过）: ${(e.message || '').split('\n')[0]}`
+    ]);
+  }
+  // 坑 mixed-baseline-drift-hint（ql-20260915-004）：merge 成功出口的混合基线提示（推进面
+  // 终点 = preMergeHead，剥离本 merge 自身交付，保精确命中为真信号）
+  annotateCommittedDrift(result, {
+    projectRoot, baseHash: meta.baselineCommit || meta.baseHash,
+    files: manifestFace, head: preMergeHead || 'HEAD',
+  });
   try { result.mergeSummary = git(projectRoot, ['log', '--oneline', '-1']); } catch {}
   try {
     consumeCleanupResult(wm.cleanup(changeName, { force: true }), result);
@@ -1880,6 +2514,9 @@ export function assessApplyRisk(changeName, { cwd } = {}) {
   );
   // review.json 声明偏差文件（坑 apply-undeclared-deviation-block）：与顺带修复同等待遇——
   // reviewer 声明（已过 git 证据校验）的执行期偏差豁免 allowed_paths 严格校验，降 warning 注明来源。
+  // D-003@v1（task-03）后本豁免仅作用于 Gate2 的 allowed_paths 归属道——allow 面（design∪task
+  // 清单∪linked）之外的外来声明已在 Gate1（applyWorktree 3b 相交过滤）被剔除拦截，assess 整体
+  // 判定以 Gate1 收集的 errors 为准（BLOCKED）；两道口径不再重叠放行。
   const reviewDeclaredSet = new Set(collectReviewDeclaredFiles(projectRoot, changeName, { runtimeRoot: join(assessSpecBase, '.runtime') }).get('main') || []);
 
   // 检查 2: 变更在 allowed_paths 内（仅在 TaskCard 存在时）；顺带修复/review 声明文件豁免。