sillyspec 3.26.2 → 3.26.3

package/src/run/shared.js

@@ -70,6 +70,8 @@ export function assertSafeChangeName(name, label = '变更名') {
 import { buildExecuteSteps } from '../stages/execute.js'
 import { buildPlanSteps } from '../stages/plan.js'
 import { stageRegistry } from '../stages/index.js'
+import { parseRepo, parseRepoRegistry } from '../stages/plan-postcheck.js'
+import { MultiRepoContext } from './multi-repo-context.js'
 
 /**
  * 解析 prompt 中的 {{include: <name>}} 占位符：读包内 templates/prompts/<name>.md 注入。
@@ -689,6 +691,158 @@ export function formatWaitOptions(raw) {
 }
 
 
+/**
+ * 进程级 MultiRepoContext 缓存（D-013 G2：execute 启动构造一次，贯穿 execute/apply/verify 不重建）。
+ *
+ * key = `${cwd} ${changeName}`（cwd 隔离防多仓并发串扰；changeName 隔离防同进程多 change 切换串扰）。
+ * 跨 CLI 命令（execute vs apply vs verify 各是独立进程）各自构造——design §7.2 G2 明确 apply/verify
+ * 「复用 execute 实例，**或**从 review.json.repo + local.yaml repos 反推」，进程级缓存指同一 CLI 命令内复用。
+ *
+ * 失效语义：ctx 是纯内存对象（task-01 不持久化），进程结束自动释放。无需手动清理。
+ * 缓存命中场景：execute 单次 --done 内 getStageSteps（派发）+ completeStageGates（gate）+ 阶段完成
+ * 收尾多次取同一 ctx；apply/verify 同理。fail-closed 抛错不缓存（下次重试重新构造）。
+ */
+const _multiRepoCtxCache = new Map()
+
+/**
+ * 读 local.yaml 原始文本（best-effort，不存在/读失败返 ''）。
+ * 与 sync.js readLocalYamlRaw 同风格，但本模块不引 sync.js（避免循环依赖 + sync.js 非 export）。
+ * local.yaml 路径 = `<cwd>/.sillyspec/local.yaml`（与 sync.js/config-schema.js 一致）。
+ * @param {string} cwd
+ * @returns {string}
+ */
+function readLocalYamlRaw(cwd) {
+  const p = join(cwd, '.sillyspec', 'local.yaml')
+  if (!existsSync(p)) return ''
+  try {
+    return readFileSync(p, 'utf8')
+  } catch {
+    return ''
+  }
+}
+
+/**
+ * 从 plan.md 内容聚合所有 task 卡片声明的 repo:（去重，含 'main' 隐式）。
+ *
+ * design §5.4 execute 启动段 + §7.2：扫 plan.md 所有 task 卡片 frontmatter，用 parseRepo 解析
+ * repo: 字段（缺省='main'），去重后返回数组。'main' 永远隐式在列（主仓 task 不写 repo: 也算主仓）。
+ *
+ * 聚合策略：plan.md 由 plan 阶段生成，task 卡片 frontmatter 形如 `---\nrepo: sillyspec\n...\n---`
+ * （与 task-NN.md 同源）。本函数全局匹配所有 frontmatter 块（`/^---\n([\s\S]*?)\n---/mg`），
+ * 每块重新拼成完整 frontmatter 喂 parseRepo（parseRepo 内部 `^---\n...\n---` 锚开头）。
+ *
+ * @param {string} planContent
+ * @returns {string[]} 去重后的 repo 数组（至少含 'main'）
+ */
+export function aggregateDeclaredRepos(planContent) {
+  const seen = new Set(['main']) // main 永远隐式
+  if (!planContent) return ['main']
+  // 全局匹配所有 frontmatter 块（m 标志让 ^ 匹配每行行首，但此处 ^--- 要求行首 ---，
+  // 配合 [\s\S]*? 非贪婪到下一个 ---）。每块重新拼完整 frontmatter 喂 parseRepo。
+  const fmRegex = /^---\r?\n([\s\S]*?)\r?\n---/gm
+  let match
+  while ((match = fmRegex.exec(planContent)) !== null) {
+    const fmBody = match[1]
+    // 重新拼成 parseRepo 期望的完整 frontmatter（---\n<body>\n---）
+    const repo = parseRepo(`---\n${fmBody}\n---`)
+    if (repo && !seen.has(repo)) seen.add(repo)
+  }
+  return Array.from(seen)
+}
+
+/**
+ * 构造或取进程级 MultiRepoContext 单例（D-013 G2）。
+ *
+ * design §5.4 execute 启动段 + §7.2 G2 + 决策 D-001/D-013：
+ *   - 读 local.yaml repos: 段（parseRepoRegistry）→ repoRegistry Map（main 隐式不注册）
+ *   - 扫 plan.md 所有 task 卡片 repo:（aggregateDeclaredRepos）→ declaredRepos（含 'main'）
+ *   - 构造 MultiRepoContext（约束② fail-closed：未注册 repo / 跨仓 git 不可用抛错阻断）
+ *   - 按 `${cwd} ${changeName}` 缓存，同进程同 change 复用
+ *
+ * **单仓退化**（design §7.2 「main 隐式为 cwd 不用注册」）：local.yaml 无 repos: 段 + 单仓 change
+ * （declaredRepos=['main']）→ repoRegistry=空 Map，MultiRepoContext 退化为 {main:{...}} 单值 map，
+ * hasCrossRepo()=false，所有 ctx 透传点缺省行为零回归（task-01/04/05/06/07/08 各模块 ctx=null 等价）。
+ *
+ * **跨仓 fail-closed**（约束② D-007）：declaredRepos 含 local.yaml 未注册的 repo key，或跨仓仓
+ * git rev-parse 失败 → MultiRepoContext 构造抛错，本函数**不缓存**该错误，原样上抛阻断 execute 启动。
+ *
+ * 缓存语义：命中返回已构造实例；未命中且构造成功则缓存后返回；构造失败不缓存（下次重试重新构造）。
+ *
+ * @param {Object} opts
+ * @param {string} opts.cwd - 主仓 cwd
+ * @param {string} opts.changeName - 当前 change 名
+ * @param {Object} [opts.platformOpts] - 平台选项（specRoot 等，透传给 MultiRepoContext 预留）
+ * @param {boolean} [opts.noCache=false] - 跳过缓存（测试 / 显式重建场景）
+ * @returns {MultiRepoContext|null} changeName/cwd 缺失或无 plan.md 时返回 null（单仓退化，调用方按 ctx=null 处理）
+ * @throws {Error} MultiRepoContext 构造 fail-closed（约束②未注册/跨仓git不可用）
+ */
+export async function getOrCreateMultiRepoContext({ cwd, changeName, platformOpts = {}, noCache = false } = {}) {
+  if (!cwd || !changeName) return null
+  const cacheKey = `${cwd} ${changeName}`
+  if (!noCache && _multiRepoCtxCache.has(cacheKey)) {
+    return _multiRepoCtxCache.get(cacheKey)
+  }
+
+  // 读 plan.md（execute 启动入口的 change 目录），无 plan.md → 无法聚合 declaredRepos → 退化 null
+  const specDir = platformOpts?.specRoot || resolveSpecDir(cwd)
+  const planFile = join(specDir, 'changes', changeName, 'plan.md')
+  let planContent = ''
+  if (existsSync(planFile)) {
+    try {
+      planContent = readFileSync(planFile, 'utf8')
+    } catch {
+      planContent = ''
+    }
+  }
+  if (!planContent) {
+    // 无 plan.md（plan 未完成 / brainstorm 阶段 / quick 等场景）→ 无 task 卡片可扫，
+    // 不构造 ctx（返 null 退化单仓）。跨仓 task 必须 plan.md 落地后才进 execute，此处安全。
+    return null
+  }
+
+  // 聚合 declaredRepos（扫 plan.md task 卡片 repo:）+ 读 local.yaml repos: 段
+  const declaredRepos = aggregateDeclaredRepos(planContent)
+  const repoRegistry = parseRepoRegistry(readLocalYamlRaw(cwd))
+
+  // 构造 WorktreeManager（主仓 meta 读取；与 getStageSteps 同源范式）
+  let worktreeManager
+  try {
+    const { WorktreeManager } = await import('../worktree.js')
+    worktreeManager = new WorktreeManager({ cwd })
+  } catch {
+    // WorktreeManager 不可用 → 退化为最小桩（in-place-fallback 兜底 cwd）
+    worktreeManager = { getMeta: () => null }
+  }
+
+  const ctx = new MultiRepoContext({
+    cwd,
+    changeName,
+    platformOpts,
+    declaredRepos,
+    repoRegistry,
+    worktreeManager,
+  })
+
+  if (!noCache) {
+    _multiRepoCtxCache.set(cacheKey, ctx)
+  }
+  return ctx
+}
+
+/**
+ * 清除进程级 MultiRepoContext 缓存（测试隔离用）。生产代码不需手动清。
+ * @param {string} [cwd]
+ * @param {string} [changeName]
+ */
+export function _clearMultiRepoCtxCache(cwd, changeName) {
+  if (cwd && changeName) {
+    _multiRepoCtxCache.delete(`${cwd} ${changeName}`)
+  } else {
+    _multiRepoCtxCache.clear()
+  }
+}
+
+
 /**
  * 获取阶段的步骤定义（execute 需要动态构建）
  */
@@ -697,14 +851,15 @@ export async function getStageSteps(stageName, cwd, progress, specDir = null) {
     const changeDir = resolveChangeDir(cwd, progress, specDir)
     let planFile = null
     let worktreePath = null
+    let changeName = null
     if (changeDir) {
       const p = join(changeDir, 'plan.md')
       if (existsSync(p)) planFile = p
+      changeName = basename(changeDir)
       // 自动检测 worktree 路径，注入 Wave prompt 的 workdir 指令
       // 修复：之前未传 worktreePath 给 buildExecuteSteps，导致 Wave prompt 缺失工作目录指令，
       // 子代理可能把文件写到主工作区而非 worktree 内，破坏隔离。
       try {
-        const changeName = basename(changeDir)
         const { WorktreeManager } = await import('../worktree.js')
         const wm = new WorktreeManager({ cwd })
         const meta = wm.getMeta(changeName)
@@ -715,7 +870,20 @@ export async function getStageSteps(stageName, cwd, progress, specDir = null) {
         // 无 worktree meta 不阻断——可能是首次启动或 in-place 模式
       }
     }
-    return buildExecuteSteps(planFile, { worktreePath })
+    // W3 task-09：execute 启动入口构造 MultiRepoContext 单例（D-013 G2），贯穿 execute/apply/verify。
+    // 单仓 change（无 repo: / 无 local.yaml repos 段）→ ctx=null 退化单仓零回归（task-08 buildExecuteSteps 缺省 null）。
+    // 跨仓 change 缺注册 / 跨仓 git 不可用 → getOrCreateMultiRepoContext 抛错阻断 execute 启动（约束②）。
+    let ctx = null
+    if (changeName) {
+      try {
+        ctx = await getOrCreateMultiRepoContext({ cwd, changeName, platformOpts: specDir ? { specRoot: specDir } : {} })
+      } catch (e) {
+        // fail-closed 阻断：execute 启动期 ctx 构造失败（未注册 repo / 跨仓 git 不可用），
+        // 抛错让上层 runCommand 把错误返回给 Agent（不降级单仓跑——跨仓 apply 走错仓=数据所有权事故）。
+        throw new Error(`execute 启动失败：跨仓 MultiRepoContext 构造失败（${e.message}）`)
+      }
+    }
+    return buildExecuteSteps(planFile, { worktreePath, ctx })
   }
   if (stageName === 'plan') {
     const changeDir = resolveChangeDir(cwd, progress, specDir)

package/src/stage-review.js

@@ -426,6 +426,7 @@ export function printStageReviewResult(result, context = {}) {
       console.error(`   - ${err}`)
     }
     console.error(`\n   提示：tier=independent 要求独立审查子代理产出 review.json，补全后重新 --done`)
+    console.error(`   可用 sillyspec register-stage-review --change <名> --stage ${stage} [--from <已有review.json>] 一步生成 run 目录 + review.json 骨架（docHash 自动算）+ 写 marker + 自检，省掉手动建目录/写 marker`)
   }
 
   if (result.warnings.length > 0) {

package/src/stages/execute.js

@@ -1,10 +1,12 @@
-import { existsSync, readFileSync, readdirSync } from 'fs'
+import { existsSync, readFileSync, readdirSync, writeFileSync } from 'fs'
 import path from 'path'
 import { buildContractMatrix, buildConsumerInjection, buildContractFieldInjection } from '../contract-matrix.js'
 import { getRule } from '../stage-contract-spec.js'
 import { renderDispatchInstruction } from '../dispatch/strategy.js'
 import { isPathASupported } from '../dispatch/backends/sillyhub-mcp.js'
 import { readMcpConfig } from '../sillyhub-mcp/config.js'
+import { gitQuiet } from '../git-helper.js'
+import { parseRepo } from './plan-postcheck.js'
 
 /**
  * 校验 plan.md 是否满足 execute 执行契约
@@ -460,10 +462,92 @@ export function getDispatchMode() {
   if (!hasConfig) return 'local'
   return isPathASupported() ? 'sillyhub' : 'local-fallback'
 }
+
+/**
+ * 解析 task 卡的 repo 归属（W3 task-08，D-012）。
+ * 读 changeDir/tasks/task-<num>.md 的 frontmatter `repo:` 字段；缺省/无卡/'main' → 'main'。
+ * 单仓 change（无 repo: 字段）恒返 'main'，零回归。
+ *
+ * @param {{ index?: number, name?: string }} task - wave.tasks 元素
+ * @param {string|null} changeDir - change 目录绝对路径
+ * @returns {string} repoKey，'main' 或 parseRepo 返回值
+ */
+function resolveTaskRepo(task, changeDir) {
+  if (!changeDir || !task || task.index == null) return 'main'
+  const num = String(task.index).padStart(2, '0')
+  const taskFile = path.join(changeDir, 'tasks', `task-${num}.md`)
+  if (!existsSync(taskFile)) return 'main'
+  try {
+    const content = readFileSync(taskFile, 'utf8')
+    const repo = parseRepo(content)
+    return repo || 'main'
+  } catch {
+    return 'main'
+  }
+}
+
+/**
+ * 把 base_commit 锡点写入 task 卡 frontmatter（W3 task-08，D-010）。
+ * 派发跨仓 task 前 CLI 实时 git rev-parse HEAD 落盘——锁定子代理起改的 base 锚点，
+ * 防止同 Wave 多 task 改同一跨仓仓时 HEAD 推进致 diff 范围漂移（design §5.3 约束① / R-01）。
+ *
+ * 策略：幂等写——frontmatter 有 base_commit 行则就地替换，无则紧跟 repo 行后插入（
+ * 无 frontmatter 时整段创建）。仅改 frontmatter 不动正文。已存在相同值不重复写。
+ *
+ * @param {string} taskFilePath - task-NN.md 绝对路径
+ * @param {string} baseCommit - 跨仓仓 HEAD sha
+ * @returns {boolean} 是否实际写入（false = 文件不存在 / 写失败 / 值未变）
+ */
+function writeBaseCommitToTaskCard(taskFilePath, baseCommit) {
+  if (!taskFilePath || !baseCommit) return false
+  if (!existsSync(taskFilePath)) return false
+  let content
+  try {
+    content = readFileSync(taskFilePath, 'utf8')
+  } catch {
+    return false
+  }
+  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/)
+  if (!fmMatch) return false
+  const fm = fmMatch[1]
+  const baseLineRe = /^base_commit:\s*.*$/m
+  let newFm
+  if (baseLineRe.test(fm)) {
+    const existing = (fm.match(baseLineRe) || [''])[0]
+    if (existing === `base_commit: ${baseCommit}`) return false // 值未变，幂等跳过
+    newFm = fm.replace(baseLineRe, `base_commit: ${baseCommit}`)
+  } else {
+    // 紧跟 repo 行后插入（与 D-010 协议同源顺序 repo→base_commit→head_commit）
+    const repoLineRe = /^repo:\s*.*$/m
+    const anchor = `base_commit: ${baseCommit}\n`
+    if (repoLineRe.test(fm)) {
+      newFm = fm.replace(repoLineRe, m => m + '\n' + anchor.trimEnd())
+    } else {
+      // 无 repo 行：插到 frontmatter 首部（frontmatter 首字段）
+      newFm = anchor.trimEnd() + '\n' + fm
+    }
+  }
+  const newContent = content.replace(/^---\n[\s\S]*?\n---/, `---\n${newFm}\n---`)
+  if (newContent === content) return false
+  try {
+    writeFileSync(taskFilePath, newContent)
+    return true
+  } catch {
+    return false
+  }
+}
+
 /**
  * 为 Wave 生成 prompt（强制子代理执行）
+ *
+ * W3 task-08（D-012 per-task workdir）：签名加可选 `ctx`（MultiRepoContext）参数。
+ * - 无 ctx（单仓 change / 旧调用方）→ 退化为单 worktreePath 单值 worktreeSection（零回归）
+ * - 有 ctx → 按 task 逐个解析 repo 归属，构造 per-task workdir 多值表，跨仓 task 派发前
+ *   落 base_commit 锡点（D-010），注入跨仓 task commit 指引 + head_commit 落盘指引。
+ * 同 Wave 允许主仓+跨仓 task 混合（各独立 Task 调用各传 workdir，不强制同 Wave 同 repo）。
  */
 export function buildWavePrompt(wave, waveIndex, changeDir, worktreePath, options = {}) {
+  const ctx = options.ctx || null
   // ── Contract Matrix：检查是否有 provider/consumer 契约需要注入 ──
   let contractInjection = ''
   let prototypeInjection = ''
@@ -558,8 +642,97 @@ ${prototypes.map(p => `- \`${path.join(protoRelDir, p)}\``).join('\n')}
     return s
   }).join('\n')
 
-  const worktreeSection = (worktreePath)
-    ? `
+  // ── per-task workdir 解析（W3 task-08，D-012）──
+  // 无 ctx（单仓 change）→ 全 task workdir=主仓 worktreePath，沿用旧单值逻辑（零回归）。
+  // 有 ctx → 按 task 卡 repo: 字段逐个解析：主仓 task workdir=主仓 worktreePath，跨仓 task
+  // workdir=ctx.resolve(repo).worktreePath（跨仓仓根）。同 Wave 允许主仓+跨仓混合。
+  const taskRepos = wave.tasks.map(t => ctx ? resolveTaskRepo(t, changeDir) : 'main')
+  const hasCrossRepoWave = ctx ? taskRepos.some(r => r !== 'main') : false
+
+  // per-task workdir 映射（用于多值 worktreeSection + 跨仓 commit 指引）
+  // 无 ctx 或无跨仓 task → 不构造（沿用旧单值 worktreePath 注入）
+  let perTaskWorkdirs = null
+  let crossRepoCommitSection = ''
+  let baseCommitWrites = [] // [{ taskNum, repo, taskFile, written }] 跨仓 task base 锡点落盘记录
+  if (ctx && hasCrossRepoWave) {
+    perTaskWorkdirs = wave.tasks.map((t, ti) => {
+      const taskNum = String(t.index || (ti + 1)).padStart(2, '0')
+      const repo = taskRepos[ti]
+      const entry = ctx.resolve(repo)
+      const workdir = entry ? entry.worktreePath : (worktreePath || '')
+      return { taskNum, repo, workdir }
+    })
+
+    // D-010 跨仓 task base 锡点：派发前实时 git rev-parse HEAD 落 task 卡 base_commit
+    // 仅对跨仓 task（repo≠'main'）落盘，主仓 task 锚 meta.baseHash（MultiRepoContext 已处理）
+    for (const item of perTaskWorkdirs) {
+      if (item.repo === 'main') continue
+      const entry = ctx.resolve(item.repo)
+      if (!entry) continue
+      const baseCommit = gitQuiet(entry.gitDir, ['rev-parse', 'HEAD'])
+      if (!baseCommit) continue // git 不可达已由 MultiRepoContext 构造时 fail-closed 拦截，此处置防御
+      const taskFile = changeDir
+        ? path.join(changeDir, 'tasks', `task-${item.taskNum}.md`)
+        : null
+      const written = taskFile ? writeBaseCommitToTaskCard(taskFile, baseCommit) : false
+      baseCommitWrites.push({ taskNum: item.taskNum, repo: item.repo, taskFile, written, baseCommit })
+    }
+
+    // 跨仓 task commit 指引 + head_commit 落盘指引（D-010 回收时机）
+    const crossLines = perTaskWorkdirs
+      .filter(i => i.repo !== 'main')
+      .map(i => `- task-${i.taskNum} → repo \`${i.repo}\`，workdir=\`${i.workdir}\``)
+      .join('\n')
+    crossRepoCommitSection = `
+### 跨仓 task 派发与双锡点（必须严格遵守）
+
+本 Wave 含跨仓 task（直接改跨仓仓主干，**不经主仓 worktree**）：
+
+${crossLines}
+
+**派发跨仓 task 前（base 锡点，CLI 已在 prompt 构造时落盘）：**
+- 跨仓 task 卡 frontmatter 的 \`base_commit\` 已由 CLI 实时 \`git -C <跨仓仓根> rev-parse HEAD\` 锁定（base 锡点，约束①）。子代理在此 HEAD 上改+commit，不受同 Wave 其他 task 推进 HEAD 影响。
+
+**回收跨仓 task review 前（head 锡点，你必须在子代理完成后落盘）：**
+- 跨仓 task 子代理完成 commit 后、写 review.json / 勾选 checkbox **之前**，你必须运行 \`git -C <跨仓仓根> rev-parse HEAD\` 把结果写入该 task 卡 frontmatter \`head_commit:\` 字段（与 \`base_commit:\` 同源 frontmatter 锡点写入）。
+- review.json 的 \`base\` 取 task 卡 \`base_commit\`、\`head\` 取 task 卡 \`head_commit\`（**非瞬时 HEAD**），锁 diff 范围不漂移。
+
+**跨仓 task 子代理 prompt 必须注入：**
+> 该 task 改的是 \`<repo>\` 仓，workdir=\`<跨仓仓根>\`。**直接在该仓主干工作区改+commit（git add + git commit 到该仓主干），不经主仓 worktree、不建分支。** commit 到该仓主干即落盘，apply 阶段对跨仓 task 为 no-op（design §5.4 G1）。
+`
+  }
+
+  // worktreeSection：无 ctx / 无跨仓 task → 旧单值（零回归）；有 ctx 含跨仓 task → per-task 多值表
+  let worktreeSection
+  if (ctx && hasCrossRepoWave && perTaskWorkdirs) {
+    const workdirLines = perTaskWorkdirs.map(i =>
+      `  - task-${i.taskNum} (repo: ${i.repo}) → workdir: "${i.workdir}"`
+    ).join('\n')
+    worktreeSection = `
+### 工作目录（必须严格遵守，per-task）
+
+调用 Task 工具启动子代理时，**workdir 参数是强制必传的**，且本 Wave 内不同 task 的 workdir 不同（主仓 task vs 跨仓 task）。
+
+**per-task workdir 表（每个子代理按其 task 对应的 workdir 启动）：**
+
+${workdirLines}
+
+不传 workdir 或传错 workdir 会导致：主仓 task 写到跨仓仓 / 跨仓 task 写到主仓 worktree，破坏隔离与 apply 归属。
+
+\`\`\`json
+{
+  "subagent_type": "general",
+  "workdir": "<按上方 per-task 表选>",
+  "prompt": "在此编写任务描述..."
+}
+\`\`\`
+
+### 注意
+蓝图文件（tasks.md / design.md / proposal.md / requirements.md / tasks/task-XX.md）在主工作区 .sillyspec/changes/<change>/ 下，它们不在跨仓仓也不在 worktree 中。读取蓝图时使用主工作区路径，不要拼接到 worktree / 跨仓仓路径下。
+`
+  } else {
+    worktreeSection = (worktreePath)
+      ? `
 ### 工作目录（必须严格遵守）
 
 调用 Task 工具启动子代理时，**workdir 参数是强制必传的**。
@@ -576,7 +749,8 @@ ${prototypes.map(p => `- \`${path.join(protoRelDir, p)}\``).join('\n')}
 ### 注意
 蓝图文件（tasks.md / design.md / proposal.md / requirements.md）在主工作区 .sillyspec/changes/<change>/ 下，它们可能不在 worktree 中。读取蓝图时使用主工作区路径，不要拼接到 worktree 路径下。
 `
-    : ''
+      : ''
+  }
 
   // ── 派发后端段注入（task-07，D-006 / D-007 / D-008 接入）──
   // 同步判定（不发网络，零回归关键）：local（无 MCP 配置）→ dispatchSection='' → 本 prompt 与改前
@@ -616,7 +790,7 @@ ${prototypes.map(p => `- \`${path.join(protoRelDir, p)}\``).join('\n')}
 3. 勾选 plan.md 中的 checkbox
 4. 记录改动文件和测试结果
 
