sillyspec 3.26.1 → 3.26.3

package/src/index.js

@@ -75,6 +75,7 @@ SillySpec CLI — 规范驱动开发工具包
     doctor [--fix] [--stale-hours N]    健康检查 + 修复
 
   sillyspec local detect [--dir <path>]   生成本地配置 local.yaml（纯 fs 嗅探，零 token、不跑 scan）
+  sillyspec config [schema] [--json]      打印 local.yaml 全部已知键 + 生效状态 + 读取点（堵外部 agent 配置发现缺口）
   sillyspec runtime list [--json]         枚举 .sillyspec/.runtime/ 运行时产物（只读，看手上有哪些证据/状态文件）
   sillyspec dispatch <probe | hint>       SillyHub 派发能力探测 + 策略生成（agent 调用桥，仅渲染不执行 tool）
 
@@ -368,6 +369,16 @@ async function main() {
         const wt = detectWorktreeSpecDrift(resolveSpecDir(dir));
         if (wt) gateOpts.specDriftAnchor = wt.mainSpecBase;
       }
+      // W3 task-09：gate 是只读查询命令，best-effort 构造 ctx（D-013）。失败降级 null（不阻断只读命令）——
+      // ctx 让 validateTaskReviews/runVerifyTestCheck 正确切跨仓 gitDir；配置错时单仓降级会让两函数
+      // 自然报「跨仓 commit 找不到」等错误进入 check.errors，gate 结论仍如实反映问题（D-002@v1 只读契约不破）。
+      try {
+        const { getOrCreateMultiRepoContext } = await import('./run/shared.js');
+        const _ctx = await getOrCreateMultiRepoContext({ cwd: dir, changeName: gateChange, platformOpts: specDir ? { specRoot: specDir } : {} });
+        if (_ctx) gateOpts.ctx = _ctx;
+      } catch (e) {
+        console.warn(`⚠️ gate ctx 构造失败，降级单仓核验（${e.message}）`);
+      }
       const { envelope, exitCode } = await withJsonOutput(json, () => runGate(gateStage, gateChange, gateOpts));
       if (json) {
         process.stdout.write(JSON.stringify(envelope));
@@ -409,6 +420,14 @@ async function main() {
         const wt = detectWorktreeSpecDrift(resolveSpecDir(dir));
         if (wt) deriveOpts.specDriftAnchor = wt.mainSpecBase;
       }
+      // W3 task-09：derive 同 gate，best-effort 构造 ctx 透传给 verify-test/task-reviews facet（D-013）。
+      try {
+        const { getOrCreateMultiRepoContext } = await import('./run/shared.js');
+        const _ctx = await getOrCreateMultiRepoContext({ cwd: dir, changeName: deriveChange, platformOpts: specDir ? { specRoot: specDir } : {} });
+        if (_ctx) deriveOpts.ctx = _ctx;
+      } catch (e) {
+        console.warn(`⚠️ derive ctx 构造失败，降级单仓核验（${e.message}）`);
+      }
       const { envelope, exitCode } = await withJsonOutput(json, () => runDerive(facet, deriveChange, deriveOpts));
       if (json) {
         process.stdout.write(JSON.stringify(envelope));
@@ -439,7 +458,16 @@ async function main() {
       // --spec-dir 透传 platformOpts.specRoot（与 gate/derive 对称）；不传走默认 join(cwd,'.sillyspec')。
       const brPlatformOpts = {};
       if (specDir) brPlatformOpts.specRoot = specDir;
-      const result = await generateTaskReviewDrafts({ changeName: brChange, cwd: dir, platformOpts: brPlatformOpts });
+      // W3 task-09：best-effort 构造 ctx 透传（D-013），让 task-04 generateTaskReviewDrafts 跨仓 task
+      // 用跨仓 gitDir 取 base..head diff。失败降级 null（与 gate/derive 同语义，辅助修复命令不阻断）。
+      let _brCtx = null;
+      try {
+        const { getOrCreateMultiRepoContext } = await import('./run/shared.js');
+        _brCtx = await getOrCreateMultiRepoContext({ cwd: dir, changeName: brChange, platformOpts: brPlatformOpts });
+      } catch (e) {
+        console.warn(`⚠️ backfill-reviews ctx 构造失败，降级单仓草稿（${e.message}）`);
+      }
+      const result = await generateTaskReviewDrafts({ changeName: brChange, cwd: dir, platformOpts: brPlatformOpts, ctx: _brCtx });
       if (json) {
         process.stdout.write(JSON.stringify({ ok: true, command: 'backfill-reviews', change: brChange, ...result }));
       } else {
@@ -768,7 +796,18 @@ SillySpec worktree — git worktree 隔离管理
           const checkOnly = args.includes('--check-only');
           const merge = args.includes('--merge');
           const { applyWorktree } = await import('./worktree-apply.js');
-          const result = applyWorktree(wtName, { cwd: dir, checkOnly, merge });
+          // W3 task-09：apply 链路构造 ctx（D-013），让 task-05 applyWorktree 按 ctx 区分主仓 A5 / 跨仓 no-op。
+          // 跨仓 apply=no-op（G1 D-009）：校验 review.head 是跨仓真实 commit + 跳过 wm.cleanup。
+          // ctx 构造 fail-closed（约束②）——跨仓配置错时 apply 必须阻断（走错仓=数据所有权事故），不降级。
+          let _applyCtx = null;
+          try {
+            const { getOrCreateMultiRepoContext } = await import('./run/shared.js');
+            _applyCtx = await getOrCreateMultiRepoContext({ cwd: dir, changeName: wtName, platformOpts: specDir ? { specRoot: specDir } : {} });
+          } catch (e) {
+            console.error(`❌ apply 失败：跨仓 MultiRepoContext 构造失败（${e.message}）`);
+            process.exit(1);
+          }
+          const result = applyWorktree(wtName, { cwd: dir, checkOnly, merge, ctx: _applyCtx });
 
           if (result.errors.length > 0) {
             console.error(`❌ 校验失败:`);
@@ -821,6 +860,20 @@ SillySpec worktree — git worktree 隔离管理
           const { assessApplyRisk } = await import('./worktree-apply.js');
           const assessment = assessApplyRisk(wtName, { cwd: dir });
 
+          // W3 task-09：assess 自动 apply 路径构造 ctx（D-013），SAFE/WARNING 时透传给 applyWorktree。
+          // 构造 fail-closed（跨仓配置错阻断，与显式 apply case 同语义）。
+          let _assessCtx = null;
+          try {
+            const { getOrCreateMultiRepoContext } = await import('./run/shared.js');
+            _assessCtx = await getOrCreateMultiRepoContext({ cwd: dir, changeName: wtName, platformOpts: specDir ? { specRoot: specDir } : {} });
+          } catch (e) {
+            if (assessment.decision === 'SAFE' || assessment.decision === 'WARNING') {
+              console.error(`❌ assess 自动 apply 失败：跨仓 MultiRepoContext 构造失败（${e.message}）`);
+              process.exit(1);
+            }
+            // blocked 决策不触发 apply，ctx 失败仅记 warn（不阻断只读 assess 展示）
+            console.warn(`⚠️ ctx 构造失败（${e.message}）`);
+          }
           const SEPARATOR = '─'.repeat(32);
           console.log('Worktree Apply Decision');
           console.log(SEPARATOR);
@@ -852,7 +905,7 @@ SillySpec worktree — git worktree 隔离管理
           if (assessment.decision === 'SAFE' || assessment.decision === 'WARNING') {
             console.log('Action: auto-applying...');
             const { applyWorktree } = await import('./worktree-apply.js');
-            const applyResult = applyWorktree(wtName, { cwd: dir });
+            const applyResult = applyWorktree(wtName, { cwd: dir, ctx: _assessCtx });
             if (applyResult.errors.length > 0) {
               console.error('❌ apply 失败:', applyResult.errors.join('; '));
             } else {
@@ -1543,10 +1596,10 @@ SillySpec modules — 模块文档管理
       lines.push('# 测试策略：full=全量测试, module=只测变更模块, skip=跳过测试');
       lines.push('test_strategy: module');
       lines.push('');
-      lines.push('# 模块测试路径映射（可选）');
-      lines.push('# module_paths:');
-      lines.push('#   user-service: "user/"');
-      lines.push('#   order-service: "order/"');
+      lines.push('# monorepo 子模块映射（test_strategy: module 时按 git diff 命中模块收窄测试；inline flow 形态）');
+      lines.push('# modules:');
+      lines.push('#   user-service: { path: "user/", test: "cd user && npm test" }');
+      lines.push('#   order-service: { path: "order/", test: "cd order && npm test" }');
       lines.push('# 已知预存失败（可选）：verify 实测时这些失败被豁免、不阻断归档；fail-safe 仅豁免能检测到的失败行');
       lines.push('# known_failures:');
       lines.push('#   - "tests/test_legacy.py::test_old"');
@@ -1560,6 +1613,42 @@ SillySpec modules — 模块文档管理
       console.log(`   路径: ${localYamlPath}`);
       break;
     }
+    case 'config': {
+      // local.yaml 键发现缺口（2026-08-11）：键散落 ~10 个 reader，外部项目 agent 无从得知。
+      // config schema 把全部已知键 + 生效状态 + 读取点打印出来，堵住发现缺口。
+      // 数据源唯一 = src/config-schema.js（与 init 落盘的 local.yaml.example 同源）。
+      const configSub = filteredArgs[1];
+      const wantHelp = configSub === 'help' || configSub === '--help' || configSub === '-h';
+      const isSchema = !configSub || configSub === 'schema';
+      if (wantHelp) {
+        console.log(`
+SillySpec config — local.yaml 配置键速查
+
+用法:
+  sillyspec config                打印 local.yaml 全部已知键（人类可读树，默认）
+  sillyspec config schema         同上（显式子命令）
+  sillyspec config --json         机读 JSON（程序化消费）
+  sillyspec config schema --json  同上
+
+说明:
+  - 数据源：src/config-schema.js（唯一真相；reader 见各键「读取点」）
+  - 键分两类：【生效】配了即生效；【声明但未接线】代码/JSDoc 提及但无 reader，配了不生效
+  - 脱敏示例文件：sillyspec init 生成 local.yaml.example（可提交；真实 local.yaml 是 gitignored）
+`);
+        break;
+      }
+      if (!isSchema) {
+        const sug = didYouMean(configSub, ['schema']);
+        console.error(`❌ 未知子命令: config ${configSub}`);
+        if (sug) console.error(`   你是想输入「config ${sug}」吗？`);
+        console.error('用法: sillyspec config [schema] [--json]   打印 local.yaml 配置键');
+        process.exit(2);
+      }
+      const { renderSchemaHuman, renderSchemaJson } = await import('./config-schema.js');
+      if (json) console.log(renderSchemaJson());
+      else console.log(renderSchemaHuman());
+      break;
+    }
     case 'runtime': {
       // D2：.runtime/ 产物索引。CLI 往 .runtime/ 写各种证据/状态文件（db、doctor-diagnosis、
       // workflow-runs、user-inputs…），却没有命令让 agent 一眼看到「我手上有哪些产物」。

package/src/init.js

@@ -5,6 +5,7 @@ import { checkbox, confirm, input } from '@inquirer/prompts';
 import { ProgressManager } from './progress.js';
 import chalk from 'chalk';
 import { getVersion } from './version.js';
+import { renderExample } from './config-schema.js';
 // 向后兼容：getVersion 已抽到轻量 version.js（避免 index.js 为 --version 静态加载 init.js 的 inquirer 税），
 // 此处 re-export 保持 init.js 既有导出 API 不破坏（如 test/init-claude-injection.test.mjs）。
 export { getVersion };
@@ -313,6 +314,18 @@ function doInstall(projectDir, tools, subprojects = [], specDir = null) {
   const pm = new ProgressManager({ specDir: spec });
   pm.init(projectDir);
 
+  // 落盘脱敏 local.yaml.example（config-schema.js 单一数据源；不存在才写，仿 local detect skip-if-exists）
+  // 真实 local.yaml 是 gitignored 含凭据；example 可提交，是给人/外部 agent 看的配置发现物。
+  const examplePath = join(spec, 'local.yaml.example');
+  if (!existsSync(examplePath)) {
+    try {
+      writeFileSync(examplePath, renderExample());
+      console.log(chalk.green('    ✓ local.yaml.example 已生成（脱敏配置示例，可提交；真实 local.yaml 由 sillyspec local detect / platform connect 写入）'));
+    } catch (e) {
+      console.warn(chalk.yellow(`    ⚠ 生成 local.yaml.example 失败: ${e.message}`));
+    }
+  }
+
   // .gitignore 只在 specDir 在项目内时才修改
   const isExternalSpec = specDir && resolve(spec) !== resolve(projectDir, '.sillyspec');
  if (!isExternalSpec) {

package/src/machine-interface.js

@@ -106,9 +106,12 @@ export function buildEnvelope({
  * @param {string} [opts.specDriftAnchor] - drift 场景主仓 specBase 锚点（坑 execute-runs-isolation）。
  *   drift 守卫命中时由调用方传入，task-reviews 的 execute-run-id marker 落点经
  *   resolveRuntimeRoot 锚主仓 .runtime，不读 worktree 副本（与 contract-matrix 调用方同语义）。
+ * @param {object} [opts.ctx] - MultiRepoContext 单例（W3 task-09，D-013）。缺省=null 退化单仓。
+ *   透传给 validateTaskReviews（execute task-reviews check）+ runVerifyTestCheck（verify-test check），
+ *   让两函数按 ctx 切跨仓 gitDir / per-repo cwd。null 时两函数按既有单仓行为零回归。
  * @returns {Promise<{ envelope: object, exitCode: number }>}
  */
-export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, specDriftAnchor } = {}) {
+export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, specDriftAnchor, ctx = null } = {}) {
   const specRoot = specBase || resolveSpecDir(cwd);
   const pm = new ProgressManager();
 
@@ -232,6 +235,7 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
         executeRunId,
         changeDir: planDir,
         gitDir,
+        ctx,
       });
       checks.push({
         id: 'task-reviews',
@@ -243,7 +247,7 @@ export async function runGate(stage, changeName, { cwd, specBase, runtimeRoot, s
 
     // ── d. verify 阶段追加 verify-test（CLI 实测 local.yaml commands.test）──
     if (stage === 'verify') {
-      const vt = runVerifyTestCheck({ cwd, specBase: specRoot, changeName });
+      const vt = runVerifyTestCheck({ cwd, specBase: specRoot, changeName, ctx });
       const vtWarnings = [];
       if (vt.status === 'skipped') {
         vtWarnings.push(`⚠️ verify-test SKIPPED — gate 未核验测试（${vt.reason || 'local.yaml 未配置 commands.test 或显式无测试'}）。本次 gate 结论不含测试客观核验，driver 不应据 exit 0 判定测试通过；integration-critical 变更应在 verify 阶段降级 FAIL`);
@@ -334,9 +338,11 @@ export const FACETS = ['execute-evidence', 'verify-test', 'task-reviews', 'artif
  * @param {string} [opts.runtimeRoot] - .runtime 目录；默认 resolveRuntimeRoot 三级优先级解析
  * @param {string} [opts.specDriftAnchor] - drift 场景主仓 specBase 锚点（坑 execute-runs-isolation），
  *   task-reviews facet 的 execute-run-id marker 落点经 resolveRuntimeRoot 锚主仓 .runtime，不读副本。
+ * @param {object} [opts.ctx] - MultiRepoContext 单例（W3 task-09，D-013）。缺省=null 退化单仓。
+ *   透传给 verify-test / task-reviews facet（runVerifyTestCheck + validateTaskReviews）。
  * @returns {Promise<{ envelope: object, exitCode: number }>}
  */
-export async function runDerive(facet, changeName, { cwd, specBase, runtimeRoot, specDriftAnchor } = {}) {
+export async function runDerive(facet, changeName, { cwd, specBase, runtimeRoot, specDriftAnchor, ctx = null } = {}) {
   // ── 非法 facet：用法错 → exit 2（D-004@v1）──
   if (!FACETS.includes(facet)) {
     const envelope = buildEnvelope({
@@ -402,7 +408,7 @@ export async function runDerive(facet, changeName, { cwd, specBase, runtimeRoot,
 
       // ── b. verify-test：真实执行测试命令并取证 ──
       case 'verify-test': {
-        const vt = runVerifyTestCheck({ cwd, specBase: specRoot, changeName });
+        const vt = runVerifyTestCheck({ cwd, specBase: specRoot, changeName, ctx });
         data = {
           status: vt.status,
           exitCode: vt.exitCode,
@@ -464,6 +470,7 @@ export async function runDerive(facet, changeName, { cwd, specBase, runtimeRoot,
           executeRunId,
           changeDir,
           gitDir,
+          ctx,
         });
         data = {
           ok: tr.ok,

package/src/run/command.js

@@ -1004,8 +1004,10 @@ async function runAutoMode(pm, progress, cwd, flags, changeName, platformOpts =
 
   // ── Classify change on first entry ──
   if (!progress.stages?.brainstorm?.status && !progress.stages?.plan?.status) {
-    const { classifyChange } = await import('../classify-change.js')
-    const classification = classifyChange({ description: inputText || '', explicitMode })
+    const { classifyChange, readAutoModeFromLocalYaml } = await import('../classify-change.js')
+    // auto_mode 接线（2026-08-11）：从 local.yaml 读 auto_mode 段传 localConfig，让 force_*_patterns 真生效。
+    const localConfig = readAutoModeFromLocalYaml(cwd)
+    const classification = classifyChange({ description: inputText || '', explicitMode, localConfig })
     if (classification.mode === 'quick') {
       console.log(`📊 auto 模式分类：${classification.mode}（${classification.reason}）`)
       console.log(`   此变更建议使用 quick 模式，运行：sillyspec run quick "${inputText || '需求'}"`)

package/src/run/complete.js

@@ -18,7 +18,7 @@ import { join } from 'node:path'
 import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { withFileLock } from '../quicklog.js'
-import { triggerSync, WAIT_MARKER_RE, getStageSteps, formatWaitOptions, resolveRuntimeRoot } from './shared.js'
+import { triggerSync, WAIT_MARKER_RE, getStageSteps, formatWaitOptions, resolveRuntimeRoot, getOrCreateMultiRepoContext } from './shared.js'
 import { outputStep } from './prompt.js'
 import { enforceDepsGate, enforceReviewJsonGate, completeStageGates, readDesignScale } from './gates.js'
 import { handleArchiveConfirmStep, handlePlanGeneratePlanStep, handleScanProjectListStep, handleWorkflowPostCheck, handleQuickStageCompletion, handleExecuteWaveArtifact } from './complete-handlers.js'
@@ -213,7 +213,15 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     // 已存在跳过），据 git diff base..head 按 allowed_paths 归属生成 cannot_verify 草稿，进 gate 前就位。
     try {
       const { generateTaskReviewDrafts } = await import('../task-review.js')
-      const _drafts = await generateTaskReviewDrafts({ changeName, cwd, platformOpts })
+      // W3 task-09：best-effort 构造 ctx 透传（D-013），跨仓 task 草稿用跨仓 gitDir 取 diff。
+      // 失败降级 null（不阻断 execute 完成——草稿兜底本就是 best-effort，gate 会复校验）。
+      let _draftCtx = null
+      try {
+        _draftCtx = await getOrCreateMultiRepoContext({ cwd, changeName, platformOpts })
+      } catch (e) {
+        console.warn('   ⚠️ 草稿 ctx 构造失败，降级单仓草稿（' + (e && e.message ? e.message : e) + '）')
+      }
+      const _drafts = await generateTaskReviewDrafts({ changeName, cwd, platformOpts, ctx: _draftCtx })
       if (_drafts.generated > 0) {
         console.log('   📄 自动补写 ' + _drafts.generated + ' 个 per-task review.json 草稿（cannot_verify，主 agent 实现模式兜底，需 agent 复核后升级为 pass/fail）')
         if (_drafts.unattributed && _drafts.unattributed.length > 0) {
@@ -280,7 +288,15 @@ export async function completeStep(pm, progress, stageName, cwd, outputText, inp
     // 阶段完成收尾共享管线（handleScan manifest + validateMetadata/FileLocations + auxiliary 重置 +
     // runStageCompletionGates + execute worktree cleanup），消除 S1/S2/S3 三处收尾不对称（task-01 抽出）。
     // gate 失败已 rollback，early-return 跳过下方"阶段已完成/下一步"提示（合理收紧：回滚不该打完成提示）。
-    const _stageGatesResult = await completeStageGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, outputText })
+    // W3 task-09：best-effort 构造 ctx 透传给 completeStageGates（D-013），让 task-07 gate 跨仓 task
+    // 切 gitDir + per-repo verify。execute 启动期已 fail-closed 过一次，此处命中缓存或单仓退化。
+    let _completeCtx = null
+    try {
+      _completeCtx = await getOrCreateMultiRepoContext({ cwd, changeName, platformOpts })
+    } catch (e) {
+      console.warn('⚠️ 阶段完成 ctx 构造失败，降级单仓 gate（' + (e && e.message ? e.message : e) + '）')
+    }
+    const _stageGatesResult = await completeStageGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, outputText, ctx: _completeCtx })
     if (_stageGatesResult) return _stageGatesResult
 
     // gate 全过：persist completed（task-01 移后）。此处到 _write 之间若崩，DB 仍 in-progress（内存已 completed 但未落盘），下次进 CLI 读 DB 即 in-progress，不产生"假 completed"。
@@ -739,7 +755,14 @@ export async function continueStep(pm, progress, stageName, cwd, answer, options
     // persist _write 移到 completeStageGates 成功之后（task-03 / review-2026-08-09 #2）：gate 异常/失败 → rollback 回 in-progress 落盘，此处未到 _write，DB 不留假 completed。
     // 阶段完成收尾共享管线（含 execute worktree cleanup），消除 continueStep 完成分支绕过 gate 的 S2（task-01 抽出）。
     // gate 失败已 rollback，early-return 跳过下方"阶段已完成/下一步"提示（与 completeStep 同语义）。
-    const _stageGatesResult = await completeStageGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps: stageData.steps, currentIdx, outputText: null })
+    // W3 task-09：best-effort 构造 ctx 透传（D-013），与 completeStep 完成分支同语义。
+    let _contCtx = null
+    try {
+      _contCtx = await getOrCreateMultiRepoContext({ cwd, changeName, platformOpts })
+    } catch (e) {
+      console.warn('⚠️ 阶段完成 ctx 构造失败，降级单仓 gate（' + (e && e.message ? e.message : e) + '）')
+    }
+    const _stageGatesResult = await completeStageGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps: stageData.steps, currentIdx, outputText: null, ctx: _contCtx })
     if (_stageGatesResult) return _stageGatesResult
     // gate 全过：persist completed（task-03 移后；此处无 triggerSync）。
     pm._write(cwd, progress, changeName)

package/src/run/gates.js

@@ -187,7 +187,7 @@ function rollbackCompletionAndReturn(pm, progress, stageData, steps, currentIdx,
  *
  * @returns {{stageCompleted:false,currentIdx,nextPendingIdx:number}|null}
  */
-export async function runStageCompletionGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx }) {
+export async function runStageCompletionGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, ctx = null }) {
   const projectName = progress.project || basename(cwd)
   const contractResult = runValidators(stageName, cwd, changeName, { projectName, specRoot: platformOpts?.specRoot })
   if (contractResult.errors.length > 0) {
@@ -220,7 +220,7 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
     const { runVerifyTestCheck, printVerifyTestCheck } = await import('../verify-postcheck.js')
     // 测试实测是同步 execSync，长套件可跑 2~10min 且中途无输出——先预告避免 agent 误判卡死
     console.log(`\n⏳ Verify 测试对账：CLI 亲自执行 local.yaml 的 commands.test（同步，耗时可能较长，请等待…）`)
-    const testCheck = runVerifyTestCheck({ cwd, specBase, changeName })
+    const testCheck = runVerifyTestCheck({ cwd, specBase, changeName, ctx })
     printVerifyTestCheck(testCheck)
     if (testCheck.status === 'failed') {
       console.error('\n❌ verify 阶段被阻断：verify-result.md 自报告通过，但 CLI 实测测试失败。')
@@ -354,18 +354,30 @@ export async function runStageCompletionGates({ stageName, cwd, changeName, plat
           }
         }
 
-        // git 真实性校验目录：worktree 存在则用 worktree（base/head commit 在其中），否则主仓库
+        // git 真实性校验目录：worktree 存在则用 worktree（base/head commit 在其中），否则主仓库。
+        // 跨仓支持（task-07 / design §6 gates 行 + D-013）：
+        //   - 有 ctx（execute 启动入口 task-09 构造的 MultiRepoContext 实例）→ 用
+        //     ctx.resolve('main').gitDir 作为主仓 task 的校验 cwd。ctx 的 main entry 已在
+        //     _buildMainEntry 内统一编码 worktreePath/cwd + in-place-fallback 兜底（与 task-review.js:724
+        //     generateTaskReviewDrafts 的 in-place 逻辑同源），避免两处漂移。Task Review Gate 内部循环
+        //     再按 review.repo ?? 'main' 从 ctx.resolve(repo).gitDir 切跨仓 task 的 gitDir（task-04 实现）。
+        //   - 无 ctx（ctx=null 缺省，单仓 / 旧调用链）→ 走原逻辑（meta.worktreePath 或 cwd），零回归。
         let reviewGitDir = cwd
-        try {
-          const { WorktreeManager } = await import('../worktree.js')
-          const wm = new WorktreeManager({ cwd })
-          const meta = wm.getMeta(changeName)
-          if (meta?.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
-            reviewGitDir = meta.worktreePath
-          }
-        } catch {}
+        if (ctx) {
+          const mainEntry = ctx.resolve('main')
+          if (mainEntry?.gitDir) reviewGitDir = mainEntry.gitDir
+        } else {
+          try {
+            const { WorktreeManager } = await import('../worktree.js')
+            const wm = new WorktreeManager({ cwd })
+            const meta = wm.getMeta(changeName)
+            if (meta?.worktreePath && meta.mode !== 'in-place-fallback' && existsSync(meta.worktreePath)) {
+              reviewGitDir = meta.worktreePath
+            }
+          } catch {}
+        }
 
-        const reviewResult = validateTaskReviews({ planContent, runtimeRoot, executeRunId, changeDir: planFile, gitDir: reviewGitDir })
+        const reviewResult = validateTaskReviews({ planContent, runtimeRoot, executeRunId, changeDir: planFile, gitDir: reviewGitDir, ctx })
         printReviewResult(reviewResult, { runtimeRoot, executeRunId })
 
         if (!reviewResult.ok) {
@@ -557,7 +569,7 @@ function readDesignOwnFiles(specBase, changeName) {
  *          null = 全部通过，调用方继续自管收尾（如下一步提示）；
  *          非 null = gate/handler 失败已 rollback，调用方直接 return。
  */
-export async function completeStageGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, outputText }) {
+export async function completeStageGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, outputText, ctx = null }) {
   // 整体 try/catch（task-04 / review-2026-08-09 #2）：收尾段（execute 预检 + scan handler + validate* +
   // auxiliary 重置 + runStageCompletionGates）任一段抛非结构化异常 → rollbackCompletionAndReturn
   // （回滚 in-progress + 落盘 + 返回未完成对象），不冒顶 exit 1。正常的 _scanResult/_gateEarlyReturn
@@ -630,7 +642,7 @@ export async function completeStageGates({ stageName, cwd, changeName, platformO
 
   // 阶段完成校验 gate 级联（runValidators → verify-test → Plan→Execute → Stage Review → Task Review）
   if (settledCount === total && total > 0) {
-    const _gateEarlyReturn = await runStageCompletionGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx })
+    const _gateEarlyReturn = await runStageCompletionGates({ stageName, cwd, changeName, platformOpts, specBase, progress, pm, stageData, steps, currentIdx, ctx })
     if (_gateEarlyReturn) return _gateEarlyReturn
   } else if (settledCount < total) {
     console.log(`\n⚠️ 阶段校验跳过：${total} 步中仅 ${settledCount} 步标记为已结案（completed‖skipped），可能存在状态不同步。如确认阶段已完成，请运行 --status 确认。`)

package/src/run/multi-repo-context.js

@@ -0,0 +1,206 @@
+/**
+ * MultiRepoContext — 跨仓 task 运行时多仓执行上下文（W1 task-01）。
+ *
+ * 设计依据：design §7.1（接口权威定义）+ 决策 D-005/D-006/D-007/D-013。
+ *
+ * 收口 execute 链路 7 个单仓假设点（applyWorktree / validateTaskReviews /
+ * runVerifyTestCheck / generateTaskReviewDrafts 等）——把"主仓=唯一仓库"假设
+ * 抽成 Map<repoKey, RepoEntry>，单仓 change 退化为 {main:{...}} 单值 map 零回归
+ * （GOAL-2），跨仓 change 实时反映各仓 HEAD（约束①）+ 配置错误 fail-closed（约束②）。
+ *
+ * 关键约束：
+ *   - 约束①（D-006）：跨仓仓无 meta.json，base/head 不读 meta。resolveHead 实时
+ *     `git -C <crossRepo> rev-parse HEAD`（不缓存，task 推进后过期）；resolveBase
+ *     用 taskBaseCommit（task 卡 base_commit 锡点，跨仓必传）。
+ *   - 约束②（D-007）：declaredRepos 有 key 不在 repoRegistry → throw；跨仓仓
+ *     `git -C <crossRepo> rev-parse HEAD` 失败 → throw。配置错误不降级，不沿用
+ *     主仓 verifyReviewGitEvidence 的 unavailable 降级（那是环境缺失容错；跨仓
+ *     不可用是用户 local.yaml 配错，性质不同，必须阻断）。
+ *   - D-013：execute 启动时构造一次，进程级缓存贯穿 execute/apply/verify（本模块
+ *     不持有进程级缓存——ctx 实例本身就是进程级单例，由 execute 入口持有）。
+ *
+ * 不涉及生命周期契约（design §7.5）：纯内存对象，不跨进程、不持久化、不入库。
+ */
+
+import { git, gitQuiet } from '../git-helper.js';
+
+/**
+ * @typedef {Object} RepoEntry
+ * @property {string} repoKey        - repo 标识（'main' 或 local.yaml repos: 的键名）
+ * @property {string} gitDir         - git 工作目录（rev-parse/diff/apply 的 cwd）
+ * @property {string} worktreePath   - 子代理工作目录（主仓=worktreePath 或 in-place-fallback 时=cwd；跨仓=跨仓仓根）
+ * @property {string} projectRoot    - apply 目标根（主仓=主仓根；跨仓=跨仓仓根，但跨仓 apply=no-op 不用）
+ * @property {boolean} isMain        - 是否主仓
+ * @property {function} resolveHead  - () => string，实时 git rev-parse HEAD（跨仓不缓存）
+ * @property {function} resolveBase  - (taskBaseCommit?) => string，base 锚点（主仓→meta.baseHash；跨仓→taskBaseCommit 必传）
+ */
+
+export class MultiRepoContext {
+  /**
+   * @param {Object} opts
+   * @param {string} opts.cwd              - 主仓 cwd
+   * @param {string} opts.changeName       - 当前 change 名（读 worktreeManager.getMeta）
+   * @param {Object} [opts.platformOpts]   - 平台选项（specRoot 等，预留，本模块不消费）
+   * @param {string[]} opts.declaredRepos  - 所有 task 卡片声明的 repo: 值（含 'main'）
+   * @param {Map<string,string>} opts.repoRegistry - local.yaml repos: 段解析结果 Map<key, path>
+   * @param {Object} opts.worktreeManager  - WorktreeManager 实例（主仓 meta 读取；in-place-fallback 兜底 cwd）
+   * @throws {Error} 约束②: declaredRepos 中有 repoKey 不在 repoRegistry → 抛错列已注册 repo，阻断 execute
+   *                 约束②: 跨仓仓 git rev-parse 失败（路径不存在/非 git 仓）→ 抛错阻断 execute
+   */
+  constructor({ cwd, changeName, platformOpts, declaredRepos, repoRegistry, worktreeManager }) {
+    if (!cwd) throw new Error('MultiRepoContext: cwd 必传');
+    if (!Array.isArray(declaredRepos)) throw new Error('MultiRepoContext: declaredRepos 必传为数组');
+    if (!(repoRegistry instanceof Map)) throw new Error('MultiRepoContext: repoRegistry 必传为 Map<key,path>');
+    if (!worktreeManager || typeof worktreeManager.getMeta !== 'function') {
+      throw new Error('MultiRepoContext: worktreeManager 必传（需 getMeta 方法）');
+    }
+
+    this.cwd = cwd;
+    this.changeName = changeName;
+    this.platformOpts = platformOpts || {};
+    this.repoRegistry = repoRegistry;
+    this.worktreeManager = worktreeManager;
+
+    // dedupe + 保留声明顺序（同一 repo 多 task 声明只建一项）
+    const seen = new Set();
+    const orderedKeys = [];
+    for (const key of declaredRepos) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        orderedKeys.push(key);
+      }
+    }
+
+    // 约束② fail-closed 预检：declaredRepos ⊆ repoRegistry ∪ {'main'}
+    // main 隐式 = cwd，不要求注册；其余 key 必须在 repoRegistry 命中。
+    const unregistered = orderedKeys.filter(k => k !== 'main' && !repoRegistry.has(k));
+    if (unregistered.length > 0) {
+      const registered = ['main (隐式)', ...repoRegistry.keys()];
+      throw new Error(
+        `MultiRepoContext: 以下 repo 未在 local.yaml repos: 段注册：[${unregistered.join(', ')}]。` +
+        `当前已注册 repo：[${registered.join(', ')}]。` +
+        `请在 local.yaml repos: 段补注册后再启动 execute（约束② fail-closed，跨仓 apply 走错仓=数据所有权事故）。`
+      );
+    }
+
+    const map = new Map();
+    for (const repoKey of orderedKeys) {
+      map.set(repoKey, repoKey === 'main'
+        ? this._buildMainEntry()
+        : this._buildCrossRepoEntry(repoKey, repoRegistry.get(repoKey)));
+    }
+    this.map = map;
+  }
+
+  /**
+   * 主仓 RepoEntry：isMain=true，读 worktreeManager.getMeta 的 baseHash + worktreePath。
+   * in-place-fallback 模式（meta.mode==='in-place-fallback' 或 meta 缺失）worktreePath 兜底为 cwd。
+   * @returns {RepoEntry}
+   * @private
+   */
+  _buildMainEntry() {
+    const meta = this.changeName ? this.worktreeManager.getMeta(this.changeName) : null;
+    const isInPlace = !meta || meta.mode === 'in-place-fallback';
+    const worktreePath = isInPlace ? this.cwd : (meta.worktreePath || this.cwd);
+    const baseHash = meta?.baseHash || null;
+    const gitDir = worktreePath; // 主仓 git 操作 cwd = worktree（或 in-place 的 cwd）
+    const projectRoot = this.cwd;
+
+    return {
+      repoKey: 'main',
+      gitDir,
+      worktreePath,
+      projectRoot,
+      isMain: true,
+      // 主仓 HEAD：从 worktree/cwd 实时取（不缓存）。主仓单仓不变式下也可用 meta.baseHash 作 base，
+      // 但 HEAD 反映 worktree 当前态（子代理可能 commit 推进），故实时取与跨仓一致语义。
+      resolveHead: () => git(gitDir, ['rev-parse', 'HEAD']),
+      // 主仓 base：meta.baseHash（单仓不变式，CLI 创建 worktree 时锡点）。
+      // 跨仓 base 不走这里（resolveBase 必传 taskBaseCommit，由 _buildCrossRepoEntry 闭包消费）。
+      // 主仓忽略 taskBaseCommit 参数——主仓 base 永远锚 meta.baseHash，与单仓行为一致（零回归）。
+      resolveBase: (_taskBaseCommit) => {
+        if (!baseHash) {
+          throw new Error(
+            'MultiRepoContext: 主仓 meta.baseHash 缺失，无法解析 base。' +
+            '可能 worktree 未创建或 meta.json 损坏——请先 sillyspec worktree doctor 检查。'
+          );
+        }
+        return baseHash;
+      },
+    };
+  }
+
+  /**
+   * 跨仓 RepoEntry：isMain=false，gitDir=projectRoot=worktreePath=跨仓仓根。
+   * 构造时 `git -C <crossRepo> rev-parse HEAD` 必须 succeed（约束② fail-closed），
+   * 路径不存在/非 git 仓 → throw 阻断 execute。
+   * @param {string} repoKey
+   * @param {string} crossRepoPath - repoRegistry 解析出的跨仓仓绝对路径
+   * @returns {RepoEntry}
+   * @private
+   */
+  _buildCrossRepoEntry(repoKey, crossRepoPath) {
+    if (!crossRepoPath) {
+      throw new Error(
+        `MultiRepoContext: repo "${repoKey}" 在 local.yaml repos: 段注册但路径为空。` +
+        `请补全路径（约束② fail-closed）。`
+      );
+    }
+    // 约束②：跨仓 git 必须可达。失败 = 路径不存在 / 非 git 仓 / git 异常，一律阻断。
+    // 不沿用主仓 verifyReviewGitEvidence unavailable 降级（design §9 兼容策略表）。
+    let headVerify;
+    try {
+      headVerify = git(crossRepoPath, ['rev-parse', 'HEAD']);
+    } catch (e) {
+      throw new Error(
+        `MultiRepoContext: 跨仓 repo "${repoKey}" git 不可达（路径：${crossRepoPath}）。` +
+        `rev-parse HEAD 失败：${e.message}。` +
+        `请检查 local.yaml repos: 段路径是否正确、目录是否存在且为 git 仓（约束② fail-closed，配置错误不降级）。`
+      );
+    }
+    if (!headVerify) {
+      // git() 返回空串属异常态（无 commit 的空仓 rev-parse HEAD 会非零退出，已被 catch 兜底），
+      // 此处仅作防御性双保险，触发同样走 fail-closed。
+      throw new Error(
+        `MultiRepoContext: 跨仓 repo "${repoKey}"（${crossRepoPath}）rev-parse HEAD 返回空——` +
+        `疑似空 git 仓（无 commit）。跨仓 task 需仓库已有至少一个 commit（约束② fail-closed）。`
+      );
+    }
+
+    return {
+      repoKey,
+      gitDir: crossRepoPath,
+      worktreePath: crossRepoPath,
+      projectRoot: crossRepoPath,
+      isMain: false,
+      // 约束①：跨仓 HEAD 实时取，不缓存（task 推进后过期，每次 resolveHead 反映最新 HEAD）。
+      resolveHead: () => git(crossRepoPath, ['rev-parse', 'HEAD']),
+      // 约束①：跨仓 base = task 卡 base_commit 锡点（必传）。跨仓仓无 meta.json，
+      // 不读 meta；taskBaseCommit 由 task-02 DeclaredRepos 之外的 task 卡 frontmatter 提供。
+      resolveBase: (taskBaseCommit) => {
+        if (!taskBaseCommit) {
+          throw new Error(
+            `MultiRepoContext: 跨仓 repo "${repoKey}" resolveBase 必传 taskBaseCommit（task 卡 base_commit 锡点）。` +
+            `跨仓仓无 meta.json，base 只能由 task 卡片锡点提供（约束①）。`
+          );
+        }
+        return taskBaseCommit;
+      },
+    };
+  }
+
+  /** @returns {RepoEntry|null} */
+  resolve(repoKey) {
+    return this.map.get(repoKey) || null;
+  }
+
+  /** @returns {Map<string, RepoEntry>} */
+  get repos() {
+    return this.map;
+  }
+
+  /** @returns {boolean} 是否含跨仓 task（map.size>1，execute prompt 分叉用） */
+  hasCrossRepo() {
+    return this.map.size > 1;
+  }
+}