sillyspec 3.27.12 → 3.28.0

package/src/spec-sync.js

@@ -16,7 +16,7 @@
  */
 
 import { createHash } from 'crypto';
-import { existsSync, readdirSync, readFileSync, statSync, mkdirSync, writeFileSync } from 'fs';
+import { existsSync, readdirSync, readFileSync, statSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
 import { join, relative, sep } from 'path';
 
 // 与 sillyhub-daemon/src/spec-sync.ts 共用排除口径（task-07 / FR-06 / D-008@v2）：
@@ -323,6 +323,123 @@ function writeLastSyncTs(specRoot) {
   } catch { /* 标记失败只损失下次的防回推过滤，不影响本次同步结果 */ }
 }
 
+// 本地内容基线快照（坑 quicksync-conflict-granularity，2026-09-03 实证）：
+// 上次成功同步时刻的**本地文件 hash 全集**。「本地未改动」的内容级判据——
+// filterStaleUpdates 的 mtime 启发式会被 git 操作（pull/checkout/归档重写）刷新
+// mtime 击穿（本地 164 个旧归档全部伪装成「刚改过」，重试路径把陈旧副本静默
+// 推上服务器=回退）。hash 基线免疫 mtime 刷新：内容没变就是没改，服务器前进
+// 属正常多端演进 → 跟随服务器（不发 op、冲突时自动消解），只有内容真变了的
+// 文件才进冲突人工裁决。语义锚定「local at last sync」而非「server at last sync」：
+// 判据只回答「本地是否改过」，与服务器无关（bundle 拉回的新内容与快照不同 →
+// 视为本地改动照推，服务器同内容豁免兜底，无副作用）。
+const BASE_SNAPSHOT = 'spec-sync-base.json';
+
+function readBaseSnapshot(specRoot) {
+  try {
+    const raw = readFileSync(join(specRoot, '.runtime', BASE_SNAPSHOT), 'utf8');
+    const hashes = JSON.parse(raw).hashes;
+    return hashes && typeof hashes === 'object' ? hashes : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeBaseSnapshot(specRoot, localFiles) {
+  try {
+    const hashes = {};
+    for (const f of localFiles) hashes[f.path] = f.hash;
+    mkdirSync(join(specRoot, '.runtime'), { recursive: true });
+    writeFileSync(join(specRoot, '.runtime', BASE_SNAPSHOT), JSON.stringify({ ts: Date.now(), hashes }, null, 2) + '\n', 'utf8');
+  } catch { /* 快照失败只损失下次的内容级防回推，不影响本次同步结果 */ }
+}
+
+/**
+ * 丢弃「跟随服务器」型 update op（坑 quicksync-conflict-granularity ①）。
+ *
+ * 判据：本地文件 hash 与基线快照一致 = 自上次同步内容未变——此刻与服务器 hash
+ * 不同只可能是他端会话推进了服务器，本地是陈旧副本，推送即回退（spec-sync-
+ * parallel-stale-overwrite 同族，但 mtime 免疫）。与 filterStaleUpdates 互补：
+ * 快照覆盖内容级判定，mtime 兜底快照缺失（首次同步/快照损坏）的过渡期。
+ * 快照无该路径（新文件/过渡期）→ 保留 op 维持旧行为。
+ *
+ * @param {Array} ops computeSpecOps 产物
+ * @param {Array} localFiles hashFiles 产物
+ * @param {object|null} baseHashes 基线快照 { [path]: hash }；null → 不过滤
+ * @returns {{ ops: Array, followed: string[] }}
+ */
+export function dropFollowServerUpdates(ops, localFiles, baseHashes) {
+  if (!baseHashes || !Array.isArray(ops) || ops.length === 0) {
+    return { ops, followed: [] };
+  }
+  const hashByPath = new Map(localFiles.map((f) => [f.path, f.hash]));
+  const followed = [];
+  const kept = [];
+  for (const op of ops) {
+    if (op.op === 'update') {
+      const base = baseHashes[op.path];
+      const loc = hashByPath.get(op.path);
+      if (base !== undefined && loc !== undefined && base === loc) {
+        followed.push(op.path);
+        continue;
+      }
+    }
+    kept.push(op);
+  }
+  return { ops: kept, followed };
+}
+
+/**
+ * 冲突路径分流（坑 quicksync-conflict-granularity ②）：服务器 conflict 回告的路径里，
+ * 区分「本地未改动 → 自动跟随服务器」与「本地真改动 → 需人工裁决」。
+ * follower 判据 = 内容基线命中（hash 级）或 mtime 兜底（filterStaleUpdates 同款）。
+ * @returns {{ followers: string[], real: object }} real = { [path]: server_version }
+ */
+export function partitionConflictPaths(serverVersions, localFiles, baseHashes, lastSyncTs) {
+  const hashByPath = new Map(localFiles.map((f) => [f.path, f.hash]));
+  const mtimeByPath = new Map(localFiles.map((f) => [f.path, f.mtime]));
+  const followers = [];
+  const real = {};
+  for (const [path, version] of Object.entries(serverVersions || {})) {
+    const base = baseHashes?.[path];
+    const loc = hashByPath.get(path);
+    const mtime = mtimeByPath.get(path);
+    const contentUnchanged = base !== undefined && loc !== undefined && base === loc;
+    const mtimeStale = mtime !== undefined && lastSyncTs && mtime * 1000 + 1000 <= lastSyncTs;
+    if (contentUnchanged || mtimeStale) followers.push(path);
+    else real[path] = version;
+  }
+  return { followers, real };
+}
+
+/**
+ * 未决 spec 树冲突同集判定（坑 spec-sync-conflict-banner-spam）：读 .runtime 下该变更的
+ * 冲突文件，conflicting_paths 与本轮真冲突集完全一致 → 重复轮次（横幅单行降噪依据）。
+ * 文件缺失/损坏/集合增减 → false（按首报或集变化处理，全幅横幅+重写文件）。
+ */
+function isSamePendingSpecConflict(specRoot, changeName, realPaths) {
+  try {
+    const raw = readFileSync(join(specRoot, '.runtime', `spec-sync-conflict-${changeName}.json`), 'utf8');
+    const prev = JSON.parse(raw).conflicting_paths;
+    if (!Array.isArray(prev) || prev.length !== realPaths.length) return false;
+    const prevSet = new Set(prev);
+    return realPaths.every((p) => prevSet.has(p));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 清残留未决冲突标记（坑 spec-sync-conflict-banner-spam）：本轮同步无冲突 = 此前的
+ * spec 树冲突已不存在（对端停推后 last-writer-wins 收敛/本地覆盖成功），残留文件会让
+ * status 永久红标、每轮横幅去重单行提示不消。best-effort，失败只影响下一轮横幅形态。
+ */
+function clearSpecConflictMarker(specRoot, changeName) {
+  try {
+    const p = join(specRoot, '.runtime', `spec-sync-conflict-${changeName}.json`);
+    if (existsSync(p)) unlinkSync(p);
+  } catch { /* 清理失败不影响同步结果 */ }
+}
+
 /**
  * 同步本地 .sillyspec 树到平台（CLI 直跑增量同步入口）。
  *
@@ -369,15 +486,29 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
   const localFiles = hashFiles(entries);
   let ops = computeSpecOps(serverManifest, localFiles);
 
-  // 旧副本回推防护（并行会话一致性）：上次同步后本地从未改动的文件不回推覆盖服务器新内容
+  // 旧副本回推防护（并行会话一致性）：上次同步后本地从未改动的文件不回推覆盖服务器新内容。
+  // 双层判据（坑 quicksync-conflict-granularity）：内容基线快照（hash 级，免疫 git 操作刷新
+  // mtime——pull/checkout/归档重写后的旧文件内容未变即「未改动」）为主，mtime 启发式兜底
+  // 快照缺失的过渡期/新文件。forcePush（resolve --keep-local 强制重推）全旁路——用户显式
+  // 裁决「以本地为准」时本地意志高于跟随服务器语义，不得被防回推削掉。
   const lastSyncTs = readLastSyncTs(specRoot);
-  const filtered = filterStaleUpdates(ops, localFiles, lastSyncTs);
-  if (filtered.stale.length > 0) {
-    console.warn(
-      `[spec-sync] 拦下 ${filtered.stale.length} 个旧副本回推（本地自上次同步未改动而服务器已前进，如确需以本地为准：重存后重推）: ${filtered.stale.slice(0, 5).join(', ')}${filtered.stale.length > 5 ? ' 等' : ''}`
-    );
+  const baseHashes = readBaseSnapshot(specRoot);
+  if (!opts.forcePush) {
+    const dropped = dropFollowServerUpdates(ops, localFiles, baseHashes);
+    if (dropped.followed.length > 0) {
+      console.log(
+        `[spec-sync] ${dropped.followed.length} 个本地未改动文件自动跟随服务器（他端推进，内容未变不回推）: ${dropped.followed.slice(0, 5).join(', ')}${dropped.followed.length > 5 ? ' 等' : ''}`
+      );
+    }
+    ops = dropped.ops;
+    const filtered = filterStaleUpdates(ops, localFiles, lastSyncTs);
+    if (filtered.stale.length > 0) {
+      console.warn(
+        `[spec-sync] 拦下 ${filtered.stale.length} 个旧副本回推（本地自上次同步未改动而服务器已前进，如确需以本地为准：重存后重推）: ${filtered.stale.slice(0, 5).join(', ')}${filtered.stale.length > 5 ? ' 等' : ''}`
+      );
+    }
+    ops = filtered.ops;
   }
-  ops = filtered.ops;
 
   if (ops.length === 0) {
     debugLog(`[spec-sync] 无差异，跳过同步: ${changeName}`);
@@ -404,7 +535,43 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       // HUB-08 冲突闭环：落 spec-sync-conflict-<change>.json（与进度 sync-conflict-* 同目录），
       // 供 platform status 列出 + platform resolve 三态处置。此前只 warn 返回，下次 sync 用
       // 同一 base_version 继续冲突循环，无人工裁决入口。
+      //
+      // 坑 quicksync-conflict-granularity（2026-09-03 实证 164 个旧归档整树冲突）：GET 清单
+      // → 全树 hash → POST 的竞态窗内他端推进，base_version 过期引发大规模「假冲突」——
+      // 这些文件本地根本没改（与本次 quick 零交集），却把冲突文件坐实、后续自动同步进
+      // resolve 流程。冲突粒度收窄：follower（本地未改动，内容基线/mtime 判定）自动跟随
+      // 服务器、不进冲突文件；服务器「冲突 op 跳过、其余照常 apply」语义下本会话真改动
+      // 已落——follower 清空即视为本轮同步成功（写基线，下次起 pre-POST 即拦）。
       const serverVersions = body.server_versions || {};
+      const { followers, real } = opts.forcePush
+        ? { followers: [], real: serverVersions }
+        : partitionConflictPaths(serverVersions, localFiles, baseHashes, lastSyncTs);
+      const realPaths = Object.keys(real);
+
+      // 冲突横幅降噪（坑 spec-sync-conflict-banner-spam，与 sync() 进度侧 2026-08-23 修法同族）：
+      // 未决 spec 树冲突存在期间，每步自动同步都会对同一批真冲突路径再撞一次——此前每轮
+      // 重写冲突文件 + 空行+全幅双线横幅（含整包 server_versions JSON dump），「已卡死不会
+      // 自愈」连环刷屏。冲突文件在且冲突集未变 = 用户已被告知：重复轮次单行提示（可见但不
+      // 吓人），不重写文件（created_at 稳定，status 红标语义不变）；冲突集变化才重写+全幅。
+      // forcePush（resolve --keep-local 刚裁决完重推）不参与去重——需真实判定与文件刷新。
+      const pendingSame = !opts.forcePush && realPaths.length > 0 && isSamePendingSpecConflict(specRoot, changeName, realPaths);
+      if (pendingSame) {
+        if (followers.length > 0) {
+          debugLog(`[spec-sync] ${followers.length} 个本地未改动文件自动跟随服务器: ${followers.slice(0, 5).join(', ')}${followers.length > 5 ? ' 等' : ''}`);
+        }
+        console.warn(`⚠️ [spec-sync] 变更 ${changeName} 存在未决 spec 树冲突（${realPaths.length} 个文件待裁决，本轮非冲突改动已照常同步）。处理：sillyspec platform resolve ${changeName} --keep-local | --take-platform | --abort`);
+        return { synced: 0, conflict: true, serverVersions: real, autoResolved: followers.length, conflictPath: join(specRoot, '.runtime', `spec-sync-conflict-${changeName}.json`), suppressed: true };
+      }
+      if (followers.length > 0) {
+        console.warn(`[spec-sync] ${followers.length} 个本地未改动文件自动跟随服务器（正常多端前进，无需人工裁决）: ${followers.slice(0, 5).join(', ')}${followers.length > 5 ? ' 等' : ''}`);
+      }
+      if (realPaths.length === 0) {
+        writeLastSyncTs(specRoot);
+        writeBaseSnapshot(specRoot, localFiles);
+        clearSpecConflictMarker(specRoot, changeName);
+        console.log(`[spec-sync] 冲突已自动消解（0 个需人工裁决；本会话改动 ${ops.length - followers.length > 0 ? '已同步' : '无差异'}）: ${changeName}`);
+        return { synced: Math.max(ops.length - followers.length, 0), conflict: false, autoResolved: followers.length };
+      }
       let conflictPath = null;
       try {
         const runtimeDir = join(specRoot, '.runtime');
@@ -414,20 +581,28 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
           change: changeName,
           kind: 'spec-tree',
           created_at: new Date().toISOString(),
-          server_versions: serverVersions,
-          conflicting_paths: Object.keys(serverVersions),
-          note: 'spec 树文件冲突（服务器版本领先于本地 diff 基线）。resolve --keep-local 以本地为准重推；--take-platform 暂不支持（平台无文件下载端点）',
+          server_versions: real,
+          conflicting_paths: realPaths,
+          auto_followed: followers,
+          note: 'spec 树文件冲突（仅列本地真改动文件；本地未改动文件已自动跟随服务器）。resolve --keep-local 以本地为准重推；--take-platform 拉平台 bundle 覆盖冲突文件（接受服务器版本，2026-09-03 起支持）',
         }, null, 2) + '\n', 'utf8');
       } catch (e) {
         console.warn(`[spec-sync] 冲突文件写入失败（冲突信息仅打印）: ${e.message}`);
       }
+      // 横幅只列前 5 个路径（截断防刷屏，坑 spec-sync-conflict-banner-spam）：逐文件服务器
+      // 版本在冲突详情文件里，不再整包 JSON.stringify dump 到终端。
+      const shownPaths = realPaths.slice(0, 5).join(', ') + (realPaths.length > 5 ? ' 等' : '');
       console.warn('');
-      console.warn(`⚠️ [spec-sync] 检测到 spec 树冲突（${Object.keys(serverVersions).length} 个文件，服务器版本: ${JSON.stringify(serverVersions)}）`);
-      console.warn(`⚠️ 处置：sillyspec platform resolve ${changeName} --keep-local | --abort（冲突详情: ${conflictPath || '(写入失败)'}）`);
-      return { synced: 0, conflict: true, serverVersions, conflictPath };
+      console.warn(`⚠️ [spec-sync] 检测到 spec 树冲突（${realPaths.length} 个文件: ${shownPaths}；逐文件服务器版本见冲突详情文件）`);
+      console.warn(`⚠️ 处置：sillyspec platform resolve ${changeName} --keep-local | --take-platform | --abort（冲突详情: ${conflictPath || '(写入失败)'}）`);
+      return { synced: 0, conflict: true, serverVersions: real, autoResolved: followers.length, conflictPath };
     }
     console.log(`[spec-sync] 已同步 ${ops.length} 个文件变更: ${changeName}`);
+    // 本轮无冲突 = 此前的未决 spec 树冲突已不存在，清残留标记（否则 status 永久红标、
+    // 横幅去重单行提示不消——坑 spec-sync-conflict-banner-spam）
+    clearSpecConflictMarker(specRoot, changeName);
     writeLastSyncTs(specRoot);
+    writeBaseSnapshot(specRoot, localFiles);
     return { synced: ops.length };
   } catch (err) {
     console.warn(`[spec-sync] 同步异常（文件树本次未同步，下次自动重试）: ${changeName}: ${err.message}`);
@@ -441,5 +616,7 @@ export default {
   computeSpecOps,
   extractChangeDirs,
   filterStaleUpdates,
+  dropFollowServerUpdates,
+  partitionConflictPaths,
   syncSpecTree,
 };

package/src/stages/execute.js

@@ -1064,7 +1064,7 @@ ${crossLines}${crossWorktreeSection}${crossLegacySection}
 
 **回收跨仓 task（head 锡点，CLI 自动落盘，勿手写）：**
 - 子代理完成 commit 后，正常写 review.json（verdict/notes）并勾选 checkbox 即可。execute \`--done\` 时 CLI 自动对跨仓仓（worktree 模式=该仓 worktree，legacy=仓根）\`git rev-parse HEAD\` 写入该 task 卡 \`head_commit:\`（幂等，已存在不覆盖——你若手写了精确锚点则以你的为准）。
-- review.json 的 mechanics 字段（\`base\`/\`head\`/\`changedFiles\`）无需手算：\`base\` 取 task 卡 \`base_commit\`、\`head\` 取 task 卡 \`head_commit\`，写完跑 \`sillyspec backfill-reviews --change <变更名> --adopt\` 一键代填（verdict 保留）。
+- review.json 的 mechanics 字段（\`base\`/\`head\`/\`changedFiles\`/\`diffPaths\`）无需手算：\`base\` 取 task 卡 \`base_commit\`、\`head\` 取 task 卡 \`head_commit\`，写完跑 \`sillyspec backfill-reviews --change <变更名> --adopt\` 一键代填（verdict 保留）。
 `
   }
 
@@ -1243,9 +1243,13 @@ task-XX 对应：{SPEC_ROOT}/.runtime/execute-runs/{EXECUTE_RUN_ID}/tasks/task-X
  "qualityVerdict": "pass|fail|cannot_verify", "reviewerNotes": "评审说明",
  "requiredEvidence": [] }
 
+**base/head 两种取法（按提交模式选其一）：**
+- **per-task commit 模式**（默认，子代理每 task 一提交）：base=本 task 开始前的 commit，head=本 task 的 commit——base..head 天然就是本 task 的 diff，无需 diffPaths。
+- **统一 commit 模式**（主代理统一实现/收尾一次性 commit，全部 task 一个提交）：base=基线 commit（worktree meta 的 baseHash），head=统一 commit，并**必填 \`diffPaths\`（本 task 卡的 allowed_paths 原样数组）**——评审与 CLI 校验的 diff 都是 \`git diff base..head -- diffPaths\` 的路径限定切片，任务边界由 diffPaths 机器可验，不再只靠 changedFiles 归属说明。changedFiles 填切片内实际改动的文件。
+
 **评审铁律：**
 - 不信任 implementer 自报结果，对照 diff 和 task brief 验证
-- 只看当前 task 的 diff，不做全仓库漫游审查
+- 只看当前 task 的 diff（统一 commit 模式=路径限定切片），不做全仓库漫游审查
 - \`cannot_verify\` 只在确实无法验证且有待补充证据时使用，且 requiredEvidence 必须非空
 - \`sillyspec run execute --done\` 会校验所有 task 的 review.json，缺失或 fail 会阻断完成
 

package/src/sync.js

@@ -9,6 +9,7 @@
  */
 
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, unlinkSync, chmodSync, rmSync } from 'fs';
+import { createHash } from 'crypto';
 import { writeAtomicSync } from './fs-atomic.js';
 import { join, dirname, basename, isAbsolute, relative } from 'path';
 import { resolvePlatformSpecDir } from './progress.js';
@@ -1545,6 +1546,97 @@ export class SyncManager {
     return { ok: true, pulled: true, specDir, specVersion };
   }
 
+  /**
+   * spec 树 take-platform 落地（坑 spec-sync-conflict-no-take-platform，2026-09-03 用户实证
+   * 「冲突没有接受服务器版本选项」）：拉平台整树 bundle（GET /changes/-/spec-bundle，与
+   * pullSpecBundle 同端点同鉴权），但**只覆盖冲突文件列出的路径**——不整树替换，本会话/
+   * 他端的其他本地改动不动。服务器已无该路径（远端删除）→ 删本地对应文件。
+   *
+   * 覆盖后同步刷新内容基线快照（spec-sync-base.json）中被覆盖路径的 hash：下次
+   * syncSpecTree 的 dropFollowServerUpdates 判「本地未改动」不再回推——take-platform =
+   * 服务器胜出，本地内容即服务器内容，回推同值无害但走基线豁免更干净。
+   *
+   * fail-closed：路径越界（../、绝对路径）逐条跳过计入 skipped 不中断其余；bundle 拉取/
+   * 解析失败整体 ok:false（本地不动）。
+   * @param {string} specDir spec 树根
+   * @param {string[]} paths 冲突路径（POSIX 相对 specDir，来自冲突文件 conflicting_paths）
+   * @returns {Promise<{ok: boolean, overwritten?: number, removed?: number, skipped?: string[], reason?: string}>}
+   */
+  async _takePlatformSpecPaths(specDir, paths) {
+    const platform = this._getPlatform();
+    if (!platform) return { ok: false, reason: '未连接平台（take-platform 需拉平台 bundle）' };
+    if (!Array.isArray(paths) || paths.length === 0) return { ok: false, reason: '冲突文件缺 conflicting_paths，无可接受路径' };
+
+    const bundleUrl = `${platform.url}/api/changes/-/spec-bundle`;
+    let res;
+    try {
+      res = await fetch(bundleUrl, {
+        headers: { Authorization: `Bearer ${platform.token}` },
+        // 大树/慢网同 pullSpecBundle 口径（审计 B2），不与外部熔断组合（resolve 是用户显式动作）
+        signal: AbortSignal.timeout(PULL_BUNDLE_TIMEOUT_MS),
+      });
+    } catch (err) {
+      const why = (err.name === 'AbortError' || err.name === 'TimeoutError') ? `下载超时/中断（${PULL_BUNDLE_TIMEOUT_MS / 1000}s 上限）` : err.message;
+      return { ok: false, reason: `拉取 spec bundle 失败: ${why}` };
+    }
+    if (!res.ok) {
+      const why = res.status === 404 ? '平台工作区尚无 spec 内容（HTTP 404）' : `HTTP ${res.status}`;
+      return { ok: false, reason: `拉取 spec bundle 失败: ${why}` };
+    }
+    let tarBuf;
+    try { tarBuf = Buffer.from(await res.arrayBuffer()); }
+    catch (err) { return { ok: false, reason: `读取 spec bundle 失败: ${err.message}` }; }
+    let entries;
+    try { entries = _parseSpecTar(tarBuf); }
+    catch (err) { return { ok: false, reason: `spec bundle 无效: ${err.message}` }; }
+
+    const serverFiles = new Map();
+    for (const e of entries) {
+      if (e.isDir || e.name === 'PLATFORM-BUNDLE.json') continue;
+      serverFiles.set(e.name.replace(/^\.\//, ''), e.data);
+    }
+
+    const normalized = [...new Set(paths.map((p) => String(p).replace(/\\/g, '/')).filter(Boolean))];
+    let overwritten = 0;
+    let removed = 0;
+    const skipped = [];
+    for (const p of normalized) {
+      try {
+        _assertSafeTarName(p, specDir);
+        const data = serverFiles.get(p);
+        if (data !== undefined) {
+          const full = join(specDir, p);
+          mkdirSync(dirname(full), { recursive: true });
+          writeFileSync(full, data);
+          overwritten++;
+        } else if (existsSync(join(specDir, p))) {
+          // 服务器已无该文件（远端删除）→ 接受服务器 = 删本地
+          rmSync(join(specDir, p), { force: true });
+          removed++;
+        }
+      } catch {
+        skipped.push(p);
+      }
+    }
+
+    // 基线快照刷新（best-effort）：被覆盖路径回写当前盘面 hash（= 服务器内容 hash）、被删
+    // 路径移除条目——下次同步这些路径按「本地未改动」豁免回推（take-platform 语义闭环）。
+    try {
+      const baseFile = join(specDir, '.runtime', 'spec-sync-base.json');
+      let base = null;
+      try { base = JSON.parse(readFileSync(baseFile, 'utf8')); } catch { base = null; }
+      const hashes = base && typeof base.hashes === 'object' ? base.hashes : {};
+      for (const p of normalized) {
+        try { hashes[p] = createHash('sha256').update(readFileSync(join(specDir, p))).digest('hex'); }
+        catch { delete hashes[p]; }
+      }
+      mkdirSync(join(specDir, '.runtime'), { recursive: true });
+      writeFileSync(baseFile, JSON.stringify({ ts: Date.now(), hashes }, null, 2) + '\n', 'utf8');
+    } catch { /* 快照失败只损失下次的防回推精度，覆盖结果本身已成立 */ }
+
+    return { ok: true, overwritten, removed, skipped };
+  }
+
   /**
    * 冲突解决三选一（task-13 / D-002 / D-010 / D-013 / FR-05）。
    * 读 task-12 写的 sync-conflict-<change>.json，按 mode 处理后必清冲突文件防累积（R-04 / constraints）。
@@ -1636,9 +1728,11 @@ export class SyncManager {
     let specOutcome = null;
     if (specCf && mode === 'keep-local') {
       // keep-local = 本地胜出：重新 GET 清单重定 base 后 POST 本地内容（last-writer-wins），
-      // 成功清冲突文件闭环；仍冲突（平台又有更新）保留文件待下次裁决
+      // 成功清冲突文件闭环；仍冲突（平台又有更新）保留文件待下次裁决。
+      // forcePush（坑 quicksync-conflict-granularity）：用户显式裁决后本地意志高于
+      // 「未改动跟随服务器」语义——强制重推不得被内容基线/mtime 防回推过滤削掉。
       try {
-        const r = await syncSpecTree(safePlatformSpecDir(this.cwd) || join(this.cwd, '.sillyspec'), this._getPlatform(), changeName);
+        const r = await syncSpecTree(safePlatformSpecDir(this.cwd) || join(this.cwd, '.sillyspec'), this._getPlatform(), changeName, { forcePush: true });
         if (!r.conflict) {
           this.clearSpecConflictFile(changeName);
           specOutcome = { ok: true, resolved: true, reason: 'spec 树已以本地为准重定基线重推，冲突闭环' };
@@ -1649,8 +1743,32 @@ export class SyncManager {
         specOutcome = { ok: false, resolved: false, reason: `spec 树重推异常: ${err.message}` };
       }
     } else if (specCf && mode === 'take-platform') {
-      // fail-closed：平台无文件下载端点，无法把服务器内容写回本地——明确报错指路，不清文件
-      specOutcome = { ok: false, resolved: false, reason: 'spec 树冲突不支持 take-platform（平台无文件下载端点，无法把服务器内容写回本地）：请手动对齐本地文件后跑 --keep-local' };
+      // spec 树 take-platform（坑 spec-sync-conflict-no-take-platform，2026-09-03 用户实证反馈
+      // 「冲突没有接受服务器版本选项」）：平台已有 CLI 可用的整树下载端点（GET /changes/-/
+      // spec-bundle，X2 task-08）——拉 bundle 只覆盖冲突文件列出的路径（不整树替换，本地其他
+      // 改动不动），基线快照同步刷新防回推，清冲突文件闭环。此前 fail-closed 报「平台无文件
+      // 下载端点」是端点落地前的旧事实。
+      try {
+        const specDir = safePlatformSpecDir(this.cwd) || join(this.cwd, '.sillyspec');
+        const paths = Array.isArray(specCf.conflicting_paths) && specCf.conflicting_paths.length > 0
+          ? specCf.conflicting_paths
+          : Object.keys(specCf.server_versions || {});
+        const r = await this._takePlatformSpecPaths(specDir, paths);
+        if (r.ok) {
+          this.clearSpecConflictFile(changeName);
+          const skippedNote = r.skipped && r.skipped.length > 0
+            ? `，${r.skipped.length} 个路径异常跳过（${r.skipped.slice(0, 3).join(', ')}${r.skipped.length > 3 ? ' 等' : ''}）`
+            : '';
+          specOutcome = {
+            ok: true, resolved: true,
+            reason: `spec 树已接受服务器版本：覆盖 ${r.overwritten} 个冲突文件${r.removed > 0 ? `、删除 ${r.removed} 个（服务器已删）` : ''}${skippedNote}，本地改动已放弃`,
+          };
+        } else {
+          specOutcome = { ok: false, resolved: false, reason: `spec 树 take-platform 失败: ${r.reason}（可重试；或手动对齐本地文件后 --keep-local）` };
+        }
+      } catch (err) {
+        specOutcome = { ok: false, resolved: false, reason: `spec 树 take-platform 异常: ${err.message}` };
+      }
     }
 
     // ── abort：两类标记一并清（本地 DB 与文件均不变，下次 push/pull 重新检测）──

package/src/task-review.js

@@ -244,6 +244,19 @@ export function validateReviewSchema(review) {
     errors.push('缺少 head 字段（git commit hash）')
   }
 
+  // diffPaths（可选，统一 commit 模式）：路径限定评审范围。主代理统一 commit（全部 task 一个
+  // commit）下 per-task 提交区间不存在，base..head 只能取整变更区间——diffPaths=本 task 的
+  // allowed_paths，评审/校验 diff 收窄为 git diff base..head -- diffPaths 的路径限定切片
+  // （坑 task-review-unified-commit-scope，2026-09-01 实证：此前任务边界只靠 changedFiles
+  // 「归属说明」，gate 无法机器验证本 task 切片非空）。缺省=不过滤（per-task commit 模式
+  // base..head 本就是任务区间，行为零变化）。
+  if (review.diffPaths !== undefined) {
+    if (!Array.isArray(review.diffPaths) || review.diffPaths.length === 0
+        || !review.diffPaths.every(p => typeof p === 'string' && p.trim())) {
+      errors.push('diffPaths（若提供）应为非空字符串数组（路径限定评审范围，统一 commit 模式填本 task 的 allowed_paths；per-task commit 模式无需此字段）')
+    }
+  }
+
   return { ok: errors.length === 0, errors }
 }
 
@@ -499,7 +512,10 @@ export function validateTaskReviews(opts) {
             errors.push(`${taskId}: 纯验证 task（task_type: verification）零 diff 合法，但 review 缺 requiredEvidence（须披露验证区间/命令/结论出处）——声明不能替代披露`)
           }
         } else {
-          errors.push(`${taskId}: base..head（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}）无任何代码变更 — 评审了一个零改动的任务，review 疑似伪造`)
+          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}`)
           continue
         }
       }
@@ -590,6 +606,8 @@ function parsePorcelainFiles(statusOut) {
  *   1. base/head 必须是仓库中可解析的真实 commit
  *   2. base..head 的 diff 不能为空（评审一个零改动的"任务"无意义）
  *   3. review.changedFiles（如提供）必须与实际 diff 文件有交集
+ * 带 diffPaths（统一 commit 模式）时 2/3 在 `base..head -- diffPaths` 的路径限定切片上跑
+ * （坑 task-review-unified-commit-scope）：整变更区间下机器可验「本 task 切片非空」。
  *
  * git 环境不可用（非 git 仓库 / git 缺失）时返回 unavailable，由调用方降级为
  * warning——不因环境问题误杀，但记录在输出中。
@@ -694,9 +712,23 @@ export function verifyReviewGitEvidence(review, gitDir, cache = null) {
   } catch {}
   diffFiles = [...new Set(diffFiles)].filter(Boolean)
 
+  // ── diffPaths 路径限定切片（坑 task-review-unified-commit-scope，2026-09-01 实证）──
+  // 主代理统一 commit（全部 task 一个 commit）下 per-task 提交区间不存在，10 个 task 的
+  // review 只能共用同一对 base..head（整变更区间）——任务边界此前只靠 changedFiles「归属
+  // 说明」，本函数无法机器验证「本 task 的切片非空」。diffPaths（=task 的 allowed_paths）
+  // 把 emptyDiff/交叉比对收窄到切片：统一 commit 模式成为一等公民（per-task commit 模式
+  // 不填 diffPaths，行为零变化）。切片在 commit diff ∪ working-tree 并集之后过滤（与
+  // 归属口径同源：generateTaskReviewDrafts 的 allowed_paths 过滤用 pathMatches）。
+  const scopePaths = Array.isArray(review.diffPaths) && review.diffPaths.length > 0
+    ? review.diffPaths.filter(p => typeof p === 'string' && p.trim())
+    : null
+  const scopeNote = scopePaths ? `，diffPaths 切片 ${scopePaths.length} 路径` : ''
+  if (scopePaths) diffFiles = diffFiles.filter(f => scopePaths.some(p => pathMatches(f, p)))
+
   const emptyDiff = diffFiles.length === 0
 
-  // changedFiles 交叉比对：完全不相交 = review 描述的改动与实际 diff 无关（diffFiles 已含 working-tree）
+  // changedFiles 交叉比对：完全不相交 = review 描述的改动与实际 diff 无关（diffFiles 已含 working-tree，
+  // 有 diffPaths 时已收窄为路径限定切片）
   if (!emptyDiff && Array.isArray(review.changedFiles) && review.changedFiles.length > 0) {
     // 注记剥离（坑 changedfiles-annotation-suffix-mismatch，2026-08-22 实证：changedFiles 带
     // 「src/a.js（新增）」类注记后缀被判完全不相交，agent 用正则修还贪婪吞了路径段两轮才对）。
@@ -715,8 +747,9 @@ export function verifyReviewGitEvidence(review, gitDir, cache = null) {
       return diffSet.has(nf) || diffFiles.some(d => d.endsWith(nf) || nf.endsWith(d))
     })
     if (!hasOverlap) {
-      errors.push(`changedFiles 与实际 git diff（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}，${diffFiles.length} 个文件）完全不相交 — review 内容与代码变更无关。` +
-        `检查：changedFiles 必须是纯文件路径（注记/说明写 reviewerNotes，不拼进路径数组）；路径拼写与 diff 对照`)
+      errors.push(`changedFiles 与实际 git diff（${review.base.slice(0, 8)}..${review.head.slice(0, 8)}${scopeNote}，${diffFiles.length} 个文件）完全不相交 — review 内容与代码变更无关。` +
+        `检查：changedFiles 必须是纯文件路径（注记/说明写 reviewerNotes，不拼进路径数组）；路径拼写与 diff 对照` +
+        (scopePaths ? `；diffPaths 是否覆盖了 changedFiles 所在路径（切片按 diffPaths 过滤）` : ''))
     }
   }
 
@@ -1218,6 +1251,11 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
       base: taskBase,
       head: taskHead,
       changedFiles: taskChangedFiles,
+      // 统一 commit 模式（坑 task-review-unified-commit-scope）：base..head 是整变更区间时，
+      // diffPaths 把证据校验切片收窄到本 task 的 allowed_paths。仅在有归属切片时带
+      // （无归属草稿 changedFiles 为空，带 diffPaths 会让切片空 → emptyDiff 误判伪造，
+      // 与「留给 agent 复核升级」的草稿语义冲突）。
+      ...(allowedPaths.length > 0 ? { diffPaths: allowedPaths } : {}),
       specVerdict: 'cannot_verify',
       qualityVerdict: 'cannot_verify',
       requiredEvidence: ['auto-generated draft: 待 agent 对照 ' + taskId + ' brief + diff 复核后升级为 pass/fail'],
@@ -1378,6 +1416,14 @@ export async function adoptTaskReviewMechanics({ changeName, cwd, platformOpts =
     merged.base = taskBase
     merged.head = taskHead
     merged.changedFiles = taskChangedFiles
+    // diffPaths（统一 commit 模式，坑 task-review-unified-commit-scope）：与草稿同口径——仅
+    // 有归属切片（taskChangedFiles 非空）时带 allowed_paths，空归属不带（防切片恒空 →
+    // emptyDiff 误判伪造）。
+    if (taskChangedFiles.length > 0 && allowedPaths.length > 0) {
+      merged.diffPaths = allowedPaths
+    } else {
+      delete merged.diffPaths
+    }
     if (draftRepo) merged.repo = draftRepo
 
     let verdictTouched = false
@@ -1403,6 +1449,7 @@ export async function adoptTaskReviewMechanics({ changeName, cwd, platformOpts =
       || prev.base !== merged.base
       || prev.head !== merged.head
       || JSON.stringify(prev.changedFiles ?? null) !== JSON.stringify(merged.changedFiles)
+      || JSON.stringify(prev.diffPaths ?? null) !== JSON.stringify(merged.diffPaths ?? null)
       || prev.repo !== merged.repo
 
     try {

package/src/verify-postcheck.js

@@ -613,6 +613,31 @@ const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)
 // 与失败信号（× 行 / FAIL 横幅 / 汇总计数）无关，全部剔除。
 const CONSOLE_CAPTURE_RE = /^\s*(?:stdout|stderr)\s*\|/
 const ENV_NOISE_RE = /not\s+implemented\s*:/i
+// 报表行（vitest/jest 测试运行器自身输出，非被捕获的 console 内容）：失败结果标记行
+// （×✕✗✘ 前缀 / FAIL 文件行）、❯ 文件摘要行、⎯ 分节分隔行——用作捕获块的结束边界。
+const REPORT_LINE_RE = /^\s*(?:[×✕✗✘]|FAIL\b|❯|⎯)/
+// Python/pytest 警告噪声（坑 verify-pytest-warnings-noise，2026-09-01 实证）：pytest 把
+// warnings summary 打印成「测试 id 行 + `<路径>:<行号>: <XxxWarning>: 消息` 归因行 + 缩进
+// 源码展示行」。归因行的**文件路径**常含 exception/error 子串（starlette `_exception_handler.py`
+// 是 FastAPI 全家桶标配，路径即命中 /exception/i）——整块被判失败行，backend 全量实测真实
+// 1 个守卫失败被上百行 DeprecationWarning 噪声淹没、只能人工分模块定位。warning 不是失败
+// 信号：① 区段级整段剔（区段头 → 下一 pytest 区段头）；② 行级剔（截断 tail 看不到区段头时
+// 兜底：归因/分组/Node 警告行 + 其上下文的 id/源码展示行）。真实失败的归因行（如
+// `file.py:42: AssertionError`）非 *Warning 类名，形态可分、不受影响。
+// 区段头：`============================== warnings summary ===============================`
+const PY_WARNINGS_SECTION_RE = /^\s*=+.*warnings summary.*=+\s*$/i
+// pytest 任意区段分隔头（`==== short test summary info ====` / `==== 3 failed, 300 passed in 12s ====`）
+const PY_SECTION_RE = /^\s*=+.*=+\s*$/
+// warning 归因行：`C:\...\file.py:59: DeprecationWarning: ...` / `file.py:7: UserWarning: ...`
+// （盘符/相对路径两形态；截断前缀 … 是普通非冒号字符，[^:\r\n] 天然兼容）
+const PY_WARNING_ATTR_RE = /^\s*(?:[A-Za-z]:)?(?:[^:\r\n]*[\\/])?[^:\r\n]*:\d+:\s+\w*Warning:/
+// 分组归因行：`tests/test_x.py: 13 warnings`
+const PY_WARNING_GROUP_RE = /^\s*(?:[A-Za-z]:)?[^:\r\n]*:\s*\d+\s+warnings?\b/i
+// Node 进程警告行：`(node:1234) [DEP0040] DeprecationWarning: ...`
+const NODE_WARNING_RE = /^\s*\(node:\d+\)\s*(?:\[[^\]]*\]\s*)?\w*Warning:/
+// pytest 测试 id 行（`path/to/test.py::TestClass::test_x`，无空格）——warnings summary 内
+// 逐条 warning 的归属头；只在 warning 上下文激活时剔（正常输出里的 id 行不动）
+const PY_TEST_ID_RE = /^\S+::\S+$/
 // 通过行（行首标记，剥 ANSI 后判定）：vitest/jest/mocha 的 ✓√✔ 前缀行 + jest 的 PASS 文件行。
 // 坑 verify-known-failures-pass-line-false-positive：FAILED/error:/exception 是子串匹配，
 // 通过行用例名恰含这些字样（如「✓ … 超时后 syncStatus=failed」）会被误判失败行——
@@ -630,15 +655,42 @@ const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g
  */
 export function partitionFailures(output, knownFailures) {
   const lines = String(output || '').split(/\r?\n/)
-  // 分类在剥 ANSI 后的行上做，返回保留原文（remaining 展示给 agent 时不变形）
-  const failureLines = lines.filter(l => {
-    if (PASS_LINE_RE.test(l)) return false
+  // 分类在剥 ANSI 后的行上做，返回保留原文（remaining 展示给 agent 时不变形）。
+  // 捕获块状态机（坑 verify-console-capture-block-noise，2026-08-31 daemon 套件 ~710 行实证）：
+  // vitest 把测试内 console 输出捕获为 `stdout|`/`stderr|` 横幅 + 后续内容行——旧逻辑只剔
+  // 横幅行本身，内容行（通过用例的结构化日志，常含 error:/failed 字样）仍中子串匹配成假
+  // 失败行。块以横幅开始，直到下一报表行（通过/失败标记、FAIL 文件行、❯ 文件摘要、⎯ 分节
+  // 符、汇总行）结束；块内内容行一律剔除。真实失败恒有 ×/FAIL 报表行（先结束块、照常参与
+  // 分类），失败检出不受影响；检测不到失败行时 judgeWithKnownFailures 仍 fail-safe 判 failed。
+  const failureLines = []
+  let inCapture = false
+  // pytest warnings summary 区段态：区段头开区、下一 pytest 区段头收区，区段内容整段剔
+  let inPyWarnings = false
+  // warning 上下文态（行级兜底）：命中归因/分组/Node 警告行后，紧随的缩进源码展示行、
+  // pytest 测试 id 行与组间空行同属该 warning 展示块，一并剔；报表行/其他内容行终结上下文。
+  let pyWarnCtx = false
+  for (const l of lines) {
     const bare = l.replace(ANSI_RE, '')
-    if (PASS_LINE_RE.test(bare)) return false
-    if (CONSOLE_CAPTURE_RE.test(bare)) return false
-    if (ENV_NOISE_RE.test(bare)) return false
-    return PER_TEST_FAIL_RE.test(bare) && !SUMMARY_LINE_RE.test(bare)
-  })
+    if (CONSOLE_CAPTURE_RE.test(bare)) { inCapture = true; pyWarnCtx = false; continue }
+    if (PY_WARNINGS_SECTION_RE.test(bare)) { inPyWarnings = true; pyWarnCtx = true; continue }
+    if (inPyWarnings) {
+      if (PY_SECTION_RE.test(bare)) inPyWarnings = false // 下一区段头（short test summary info 等）收区
+      continue // 区段内容（测试 id / 归因 / 源码展示行）：warning 噪声，非失败信号
+    }
+    const isReportLine = PASS_LINE_RE.test(bare) || REPORT_LINE_RE.test(bare) || SUMMARY_LINE_RE.test(bare)
+    if (inCapture && !isReportLine) continue // 捕获块内容行：console 噪声，非失败信号
+    if (isReportLine) inCapture = false
+    // ── Python/pytest 警告行级剔除（截断 tail 无区段头时的兜底）──
+    if (PY_WARNING_ATTR_RE.test(bare) || PY_WARNING_GROUP_RE.test(bare) || NODE_WARNING_RE.test(bare)) { pyWarnCtx = true; continue }
+    if (pyWarnCtx) {
+      if (isReportLine) pyWarnCtx = false // 报表行（含 short summary 区段头）终结 warning 上下文
+      else if (PY_TEST_ID_RE.test(bare) || /^\s{2,}\S/.test(bare) || bare.trim() === '') continue // 同块源码展示 / 测试 id / 组间空行
+      else pyWarnCtx = false
+    }
+    if (PASS_LINE_RE.test(bare)) continue
+    if (ENV_NOISE_RE.test(bare)) continue
+    if (PER_TEST_FAIL_RE.test(bare) && !SUMMARY_LINE_RE.test(bare)) failureLines.push(l)
+  }
   const pats = (knownFailures || []).map(p => String(p).toLowerCase()).filter(Boolean)
   const exempted = []
   const remaining = []

package/src/verify-probes.js

@@ -257,6 +257,9 @@ export function renderVerifyProbesReport(result) {
   if ((probe5.scanRoots || []).length > 1) {
     L.push(`- ℹ️ 后端端点比对集为多根并集（主仓既有 ∪ worktree 新增 ∪ 存量 artifact），共扫 ${probe5.scanRoots.length} 个根`)
   }
+  if (probe5.prefixAlignedCount > 0) {
+    L.push(`- ℹ️ ${probe5.prefixAlignedCount} 处前端调用经挂载前缀对齐匹配（endpoints 提取不含 include_router/app.use 挂载点前缀，比对时剥除对齐——非契约缺口）`)
+  }
   if ((probe5.missingBackend || []).length > 0) {
     L.push('')
     L.push('| 状态 | 前端调用 | 后端端点 | 文件 |')