sillyspec 3.27.7 → 3.27.11

package/src/stages/execute.js

@@ -1006,14 +1006,19 @@ ${indexLines}
       return { taskNum, repo, workdir }
     })
 
-    // D-010 跨仓 task base 锡点：派发前实时 git rev-parse HEAD 落 task 卡 base_commit
-    // 仅对跨仓 task（repo≠'main'）落盘，主仓 task 锚 meta.baseHash（MultiRepoContext 已处理）
+    // D-010 跨仓 task base 锡点：派发前落 task 卡 base_commit
+    // 仅对跨仓 task（repo≠'main'）落盘，主仓 task 锚 meta.baseHash（MultiRepoContext 已处理）。
+    // worktree 模式（跨仓 worktree 隔离，坑 cross-repo-no-worktree-isolation）优先 entry.baseCommitHint
+    //（= meta.baseHash 创建时快照）——worktree HEAD 会随子代理 commit 推进，rev-parse HEAD 当 base
+    // 会把 Wave 内前序 task 的交付错算进后续 task 的 base；legacy 直写模式沿用跨仓根实时 HEAD。
     const baseCommitCache = new Map() // 同仓多 task 只 spawn 一次
     for (const item of perTaskWorkdirs) {
       if (item.repo === 'main') continue
       const entry = ctx.resolve(item.repo)
       if (!entry) continue
-      if (!baseCommitCache.has(entry.gitDir)) baseCommitCache.set(entry.gitDir, gitQuiet(entry.gitDir, ['rev-parse', 'HEAD']))
+      if (!baseCommitCache.has(entry.gitDir)) {
+        baseCommitCache.set(entry.gitDir, entry.baseCommitHint || gitQuiet(entry.gitDir, ['rev-parse', 'HEAD']))
+      }
       const baseCommit = baseCommitCache.get(entry.gitDir)
       if (!baseCommit) continue // git 不可达已由 MultiRepoContext 构造时 fail-closed 拦截，此处置防御
       const taskFile = changeDir
@@ -1023,28 +1028,43 @@ ${indexLines}
       baseCommitWrites.push({ taskNum: item.taskNum, repo: item.repo, taskFile, written, baseCommit })
     }
 
-    // 跨仓 task commit 指引 + head_commit 落盘指引（D-010 回收时机）
+    // 跨仓 task commit 指引 + head_commit 落盘指引（D-010 回收时机）。
+    // worktree 模式（跨仓 worktree 隔离）：子代理在跨仓 worktree 分支改+commit，apply 阶段 CLI
+    // 统一 patch 回跨仓主工作区（与主仓同构）；legacy 直写模式保留原文案（commit 直落跨仓主干）。
+    const crossWorktreeItems = perTaskWorkdirs.filter(i => {
+      const e = i.repo !== 'main' ? ctx.resolve(i.repo) : null
+      return e && e.isWorktree
+    })
+    const crossLegacyItems = perTaskWorkdirs.filter(i => i.repo !== 'main' && !crossWorktreeItems.some(w => w.taskNum === i.taskNum))
     const crossLines = perTaskWorkdirs
       .filter(i => i.repo !== 'main')
-      .map(i => `- task-${i.taskNum} → repo \`${i.repo}\`，workdir=\`${i.workdir}\``)
+      .map(i => {
+        const e = ctx.resolve(i.repo)
+        return `- task-${i.taskNum} → repo \`${i.repo}\`，workdir=\`${i.workdir}\`${e && e.isWorktree ? '（worktree 隔离）' : ''}`
+      })
       .join('\n')
-    crossRepoCommitSection = `
-### 跨仓 task 派发与双锡点
-
-本 Wave 含跨仓 task（直接改跨仓仓主干，**不经主仓 worktree**）：
+    const crossWorktreeSection = crossWorktreeItems.length > 0 ? `
 
