sillyspec 3.26.2 → 3.26.3

package/src/verify-postcheck.js

@@ -436,11 +436,62 @@ function gitChangedFiles(cwd) {
  *      → 命中无关模块（如 ppm 变更误测 daemon/frontend）。与 task-review.js 同源。
  *   2. 无 worktree meta / diff 异常 → 主仓 `git diff --name-only HEAD`（brownfield 原行为）
  *
+ * 跨仓支持（task-06 / D-004 / design §6 A6）：ctx 参数可选，缺省走单仓原逻辑（零回归，
+ * GOAL-2）。ctx 非空且含跨仓 entry 时，主仓 diff 走原逻辑，再 per-repo 在各跨仓仓
+ * gitDir 跑 `git diff --name-only HEAD` 合并入结果（design §6 行 136 「per-repo 取 diff
+ * 合并」字面契约）。跨仓仓 diff 路径相对各自仓根。
+ *
+ * 注：runVerifyTestCheck 的 module 子集策略只消费主仓 diff（跨仓仓不参与 module 子集，
+ * 跨仓仓无 module 映射，design §6 + §5.4），故本函数的跨仓合并 diff 在 module 子集
+ * 路径无副作用——本函数仅供「per-repo diff 合并」语义契约 + 未来 consumer 复用。
+ *
  * @param {string} cwd - 项目根目录（主仓）
  * @param {string|null} changeName
+ * @param {object|null} [ctx] - MultiRepoContext 实例（可选，缺省/null 走单仓原逻辑）
  * @returns {string[]|null} 变更文件列表；git 不可用返回 null（调用方按 hitCount=-1 处理）
  */
-export function resolveVerifyChangedFiles(cwd, changeName) {
+export function resolveVerifyChangedFiles(cwd, changeName, ctx = null) {
+  // 主仓 diff（原逻辑不动，单仓零回归）
+  const mainFiles = resolveMainChangedFiles(cwd, changeName)
+
+  // 无 ctx / ctx 无跨仓 entry → 主仓 diff 即结果（零回归）
+  if (!ctx || typeof ctx.repos !== 'object' || ctx.repos === null) return mainFiles
+  const crossEntries = []
+  for (const entry of ctx.repos.values()) {
+    if (entry && entry.isMain === false) crossEntries.push(entry)
+  }
+  if (crossEntries.length === 0) return mainFiles
+
+  // 主仓 git 不可用（null）→ 不强制兜底，保留 null 语义让调用方按 hitCount=-1 处理。
+  // 跨仓仓 diff 各自取，任一可用即合并；全不可用且主仓 null → 返 null。
+  // 跨仓仓 diff 锚点：HEAD~1..HEAD（跨仓 task 子代理 commit 到主干，verify 时最近一笔 commit
+  // 即本次 task 改动；多 task 同仓时仅反映最近一笔，精确范围由 task 卡 base/head 锡点锚定，
+  // 那是 task-04 的 scope，本函数不消费锡点——跨仓合并 diff 在 verify-postcheck 内仅供
+  // 「per-repo diff 合并」语义契约 + 未来 consumer，module 子集只用主仓 diff）。
+  const merged = mainFiles ? mainFiles.slice() : []
+  let anyAvailable = mainFiles !== null
+  for (const entry of crossEntries) {
+    // 跨仓仓 gitDir = 跨仓仓根（MultiRepoContext._buildCrossRepoEntry 已 fail-closed 保证可达）
+    const files = runGitDiffNameOnly(entry.gitDir, 'HEAD~1..HEAD')
+    if (files !== null) {
+      anyAvailable = true
+      for (const f of files) {
+        if (!merged.includes(f)) merged.push(f)
+      }
+    }
+  }
+  return anyAvailable ? merged : null
+}
+
+/**
+ * 主仓变更文件解析（原 resolveVerifyChangedFiles 逻辑，单仓零回归基线）。
+ * 抽出供 resolveVerifyChangedFiles 复用，跨仓合并时主仓部分走此函数（不动）。
+ *
+ * @param {string} cwd - 主仓根
+ * @param {string|null} changeName
+ * @returns {string[]|null}
+ */
+function resolveMainChangedFiles(cwd, changeName) {
   if (changeName) {
     const metaPath = join(cwd, '.sillyspec', '.runtime', 'worktrees', changeName, 'meta.json')
     if (existsSync(metaPath)) {
@@ -464,10 +515,18 @@ export function resolveVerifyChangedFiles(cwd, changeName) {
 /**
  * 执行 verify 实测：读取 local.yaml 配置，按 test_strategy 决定全量或模块子集。
  *
+ * 跨仓支持（task-06 / D-004 / design §5.4 + §6 A6 + §9）：opts.ctx 可选，缺省走单仓
+ * 原逻辑（零回归，GOAL-2）。ctx 非空且含跨仓 entry 时，主仓跑原 module 子集 / full npm
+ * test（行为不变），再 per-repo cwd 在各跨仓仓根跑 full npm test（跨仓仓不参与 module
+ * 子集策略——跨仓仓无主仓的 module 映射，design §6 + §5.4）；跨仓仓无 package.json 则
+ * 跳过 + warn 不阻断 verify（design §9 兼容策略「跨仓仓无 package.json 跳过 warn」）。
+ * 任一仓 fail → 整体 fail（fail-fast 语义，跨仓仓的真实失败不能被主仓 PASS 掩盖）。
+ *
  * @param {object} opts
- * @param {string} opts.cwd - 项目根目录（测试执行目录）
+ * @param {string} opts.cwd - 项目根目录（主仓，测试执行目录）
  * @param {string} opts.specBase - .sillyspec（或平台 specRoot）目录
  * @param {string|null} [opts.changeName]
+ * @param {object|null} [opts.ctx] - MultiRepoContext 实例（可选，缺省/null 走单仓原逻辑）
  * @returns {{
  *   status: 'passed'|'failed'|'skipped',
  *   command: string|null,
@@ -478,7 +537,7 @@ export function resolveVerifyChangedFiles(cwd, changeName) {
  *   resultPath: string|null,
  * }}
  */
-export function runVerifyTestCheck({ cwd, specBase, changeName = null }) {
+export function runVerifyTestCheck({ cwd, specBase, changeName = null, ctx = null }) {
   const localYamlPath = join(specBase, 'local.yaml')
   const yamlText = existsSync(localYamlPath) ? readFileSync(localYamlPath, 'utf8') : null
 
@@ -487,6 +546,8 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null }) {
 
   // —— 模块子集路径（test_strategy: module）：算 modulesPresent / hitCount / hits ——
   // resolveVerifyChangedFiles 返回 null 表示 git 不可用 → hitCount=-1（与 0 命中区分）。
+  // 注：module 子集策略只用主仓 diff（跨仓仓不参与 module 子集，design §6 + §5.4），
+  //     故此处不传 ctx（避免跨仓路径误命中主仓 module 映射）。
   let modulesPresent = false
   let hitCount = 0
   let hits = []
@@ -505,13 +566,13 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null }) {
   }
 
   const action = decideVerifyTestAction({ strategy, modulesPresent, hitCount })
+  let mainResult
   if (action === 'module-subset') {
-    return runModuleSubset({ cwd, specBase, changeName, hits, knownFailures })
-  }
-  if (action === 'module-zero-hit-skip') {
+    mainResult = runModuleSubset({ cwd, specBase, changeName, hits, knownFailures })
+  } else if (action === 'module-zero-hit-skip') {
     // module 模式 0 命中：不静默回退注定超时/含预存失败的全量（坑 verify-worktree-... 修复方向 3）。
     // 据 verify-result.md 自报告判定；想跑全量请显式设 test_strategy: full。
-    return {
+    mainResult = {
       status: 'skipped',
       command: null,
       exitCode: null,
@@ -522,12 +583,182 @@ export function runVerifyTestCheck({ cwd, specBase, changeName = null }) {
       mode: 'module-zero-hit',
       fallbackReason: null,
     }
+  } else {
+    // —— 全量路径（full / module 无块 / module git 不可用）——
+    // fallbackReason 非 null 表示本次全量是"非显式"的（缺省/配置不全/未命中），需明示。
+    const fallbackReason = computeFullFallbackReason({ strategy, modulesPresent, hitCount })
+    mainResult = runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason, knownFailures })
+  }
+
+  // —— 跨仓仓 per-repo cwd 跑 full npm test（task-06 / D-004 / design §5.4 + §6 A6）——
+  // ctx 为空或无跨仓 entry → 直接返主仓结果（单仓零回归，GOAL-2）。
+  // 跨仓仓不参与 module 子集策略，只跑 full npm test（design §6 + §5.4）；
+  // 跨仓仓无 package.json → 跳过 + warn 不阻断（design §9 兼容策略）。
+  // 任一跨仓仓 fail → 整体 fail（合并语义）。
+  return mergeCrossRepoResults(mainResult, ctx)
+}
+
+/**
+ * per-repo cwd 跑跨仓仓 full npm test，合并进主仓结果。
+ *
+ * design §6 A6 + §5.4 + §9 兼容策略：
+ *   - 跨仓仓有 package.json → 在该仓 projectRoot cwd 跑 full npm test（跨仓仓 own local.yaml
+ *     若有 commands.test 用之，否则 fallback `npm test`）
+ *   - 跨仓仓无 package.json → 跳过 + console.warn（不阻断 verify）
+ *   - 跨仓仓只跑 full npm test，不参与 module 子集策略（module 映射主仓强相关）
+ *   - 任一仓 fail → 整体 fail；主仓 skipped + 跨仓仓 passed → 整体 passed（跨仓仓有测试即有效）
+ *
+ * 单仓 ctx（无跨仓 entry）→ 直接返主仓结果，零行为变化（GOAL-2）。
+ *
+ * @param {object} mainResult - 主仓 runVerifyTestCheck 结果
+ * @param {object|null} ctx - MultiRepoContext 实例
+ * @returns {object} 合并后结果（shape 同 mainResult）
+ */
+function mergeCrossRepoResults(mainResult, ctx) {
+  if (!ctx || typeof ctx.repos !== 'object' || ctx.repos === null) return mainResult
+  const crossEntries = []
+  for (const entry of ctx.repos.values()) {
+    if (entry && entry.isMain === false) crossEntries.push(entry)
+  }
+  if (crossEntries.length === 0) return mainResult
+
+  const crossResults = []
+  for (const entry of crossEntries) {
+    const crossResult = runCrossRepoFullTest(entry)
+    crossResults.push({ repoKey: entry.repoKey, projectRoot: entry.projectRoot, result: crossResult })
+  }
+
+  // 合并：任一 fail → fail；否则取主仓 status（passed/skipped 与跨仓 passed 合并）
+  const failedRepos = crossResults.filter(r => r.result.status === 'failed')
+  if (failedRepos.length > 0) {
+    return mergeResultStatus({
+      status: 'failed',
+      mainResult,
+      crossResults,
+      reason: `跨仓仓测试失败：${failedRepos.map(r => r.repoKey).join(', ')}`,
+    })
+  }
+  // 跨仓仓全 passed 或 skipped（无 package.json）→ 主仓 status 不变（合并跨仓信息到 outputTail）
+  return mergeResultInfo(mainResult, crossResults)
+}
+
+/**
+ * 在单个跨仓仓根跑 full npm test（跨仓仓不参与 module 子集，只跑 full）。
+ * 跨仓仓 own local.yaml 若存在且配 commands.test → 用之；否则 fallback `npm test`。
+ * 跨仓仓无 package.json → 跳过 + warn。
+ *
+ * @param {object} entry - RepoEntry（isMain=false）
+ * @returns {object} 结果 shape 对齐 runFullCommand 返回
+ */
+function runCrossRepoFullTest(entry) {
+  const projectRoot = entry.projectRoot
+  // 跨仓仓无 package.json → 跳过 + warn（design §9 兼容策略，不阻断 verify）
+  if (!existsSync(join(projectRoot, 'package.json'))) {
+    console.warn(`⚠️  跨仓 repo "${entry.repoKey}"（${projectRoot}）无 package.json，跳过该仓 npm test（design §9 兼容策略，不阻断 verify）。`)
+    return {
+      status: 'skipped',
+      command: null,
+      exitCode: null,
+      durationMs: null,
+      outputTail: null,
+      reason: `跨仓 repo "${entry.repoKey}" 无 package.json，跳过 npm test`,
+      resultPath: null,
+      mode: 'cross-repo-skip',
+      repoKey: entry.repoKey,
+    }
   }
 
-  // —— 全量路径（full / module 无块 / module git 不可用）——
-  // fallbackReason 非 null 表示本次全量是"非显式"的（缺省/配置不全/未命中），需明示。
-  const fallbackReason = computeFullFallbackReason({ strategy, modulesPresent, hitCount })
-  return runFullCommand({ yamlText, localYamlPath, cwd, specBase, changeName, fallbackReason, knownFailures })
+  // 跨仓仓 own local.yaml（在跨仓仓 .sillyspec/ 下，若存在）配 commands.test → 用之；否则 `npm test`
+  // 注：跨仓仓按 NG-1 不建 .sillyspec/，但容错读取（用户可手动放 local.yaml 配跨仓仓特定测试命令）
+  const crossLocalYaml = join(projectRoot, '.sillyspec', 'local.yaml')
+  let command = 'npm test'
+  let crossKnownFailures = []
+  if (existsSync(crossLocalYaml)) {
+    try {
+      const crossYaml = readFileSync(crossLocalYaml, 'utf8')
+      const extracted = extractTestCommand(crossYaml)
+      if (extracted) command = extracted
+      crossKnownFailures = extractKnownFailures(crossYaml)
+    } catch { /* 读取失败 fallback npm test */ }
+  }
+
+  const startedAt = Date.now()
+  let exitCode = 0
+  let output = ''
+  let reason = null
+  try {
+    output = execSync(command, {
+      cwd: projectRoot,
+      encoding: 'utf8',
+      timeout: TEST_TIMEOUT_MS,
+      maxBuffer: 32 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+  } catch (e) {
+    exitCode = typeof e.status === 'number' ? e.status : 1
+    output = [e.stdout, e.stderr].filter(Boolean).join('\n') || e.message
+    reason = e.signal === 'SIGTERM' && Date.now() - startedAt >= TEST_TIMEOUT_MS
+      ? `跨仓 repo "${entry.repoKey}" 测试超时（>${TEST_TIMEOUT_MS / 1000}s）`
+      : `跨仓 repo "${entry.repoKey}" 测试退出码 ${exitCode}`
+  }
+  const durationMs = Date.now() - startedAt
+  const outputTail = output.length > OUTPUT_TAIL_CHARS ? '…' + output.slice(-OUTPUT_TAIL_CHARS) : output
+  const judged = judgeWithKnownFailures(exitCode, output, reason, crossKnownFailures)
+
+  return {
+    status: judged.status,
+    command,
+    exitCode,
+    durationMs,
+    outputTail,
+    reason: judged.reason,
+    resultPath: null,
+    mode: 'cross-repo-full',
+    repoKey: entry.repoKey,
+    exemptedCount: judged.exemptedCount,
+  }
+}
+
+/**
+ * 合并失败状态：整体 failed，保留主仓 + 各跨仓仓明细到 outputTail / reason。
+ */
+function mergeResultStatus({ status, mainResult, crossResults, reason }) {
+  const parts = []
+  parts.push(`── main (${mainResult.status}) ──\n${mainResult.outputTail || mainResult.reason || ''}`)
+  for (const cr of crossResults) {
+    parts.push(`── cross-repo ${cr.repoKey} (${cr.result.status}) ──\n${cr.result.outputTail || cr.result.reason || ''}`)
+  }
+  const mergedTail = parts.join('\n')
+  return {
+    status,
+    command: mainResult.command ? `${mainResult.command} + cross-repo[${crossResults.map(r => r.repoKey).join(',')}]` : `cross-repo[${crossResults.map(r => r.repoKey).join(',')}]`,
+    exitCode: 1,
+    durationMs: (mainResult.durationMs || 0) + crossResults.reduce((n, r) => n + (r.result.durationMs || 0), 0),
+    outputTail: mergedTail.length > OUTPUT_TAIL_CHARS ? '…' + mergedTail.slice(-OUTPUT_TAIL_CHARS) : mergedTail,
+    reason,
+    resultPath: mainResult.resultPath,
+    mode: 'cross-repo-merged',
+    fallbackReason: mainResult.fallbackReason || null,
+  }
+}
+
+/**
+ * 合并信息（跨仓仓全 passed/skipped）：主仓 status 保留，跨仓仓 PASSED 信息附入 outputTail。
+ */
+function mergeResultInfo(mainResult, crossResults) {
+  const crossPassed = crossResults.filter(r => r.result.status === 'passed')
+  const crossSkipped = crossResults.filter(r => r.result.status === 'skipped')
+  if (crossPassed.length === 0 && crossSkipped.length === 0) return mainResult
+  const crossSummary = []
+  for (const cr of crossPassed) crossSummary.push(`cross-repo ${cr.repoKey}: PASS`)
+  for (const cr of crossSkipped) crossSummary.push(`cross-repo ${cr.repoKey}: SKIP(${cr.result.reason || 'no package.json'})`)
+  const crossLine = `\n── 跨仓仓 npm test ──\n${crossSummary.join('\n')}`
+  const mergedTail = (mainResult.outputTail || '') + crossLine
+  return {
+    ...mainResult,
+    outputTail: mergedTail.length > OUTPUT_TAIL_CHARS ? '…' + mergedTail.slice(-OUTPUT_TAIL_CHARS) : mergedTail,
+    mode: mainResult.mode ? `${mainResult.mode}+cross-repo` : 'cross-repo-merged',
+  }
 }
 
 /**

package/src/worktree-apply.js

@@ -18,8 +18,9 @@ import { join, resolve } from 'path';
 import { tmpdir } from 'os';
 import { WorktreeManager } from './worktree.js';
 import { parseFileChangeList, parseFileChangeListDetailed, pathMatches } from './change-list.js';
-import { parseAllowedPaths } from './stages/plan-postcheck.js';
+import { parseAllowedPaths, parseRepo } from './stages/plan-postcheck.js';
 import { git, gitQuiet } from './git-helper.js';
+import { resolveLatestExecuteRunId, readReview } from './task-review.js';
 
 const CHANGES_REL = '.sillyspec/changes';
 
@@ -191,36 +192,145 @@ function getBlobHashMap(cwd, treeish, files) {
  * 两 gate 口径不一致）。union 后两源并集为准；plan 已过 validateDesignFileCoverage 单向校验（design ⊆
  * plan），union 不会放开 design/plan 之外的任意文件（仍拦完全越界文件）。
  *
+ * **跨仓切片（task-05 / D-009 / design §6 A4）**：返回 `Map<repoKey, Set<path>>`，按 task 卡片
+ * `repo:` 字段把 allowed_paths 归属到对应 repo；design §6 清单归属 'main'（清单文件相对主仓根）。
+ * 单仓 change（task 卡无 repo:）→ 所有 allowed_paths 归 'main' → `{main: Set}` 退化零回归
+ * （GOAL-2）。allowed_paths 基准=各 repo 自身根（跨仓 task 卡片 allowed_paths 相对跨仓仓根，design §7.2）。
+ *
+ * 主流程（applyWorktree A5 主仓 apply）只消费 main 仓的 Set（主仓 worktree diff 只含主仓文件，
+ * 跨仓文件不在主仓 worktree 故永不进 diff）；跨仓 task 走 no-op（D-009），其 allowed_paths 仅
+ * 作 Map 切片返回，供上游（assess / 跨仓 review 校验）按 repo 取用。
+ *
  * @param {string} projectRoot - 主仓库根
  * @param {string} changeName - 变更名
- * @returns {Set<string>} 并集清单（无 design 清单且无 task 卡片时为空集）
+ * @returns {Map<string, Set<string>>} repoKey → 并集清单 Set（无 design 清单且无 task 卡片时为空 Map）
  */
 export function resolveApplyAllowSet(projectRoot, changeName) {
-  const allowSet = parseFileChangeList(join(projectRoot, CHANGES_REL, changeName, 'design.md'), { keepSillyspecDocs: true });
+  const repoMap = new Map();
+  const getOrCreate = (key) => {
+    if (!repoMap.has(key)) repoMap.set(key, new Set());
+    return repoMap.get(key);
+  };
+  // design §6 清单归属 main（清单路径相对主仓根；跨仓 task 的 allowed_paths 由 task 卡片 repo 切片）
+  const mainSet = getOrCreate('main');
+  parseFileChangeList(
+    join(projectRoot, CHANGES_REL, changeName, 'design.md'),
+    { keepSillyspecDocs: true }
+  ).forEach(p => mainSet.add(p));
   const tasksDir = join(projectRoot, CHANGES_REL, changeName, 'tasks');
   if (existsSync(tasksDir)) {
     for (const tf of readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f))) {
-      for (const p of parseAllowedPaths(readFileSync(join(tasksDir, tf), 'utf8'))) allowSet.add(p);
+      const content = readFileSync(join(tasksDir, tf), 'utf8');
+      // task 卡 repo: 字段切片（缺省='main'，design §7.2）；跨仓 task 的 allowed_paths 相对跨仓仓根。
+      const repoKey = parseRepo(content) || 'main';
+      const repoSet = getOrCreate(repoKey);
+      for (const p of parseAllowedPaths(content)) repoSet.add(p);
+    }
+  }
+  return repoMap;
+}
+
+/**
+ * 跨仓 task apply = no-op 校验（task-05 / D-009 / design §6 A3 G1）。
+ *
+ * 跨仓 task 的 commit 已由子代理直接落跨仓仓主干（NG-3），apply 阶段无 patch 可打（跨仓仓无
+ * worktree/meta/分支——A5 patch 路径不可复用）。本函数对每个跨仓 repo 的 task review.head
+ * 校验是否为该跨仓仓真实 commit（约束①+② 保险，R-05：子代理漏 commit / head 伪造 → 这里拦）。
+ *
+ * 不调 wm.cleanup（跨仓仓无主仓 worktree 可清——wm.cleanup 只作用主仓 worktree，跨仓仓主干工作区
+ * 永不进主仓 worktree 生命周期，无需也无法 cleanup）。这是 D-009 no-op 的关键：跨仓 commit 已落主干，
+ * apply 只校验不复用 patch、不 cleanup。
+ *
+ * review.json 物理在主仓 execute-runs（D-003），含 repo + head 字段（design §7.4）。本函数读主仓
+ * execute-runs 取最新 runId 的 reviews，按 review.repo 切片到对应跨仓 entry 校验 head。
+ *
+ * 无 review.json（execute 未走完 / 单 task --done 中途）→ 记 warning 不阻断（apply 可在 review 落盘前
+ * 被调用，如 worktree apply --check-only 预检；真阻断由 Task Review Gate 负责，这里不重复）。
+ *
+ * @param {object} ctx - MultiRepoContext（design §7.1）
+ * @param {string} projectRoot - 主仓根（读 .sillyspec/.runtime/execute-runs）
+ * @param {string} changeName
+ * @returns {{ errors: string[], warnings: string[], validated: Array<{repo:string, task:string, head:string}> }}
+ */
+function validateCrossRepoNoOp(ctx, projectRoot, changeName) {
+  const errors = [];
+  const warnings = [];
+  const validated = [];
+  if (!ctx || typeof ctx.hasCrossRepo !== 'function' || !ctx.hasCrossRepo()) {
+    return { errors, warnings, validated }; // 单仓退化：无跨仓，no-op 无事可做（零回归）
+  }
+  // review.json 物理在主仓 .runtime/execute-runs（D-003）。runtimeRoot = <projectRoot>/.sillyspec/.runtime
+  const runtimeRoot = join(projectRoot, '.sillyspec', '.runtime');
+  const runId = resolveLatestExecuteRunId({ runtimeRoot, changeName });
+  if (!runId) {
+    // 无 execute run → 无 review 可校验。不阻断（Task Review Gate 负责拦截 review 缺失），
+    // 仅 warn 提示跨仓 head 校验被跳过（约束①保险在此场景未触发，但功能不崩）。
+    warnings.push(`跨仓 task no-op 校验跳过：未找到 execute runId（${runtimeRoot}），无法读取跨仓 review.head。跨仓 commit 校验交由 Task Review Gate 负责。`);
+    return { errors, warnings, validated };
+  }
+  const tasksDir = join(runtimeRoot, 'execute-runs', runId, 'tasks');
+  if (!existsSync(tasksDir)) {
+    warnings.push(`跨仓 task no-op 校验跳过：execute run ${runId} 无 tasks/ 目录。`);
+    return { errors, warnings, validated };
+  }
+  // 遍历 ctx.repos，只对跨仓 entry（isMain=false）校验。每 entry 读所有 review.json 取 repo 匹配的 head。
+  for (const [repoKey, entry] of ctx.repos) {
+    if (entry.isMain) continue; // 主仓走 A5，不在此 no-op
+    // 扫 tasks/ 下 review.json，取 repo === repoKey 的 head 校验
+    let taskEntries = [];
+    try { taskEntries = readdirSync(tasksDir).filter(f => /^task-\d+$/.test(f)); } catch { taskEntries = []; }
+    for (const taskId of taskEntries) {
+      const reviewPath = join(tasksDir, taskId, 'review.json');
+      if (!existsSync(reviewPath)) continue;
+      const r = readReview(reviewPath);
+      // readReview 走 validateReviewSchema（task-03 扩展 repo 字段后兼容）；review 不完整则跳过（不在此拦）
+      if (!r.ok || !r.review) continue;
+      const reviewRepo = r.review.repo || 'main'; // schemaVersion=1 无 repo 视 main（design §9 兼容）
+      if (reviewRepo !== repoKey) continue;
+      const head = r.review.head;
+      if (!head) continue; // schema 校验已挡缺 head，防御性跳过
+      // 校验 head 是该跨仓仓真实 commit：git cat-file -e HEAD~0 / rev-parse 校验存在
+      // 用 cat-file -e <head> 校验 commit 存在（rev-parse 对缩写/不存在都非零退出）
+      const exists = gitQuiet(entry.gitDir, ['cat-file', '-e', head]);
+      if (exists === null) {
+        errors.push(
+          `跨仓 task no-op 校验失败：task ${taskId}（repo: ${repoKey}）的 review.head ${head} ` +
+          `不是跨仓仓 ${entry.gitDir} 的真实 commit（git cat-file -e 失败）。` +
+          `跨仓 task 的 commit 必须由子代理直接落跨仓仓主干（D-009），apply 为 no-op 不复用 patch，` +
+          `故 head 真实性是跨仓改动落地的唯一保险（约束①+②，R-05）。请检查子代理是否漏 commit 或 head 锡点漂移。`
+        );
+      } else {
+        validated.push({ repo: repoKey, task: taskId, head });
+      }
     }
   }
-  return allowSet;
+  return { errors, warnings, validated };
 }
 
 /**
  * apply worktree 变更到主工作区
  *
+ * **跨仓 task no-op（task-05 / D-009 / design §6 A3/A5）**：当传 ctx 且 ctx.hasCrossRepo() 时，
+ * 跨仓 task 的 commit 已由子代理直接落跨仓仓主干（NG-3 跨仓不经主仓 worktree），apply 阶段对跨仓
+ * task = no-op（无 patch 可打，跨仓仓无 worktree/meta/分支——A5 patch 路径不可复用）。只校验跨仓
+ * task review.head 是跨仓仓真实 commit（约束①+② 保险，R-05）+ 不调 wm.cleanup（跨仓仓无主仓 worktree
+ * 可清，wm.cleanup 只作用于主仓 worktree）。主仓 task 走原 A5 完整 apply 不动（GOAL-2 单仓零回归）。
+ *
  * @param {string} changeName - 变更名
- * @param {{ cwd?: string, checkOnly?: boolean }} opts
+ * @param {{ cwd?: string, checkOnly?: boolean, merge?: boolean, ctx?: object }} opts
+ *   - ctx：可选 MultiRepoContext（design §7.1）。缺省=单仓退化（仅主仓 apply，零行为变化，GOAL-2）。
+ *     提供 ctx 且含跨仓 entry 时，触发跨仓 no-op 校验（校验 review.head 真实 + 不 cleanup 跨仓）。
  * @returns {{
  *   ok: boolean,
  *   changedFiles: string[],
  *   extraFiles: string[],
  *   hashMismatchFiles: string[],
  *   patchPath: string|null,
- *   errors: string[]
+ *   errors: string[],
+ *   crossRepoValidated?: Array<{ repo: string, head: string }>
  * }}
  */
-export function applyWorktree(changeName, { cwd, checkOnly = false, merge = false } = {}) {
+export function applyWorktree(changeName, { cwd, checkOnly = false, merge = false, ctx = null } = {}) {
   const projectRoot = cwd || process.cwd();
   const wm = new WorktreeManager({ cwd: projectRoot });
   const meta = wm.getMeta(changeName);
@@ -234,8 +344,22 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
     patchPath: null,
     errors: [],
     merged: false,
+    crossRepoValidated: [],
   };
 
+  // --- 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 直接返回空（零回归）。
+  if (ctx) {
+    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);
+    result.crossRepoValidated = cross.validated;
+    // 跨仓 head 校验失败 = 跨仓改动未真落地，apply 不可继续（即使主仓 patch 能跑，跨仓 task 实际未完成）
+    if (cross.errors.length > 0) return result;
+  }
+
   // --- 1. 校验 worktree 存在 + meta.json 有效 ---
   if (!meta) {
     result.errors.push(`worktree not found: ${changeName}。meta.json 不存在或已损坏。`);
@@ -297,7 +421,11 @@ export function applyWorktree(changeName, { cwd, checkOnly = false, merge = fals
   }
 
   // --- 3. 解析 apply 文件清单（design §6 清单 ∪ plan TaskCard allowed_paths，execute 复盘 c） ---
-  const allowSet = resolveApplyAllowSet(projectRoot, changeName);
+  // resolveApplyAllowSet 返回 Map<repo, Set>（task-05 跨仓切片）；主仓 apply 只消费 main 仓 Set
+  // （主仓 worktree diff 只含主仓文件，跨仓文件在跨仓仓不进主仓 worktree diff）。跨仓 allowed_paths
+  // 仅作 Map 切片返回供上游用，主流程不消费（跨仓 apply=no-op，D-009）。
+  const allowMap = resolveApplyAllowSet(projectRoot, changeName);
+  const allowSet = allowMap.get('main') || new Set();
   const hasAllowList = allowSet.size > 0;
 
   // --- 3.5 主干已提交推进检测：hashMismatch 前移（Grill P0 修复，design §step 顺序修正）---

package/.sillyspec-platform-cleaned

@@ -1 +0,0 @@
-2026-08-10T17:08:53.237Z

package/.sillyspec-platform.json

@@ -1,7 +0,0 @@
-{
-  "specRoot": "C:\\Users\\qinyi\\IdeaProjects\\sillyspec\\.sillyspec",
-  "runtimeRoot": null,
-  "workspaceId": null,
-  "scanRunId": null,
-  "savedAt": "2026-08-11T08:03:50.313Z"
-}