sillyspec 3.26.1 → 3.26.3

package/src/task-review.js

@@ -12,13 +12,38 @@ import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync, statSy
 import { join, resolve } from 'path'
 import { execFileSync } from 'child_process'
 import { pathMatches } from './change-list.js'
-import { parseAllowedPaths } from './stages/plan-postcheck.js'
+import { parseAllowedPaths, parseRepo, parseBaseCommit, parseHeadCommit } from './stages/plan-postcheck.js'
 import { resolveVerifyChangedFiles } from './verify-postcheck.js'
 import { WorktreeManager } from './worktree.js'
 import { resolveRuntimeRoot } from './run/shared.js'
 
 // ── review.json schema version ──
+//
+// design §7.4 / R-07：task-review 的 review.json schemaVersion 1→2（新增可选 repo 字段），
+// 旧 v1（无 repo）向后兼容视 'main'，不阻断既有 change archive。
+//
+// 关于常量与"1→2"：REVIEW_SCHEMA_VERSION 常量被 stage-review.js（文档型阶段评审）共享——
+// stage-review.test.mjs:358 + register.test.mjs:40 断言其值 === 1，且 stage-review.js 不在本次
+// 变更的 allowed_paths 内。两个 schema（task code-review / stage doc-review）逻辑独立，但历史共享
+// 同一常量。本期保持 REVIEW_SCHEMA_VERSION=1 作 stage-review 写侧默认值（不破坏 stage-review），
+// 同时用 REVIEW_SCHEMA_VERSIONS_ACCEPTED=[1,2] 表达"读侧接受两版"——validateReviewSchema 兼容 v1/v2，
+// 跨仓 task 写 review.json 可用 v2 带 repo 字段，单仓/旧 change 仍用 v1。后续可拆分 stage-review 专用
+// 常量，本期遵循 allowed_paths 约束不扩散到 stage-review.js。
 export const REVIEW_SCHEMA_VERSION = 1
+export const REVIEW_SCHEMA_VERSIONS_ACCEPTED = [1, 2]
+// repo 缺省值（review.repo / task 卡 repo 缺省时统一按 'main' 处理）。design §7.2 / §7.4。
+export const DEFAULT_REPO_KEY = 'main'
+
+/**
+ * 规范化 review.repo / task 卡 repo 字段为有效 repoKey。
+ * 缺省 / 非字符串 / 空串 → 'main'（向后兼容旧 v1 review + 无 repo 声明的单仓 task）。
+ * @param {any} repo
+ * @returns {string}
+ */
+export function normalizeRepoKey(repo) {
+  if (typeof repo !== 'string' || repo.trim() === '') return DEFAULT_REPO_KEY
+  return repo.trim()
+}
 
 // ── 合法 verdict 枚举 ──
 export const VALID_VERDICTS = ['pass', 'fail', 'cannot_verify']
@@ -156,6 +181,12 @@ export function summarizeTaskCompletion({ changeDir, runtimeRoot, changeName })
 
 /**
  * 校验单个 review.json 文件
+ *
+ * schema 版本（design §7.4 / R-07）：接受 v1（无 repo，单仓向后兼容）+ v2（新增可选 repo 字段，
+ * 跨仓 task 标记 repo: <key>）。repo 缺省 / 非字符串 → 视 'main'（normalizeRepoKey），不阻断。
+ * repo 的真实存在性（local.yaml repos 注册）由 MultiRepoContext 约束② fail-closed 兜底，schema 层
+ * 只做"非字符串时不阻断"的宽松类型校验（review.json 是 agent 手写产物，宽松避免误杀）。
+ *
  * @param {object} review - 解析后的 JSON 对象
  * @returns {{ ok: boolean, errors: string[] }}
  */
@@ -166,14 +197,20 @@ export function validateReviewSchema(review) {
     return { ok: false, errors }
   }
 