-${crossLines}
+**跨仓 worktree task（repo 已建 worktree 隔离）——像主仓 task 一样工作：**
+- 子代理在 workdir（跨仓 worktree）内改+commit（git add + git commit 到 worktree 当前分支），**不要碰跨仓主工作副本**。
+- apply 阶段 CLI 统一把各跨仓 worktree 的交付 patch 回对应跨仓主工作区（勿手工 apply）。
+- base 已锚 worktree meta.baseHash（创建时快照），review 的 base/head 由 CLI 按 task 卡锡点解析。` : ''
+    const crossLegacySection = crossLegacyItems.length > 0 ? `
 
 **派发跨仓 task 前（base 锡点，CLI 已在 prompt 构造时落盘）：**
 - 跨仓 task 卡 frontmatter 的 \`base_commit\` 已由 CLI 实时 \`git -C <跨仓仓根> rev-parse HEAD\` 锁定（base 锡点，约束①）。子代理在此 HEAD 上改+commit，不受同 Wave 其他 task 推进 HEAD 影响。
 
+**跨仓 task 子代理 prompt 必须注入（legacy 直写模式）：**
+> 该 task 改的是 \`<repo>\` 仓，workdir=\`<跨仓仓根>\`。**直接在该仓主干工作区改+commit（git add + git commit 到该仓主干），不经主仓 worktree、不建分支。** commit 到该仓主干即落盘，apply 阶段对跨仓 task 为 no-op（design §5.4 G1）。
+> task 卡 allowed_paths 是相对**该仓根**的路径（如 \`src/routes/x.js\`）——不带仓库名前缀（\`<repo>/src/...\` ❌）、不是绝对路径；在 workdir 下直接按相对路径定位文件。` : ''
+    crossRepoCommitSection = `
+### 跨仓 task 派发与双锡点
+
+${crossLines}${crossWorktreeSection}${crossLegacySection}
+
 **回收跨仓 task（head 锡点，CLI 自动落盘，勿手写）：**
-- 子代理完成 commit 后，正常写 review.json（verdict/notes）并勾选 checkbox 即可。execute \`--done\` 时 CLI 自动 \`git -C <跨仓仓根> rev-parse HEAD\` 写入该 task 卡 \`head_commit:\`（幂等，已存在不覆盖——你若手写了精确锚点则以你的为准）。
+- 子代理完成 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 保留）。
-
-**跨仓 task 子代理 prompt 必须注入：**
-> 该 task 改的是 \`<repo>\` 仓，workdir=\`<跨仓仓根>\`。**直接在该仓主干工作区改+commit（git add + git commit 到该仓主干），不经主仓 worktree、不建分支。** commit 到该仓主干即落盘，apply 阶段对跨仓 task 为 no-op（design §5.4 G1）。
-> task 卡 allowed_paths 是相对**该仓根**的路径（如 \`src/routes/x.js\`）——不带仓库名前缀（\`<repo>/src/...\` ❌）、不是绝对路径；在 workdir 下直接按相对路径定位文件。
 `
   }
 
@@ -1245,10 +1265,11 @@ task-XX 对应：{SPEC_ROOT}/.runtime/execute-runs/{EXECUTE_RUN_ID}/tasks/task-X
 
 ### 完成后
 1. 为每个后端 router task 生成 API 端点 artifact——**用 CLI 命令，勿手扫装饰器手写（易漏 endpoint）**：
-   - 逐 task 运行：sillyspec endpoints extract --change <change> --task <task-NN>（<change> = 当前变更名）
+   - 聚合一次跑全：sillyspec endpoints extract --change <change> --all-tasks（逐 task 卡 allowed_paths 各自提取落盘，<change> = 当前变更名；与 verify 探针 5 聚合对账口径一致）
    - CLI 静态扫描变更文件（FastAPI @router.* / Express router.* / Spring @*Mapping）生成
      {SPEC_ROOT}/.runtime/contract-artifacts/<task-name>/endpoints.json
    - 格式: { "task": "task-XX", "type": "backend_endpoints", "endpoints": [{ "method": "GET", "path": "/api/ppm/xxx" }] }（CLI 已按此格式写好，verify 探针 5 直接消费）