-${worktreeSection}${dispatchSection}
+${worktreeSection}${crossRepoCommitSection}${dispatchSection}
 ### 任务摘要（按需读取完整蓝图）
 为每个任务启动子代理时，**只需告知任务目标和蓝图文件路径，让子代理按需读取**：
 
@@ -680,7 +854,7 @@ task-XX 对应：{SPEC_ROOT}/.runtime/execute-runs/{EXECUTE_RUN_ID}/tasks/task-X
 
 **review.json 必填字段：**
 
-{ "name_zh": "任务评审", "schemaVersion": 1, "task": "task-XX", "base": "<git-base-commit>", "head": "<git-head-commit>",
+{ "name_zh": "任务评审", "schemaVersion": {REVIEW_SCHEMA_VERSION}, "task": "task-XX", "base": "<git-base-commit>", "head": "<git-head-commit>",
  "changedFiles": ["src/foo.js"], "specVerdict": "pass|fail|cannot_verify",
  "qualityVerdict": "pass|fail|cannot_verify", "reviewerNotes": "评审说明",
  "requiredEvidence": [] }
@@ -729,10 +903,14 @@ export function buildExecuteSteps(planFilePath = null, options = {}) {
   // 尝试获取 worktree 路径（可能由前缀步骤创建）
   const worktreePath = options.worktreePath || null
 
+  // W3 task-08：ctx 由 execute 启动入口（task-09）透传，进程级单例贯穿 execute/apply/verify
+  // （D-013）。缺省=null → buildWavePrompt 退化为单仓单 worktreePath（零回归）。
+  const ctx = options.ctx || null
+
   const waveSteps = waves.map((wave, i) => ({
     name: `Wave ${i + 1} 执行`,
     mode: 'implementation',
-    prompt: buildWavePrompt(wave, i + 1, changeDir, worktreePath, { dispatchMode: options.dispatchMode, branch: options.branch }),
+    prompt: buildWavePrompt(wave, i + 1, changeDir, worktreePath, { dispatchMode: options.dispatchMode, branch: options.branch, ctx }),
     outputHint: `Wave ${i + 1} 执行结果`,
     optional: false
   }))