sillyspec 3.32.4 → 3.32.6

package/src/spec-sync.js

@@ -594,11 +594,29 @@ export function isFollowerSetChanged(specRoot, key, list) {
  * @param {string} changeName - 当前变更名
  * @returns {Promise<{synced: number, conflict?: boolean, serverVersions?: object}>}
  */
+/**
+ * 冲突路径 → 变更名归因标签（2026-10-11-sync-conflict-tri-fix FR-03 全树同步入口用）：
+ * changes/(archive/)?<名>/ 前缀提取，全部路径归因到同一变更 → 用该变更名（冲突文件
+ * spec-sync-conflict-<名>.json 与 per-change 流程兼容，resolve/status UX 不变）；
+ * 跨多变更或无可归因路径 → 'full-tree'（单文件合并裁决，resolve 整体 force-push）。
+ */
+function attributeChangeLabel(paths) {
+  const names = new Set()
+  for (const p of paths) {
+    const m = p.match(/^changes\/(?:archive\/)?([^/]+)\//)
+    if (m) names.add(m[1])
+  }
+  return names.size === 1 ? [...names][0] : 'full-tree'
+}
+
 export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
   if (!platform || !platform.url || !platform.token) {
     debugLog('[spec-sync] 未连接平台（本地合法状态）；跳过 spec 树增量同步');
     return { synced: 0 };
   }
+  // 全树入口（platform sync 无 --change，2026-10-11-sync-conflict-tri-fix FR-03）
+  // changeName=null：日志用 full-tree 标签，冲突归因见下方 conflictLabel。
+  const logLabel = changeName || 'full-tree';
   // 绑定连接类失败噪音闸（sync-noise.js）：本目录所有 [spec-sync]/[sync] 失败 warn 的
   // 跨进程静默窗口 marker 落这里（与 SyncManager 构造器绑定同目录）。
   try { bindSyncNoiseRoot(join(specRoot, '.runtime')); } catch { /* 直通降级 */ }
@@ -622,7 +640,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       // 8 分钟才被后续步骤的同步补上）。失败可见、成功不打扰。
       // 连接类失败（404=端点未就绪 / 5xx）走噪音闸（sync-noise.js）：平台未就绪期每步
       // 自动同步重刷同一行，淹没门禁输出；其余状态码（4xx 业务态）每轮该看见。
-      const line = `[spec-sync] 拉取清单失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${changeName}`;
+      const line = `[spec-sync] 拉取清单失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${logLabel}`;
       if (isConnectionClassStatus(res.status)) syncConnectionWarn(line);
       else console.warn(line);
       return { synced: 0 };
@@ -630,7 +648,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
     const body = await res.json().catch(() => ({}));
     serverManifest = body.files || {};
   } catch (err) {
-    const line = `[spec-sync] 拉取清单异常（文件树本次未同步，下次自动重试）: ${changeName}: ${describeSyncError(err)}`;
+    const line = `[spec-sync] 拉取清单异常（文件树本次未同步，下次自动重试）: ${logLabel}: ${describeSyncError(err)}`;
     syncConnectionWarn(line); // 网络/超时/熔断均连接类
     return { synced: 0 };
   }
@@ -671,7 +689,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
   }
 
   if (ops.length === 0) {
-    debugLog(`[spec-sync] 无差异，跳过同步: ${changeName}`);
+    debugLog(`[spec-sync] 无差异，跳过同步: ${logLabel}`);
     clearStaleTombstoneMarkers(specRoot);
     return { synced: 0 };
   }