+   - 只提单 task（--task task-NN）会让探针 5 用局部端点集对账放大假 missing——多 task 变更必用 --all-tasks
 `
 }
 

package/src/stages/plan.js

@@ -137,6 +137,12 @@ const stepGeneratePlan = {
 4. **写回任务清单**：把展开后的任务清单写回 tasks.md（checkbox 行 \`- [ ] task-XX: 一句话任务名\`，可附 \`[model:xxx]\`/\`(depends_on: task-01,02)\` 行内标注）。**写回规则（D-002@v1）**：保留 frontmatter/中文标题/所有非 task-XX 行（quick 挂载的 ql-xxx 勾选行、注记等逐行保留），仅重写 task-XX checkbox 行集合——防摧毁 quick 挂载条目
 5. 保存 plan.md（审查在下一步"审查计划"独立进行，不在本步自审——避免生成与自审同一次输出）；frontmatter 保留 plan_level 字段不删。**plan.md Wave 段下任务一律纯 ID 引用行**（\`- task-XX\`，不重抄任务名——任务名唯一真相在 tasks.md，重抄即双写漂移）
 
+> ⚠️ **Wave 段格式铁律（踩坑：旧先例 \`- [ ] task-XX: 描述\` 格式会导致 postcheck 告警）：**
+> ✅ 正确：\`- task-01\`（裸 ID 引用行，无 checkbox 无任务名）
+> ❌ 错误：\`- [ ] task-01: 添加用户创建接口\`（checkbox + 任务名——这是 tasks.md 格式，不是 plan.md Wave 段格式）
+> tasks.md 格式：\`- [ ] task-01: 一句话任务名\`（execute 从这里解析任务清单）
+> plan.md Wave 段格式：\`- task-01\`（纯 ID 引用，execute 据此分组）
+
 ---
 
 #### plan_level = none
@@ -446,6 +452,8 @@ related_tests:                           # 可选。当本 task 改动会导致
 - **task id 从 1 连续**：task-01、task-02、task-03… 不能跳号或重号（postcheck 校验 id 连续性，gap 会拦）
 这两条是跨 task 全局约束，子代理只写单卡看不到全局——你（主 agent）分派子代理前必须先在 plan.md 里确认 Wave 划分与编号正确。
 
+⚠️ **TaskCard 必备字段（缺一 postcheck 直接阻断）：** id、title（英文）、**title_zh（中文标题，必填）**、allowed_paths、goal、implementation、acceptance、verify、constraints。骨架已由 taskcard CLI 预生成（含 title_zh 占位），子代理只需 Edit 填值，不要删除任何必备字段。
+
 ## 任务清单
 ${taskList}
 

package/src/task-review.js

@@ -1107,11 +1107,18 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
     const reviewPath = join(reviewDir, 'review.json')
 
     // 幂等：review.json 已存在（无论合法/解析错/schema 错）一律跳过，绝不覆盖人工/子代理 verdict
+    // 双重守卫：readReview 判定 + existsSync 兜底（坑 task-review-draft-overwrite：已存在真实
+    // review 仍被草稿覆盖的变体——readReview 路径/权限异常时 existsSync 作为最后防线）
     const existing = readReview(reviewPath)
     if (existing.ok || existing.parseError || existing.schemaError) {
       skipped++
       continue
     }
+    if (existsSync(reviewPath)) {
+      // readReview 未捕获但文件存在（极端：权限/路径长度等）→ 宁跳不覆盖
+      skipped++
+      continue
+    }
 
     const content = readFileSync(join(tasksDir, tf), 'utf8')
     const allowedPaths = parseAllowedPaths(content)

package/src/verify-postcheck.js

@@ -579,10 +579,21 @@ export function extractKnownFailures(yamlText) {
   if (inline) {
     return inline[1].split(',').map(s => s.trim().replace(/^['"]|['"]$/g, '')).filter(Boolean)
   }
-  const block = yaml.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?)+)/m)
+  // 坑 verify-known-failures-comment-line-truncation（2026-08-28 连续踩两次）：块内注释行/空行
+  // 打断「连续列表项」的捕获链 → 只取到注释前的项，注释后的项静默丢失 → 清单残缺、
+  // verify 实测 remaining>0 假红。块定义放行注释行与空行（提取侧本就只认 `- ` 项行，
+  // 吸收进块的注释不影响结果）。
+  const block = yaml.match(/^known_failures:\s*\n((?:[ \t]+-[ \t].+\n?|[ \t]*#[^\n]*\n?|[ \t]*\n)+)/m)
   if (block) {
     return (block[1].match(/^[ \t]+-[ \t]+(.+)/gm) || [])
-      .map(s => s.replace(/^[ \t]+-[ \t]+/, '').trim().replace(/^['"]|['"]$/g, '').replace(/#.*$/, '').trim())
+      .map(s => {
+        const item = s.replace(/^[ \t]+-[ \t]+/, '').trim()
+        const full = item.match(/^(['"])(.*)\1$/)
+        if (full) return full[2] // 整体引号值原样保留（内部 # 不是注释）
+        const stripped = item.replace(/[ \t]+#.*$/, '').trim() // 行尾注释须 # 前有空白（YAML 语义），裸 # 不截
+        const q2 = stripped.match(/^(['"])(.*)\1$/)
+        return q2 ? q2[2] : stripped
+      })
       .filter(Boolean)
   }
   return []
@@ -591,9 +602,25 @@ export function extractKnownFailures(yamlText) {
 // 单条失败行标记（跨 pytest/jest/vitest/go/generic）。大小写不敏感。
 // 刻意用 FAIL/FAILED + 配合 SUMMARY_LINE_RE 排除汇总行：否则 pytest/jest 的
 // "N failed" 汇总会被误判为「需豁免的失败行」→ 永远 remaining>0 → known_failures 失效。
-const PER_TEST_FAIL_RE = /(FAILED|\bFAIL\b|✕|✗|✘|panic\s*:|assertionerror|traceback|---\s*fail|error:|exception)/i
-// 汇总/计数行（非单条失败）：pytest === 框、jest "Tests:"、裸 "N failed/passed"、go "FAILED in Ns" 等。
-const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)\b|tests?\s*:|test\s+suites?\s*:|failed\s+in\s+\d)/i
+// ×(U+00D7) 是 vitest 失败行的实际前缀标记（✕✗✘ 是 jest/mocha 形态）。
+const PER_TEST_FAIL_RE = /(FAILED|\bFAIL\b|✕|✗|✘|×|panic\s*:|assertionerror|traceback|---\s*fail|error:|exception)/i
+// 汇总/计数行（非单条失败）：pytest === 框、jest "Tests:"、vitest "Test Files  N failed"/"Tests  N failed | M passed"
+// （无冒号形态）、裸 "N failed/passed"、go "FAILED in Ns"、pnpm "ELIFECYCLE Test failed" 退出横幅等。
+const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)\b|tests?\s*:|test\s+suites?\s*:|^\s*(?:test\s+files|tests?)\s+\d|failed\s+in\s+\d|failed\s+tests\s+\d|elifecycle)/i
+// 控制台捕获噪声行（非失败信号）：vitest 把测试内 console 输出捕获为
+// `stderr | <file> > <测试名>` 横幅 + 后续内容行——挂在通过用例上的噪声里常含
+// error:/failed 字样（jsdom「Not implemented」警告、用例名本身带 failed 等），
+// 与失败信号（× 行 / FAIL 横幅 / 汇总计数）无关，全部剔除。
+const CONSOLE_CAPTURE_RE = /^\s*(?:stdout|stderr)\s*\|/
+const ENV_NOISE_RE = /not\s+implemented\s*:/i
+// 通过行（行首标记，剥 ANSI 后判定）：vitest/jest/mocha 的 ✓√✔ 前缀行 + jest 的 PASS 文件行。
+// 坑 verify-known-failures-pass-line-false-positive：FAILED/error:/exception 是子串匹配，
+// 通过行用例名恰含这些字样（如「✓ … 超时后 syncStatus=failed」）会被误判失败行——
+// 2710 用例套件 382 个"失败行"里 378 假阳性，known_failures 无法逐条枚举而实质失效。
+// 框架输出里通过行恒以通过标记开头、失败行恒以失败标记开头，行首判定即足以分离两类。
+const PASS_LINE_RE = /^\s*(?:[✓√✔]|PASS\b)/
+// ANSI 色码剥离（分类用）：TTY 捕获的输出里 ✓/× 前缀可能被色码包裹，行首锚定会失配。
+const ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g
 
 /**
  * 把测试输出按行筛出「失败行」，再按 known_failures 模式分为已豁免 / 未豁免。
@@ -603,7 +630,15 @@ const SUMMARY_LINE_RE = /(={2,}.*={2,}|^\s*\d+\s+(failed|passed|skipped|pending)
  */
 export function partitionFailures(output, knownFailures) {
   const lines = String(output || '').split(/\r?\n/)
-  const failureLines = lines.filter(l => PER_TEST_FAIL_RE.test(l) && !SUMMARY_LINE_RE.test(l))
+  // 分类在剥 ANSI 后的行上做，返回保留原文（remaining 展示给 agent 时不变形）
+  const failureLines = lines.filter(l => {
+    if (PASS_LINE_RE.test(l)) return false
+    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)
+  })
   const pats = (knownFailures || []).map(p => String(p).toLowerCase()).filter(Boolean)
   const exempted = []
   const remaining = []
@@ -1528,6 +1563,12 @@ export function printVerifyParityCheck(result) {
     console.warn(`   - ${m.method} ${m.path}  ← ${m.consumerFile}:${m.consumerLine}`)
   }
   if (result.missingBackend.length > 20) console.warn(`   …还有 ${result.missingBackend.length - 20} 个`)
+  // 全仓口径告警（坑 probe5-single-task-artifact-scope，2026-08-28 实证：diff/apply 清单都不可得
+  // 时回退全仓，全仓调用 × 本变更局部端点 = 大量假 missing，agent 照单记 FAIL 误导归档判定）
+  if (/\[scope: full-repo\]/.test(result.summary || '')) {
+    console.warn('   ⚠️  本次 scope 为 full-repo（diff 与 apply-pathspec 均不可得时的兜底）——missing 大概率是口径错配噪音而非真实 contract gap。')
+    console.warn('      先收窄复跑：sillyspec verify-probes --change <变更名>（change-diff/apply-pathspec 口径）再判定。')
+  }
   console.warn('   提示：检查是否后端漏实现，或前端调用了尚未实现的端点。确认无误可在 design.md 标注豁免。')
 }
 

package/src/worktree-apply.js

@@ -16,6 +16,7 @@ import { existsSync, unlinkSync, writeFileSync, mkdtempSync, rmSync, readdirSync
 import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 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';
@@ -440,6 +441,182 @@ export async function withMainRepoLock(projectRoot, changeName, purpose, fn, opt
   }
 }
 
+/**
+ * 跨仓 worktree 真实 apply（坑 cross-repo-no-worktree-isolation，2026-08-27）。
+ *
+ * 对有 worktree meta 的跨仓仓（worktree-cross.js 创建）执行与主仓 A5 同构的 patch 回落：
+ *   deliverables（diff baselineCommit||baseHash + untracked，filterDeliverableFiles 排除基础设施）
+ *   → 清单校验（resolveApplyAllowSet 按 repo 切片 ∪ review 声明切片）
+ *   → 跨仓主工作副本 dirty 重叠拦截
+ *   → patch（tracked diff + untracked add/diff --cached/reset，Buffer 防二进制损坏）
+ *   → git apply --3way 回跨仓主工作副本；成功后 cleanup 该跨仓 worktree（分支保留作锚）。
+ *
+ * 与主仓 apply 的顺序契约：本函数在主仓 patch 动作**之前**调用——任一跨仓失败即整体报错返回，
+ * 主仓工作区不动（不留半套状态）。legacy 直写模式的跨仓仓无 meta，不走本函数（原 no-op 校验）。
+ *
+ * @param {string} changeName
+ * @param {string} projectRoot 主仓根
+ * @param {object} ctx MultiRepoContext
+ * @param {{ checkOnly?: boolean }} opts
+ * @returns {{ repos: string[], applied: Array<{repoKey, changedFiles}>, errors: string[], warnings: string[], crossCleanups: string[] }}
+ */
+function applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly = false } = {}) {
+  const specBase = (ctx.platformOpts && ctx.platformOpts.specRoot) || join(projectRoot, '.sillyspec');
+  const out = { repos: [], applied: [], errors: [], warnings: [], crossCleanups: [] };
+  for (const [repoKey, entry] of ctx.repos) {
+    if (entry.isMain) continue;
+    const cm = getCrossWorktreeMeta(specBase, changeName, repoKey);
+    if (!cm || !cm.isCross || !cm.worktreePath || !existsSync(cm.worktreePath)) continue;
+    out.repos.push(repoKey);
+    const crossRoot = cm.crossRepoRoot || entry.projectRoot;
+    const deliverableBase = cm.baselineCommit || cm.baseHash;
+
+    // 交付集合（与主仓 step2 同口径：--name-status 捕 rename/delete + untracked，过滤基础设施文件）
+    let changedFiles = [];
+    const deletedFiles = [];
+    try {
+      const statusRaw = git(cm.worktreePath, ['diff', '--name-status', deliverableBase]);
+      const statusFiles = new Set();
+      if (statusRaw) {
+        for (const line of statusRaw.split('\n').filter(Boolean)) {
+          const parts = line.split('\t');
+          if (parts.length >= 2) statusFiles.add(parts[parts.length - 1]);
+          if (parts.length >= 3) statusFiles.add(parts[parts.length - 2]);
+          if (parts[0].startsWith('D')) deletedFiles.push(parts[parts.length - 1]);
+        }
+      }
+      const untrackedRaw = gitQuiet(cm.worktreePath, ['ls-files', '--others', '--exclude-standard']) || '';
+      changedFiles = filterDeliverableFiles([...new Set([...statusFiles, ...untrackedRaw.split('\n').filter(Boolean)])]);
+    } catch (e) {
+      out.errors.push(`跨仓 ${repoKey}：获取变更文件列表失败（${cm.worktreePath}）: ${e.message}`);
+      continue;
+    }
+
+    if (changedFiles.length === 0) {
+      if (!checkOnly) {
+        const cr = cleanupCrossWorktrees({ cwd: crossRoot, changeName, specBase, force: true });
+        for (const r of cr.results) {
+          if (r.result === 'cleaned') out.crossCleanups.push(`${repoKey}（无变更，worktree 已清理）`);
+          else out.warnings.push(`跨仓 ${repoKey} 无变更但清理 partial：${(r.details || []).join('; ')}`);
+        }
+      }
+      out.applied.push({ repoKey, changedFiles: [] });
+      continue;
+    }
+
+    // 清单校验（per-repo 切片 + review 声明切片并入，与主仓 Gate1/3b 同语义）
+    const allowMap = resolveApplyAllowSet(projectRoot, changeName);
+    let allowSet = allowMap.get(repoKey) || new Set();
+    const reviewDeclared = collectReviewDeclaredFiles(projectRoot, changeName).get(repoKey);
+    if (reviewDeclared) {
+      const merged = new Set([...allowSet]);
+      for (const f of reviewDeclared) {
+        if (![...merged].some(ap => pathMatches(f, ap))) merged.add(f);
+      }
+      allowSet = merged;
+    }
+    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  ')}`
+        );
+        if (!checkOnly) continue;
+      }
+    }
+
+    if (checkOnly) {
+      out.applied.push({ repoKey, changedFiles });
+      continue;
+    }
+
+    // 跨仓主工作副本 dirty 重叠拦截（与主仓 step4.5 同语义：重叠 = git apply 无法安全应用）
+    try {
+      const dirtyFiles = [...new Set(
+        ((gitQuiet(crossRoot, ['diff', '--name-only', 'HEAD']) || '').split('\n').filter(Boolean))
+          .concat((gitQuiet(crossRoot, ['ls-files', '--others', '--exclude-standard']) || '').split('\n').filter(Boolean))
+      )].filter(f => !f.startsWith('.sillyspec/') && f !== 'meta.json');
+      const overlap = dirtyFiles.filter(f => changedFiles.includes(f));
+      if (overlap.length > 0) {
+        out.errors.push(
+          `跨仓 ${repoKey}（${crossRoot}）主工作副本以下未提交文件与本次 apply 重叠，无法安全应用：\n  ${overlap.join('\n  ')}\n` +
+          `请先在跨仓仓提交或 stash 这些改动后重试 apply。`
+        );
+        continue;
+      }
+    } catch (e) {
+      out.errors.push(`跨仓 ${repoKey}：dirty 重叠检测失败（${crossRoot}）: ${e.message}`);
+      continue;
+    }
+
+    // patch 生成 + apply --3way（tracked/untracked 分流与 Buffer 聚合，与主仓 step7 同款）
+    const patchFiles = allowSet.size > 0
+      ? resolvePatchFiles(changedFiles, allowSet, true)
+      : changedFiles;
+    const tmpDir = mkdtempSync(join(tmpdir(), 'sillyspec-cross-'));
+    const patchPath = join(tmpDir, 'apply.patch');
+    try {
+      const inTree = new Set(
+        (gitQuiet(cm.worktreePath, ['ls-tree', '-r', '--name-only', deliverableBase]) || '').split('\n').filter(Boolean)
+      );
+      const inIndexRaw = patchFiles.length > 0
+        ? (gitQuiet(cm.worktreePath, ['ls-files', '--', ...patchFiles]) || '')
+        : '';
+      const inIndex = new Set(inIndexRaw.split('\n').filter(Boolean));
+      const trackedFiles = patchFiles.filter(f => inTree.has(f) || inIndex.has(f));
+      const untrackedPatchFiles = patchFiles.filter(f => !trackedFiles.includes(f));
+      const patchParts = [];
+      if (trackedFiles.length > 0) {
+        patchParts.push(git(cm.worktreePath, ['diff', '--binary', deliverableBase, '--', ...trackedFiles], { encoding: 'buffer', timeout: 60000 }));
+      }
+      if (untrackedPatchFiles.length > 0) {
+        git(cm.worktreePath, ['add', '--', ...untrackedPatchFiles]);
+        try {
+          patchParts.push(git(cm.worktreePath, ['diff', '--binary', '--cached', '--', ...untrackedPatchFiles], { encoding: 'buffer', timeout: 60000 }));
+        } finally {
+          gitQuiet(cm.worktreePath, ['reset', 'HEAD', '--', ...untrackedPatchFiles]);
+        }
+      }
+      const patchContent = Buffer.concat(patchParts);
+      if (patchContent.length === 0) {
+        out.applied.push({ repoKey, changedFiles: [] });
+        continue;
+      }
+      writeFileSync(patchPath, patchContent);
+      try {
+        git(crossRoot, ['apply', '--3way', patchPath], { timeout: 30000 });
+      } catch (e) {
+        // 冲突回滚：tracked 文件还原 HEAD 版，--3way 新建的部分文件删除（与主仓 rollbackApply 同语义）
+        const rawStderr = e.message || '';
+        for (const f of patchFiles) {
+          try {
+            if (gitQuiet(crossRoot, ['cat-file', '-e', `HEAD:${f}`]) !== null) {
+              gitQuiet(crossRoot, ['checkout', 'HEAD', '--', f]);
+            } else {
+              try { rmSync(join(crossRoot, f), { force: true }) } catch { /* 新文件删除失败留残，rescue 提示 */ }
+            }
+          } catch { /* 回滚尽力而为 */ }
+        }
+        out.errors.push(
+          `跨仓 ${repoKey}：apply --3way 失败（已回滚跨仓主工作副本到 apply 前状态）：${rawStderr}\n` +
+          `可选：进 ${crossRoot} 手工合并 worktree 分支 ${cm.branch}（git merge ${cm.branch}），完成后手动清理跨仓 worktree。`
+        );
+        continue;
+      }
+      out.applied.push({ repoKey, changedFiles: patchFiles });
+      // 成功 → 清理该跨仓 worktree（分支保留作 review 锚点）
+      const cr = cleanupCrossWorktrees({ cwd: crossRoot, changeName, specBase, force: true });
+      for (const r of cr.results) {
+        if (r.result === 'cleaned') out.crossCleanups.push(repoKey);
+        else out.warnings.push(`跨仓 ${repoKey} apply 成功但清理 partial：${(r.details || []).join('; ')}${(r.residual || []).length ? '；残留: ' + r.residual.join('; ') : ''}`);
+      }
+    } finally {
+      try { rmSync(tmpDir, { recursive: true, force: true }) } catch { /* 临时目录清理尽力而为 */ }
+    }
+  }
+  return out;
+}
+
 export function applyWorktree(changeName, { cwd, checkOnly = false, merge = false, base = 'merge-base', ctx = null, skipOverlap = false, stashDirty = false } = {}) {
   const projectRoot = cwd || process.cwd();
   const wm = new WorktreeManager({ cwd: projectRoot });
@@ -458,11 +635,26 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     skippedOverlapFiles: [],
   };
 