-  if (review.schemaVersion !== REVIEW_SCHEMA_VERSION) {
-    errors.push(`schemaVersion 应为 ${REVIEW_SCHEMA_VERSION}，实际为 ${review.schemaVersion}`)
+  if (!REVIEW_SCHEMA_VERSIONS_ACCEPTED.includes(review.schemaVersion)) {
+    errors.push(`schemaVersion 应为 ${REVIEW_SCHEMA_VERSIONS_ACCEPTED.join(' 或 ')}，实际为 ${review.schemaVersion}`)
   }
 
   if (!review.task || typeof review.task !== 'string') {
     errors.push('缺少 task 字段（应为 "task-XX" 格式）')
   }
 
+  // repo（可选，v2 新增）：类型宽松校验。非字符串 / 空串 → 视 'main'，不阻断 schema。
+  // 跨仓 repo 的注册存在性由 MultiRepoContext 构造时 fail-closed 校验（约束②）。
+  if (review.repo !== undefined && typeof review.repo !== 'string') {
+    errors.push(`repo 字段（若提供）应为字符串，实际类型为 ${typeof review.repo}`)
+  }
+
   if (!VALID_VERDICTS.includes(review.specVerdict)) {
     errors.push(`specVerdict 无效：${review.specVerdict}（应为 ${VALID_VERDICTS.join('/')})`)
   }
@@ -306,6 +343,11 @@ export function validateCheckedTaskReviews({ planContent, runtimeRoot, executeRu
  * @param {string} opts.runtimeRoot - .sillyspec/.runtime 的绝对路径
  * @param {string} opts.executeRunId - execute run id（如 'exec-2026-06-23-131400'）
  * @param {boolean} [opts.allowCannotVerify=true] - 是否允许 cannot_verify（默认允许，给 warning）
+ * @param {string} [opts.changeDir] - change 目录（读 task-NN.md frontmatter 判 low_risk）
+ * @param {string} [opts.gitDir] - 主仓 git 工作目录（单仓 review 真实性校验 cwd；无 ctx 时用此）
+ * @param {object} [opts.ctx] - MultiRepoContext 实例（D-013：缺省/null → 走 opts.gitDir 单仓零回归；
+ *   有 ctx 时按 review.repo（缺省 'main'）从 ctx.resolve(repo).gitDir 取每条 review 的校验 cwd，
+ *   跨仓 gitDir=跨仓仓根，使 base..head diff 在正确仓跑——design §6 task-review A1 行）
  * @returns {{ ok: boolean, errors: string[], warnings: string[], requiredEvidence: Array<{task: string, verdict: string, evidence: string[]}> }}
  */
 /**
@@ -327,7 +369,7 @@ function isTaskLowRisk(changeDir, taskId) {
 }
 
 export function validateTaskReviews(opts) {
-  const { planContent, runtimeRoot, executeRunId, allowCannotVerify = true, changeDir = null, gitDir = null } = opts
+  const { planContent, runtimeRoot, executeRunId, allowCannotVerify = true, changeDir = null, gitDir = null, ctx = null } = opts
 
   const taskIds = parseTaskIdsFromPlan(planContent)
 
@@ -382,8 +424,23 @@ export function validateTaskReviews(opts) {
     }
 
     // ── git 真实性交叉校验：base/head 必须是真实 commit，diff 不能为空 ──
-    if (gitDir) {
-      const evidence = verifyReviewGitEvidence(review, gitDir)
+    // D-013 + design §6 A1：有 ctx 时按 review.repo（缺省 'main'）切 gitDir——跨仓 review 的
+    // base/head 是跨仓仓 commit，必须在跨仓仓根跑 rev-parse/diff，否则判伪造误杀。无 ctx 时退回
+    // opts.gitDir（单仓零回归）。reviewGitDir 为 null 则跳过证据校验（与原逻辑一致）。
+    let reviewGitDir = gitDir
+    if (ctx) {
+      const repoKey = normalizeRepoKey(review.repo)
+      const entry = ctx.resolve(repoKey)
+      if (entry && entry.gitDir) {
+        reviewGitDir = entry.gitDir
+      } else if (repoKey !== 'main') {
+        // 跨仓 repo 在 ctx 中未注册 → 不应发生（MultiRepoContext 构造已 fail-closed 拦截未注册），
+        // 防御性降级为 warning 提示，不阻断（review.json schema 已过，仓库解析交给 ctx 上游负责）。
+        warnings.push(`${taskId}: review.repo="${repoKey}" 在 MultiRepoContext 未解析到 entry，退回主仓 gitDir 校验`)
+      }
+    }
+    if (reviewGitDir) {
+      const evidence = verifyReviewGitEvidence(review, reviewGitDir)
       for (const w of evidence.warnings) warnings.push(`${taskId}: ${w}`)
       if (!evidence.ok) {
         for (const err of evidence.errors) errors.push(`${taskId}: ${err}`)
@@ -681,10 +738,10 @@ export function resolveLatestExecuteRunId({ runtimeRoot, changeName }) {
  * fail-open：任何异常 → 返回统计，仅 console.warn，不阻断 execute 完成（草稿是兜底，
  * 缺了也只是退回原状——gate 报缺 review.json，agent 手补，不比修复前差）。
  *
- * @param {{ changeName: string, cwd: string, platformOpts?: object }} opts
+ * @param {{ changeName: string, cwd: string, platformOpts?: object, ctx?: object|null }} opts
  * @returns {Promise<{ generated: number, skipped: number, unattributed: string[], reason?: string, executeRunId?: string }>}
  */
-export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts = {} }) {
+export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts = {}, ctx = null }) {
   const specBase = platformOpts.specRoot || join(cwd, '.sillyspec')
   const runtimeRoot = resolveRuntimeRoot(platformOpts, specBase)
   const changeDir = join(specBase, 'changes', changeName)
@@ -709,11 +766,15 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
 
   // base..head diff 文件集（worktree-aware；null=git 不可用，[]=无 commit diff）
   const diffFiles = resolveVerifyChangedFiles(cwd, changeName)
-  if (!diffFiles || diffFiles.length === 0) {
+  // 单仓模式（无 ctx）：主仓无 diff 即无任何 task 可生成 → 提前返回（原逻辑零回归）。
+  // 有 ctx：主仓无 diff 不阻断——跨仓 task 的 diff 在跨仓仓根独立取（per-task），主仓 task 自然跳过（空 changedFiles）。
+  if (!ctx && (!diffFiles || diffFiles.length === 0)) {
     return { generated: 0, skipped: 0, unattributed: [], executeRunId, reason: 'base..head 无代码 diff（改动未 commit？）' }
   }
 
   // base/head + gitDir：与 gates.js reviewGitDir 同源（worktree 优先，in-place 回退 cwd）
+  // 有 ctx 时主仓 base/head 仅供主仓 task 用；ctx 主仓 entry 也可提供 base（meta.baseHash 同源）。
+  // 主仓 base/head 解析失败 + 无 ctx → 提前返回（原逻辑）；有 ctx → 仅记 null，主仓 task 后续跳过（不阻断跨仓 task）。
   let base = null
   let head = null
   let reviewGitDir = cwd
@@ -726,12 +787,19 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
     }
   } catch {}
   if (!base) {
-    return { generated: 0, skipped: 0, unattributed: diffFiles, executeRunId, reason: '无 worktree meta.baseHash（无法定 base/head）' }
-  }
-  try {
-    head = runGit(reviewGitDir, ['rev-parse', 'HEAD'])
-  } catch {
-    return { generated: 0, skipped: 0, unattributed: diffFiles, executeRunId, reason: 'git rev-parse HEAD 失败（' + reviewGitDir + '）' }
+    if (!ctx) {
+      return { generated: 0, skipped: 0, unattributed: diffFiles, executeRunId, reason: '无 worktree meta.baseHash（无法定 base/head）' }
+    }
+    // 有 ctx：主仓 base 缺失（主仓无 worktree / 单纯跨仓 change）→ 主仓 task 后续跳过，跨仓 task 照常
+  } else {
+    try {
+      head = runGit(reviewGitDir, ['rev-parse', 'HEAD'])
+    } catch {
+      if (!ctx) {
+        return { generated: 0, skipped: 0, unattributed: diffFiles, executeRunId, reason: 'git rev-parse HEAD 失败（' + reviewGitDir + '）' }
+      }
+      // 有 ctx：主仓 HEAD 失败不阻断跨仓 task；head 留 null，主仓 task 后续按空 changedFiles 跳过
+    }
   }
 
   const taskFiles = readdirSync(tasksDir).filter(f => /^task-\d+\.md$/.test(f)).sort()
