sillyspec 3.26.2 → 3.26.3

package/src/stages/plan-postcheck.js

@@ -9,12 +9,13 @@
  *
  * 这些都是 noAI 步骤，不需要 LLM 参与。
  */
-import { existsSync, readFileSync as _readFileSync, readdirSync } from 'fs'
+import { existsSync, readFileSync as _readFileSync, readdirSync, mkdtempSync, writeFileSync, rmSync } from 'fs'
 // 归一化行尾为 LF：Windows 下 python/编辑器文本模式写 .md 会产生 CRLF，致本模块多处
 // frontmatter/字段正则（`^---\n`、`allowed_paths:\s*\n…`、`^goal:` 等）失配，报「缺 frontmatter
 // /缺字段」假错误（见缺陷 windows-python-crlf-taskcard）。读取时统一转 LF，一处覆盖全部正则。
 const readFileSync = (filePath, encoding) => _readFileSync(filePath, encoding).replace(/\r\n/g, '\n')
 import { join as pJoin } from 'path'
+import { tmpdir } from 'os'
 import jsYaml from 'js-yaml'
 import { parseFileChangeList, pathMatches } from '../change-list.js'
 import { getRule } from '../stage-contract-spec.js'
@@ -80,6 +81,111 @@ export function parseAllowedPaths(content) {
   return []
 }
 