-  // --- 0. 跨仓 task no-op 校验（task-05 / D-009） ---
-  // 跨仓 task 的 commit 已落跨仓仓主干，apply = no-op（无 patch）。仅校验 review.head 是跨仓仓真实
-  // commit + 不 cleanup（wm.cleanup 只作用主仓 worktree）。校验失败 → 推 errors 阻断 apply（R-05）。
-  // 单仓 ctx 缺省 / 无跨仓 entry → validateCrossRepoNoOp 直接返回空（零回归）。
+  // --- 0. 跨仓处理（task-05 / D-009 + 坑 cross-repo-no-worktree-isolation） ---
+  // 0a. worktree 模式的跨仓仓：真实 apply（patch 回跨仓主工作副本 + 成功后 cleanup worktree）。
+  //     在主仓任何动作之前跑——任一跨仓失败即整体返回，主仓工作区不动（不留半套状态）。
+  // 0b. legacy 直写模式的跨仓仓：no-op 校验（review.head 是跨仓真实 commit + 不 cleanup）。
+  // 单仓 ctx 缺省 / 无跨仓 entry → 两步都空转（零回归）。
   if (ctx) {
+    const crossApplied = applyCrossRepoWorktrees(changeName, projectRoot, ctx, { checkOnly });
+    if (crossApplied.repos.length > 0) {
+      result.crossRepoApplied = crossApplied.applied;
+      for (const w of crossApplied.warnings) result.warnings = (result.warnings || []).concat([w]);
+      if (crossApplied.crossCleanups.length > 0) {
+        result.warnings = (result.warnings || []).concat([
+          `跨仓 worktree 已 apply 并清理：${crossApplied.crossCleanups.join(', ')}（分支保留作 review 锚点）`
+        ]);
+      }
+      if (crossApplied.errors.length > 0) {
+        result.errors.push(...crossApplied.errors);
+        return result; // 跨仓未落地 = 该仓 task 实际未完成，主仓 apply 不可继续
+      }
+    }
     const cross = validateCrossRepoNoOp(ctx, projectRoot, changeName);
     for (const e of cross.errors) result.errors.push(e);
     if (cross.warnings.length > 0) result.warnings = (result.warnings || []).concat(cross.warnings);
@@ -1185,6 +1377,60 @@ function rollbackApply(projectRoot, trackedFiles, newFiles, rawStderr = '') {
  * @param {object} p.result - applyWorktree 的 result（预对齐信息写入 result.warnings，可追溯，约束④）
  * @returns {{ aligned: string[], commit: string|null }} aligned=本次对齐的文件（空数组=未对齐）
  */
+/**
+ * merge 前自动 commit worktree 未提交交付物（坑 apply-merge-uncommitted-noop，2026-08-28 实证：
+ * 子代理默认不 commit，分支 tip 只有 baseline checkpoint → git merge 空转「Already up to date」/
+ * --no-ff 空合并，交付零落地，落地校验报错后只能手工 cherry-pick/cp 补救）。
+ * 默认 patch 路径本就能吃未提交内容（git diff <base> 到工作区）；只有 --merge/降级 merge 路径
+ * 只看已提交——在此补上衔接。与 preAlignBaselineToMain 同款 pathspec commit（坑
+ * git-commit-sweeps-prestaged：不扫入其他 staged 改动）。
+ *
+ * best-effort：commit 失败只 warning，交由下方落地校验兜底报错（不劣于原行为）。
+ * @returns {{ committed: string[], skipped: boolean, shortHash: string|null }}
+ */
+function autoCommitWorktreeWip({ meta, result, changeName }) {
+  const out = { committed: [], skipped: true, shortHash: null };
+  const worktreePath = meta?.worktreePath;
+  if (!worktreePath || !existsSync(worktreePath)) return out;
+  if (meta.mode && meta.mode !== 'worktree') return out;
+
+  // 未提交交付物 = tracked-modified（vs HEAD）∪ untracked，过 filterDeliverableFiles（排 meta.json/.sillyspec）
+  let wip = [];
+  try {
+    const modRaw = gitQuiet(worktreePath, ['diff', '--name-only', 'HEAD']);
+    const untrackedRaw = gitQuiet(worktreePath, ['ls-files', '--others', '--exclude-standard']);
+    wip = filterDeliverableFiles([
+      ...new Set([...(modRaw || '').split('\n'), ...(untrackedRaw || '').split('\n')].filter(Boolean)),
+    ]);
+  } catch { return out; }
+  if (wip.length === 0) return out;
+
+  try {
+    git(worktreePath, ['add', '-A', '--', ...wip]);
+    try {
+      git(worktreePath, ['commit', '--no-verify', '-m',
+        `sillyspec: auto-commit worktree WIP (${wip.length} files, apply --merge)`, '--', ...wip]);
+    } catch {
+      // 仓级 git 身份缺失时 commit 拒绝——补 -c 身份重试一次（worktree 继承不到全局配置的形态）
+      git(worktreePath, ['-c', 'user.name=sillyspec', '-c', 'user.email=sillyspec@apply.local',
+        'commit', '--no-verify', '-m',
+        `sillyspec: auto-commit worktree WIP (${wip.length} files, apply --merge)`, '--', ...wip]);
+    }
+    out.committed = wip;
+    out.skipped = false;
+    out.shortHash = gitQuiet(worktreePath, ['rev-parse', '--short', 'HEAD']);
+    result.warnings = result.warnings || [];
+    result.warnings.push(
+      `worktree 有 ${wip.length} 个未提交交付文件（子代理未 commit），已在分支自动 commit` +
+      `${out.shortHash ? `（${out.shortHash}）` : ''} 再 merge：${wip.slice(0, 5).join(', ')}${wip.length > 5 ? ' 等' : ''}`
+    );
+  } catch (e) {
+    result.warnings = result.warnings || [];
+    result.warnings.push(`worktree WIP 自动 commit 失败（merge 可能空转，落地校验将报未落地）：${(e.message || '').split('\n')[0]}`);
+  }
+  return out;
+}
+
 function preAlignBaselineToMain({ meta, branch, projectRoot, result }) {
   const pushWarning = (msg) => {
     result.warnings = result.warnings || [];
@@ -1303,6 +1549,10 @@ export function applyByMerge(result, changeName, projectRoot, wm, opts = {}) {
   // --- merge 前预对齐（D-002@v1 / task-02）：baseline 并行旧文件对齐 main 版，消除 merge 冲突主因 ---
   preAlignBaselineToMain({ meta, branch, projectRoot, result });
 
+  // --- merge 前自动 commit 未提交交付物（坑 apply-merge-uncommitted-noop）：预对齐在前——
+  // 它跳过 dirty 文件（不覆盖 WIP）且只提交对齐集；WIP commit 在后，两者不混提交 ---
+  autoCommitWorktreeWip({ meta, result, changeName });
+
   try {
     git(projectRoot, ['merge', '--no-ff', branch], { timeout: 30000 });
   } catch (e) {