@@ -688,7 +706,7 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       signal: withSignal(30000),
     });
     if (!res.ok) {
-      const line = `[spec-sync] 同步请求失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${changeName}`;
+      const line = `[spec-sync] 同步请求失败 HTTP ${res.status}（文件树本次未同步，下次自动重试）: ${logLabel}`;
       if (isConnectionClassStatus(res.status)) syncConnectionWarn(line);
       else console.warn(line);
       return { synced: 0 };
@@ -719,6 +737,9 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
         ? { followers: [], real: serverVersions }
         : partitionConflictPaths(serverVersions, localFiles, baseHashes, lastSyncTs);
       const realPaths = Object.keys(real).filter((p) => !tombSet.has(p));
+      // 全树入口（changeName=null）冲突归因：单一变更 → 该变更名（冲突文件/markers 与
+      // per-change 流程同名兼容）；跨变更 → 'full-tree' 单文件合并裁决。
+      const conflictLabel = changeName || attributeChangeLabel(realPaths);
 
       // 纯墓碑形态：版本冲突面为空、拒收全是墓碑 → 不写/不清通用冲突标记（clear 会把
       // 状态洗成「已消解」误导 status），单独落冲突文件 + 正确恢复指引。
@@ -743,13 +764,13 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       // 自愈」连环刷屏。冲突文件在且冲突集未变 = 用户已被告知：重复轮次单行提示（可见但不
       // 吓人），不重写文件（created_at 稳定，status 红标语义不变）；冲突集变化才重写+全幅。
       // forcePush（resolve --keep-local 刚裁决完重推）不参与去重——需真实判定与文件刷新。
-      const pendingSame = !opts.forcePush && realPaths.length > 0 && isSamePendingSpecConflict(specRoot, changeName, realPaths);
+      const pendingSame = !opts.forcePush && realPaths.length > 0 && isSamePendingSpecConflict(specRoot, conflictLabel, 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 };
+        console.warn(`⚠️ [spec-sync] 变更 ${conflictLabel} 存在未决 spec 树冲突（${realPaths.length} 个文件待裁决，本轮非冲突改动已照常同步）。处理：sillyspec platform resolve ${conflictLabel} --keep-local | --take-platform | --abort`);
+        return { synced: 0, conflict: true, serverVersions: real, autoResolved: followers.length, conflictPath: join(specRoot, '.runtime', `spec-sync-conflict-${conflictLabel}.json`), suppressed: true };
       }
       if (followers.length > 0) {
         console.warn(`[spec-sync] ${followers.length} 个本地未改动文件自动跟随服务器（正常多端前进，无需人工裁决）: ${followers.slice(0, 5).join(', ')}${followers.length > 5 ? ' 等' : ''}`);
@@ -757,18 +778,18 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       if (realPaths.length === 0) {
         writeLastSyncTs(specRoot);
         writeBaseSnapshot(specRoot, localFiles);
-        clearSpecConflictMarker(specRoot, changeName);
+        clearSpecConflictMarker(specRoot, conflictLabel);
         noteSyncSuccess();
-        console.log(`[spec-sync] 冲突已自动消解（0 个需人工裁决；本会话改动 ${ops.length - followers.length > 0 ? '已同步' : '无差异'}）: ${changeName}`);
+        console.log(`[spec-sync] 冲突已自动消解（0 个需人工裁决；本会话改动 ${ops.length - followers.length > 0 ? '已同步' : '无差异'}）: ${conflictLabel}`);
         return { synced: Math.max(ops.length - followers.length, 0), conflict: false, autoResolved: followers.length };
       }
       let conflictPath = null;
       try {
         const runtimeDir = join(specRoot, '.runtime');
         mkdirSync(runtimeDir, { recursive: true });
-        conflictPath = join(runtimeDir, `spec-sync-conflict-${changeName}.json`);
+        conflictPath = join(runtimeDir, `spec-sync-conflict-${conflictLabel}.json`);
         writeFileSync(conflictPath, JSON.stringify({
-          change: changeName,
+          change: conflictLabel,
           kind: 'spec-tree',
           created_at: new Date().toISOString(),
           server_versions: real,
@@ -786,20 +807,28 @@ export async function syncSpecTree(specRoot, platform, changeName, opts = {}) {
       console.warn('');
       console.warn(`⚠️ [spec-sync] 检测到 spec 树冲突（${realPaths.length} 个文件: ${shownPaths}；逐文件服务器版本见冲突详情文件）`);
       if (tombNote) console.warn(`⚠️ [spec-sync]${tombNote.trim()}`);
-      console.warn(`⚠️ 处置：sillyspec platform resolve ${changeName} --keep-local | --take-platform | --abort（冲突详情: ${conflictPath || '(写入失败)'}）`);
+      console.warn(`⚠️ 处置：sillyspec platform resolve ${conflictLabel} --keep-local | --take-platform | --abort（冲突详情: ${conflictPath || '(写入失败)'}）`);
       return { synced: 0, conflict: true, serverVersions: real, autoResolved: followers.length, conflictPath };
     }
     noteSyncSuccess();
-    console.log(`[spec-sync] 已同步 ${ops.length} 个文件变更: ${changeName}`);
+    console.log(`[spec-sync] 已同步 ${ops.length} 个文件变更: ${logLabel}`);
     // 本轮无冲突 = 此前的未决 spec 树冲突已不存在，清残留标记（否则 status 永久红标、
-    // 横幅去重单行提示不消——坑 spec-sync-conflict-banner-spam）
-    clearSpecConflictMarker(specRoot, changeName);
+    // 横幅去重单行提示不消——坑 spec-sync-conflict-banner-spam）。全树入口
+    // （changeName=null，2026-10-11-sync-conflict-tri-fix FR-03）按归因清：只清本轮
+    // ops 触及变更的标记——未触及变更的未决冲突不因全树绿而误清。
+    if (changeName) {
+      clearSpecConflictMarker(specRoot, changeName);
+    } else {
+      for (const name of new Set(ops.map((o) => attributeChangeLabel([o.path])))) {
+        if (name !== 'full-tree') clearSpecConflictMarker(specRoot, name);
+      }
+    }
     clearStaleTombstoneMarkers(specRoot);
     writeLastSyncTs(specRoot);
     writeBaseSnapshot(specRoot, localFiles);
     return { synced: ops.length };
   } catch (err) {
-    const line = `[spec-sync] 同步异常（文件树本次未同步，下次自动重试）: ${changeName}: ${describeSyncError(err)}`;
+    const line = `[spec-sync] 同步异常（文件树本次未同步，下次自动重试）: ${logLabel}: ${describeSyncError(err)}`;
     syncConnectionWarn(line); // 网络/超时/熔断均连接类
     return { synced: 0 };
   }

package/src/stages/plan-postcheck.js

@@ -261,6 +261,34 @@ export function detectDuplicateTopKeys(fmText) {
  * @returns {Map<string, string>} repoKey → absolutePath
  */
 export function parseRepoRegistry(yamlText) {
+  return _parseRepoEntries(yamlText, 'path')
+}
+
+/**
+ * repos 段条目的 worktree 子键 → Map<repoKey, 落位根目录>（坑 cross-wt-toolchain-split 配置
+ * 简化，2026-10-10 用户反馈：独立 worktree.crossPlacement 段与仓注册分居两处形态重——落位
+ * 直接内联在注册条目上）。
+ *
+ * 只认对象形态条目的 worktree 子键；字符串条目（值即路径）无落位语义不入 Map。清洗规则
+ * （CRLF/行内注释/引号）与 parseRepoRegistry 同源。
+ * @param {string} yamlText
+ * @returns {Map<string, string>} repoKey → 落位根目录（未配置的仓不在 Map）
+ */
+export function parseRepoWorktreePlacements(yamlText) {
+  return _parseRepoEntries(yamlText, 'worktree')
+}
+
+/**
+ * repos 段统一解析内核：subkey='path' → 注册表（字符串条目值即 path）；subkey='worktree' →
+ * 落位内联（仅对象条目）。条目三形态：
+ *   urgent: /mnt/e/repo                                # 字符串（值即 path，worktree 不适用）
+ *   urgent: {path: /mnt/e/repo, worktree: /mnt/e/wt}   # inline flow 对象
+ *   urgent:                                            # 块式对象
+ *     path: /mnt/e/repo
+ *     worktree: /mnt/e/wt
+ * @returns {Map<string, string>}
+ */
+function _parseRepoEntries(yamlText, subkey) {
   const reg = new Map()
   if (!yamlText) return reg
   // CRLF 归一（坑 register-repo-crlf-idempotent-loop，2026-08-23 实证：Windows 下 agent Write
@@ -269,6 +297,7 @@ export function parseRepoRegistry(yamlText) {
   // 幂等跳过不落盘 → 死循环。同文件 parseAllowedPaths/parseDependsOn/parseBaseCommit 均有此
   // 归一，本函数是唯一缺口）
   const lines = String(yamlText).replace(/\r\n?/g, '\n').split('\n')
+  const cleanVal = (v) => String(v || '').replace(/\s+#.*$/, '').trim().replace(/^['"]|['"]$/g, '')
   let startIdx = -1
   for (let i = 0; i < lines.length; i++) {
     if (/^repos:\s*(?:#.*)?$/.test(lines[i])) { startIdx = i; break }
@@ -281,15 +310,44 @@ export function parseRepoRegistry(yamlText) {
     // 条目格式：  <key>: <value>（key 限 [A-Za-z0-9_.\-]，与 parseLocalYamlModules 对齐）
     const entry = line.match(/^\s+([A-Za-z0-9_.\-]+):\s*(.*)$/)
     if (!entry) continue
-    const value = (entry[2] || '').trim()
-    if (value === '' || value.startsWith('#')) continue
-    // 去可选行内注释（`value # comment`）—— 注意路径不含 ` #`，注释前必带空格
-    const cleaned = value.replace(/\s+#.*$/, '').trim()
-    if (cleaned === '') continue
-    // 去首尾可选引号（YAML 字符串引用），保留路径内反斜杠原样
-    const path = cleaned.replace(/^['"]|['"]$/g, '')
-    if (path === '') continue
-    reg.set(entry[1], path)
+    const key = entry[1]
+    const indent = line.length - line.trimStart().length
+    const rawValue = (entry[2] || '').trim()
+
+    if (rawValue !== '' && !rawValue.startsWith('#')) {
+      if (rawValue.startsWith('{') && rawValue.endsWith('}')) {
+        // inline flow 对象：拆逗号取目标子键（值内逗号不支持——路径含逗号请用块式）
+        let hit = null
+        for (const part of rawValue.slice(1, -1).split(',')) {
+          const idx = part.indexOf(':')
+          if (idx === -1) continue
+          if (part.slice(0, idx).trim() === subkey) { hit = cleanVal(part.slice(idx + 1)); break }
+        }
+        if (hit) reg.set(key, hit)
+      } else if (subkey === 'path') {
+        // 字符串条目：值即 path（worktree 子键语义不适用于字符串形态）
+        const cleaned = cleanVal(rawValue)
+        if (cleaned !== '') reg.set(key, cleaned)
+      }
+      continue
+    }
+
+    // 块式对象条目（value 空）：消费整个子键块（缩进更深的连续行），取目标子键首个命中——
+    // 整块消费防子键行（path:/worktree:）被外层循环误当条目再匹配（'path'/'worktree' 混进
+    // registry 污染 Map）
+    let j = i + 1
+    for (; j < lines.length; j++) {
+      const l = lines[j]
+      if (l.trim() === '' || l.trim().startsWith('#')) continue
+      const subIndent = l.length - l.trimStart().length
+      if (subIndent <= indent) break // 离开本条目块（下一条目或段结束）
+      const sub = l.match(/^\s+([A-Za-z0-9_.\-]+):\s*(.*)$/)
+      if (sub && sub[1] === subkey && !reg.has(key)) {
+        const cleaned = cleanVal(sub[2])
+        if (cleaned !== '' && !cleaned.startsWith('#')) reg.set(key, cleaned)
+      }
+    }
+    i = j - 1 // 整块已消费；外层 ++ 落在块尾后第一行（下一条目或段边界）
   }
   return reg
 }

package/src/sync.js

@@ -2333,6 +2333,9 @@ export function listConflictFiles(cwd) {
 // 清单为锚做全树 diff，与变更目录无关——triggerSync 对 quick 会话降级只调本函数，
 // 不走 sync()（后者第二道 existsSync 门会以「变更不存在」提前 return）。
 // 未连接平台 → {synced: 0} 静默（本地合法状态，与 syncSpecTree 内部口径一致）。
+// 2026-10-11-sync-conflict-tri-fix FR-03：changeName=null 是合法形态——CLI 手动
+// 全树同步入口（platform sync 无 --change）经此走全树 diff；冲突归由 syncSpecTree
+// 内部 attributeChangeLabel 按路径归因（单一变更名或 'full-tree'）。
 export async function syncSpecTreeOnly(changeName, cwd, opts = {}) {
   const sm = new SyncManager(cwd);
   const platform = sm._getPlatform();

package/src/verify-postcheck.js

@@ -58,7 +58,21 @@ import { runVerifyProbes, readSmokeResultRecord, deriveSmokeSectionState, scanSm
 import { parseEvidenceSlots, classifyVerifiedFile } from './verify-facts-schema.js'
 
 // 测试命令最长执行时间；超时视为失败（防止 CLI 被挂起的测试卡死）
-const TEST_TIMEOUT_MS = Number(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60 * 1000
+// 单位统一（坑 active-pitfalls SILLYSPEC_TEST_TIMEOUT_MS 单位二义，2026-10-10 实证）：
+// 此前本常量裸读 env 当毫秒，而 resolveTestTimeoutMs 按文档契约（config-schema
+// test_timeout_sec 同效）当秒×1000——同一变量两读法，按文档传秒值（如 1800）被批执行器
+// 当 1.8s 帽、deps 批瞬时 ETIMEDOUT。统一走 parseTestTimeoutEnvMs：秒契约为准；
+// ≥10000 的值按毫秒兼容解释（实证期的规避口径）并告警促改秒。
+function parseTestTimeoutEnvMs(raw) {
+  const e = Number(raw)
+  if (!Number.isFinite(e) || e <= 0) return null
+  if (e >= 10_000) {
+    console.warn(`⚠️ SILLYSPEC_TEST_TIMEOUT_MS=${e} 按毫秒解释（= ${(e / 1000).toFixed(0)}s）——本变量契约单位是秒（与 test_timeout_sec 同效），建议改传秒值。`)
+    return e
+  }
+  return e * 1000
+}
+const TEST_TIMEOUT_MS = parseTestTimeoutEnvMs(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60 * 1000
 
 /**
  * 测试超时配置链（R9 实证 2026-09-23）：local.yaml commands.test_timeout_sec > env
@@ -69,8 +83,7 @@ const TEST_TIMEOUT_MS = Number(process.env.SILLYSPEC_TEST_TIMEOUT_MS) || 10 * 60
 export function resolveTestTimeoutMs(yamlText, env = process.env) {
   const m = String(yamlText || '').match(/^\s*test_timeout_sec:\s*([0-9]+)\s*(?:#.*)?$/m)
   if (m && Number(m[1]) > 0) return Number(m[1]) * 1000
-  const e = Number(env.SILLYSPEC_TEST_TIMEOUT_MS)
-  return Number.isFinite(e) && e > 0 ? e * 1000 : TEST_TIMEOUT_MS
+  return parseTestTimeoutEnvMs(env.SILLYSPEC_TEST_TIMEOUT_MS) || TEST_TIMEOUT_MS
 }
 const OUTPUT_TAIL_CHARS = 4000
 // 判账失败行台账上限（坑 verify-test-reconcile-tail-blindspot）：对账按完整输出判、tail 只存
@@ -1936,7 +1949,29 @@ function resolveMainChangedFiles(cwd, changeName, specBase = null) {
       const diffBase = meta?.baselineCommit || meta?.actualBaseHash || meta?.baseHash
       if (diffBase) {
         const gitDir = found.gitDir
-        const files = runGitDiffNameOnly(gitDir, `${diffBase}..HEAD`)
+        // 基点 merge-base 化（坑 verify-reconcile-base-stale-parallel-drift，2026-10-10 实证：
+        // 执行期把 main 合入 worktree 分支后，立项 diffBase..HEAD 把主仓并行演进算成本变更
+        // 产出——对账 21 条 undeclared 噪声淹没真实信号。改锚 merge-base(<主分支>, HEAD)：
+        // 只含本分支自身提交；未合 main 时 merge-base == 立项点行为零变化。不放大守卫：
+        // 仅当 mb 是 diffBase 的后代（窗口只收窄）才采用，否则退旧区间。
+        let anchor = String(diffBase)
+        try {
+          const headHash = String(gitQuiet(gitDir, ['rev-parse', 'HEAD'], { timeout: 15000 }) || '').trim()
+          const mainRef = typeof meta?.baseBranch === 'string' && meta.baseBranch.trim() ? meta.baseBranch.trim() : 'main'
+          let mb = gitQuiet(gitDir, ['merge-base', mainRef, 'HEAD'], { timeout: 15000 })
+          if (!(typeof mb === 'string' && mb.trim())) mb = gitQuiet(gitDir, ['merge-base', 'master', 'HEAD'], { timeout: 15000 })
+          // 三重守卫：mb == HEAD（提交落主分支本身/in-place 形态——主分支即本变更线，
+          // 收窄到 HEAD 会清空 diff 面）或 mb == 立项点（零变化）或 mb 非立项点后代
+          // （窗口放大）时一律保持旧锚。仅「严格收窄」形态才采用 merge-base。
+          if (typeof mb === 'string' && mb.trim()) {
+            const mbHash = mb.trim()
+            if (mbHash !== String(diffBase) && mbHash !== headHash && headHash) {
+              const isDesc = gitQuiet(gitDir, ['merge-base', '--is-ancestor', String(diffBase), mbHash], { timeout: 15000 })
+              if (isDesc === '') anchor = mbHash
+            }
+          }
+        } catch { /* 退旧区间（不放大） */ }
+        const files = runGitDiffNameOnly(gitDir, `${anchor}..HEAD`)
         // 坑 verify-evidence-account-diff-misses-committed-changes（2026-09-13 实证）：
         // wt-commit 流程把本变更提交落在**主仓 HEAD**，worktree 分支不前移——仅查 worktree
         // 侧 diffBase..HEAD 时已提交文件全部 miss（7 task diffHit=false 连环假红，verify 两连
@@ -2801,8 +2836,19 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   const SUITE_META_RE = /(^|\/)run-tests\.mjs$/
   const jsMeta = js.filter(f => SUITE_META_RE.test(norm(f)))
   const jsList = js.filter(f => !SUITE_META_RE.test(norm(f)))
+  // 非测试形态拆批（坑 verify-dynamic-subset-node-test-ts-source，2026-10-10 平台侧实证，
+  // 用户授权修复）：deps 面（FR 绑定 / 增量账本 / 依赖发现）可携带非测试文件——node --test
+  // 语义「文件即测试」直跑源码必败（TS 源码 import './x.js' 无 resolver 映射
+  // ERR_MODULE_NOT_FOUND）、vitest/jest 点名非测试文件 No test suite found、pytest 点名
+  // 非测试 .py 0 collected exit 5——三执行批统一只收测试形态（isTestFilePath 同口径），
+  // 被拆文件 nontest-skip 批点名披露（不跑不拦，绑定面脏数据可见可治理）。
+  const pyNonTest = py.filter(f => !isTestFilePath(f))
+  const pyTest = py.filter(f => isTestFilePath(f))
+  const jsNonTest = jsList.filter(f => !isTestFilePath(f))
+  const jsTest = jsList.filter(f => isTestFilePath(f))
+  const nonTestFiles = [...pyNonTest, ...jsNonTest]
   const CAP = 30
-  const pyCap = py.length === 0 ? 0 : jsList.length === 0 ? CAP : Math.max(5, Math.min(CAP - 5, Math.round(CAP * py.length / (py.length + jsList.length))))
+  const pyCap = pyTest.length === 0 ? 0 : jsTest.length === 0 ? CAP : Math.max(5, Math.min(CAP - 5, Math.round(CAP * pyTest.length / (pyTest.length + jsTest.length))))
   const jsCap = CAP - pyCap
   // 配额制组卷（2026-10-06-fr-regress-cap-drop）：优先面整跑豁免帽，普通依赖填剩余席位；
   // dropped 只计普通依赖弃置（优先面零弃置是构造保证），组内序保持「优先前缀+字母序」。
@@ -2812,8 +2858,8 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
     const ordinaryRun = ordinary.slice(0, Math.max(0, quota - prioInGroup.length))
     return { run: [...prioInGroup, ...ordinaryRun], prioCount: prioInGroup.length, dropped: ordinary.length - ordinaryRun.length, prioDropped: 0 }
   }
-  const pyQ = quotaFill(py, pyCap)
-  const jsQ = quotaFill(jsList, jsCap)
+  const pyQ = quotaFill(pyTest, pyCap)
+  const jsQ = quotaFill(jsTest, jsCap)
   const pyRun = pyQ.run
   const jsRun = jsQ.run
   // .py 运行器推断双源（2026-09-26-dynamic-test-inference）：① 命中模块命令串（旧路径，兼容期）；
@@ -2883,8 +2929,10 @@ function buildDepsBatches({ deps, changedFiles = [], hits = [], cwd = null, prio
   // dropped 只计普通依赖弃置、prioDropped=防御路径计数（构造上恒 0——quotaFill 保证优先面零弃置，
   // >0 即组卷逻辑被破坏，消费面 loud 披露）。js 批经 jsNative/jsProject 内容分流后计数随分流面。
   if (pyRun.length > 0) batches.push({ name: 'deps(auto-py)', short: 'py', command: `${pyRunner} ${pyRun.map(rebase).join(' ')}`, count: pyRun.length, prioCount: pyQ.prioCount, dropped: pyQ.dropped, prioDropped: pyQ.prioDropped, files: pyRun })
-  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: jsList.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
+  if (jsNative.length > 0) batches.push({ name: 'deps(auto-js)', short: 'js', command: `node --test --test-reporter=spec --test-reporter-destination=stderr --test-reporter=tap --test-reporter-destination=stdout ${jsNative.join(' ')}`, count: jsNative.length, prioCount: jsNative.filter(f => prio(f) === 0).length, dropped: jsTest.length - jsRun.length, prioDropped: jsQ.prioDropped, tap: true, files: jsNative })
   if (jsMeta.length > 0) batches.push({ name: 'deps(auto-js-meta-skip)', short: 'js-meta-skip', command: null, count: jsMeta.length, dropped: 0, skip: true, files: jsMeta, reason: '套件编排器（run-tests.mjs=npm test 组卷入口）非单测文件——内嵌执行=递归全量套件（嵌套 runner 污染假败）；全量门由收口实测/CI 的 npm test 承担' })
+
+  if (nonTestFiles.length > 0) batches.push({ name: 'deps(auto-nontest-skip)', short: 'nontest-skip', command: null, count: nonTestFiles.length, dropped: 0, skip: true, files: nonTestFiles, reason: `非测试形态文件 ${nonTestFiles.length} 个不进单测执行批（node --test 语义「文件即测试」/ vitest No test suite found / pytest 0 collected exit 5——直跑必假败；坑 verify-dynamic-subset-node-test-ts-source）：${nonTestFiles.slice(0, 3).join('、')}${nonTestFiles.length > 3 ? ' 等' : ''}——FR 绑定面脏数据可 sillyspec tests --unbind --tests <路径> 清行` })
   if (jsProjectRun.length > 0) {
     if (jsxRunner) {
       const isVitest = /vitest/.test(jsxRunner)

package/src/verify-probes.js

@@ -1758,15 +1758,22 @@ export function parseTaskAcceptance(content) {
 }
 
 /**
- * allowed_paths 条目是否测试形态（结构归属面）：test/ 前缀，或文件名含 .test. / _test. / spec
- * 惯例（(?:^|[._-])test(?:[._-]|$) 覆盖 foo.test.mjs / foo_test.js / test-foo.js 三形）。
- * 比探针 3 的存在性面（isTestFileName 文件名形态判定，宽松存在性提示）严格——这是 3/7 口径差异的落点。
- */
-function isProbe7TestPath(p) {
+ * allowed_paths 条目是否测试形态（结构归属面）：tests?/ 或 __tests__/ 目录段，或文件名
+ * .test./.spec. js 系后缀锚，或 python test_*.py / *_test.py——与 verify-postcheck 执行侧
+ * isTestFilePath 同口径（坑 verify-dynamic-subset-node-test-ts-source，2026-10-10 平台侧
+ * 实证：旧 /spec/i 裸子串把 spec-sync.ts 等「文件名含 spec 字样」的源码误判为测试路径，
+ * 随 trace 落盘进 FR 机器绑定行，后续变更经 FR 回归面被 node --test 直跑假败）。
+ * 漏检边界（宁紧勿松）：foo_test.js 连字形态不再预填——落 agent 手查是 fail-visible，
+ * 误绑产假败是 fail-hidden 更糟。比探针 3 的存在性面（isTestFileName 宽松提示）严格——
+ * 3/7 口径差异落点。
+ */
+export function isProbe7TestPath(p) {
   const posix = String(p).split('\\').join('/')
-  if (/^test\//.test(posix)) return true
+  if (/(^|\/)(tests?|__tests__)\//.test(posix)) return true
   const name = basename(posix)
-  return /(?:^|[._-])test(?:[._-]|$)/i.test(name) || /spec/i.test(name)
+  return /\.(test|spec)\.[cm]?(js|jsx|ts|tsx)$/.test(name)
+    || /(^|\/)test_[^\/]+\.py$/.test(posix)
+    || /(^|\/)[^\/]+_test\.py$/.test(posix)
 }
 
 /**

package/src/worktree-apply.js

@@ -1046,6 +1046,43 @@ export async function withMainRepoLock(projectRoot, changeName, purpose, fn, opt
   }
 }
 
+/**
+ * 跨仓主副本直写检测（FR-06，D-003@v1——坑 cross-wt-toolchain-split 2026-10-10 用户实证：
+ * agent 绕开 worktree 回主副本直写 master，5 个 fire commit 落主干、空 worktree 被静默清理，
+ * 全程零提示）。
+ *
+ * 判定：主副本 base 锚（meta.baselineCommit||baseHash，与 worktree 交付 diff 同锚）之后有
+ * commit 推进，且推进触及的文件与本变更该仓声明文件面（resolveApplyAllowSet 切片）以
+ * pathMatches 容差相交 → 返回 { commits, files }（交集文件，声明面命中口径与清单校验一致）。
+ * 纯检测不写盘：advisory，调用方（applyCrossRepoWorktrees）负责出 warning。
+ *
+ * fail-open（FR-07）：git 不可达 / baseHash 缺失 / allowSet 空 / 任何异常 → null（调用方静默
+ * 跳过——并行会话无关推进是合法态，误报成本高于漏报面已由 D-003 故障面接受）。
+ *
+ * @param {string} crossRoot 跨仓主副本仓根
+ * @param {string} baseHash base 锚（worktree meta 的 baselineCommit||baseHash）
+ * @param {Set<string>} allowSet 该仓声明文件面（相对跨仓仓根；空 = 声明面缺失不检测）
+ * @returns {{ commits: number, files: string[] }|null} null = 无推进/无交集/检测不可得
+ */
+export function detectCrossMainCopyBypass(crossRoot, baseHash, allowSet) {
+  try {
+    if (!crossRoot || !baseHash || !(allowSet instanceof Set) || allowSet.size === 0) return null;
+    const countRaw = gitQuiet(crossRoot, ['rev-list', '--count', `${baseHash}..HEAD`]);
+    if (countRaw === null) return null; // git 失败（非仓/锚悬空）→ fail-open
+    const commits = Number(String(countRaw).trim());
+    if (!Number.isFinite(commits) || commits <= 0) return null; // 无推进 → 合法态
+    const raw = gitQuiet(crossRoot, ['diff', '--name-only', baseHash, 'HEAD']);
+    if (raw === null) return null;
+    const touched = raw.split('\n').map(s => s.trim()).filter(Boolean);
+    if (touched.length === 0) return null;
+    const files = touched.filter(f => [...allowSet].some(ap => pathMatches(f, ap)));
+    if (files.length === 0) return null; // 推进但与声明面无交集 → 并行会话，不告警
+    return { commits, files };
+  } catch {
+    return null;
+  }
+}
+
 /**
  * 跨仓 worktree 真实 apply（坑 cross-repo-no-worktree-isolation，2026-08-27）。
  *
@@ -1104,6 +1141,31 @@ function applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly = fal
       continue;
     }
 
+    // 声明面解析（提前到空清理分支前——直写检测需要 allowSet 覆盖「空 worktree 被静默清理」
+    // 的 D-007 签名场景；清单校验段复用同一份，零行为差）。
+    // 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 });
+    const allowSet = allowMap.get(repoKey) || new Set();
+    const reviewDeclared = collectReviewDeclaredFiles(projectRoot, changeName, { runtimeRoot: join(specBase, '.runtime') }).get(repoKey);
+
+    // 跨仓主副本直写检测（FR-06，D-003@v1 advisory——坑 cross-wt-toolchain-split 2026-10-10
+    // 实证：agent 绕开 worktree 回主副本直写 master，空 worktree 在此被静默清理零提示）：
+    // 主副本 base 锚之后有提交推进且推进文件与声明面相交 = 本变更签名，warning 列证。
+    // 交集空/无推进/声明面缺失不告警（并行会话无关推进合法）；检测异常 fail-open（FR-07）。
+    try {
+      const bypass = detectCrossMainCopyBypass(crossRoot, deliverableBase, allowSet);
+      if (bypass) {
+        out.warnings.push(
+          `跨仓 ${repoKey}：疑似绕过 worktree 直写主干——base ${String(deliverableBase).slice(0, 8)} 之后主副本有 ${bypass.commits} 个 commit，以下文件与本变更声明面相交：\n  ${bypass.files.join('\n  ')}\n` +
+          `（worktree 隔离被绕开：请核对该仓执行期决策留痕；若属误写应把提交摘到分支重走 apply。advisory 警告不阻断 apply。）`
+        );
+      }
+    } catch { /* 直写检测 fail-open，不阻断 apply */ }
+
     if (changedFiles.length === 0) {
       if (!checkOnly) {
         const cr = cleanupCrossWorktrees({ cwd: crossRoot, changeName, specBase, force: true });
@@ -1117,14 +1179,6 @@ function applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly = fal
     }
 
     // 清单校验（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 });
-    const allowSet = allowMap.get(repoKey) || new Set();
-    const reviewDeclared = collectReviewDeclaredFiles(projectRoot, changeName, { runtimeRoot: join(specBase, '.runtime') }).get(repoKey);
     const reviewForeign = [];
     if (reviewDeclared && allowSet.size > 0) {
       const face = [...allowSet];