+/**
+ * 从 task-NN.md frontmatter 解析标量字段（repo / base_commit / head_commit）。
+ * 复用 parseTaskContracts 的 frontmatter 提取 + js-yaml load 模式（标量可选字段，正则对引号/空值脆弱）。
+ *
+ * design §7.2 跨仓 task 卡 frontmatter 协议：
+ *   repo: sillyspec          # 可选，缺省='main'（调用方视 null 为 main）
+ *   base_commit: <sha>       # 可选，CLI 锡点写入（派发前落盘 base）
+ *   head_commit: <sha>       # 可选，CLI 锡点写入（回收 review 前落盘 head）
+ *
+ * 缺省 / 空值 / 无 frontmatter → null（向后兼容旧 task 卡）。
+ * @param {string} content - task 文件内容
+ * @param {string} field - frontmatter 字段名
+ * @returns {string|null}
+ */
+function parseFrontmatterScalar(content, field) {
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!fmMatch) return null
+  let fm
+  try {
+    fm = jsYaml.load(fmMatch[1]) || {}
+  } catch {
+    return null
+  }
+  const v = fm[field]
+  if (v == null) return null
+  const s = String(v).trim()
+  return s === '' ? null : s
+}
+
+/**
+ * 解析 task-NN.md frontmatter 的 repo 字段（跨仓 task 声明）。
+ * 缺省=null（=main，调用方按主仓处理）。design §7.2 / D-001。
+ * @param {string} content
+ * @returns {string|null}
+ */
+export function parseRepo(content) {
+  return parseFrontmatterScalar(content, 'repo')
+}
+
+/**
+ * 解析 task-NN.md frontmatter 的 base_commit 字段（CLI 派发跨仓 task 前落盘的 base 锡点）。
+ * 缺省=null（未锡点 / 单仓 task）。design §7.2 / D-010。
+ * @param {string} content
+ * @returns {string|null}
+ */
+export function parseBaseCommit(content) {
+  return parseFrontmatterScalar(content, 'base_commit')
+}
+
+/**
+ * 解析 task-NN.md frontmatter 的 head_commit 字段（CLI 回收 review 前落盘的 head 锡点）。
+ * 缺省=null（未锡点 / 单仓 task）。design §7.2 / D-010。
+ * @param {string} content
+ * @returns {string|null}
+ */
+export function parseHeadCommit(content) {
+  return parseFrontmatterScalar(content, 'head_commit')
+}
+
+/**
+ * 从 local.yaml 文本解析 repos: 段（跨仓 workspace 注册表）。
+ * 与 parseLocalYamlModules 同风格（轻量行扫描，不引 yaml 依赖），结构 Map<repoKey, absolutePath>。
+ *
+ * design §7.3 local.yaml repos schema：
+ *   repos:
+ *     sillyspec: C:/Users/qinyi/IdeaProjects/sillyspec
+ *     # main 不用注册（隐式 = cwd / specRoot 父目录）
+ *
+ * 无 repos 段 / 空段 / 入参空 → 空 Map（单仓 change 不读，向后兼容）。
+ *
+ * **职责边界**：本函数只 parse local.yaml 文本，不读 local.yaml 文件（文件读取入口归
+ * execute 启动 / task-09）。本函数不校验 declaredRepos ⊆ registry（D-007 fail-closed
+ * 校验在 MultiRepoContext 构造时做）。
+ * @param {string} yamlText
+ * @returns {Map<string, string>} repoKey → absolutePath
+ */
+export function parseRepoRegistry(yamlText) {
+  const reg = new Map()
+  if (!yamlText) return reg
+  const lines = yamlText.split('\n')
+  let startIdx = -1
+  for (let i = 0; i < lines.length; i++) {
+    if (/^repos:\s*(?:#.*)?$/.test(lines[i])) { startIdx = i; break }
+  }
+  if (startIdx === -1) return reg
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i]
+    // 遇到新的顶层 key（行首非空格且非注释）→ repos 段结束
+    if (line.length > 0 && !line.startsWith(' ') && !line.startsWith('\t') && !line.startsWith('#') && line.trim() !== '') break
+    // 条目格式：  <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)
+  }
+  return reg
+}
+
 /**
  * 检查 task-NN.md 是否包含验收标准章节
  * @param {string} content
@@ -253,6 +359,11 @@ export function validateBlueprintConsistency(changeDir) {
   // task 卡片基础字段文案从 manifest 同源(plan.task-card-structure);${id} 由下方 `${taskId} (${file})` 替换。
   const bsRule = getRule('plan.task-card-structure')
   const taskInfo = new Map()
+  // pathOwners 按 (repo, path) 二元组聚合（design §5.3 约束③ / D-008）：键 = `${repo}|${path}`，
+  // repo 缺省='main'（parseRepo 返 null → main）。跨仓 task 与主仓 task 同名物理路径分属不同 repo
+  // → 二元组键不同 → 不误判同 Wave 冲突（如主仓 src/task-review.js vs sillyspec src/task-review.js）。
+  // ⚠️ 键分隔符 `|` 假设 repo 名与 path 均不含 `|`（repo 名约束 [A-Za-z0-9_.\-]、path 含 / \，极低概率含 |）。
+  // value 结构 { repo, path, owners }：冲突文案对外仍显示纯 path（用户体验），内部按二元组判冲突。
   const pathOwners = new Map()
 
   for (const file of taskFiles) {
@@ -268,6 +379,8 @@ export function validateBlueprintConsistency(changeDir) {
     const allowedPaths = parseAllowedPaths(content)
     const hasAcceptance = hasAcceptanceCriteria(content)
     const hasTdd = hasTddOrVerify(content)
+    // repo 缺省='main'（parseRepo 返 null → 单仓 task，与既有行为零回归）
+    const repo = parseRepo(content) || 'main'
 
     taskInfo.set(taskId, { dependsOn, allowedPaths, hasAcceptance, hasTdd, file })
 
@@ -282,17 +395,19 @@ export function validateBlueprintConsistency(changeDir) {
     }
 
     for (const p of allowedPaths) {
-      if (!pathOwners.has(p)) pathOwners.set(p, [])
-      pathOwners.get(p).push(taskId)
+      const key = `${repo}|${p}`
+      if (!pathOwners.has(key)) pathOwners.set(key, { repo, path: p, owners: [] })
+      pathOwners.get(key).owners.push(taskId)
     }
   }
 
-  // 路径冲突（Wave 感知）：同 Wave 内 >1 task 共享 allowed_path → execute 强制并行（execute.js:603）
+  // 路径冲突（Wave 感知）：同 repo 同 Wave 内 >1 task 共享 allowed_path → execute 强制并行（execute.js:603）
   // 子代理会互相覆盖该文件 → error。跨 Wave 同文件 → 串行执行安全 → warning。
+  // 按 (repo, path) 二元组判冲突（约束③）：跨仓 task 与主仓 task 同名路径不误判（不同 repo → 不同键）。
   // Wave 口径 = plan.md 显式 `## Wave N`（parseTaskWavesFromPlan，与 execute 同源，非 topoSort 建议值）；
-  // plan.md 无显式 Wave → execute 全并行（隐式单 Wave，execute.js:402-408）→ 同文件即冲突。
+  // plan.md 无显式 Wave → execute 全并行（隐式单 Wave，execute.js:402-408）→ 同 repo 同文件即冲突。
   const waveOfTask = parseTaskWavesFromPlan(pJoin(changeDir, 'plan.md'))
-  for (const [p, owners] of pathOwners) {
+  for (const [, { repo, path: p, owners }] of pathOwners) {
     if (owners.length < 2) continue
     if (waveOfTask === null) {
       errors.push(
@@ -515,6 +630,120 @@ export function validateTaskCommands(changeDir, projectRoot, modules = null) {
 // 路径容差匹配（normalizePath / globMatch / pathMatches）复用自 change-list.js，
 // design 清单解析与 allowed_paths 对账共用同一套匹配语义，避免两处逻辑漂移。
 
+/**
+ * design §6 按仓分段段头识别（D-014）：`## <repo> 仓变更`（如 `## sillyspec 仓变更`）。
+ * 段头为 h2，repo 名取段头首 token（去空白/编号前缀）。容忍可选编号前缀与尾随空白/冒号。
+ * 不命中（非仓变更段头）→ null。
+ */
+const REPO_SECTION_HEADER_RE = /^#{2,3}\s+(?:\d+[.)]\s*)?([A-Za-z0-9_.\-]+)\s*仓变更\s*[:：]?\s*$/
+
+/**
+ * design §6 文件清单章节标题（与 change-list.js FILE_LIST_SECTION_RE 同源，避免 import 私有常量）。
+ * 容忍可选编号前缀（`## 6. 文件变更清单`），与 change-list 解析口径一致。
+ */
+const FILE_LIST_SECTION_RE = /^#{2,3}\s*(?:\d+[.)]\s*)?(文件变更清单|变更文件清单|文件清单|File Changes|Files to Change)/im
+
+/**
+ * 按 repo 解析 design §6 文件清单（约束③ / D-014）。
+ *
+ * 支持 design §6 按仓分段：`## <repo> 仓变更` 段头下的路径归该 repo；无段头时整章节归 'main'
+ * （向后兼容单仓 design，与原 parseFileChangeList 行为等价）。段内路径解析复用 parseFileChangeList
+ * （表格列定位 / exclude 子段 / 占位符过滤 / CRLF 容错全部继承，零漂移）——方法是：把每段内容包成
+ * 临时 design 文件（前置标准 `## 文件变更清单` 标题），写 OS tmp 调 parseFileChangeList，立即清理。
+ *
+ * 为什么不复用单次 parseFileChangeList：change-list.js 的通用 parser 把段头 `## <repo> 仓变更`
+ * 当成「下一个 ## 章节」截断主章节（line 173 `^##\s`），跨仓段路径会丢——这正是 task-03 要修的。
+ *
+ * 返回值结构（与 pathOwners 二元组对齐）：
+ *   Map<repo, Set<path>> —— 每个 repo 的 design 清单路径集
+ *   外加 _hasSegmentHeader 标记（调用方据此决定是否走分段对账路径）
+ *
+ * @param {string} designPath - design.md 绝对路径
+ * @returns {{ byRepo: Map<string, Set<string>>, hasSegmentHeader: boolean, allFiles: string[] }}
+ */
+function parseDesignCoverageByRepo(designPath) {
+  const byRepo = new Map()
+  const allFiles = []
+  if (!designPath || !existsSync(designPath)) {
+    return { byRepo, hasSegmentHeader: false, allFiles }
+  }
+  const content = readFileSync(designPath, 'utf8')
+
+  const sectionMatch = content.match(FILE_LIST_SECTION_RE)
+  if (!sectionMatch) {
+    return { byRepo, hasSegmentHeader: false, allFiles }
+  }
+
+  // 主章节起点（match index）→ 扫描到下一个非段头的 `## ` 标题或文件末尾。
+  // 段头 `## <repo> 仓变更` 是 h2 但属本章节的子分段，不应触发章节结束。
+  const lines = content.slice(sectionMatch.index).split('\n')
+  // 先扫一遍：本章节内是否含至少一个段头（决定 hasSegmentHeader / 走分段路径 vs 退化路径）
+  let hasSegmentHeader = false
+  const sectionLines = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    if (i > 0 && /^##\s/.test(line) && !REPO_SECTION_HEADER_RE.test(line)) {
+      // 遇到非段头的 h2 标题（如 `## 7. 接口定义`）→ 主章节结束
+      break
+    }
+    if (REPO_SECTION_HEADER_RE.test(line)) hasSegmentHeader = true
+    sectionLines.push(line)
+  }
+
+  if (!hasSegmentHeader) {
+    // 无段头 → 整章节归 main（等价原 parseFileChangeList 行为）
+    const main = new Set(parseFileChangeList(designPath))
+    if (main.size > 0) byRepo.set('main', main)
+    for (const p of main) allFiles.push(p)
+    return { byRepo, hasSegmentHeader: false, allFiles }
+  }
+
+  // 有段头 → 按 repo 切片，每段构造临时 design 调 parseFileChangeList
+  // 当前 repo：段头之前的内容（主章节标题到第一个段头之间）归 'main'
+  let currentRepo = 'main'
+  const segments = new Map() // repo -> 行数组（含表格/列表，不含段头本身）
+  let beforeFirstHeader = [] // 段头之前的 main 段内容
+  let seenHeader = false
+  for (const line of sectionLines.slice(1)) { // 跳过主章节标题行（sectionLines[0]）
+    const hdr = line.match(REPO_SECTION_HEADER_RE)
+    if (hdr) {
+      currentRepo = hdr[1]
+      seenHeader = true
+      if (!segments.has(currentRepo)) segments.set(currentRepo, [])
+      continue
+    }
+    if (!seenHeader) {
+      beforeFirstHeader.push(line)
+    } else {
+      segments.get(currentRepo).push(line)
+    }
+  }
+
+  // 段头之前的 main 段（若有内容）也要对账
+  if (beforeFirstHeader.filter(l => l.trim()).length > 0) {
+    segments.set('main', beforeFirstHeader)
+  }
+
+  const tmpDir = mkdtempSync(pJoin(tmpdir(), 'design-cov-seg-'))
+  try {
+    for (const [repo, segLines] of segments) {
+      // 把段内容包成完整 design md（前置主章节标题，让 parseFileChangeList 识别章节起点）
+      const virtualDesign = ['## 文件变更清单', '', ...segLines, ''].join('\n')
+      const tmpPath = pJoin(tmpDir, `${repo}.md`)
+      writeFileSync(tmpPath, virtualDesign)
+      const segFiles = [...parseFileChangeList(tmpPath)]
+      if (segFiles.length === 0) continue
+      const set = byRepo.get(repo) || new Set()
+      for (const p of segFiles) { set.add(p); allFiles.push(p) }
+      byRepo.set(repo, set)
+    }
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true })
+  }
+
+  return { byRepo, hasSegmentHeader: true, allFiles }
+}
+
 /**
  * design.md 文件变更清单 → tasks allowed_paths 覆盖对账
  *
@@ -525,6 +754,10 @@ export function validateTaskCommands(changeDir, projectRoot, modules = null) {
  * 在 plan-postcheck（execute 前）确定性拦截：design 清单中每个源码文件必须被
  * 至少一个 task 的 allowed_paths 覆盖（前缀 / glob 容差匹配）。
  *
+ * 跨仓分段对账（约束③ / D-014）：design §6 支持 `## <repo> 仓变更` 段头按仓分段，
+ * task allowed_paths 按 (repo, path) 二元组归属——跨仓 task 的 allowed_paths 只覆盖
+ * 对应 repo 段的 design 清单，不与主仓段交叉误判。无段头时整章节归 main（零回归）。
+ *
  * fail-open 边界（不阻断）：design.md 不存在、无 task 卡片（none 级别）、
  * task 卡片均无 allowed_paths（由 validatePlanFeasibility 把关）。
  * 阻断边界：有 task 卡片但 design 缺清单章节（light/full 已生成 task → design 必有清单）、
@@ -552,7 +785,8 @@ export function validateDesignFileCoverage(changeDir) {
     return { ok: true, errors, warnings, designFiles: [], uncovered: [] }
   }
 
-  const designFiles = [...parseFileChangeList(designPath)]
+  // 按仓分段解析 design §6（约束③）：段头 `## <repo> 仓变更` → 段内路径归该 repo；无段头 → 全 main
+  const { byRepo: designByRepo, hasSegmentHeader, allFiles: designFiles } = parseDesignCoverageByRepo(designPath)
   // 两种断裂文案(缺清单章节 / 文件未覆盖)从 manifest 同源(plan.design-file-coverage.data)。
   const dcRule = getRule('plan.design-file-coverage')
   if (designFiles.length === 0) {
@@ -561,16 +795,37 @@ export function validateDesignFileCoverage(changeDir) {
     errors.push(dcRule.data.messageMissingList)
     return { ok: false, errors, warnings, designFiles: [], uncovered: [] }
   }
-  const allAllowed = []
+
+  // task allowed_paths 也按 (repo, path) 二元组收集（与 pathOwners 同口径，约束③）：
+  // 跨仓 task 的 allowed_paths 只覆盖对应 repo 的 design 段，不与主仓段交叉误判。
+  const taskAllowedByRepo = new Map() // repo -> string[]
+  let totalAllowed = 0
   for (const file of taskFiles) {
     const content = readFileSync(pJoin(tasksDir, file), 'utf8')
-    allAllowed.push(...parseAllowedPaths(content))
+    const repo = parseRepo(content) || 'main'
+    const allowed = parseAllowedPaths(content)
+    if (allowed.length === 0) continue
+    totalAllowed += allowed.length
+    const arr = taskAllowedByRepo.get(repo) || []
+    arr.push(...allowed)
+    taskAllowedByRepo.set(repo, arr)
   }
-  if (allAllowed.length === 0) {
+  if (totalAllowed === 0) {
     return { ok: true, errors, warnings, designFiles, uncovered: [] }
   }
 
-  const uncovered = designFiles.filter(df => !allAllowed.some(ap => pathMatches(df, ap)))
+  // 对账：design 的每条 (repo, path) 必须被同 repo 的 task allowed_paths 覆盖。
+  // 无分段（单仓）时 byRepo 只含 main，taskAllowedByRepo 也只含 main → 退化原扁平对账（零回归）。
+  const uncovered = []
+  for (const [repo, paths] of designByRepo) {
+    const allowed = taskAllowedByRepo.get(repo) || []
+    for (const df of paths) {
+      // 同 repo 无 task 声明 → 整段无覆盖；或有 task 但无 pathMatches → 未覆盖
+      if (!allowed.some(ap => pathMatches(df, ap))) {
+        uncovered.push(hasSegmentHeader ? `[${repo}] ${df}` : df)
+      }
+    }
+  }
   if (uncovered.length > 0) {
     errors.push(
       dcRule.data.messageUncovered

package/src/sync.js

@@ -268,6 +268,29 @@ export class SyncManager {
     }
     console.log(`[sync] 平台连接成功: ${url}`);
 
+    // 换发 workspace-scoped 同步 token（task-09 / D-005@v1）：用传入 user 级 token
+    // （shk_live_ / JWT）作 Bearer + 本地 root_path（connect 的 cwd，与平台
+    // Workspace.root_path 绑定值等值匹配）调 resolve-by-root-path。成功取 shpsync_
+    // 覆盖 token 写入 platform 段；404（root_path 未绑）/403（无 WORKSPACE_WRITE）/断网
+    // 均降级沿用原 token 继续（best-effort 不阻断 connect）。
+    let effectiveToken = token;
+    const resolveUrl = `${normalizedUrl}/api/workspaces/resolve-by-root-path`;
+    const resolved = await fetchJson(resolveUrl, {
+      method: 'POST',
+      headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ root_path: this.cwd }),
+    });
+    if (resolved && resolved.token && resolved.token.startsWith('shpsync_')) {
+      effectiveToken = resolved.token;
+      console.log(
+        `[sync] 已换发 workspace-scoped 同步 token (workspace: ${resolved.workspace_id})`
+      );
+    } else {
+      console.warn(
+        '[sync] 换发 workspace-scoped token 失败（404/403/断网），沿用原 token 继续'
+      );
+    }
+
     // 解析推送者身份（D-004）：显式 > git user.name > env；全失败留空不写 user 字段
     const resolvedUser = resolvePlatformUser(this.cwd, user);
 
@@ -275,7 +298,7 @@ export class SyncManager {
     // （旧 read-modify-write 经 parseSimpleYaml 丢注释+丢非扁平结构，round-trip 清空用户手填内容）。
     const platformEntries = [
       `  url: ${normalizedUrl}`,
-      `  token: ${token}`,
+      `  token: ${effectiveToken}`,
       `  last_connected: ${new Date().toISOString()}`,
     ];
     if (resolvedUser) {

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 }
 }