@@ -753,34 +821,76 @@ export async function generateTaskReviewDrafts({ changeName, cwd, platformOpts =
 
     const content = readFileSync(join(tasksDir, tf), 'utf8')
     const allowedPaths = parseAllowedPaths(content)
-    const changedFiles = allowedPaths.length > 0
-      ? diffFiles.filter(f => allowedPaths.some(p => pathMatches(f, p)))
-      : []
+
+    // ── 多仓分支（design §6 A2 / D-006 / D-010）：跨仓 task 用 task 卡双锡点 + 跨仓仓 diff ──
+    const taskRepo = normalizeRepoKey(parseRepo(content))
+    const crossEntry = (ctx && taskRepo !== DEFAULT_REPO_KEY) ? ctx.resolve(taskRepo) : null
+    let taskBase = base
+    let taskHead = head
+    let taskChangedFiles
+    let draftRepo
+
+    if (crossEntry) {
+      // 跨仓 task：base/head 必须读 task 卡锡点（跨仓仓无 meta.json）。缺任一 → 跳过留给 agent。
+      const baseCommit = parseBaseCommit(content)
+      const headCommit = parseHeadCommit(content)
+      if (!baseCommit || !headCommit) {
+        skipped++
+        continue
+      }
+      taskBase = baseCommit
+      taskHead = headCommit
+      draftRepo = taskRepo
+      // 跨仓 diff 在跨仓仓根跑（base..head 锡点锚定，非瞬时 HEAD——D-010 head 精度）
+      let crossDiffFiles = []
+      try {
+        const out = runGit(crossEntry.gitDir, ['diff', '--name-only', `${baseCommit}..${headCommit}`])
+        crossDiffFiles = out ? out.split('\n').filter(Boolean).map(p => p.replace(/\\/g, '/')) : []
+      } catch {
+        // git diff 失败（锡点非真实 commit 等）→ 不生成伪造草稿，留给 agent 手补
+        skipped++
+        continue
+      }
+      taskChangedFiles = allowedPaths.length > 0
+        ? crossDiffFiles.filter(f => allowedPaths.some(p => pathMatches(f, p)))
+        : crossDiffFiles
+    } else {
+      // 主仓 task（taskRepo='main' 或无 ctx 跨仓解析失败 → 退单仓口径）
+      // diffFiles 可能为 null（git 不可用）——有 ctx 时主仓 git 异常不阻断跨仓 task，主仓 task 自然跳过。
+      const mainDiff = Array.isArray(diffFiles) ? diffFiles : []
+      taskChangedFiles = allowedPaths.length > 0
+        ? mainDiff.filter(f => allowedPaths.some(p => pathMatches(f, p)))
+        : []
+    }
 
     // 空 changedFiles 的 task 不生成（verifyReviewGitEvidence 判空 diff 伪造，留给 agent 手补）
-    if (changedFiles.length === 0) {
+    if (taskChangedFiles.length === 0) {
       skipped++
       continue
     }
-    changedFiles.forEach(f => attributed.add(f))
+    // unattributed 只统计主仓 diff（跨仓 diff 路径相对跨仓仓根，与主仓 unattributed 语义无关）
+    if (!crossEntry) {
+      taskChangedFiles.forEach(f => attributed.add(f))
+    }
 
     const draft = {
       schemaVersion: REVIEW_SCHEMA_VERSION,
       task: taskId,
-      base,
-      head,
-      changedFiles,
+      base: taskBase,
+      head: taskHead,
+      changedFiles: taskChangedFiles,
       specVerdict: 'cannot_verify',
       qualityVerdict: 'cannot_verify',
       requiredEvidence: ['auto-generated draft: 待 agent 对照 ' + taskId + ' brief + diff 复核后升级为 pass/fail'],
-      reviewerNotes: 'auto-generated draft from git diff ' + base.slice(0, 8) + '..' + head.slice(0, 8) + ';verdict=未评审（worktree execute 主 agent 实现模式兜底，坑2）',
+      reviewerNotes: 'auto-generated draft from git diff ' + taskBase.slice(0, 8) + '..' + taskHead.slice(0, 8) + ';verdict=未评审（worktree execute 主 agent 实现模式兜底，坑2）',
     }
+    if (draftRepo) draft.repo = draftRepo
     mkdirSync(reviewDir, { recursive: true })
     writeFileSync(reviewPath, JSON.stringify(draft, null, 2) + '\n')
     generated++
   }
 
-  const unattributed = diffFiles.filter(f => !attributed.has(f))
+  const unattributed = (Array.isArray(diffFiles) ? diffFiles : []).filter(f => !attributed.has(f))
   return { generated, skipped, unattributed, executeRunId }
 }
 

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',
+  }
 }
 
 /**