sillyspec 3.27.6 → 3.27.9

package/src/run/stage.js

@@ -21,7 +21,7 @@ import { existsSync, readdirSync, readFileSync, mkdirSync } from 'node:fs'
 import { writeAtomicSync } from '../fs-atomic.js'
 import { resolveSpecDir, resolveChangeDir, resolveRuntimeRoot, resolveQuickSessionsDir, triggerSync, safeGit, parsePorcelainPath, formatWaitOptions, checkApproval, getStageSteps, warnApprovalUnknown } from './shared.js'
 import { computeScanProfile, applyScanProfileSteps, executeScanPreflight, executeScanPostcheck } from './scan-profile.js'
-import { outputStep } from './prompt.js'
+import { outputStep, collectStageWaitHistory } from './prompt.js'
 import { allocateQuicklogEntry, deriveTitleFromLinkedChange, sanitizeDesc } from '../quicklog.js'
 import { createHash } from 'node:crypto'
 import { checkTransition } from '../stage-contract.js'
@@ -93,6 +93,26 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
       const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
       await ensureDepsFreshness(cwd, effectiveChange, execSpecBase, existingMeta)
     }
+
+    // ── 跨仓仓 worktree 隔离（坑 cross-repo-no-worktree-isolation，2026-08-27 用户实证）──
+    // 主仓 worktree 就绪后，为 plan 声明的每个跨仓仓建同构 worktree（幂等）。此前跨仓 task 直写
+    // 跨仓主工作副本，与用户在途改动混流、无 base 锚、无回滚面。fail-closed：建不起来不开工
+    //（对齐主仓 create 语义）。
+    try {
+      const { ensureCrossWorktrees } = await import('../worktree-cross.js')
+      const execSpecBase = platformOpts?.specRoot || join(cwd, '.sillyspec')
+      const cross = ensureCrossWorktrees({ cwd, changeName: effectiveChange, specBase: execSpecBase })
+      for (const c of cross.created) {
+        console.log(`🔗 跨仓 worktree 已创建: repo=${c.repoKey} → ${c.worktreePath}`)
+      }
+      for (const r of cross.reused) {
+        console.log(`🔗 跨仓 worktree 已存在: repo=${r.repoKey} → ${r.worktreePath}`)
+      }
+    } catch (e) {
+      console.error(`❌ 跨仓 worktree 创建失败: ${e.message}`)
+      console.error(`   修复后重跑本命令（已建成功的仓会幂等复用）。`)
+      process.exit(1)
+    }
   }
 
   // ── execute 阶段启动时固定 executeRunId（绑定变更名，避免跨变更复用） ──
@@ -142,18 +162,18 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
       const { resolveVerifyChangedFiles } = await import('../verify-postcheck.js')
       const activeChanges = (pm.listChanges(cwd) || []).filter(c => c && c !== changeName)
       if (activeChanges.length > 0) {
-        const myFiles = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true }) || []
+        const myFiles = resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || []
         const mySet = new Set(myFiles.map(f => f.replace(/\\/g, '/')).filter(f => !f.startsWith('.sillyspec/')))
         if (mySet.size > 0) {
           const conflicts = []
           for (const other of activeChanges) {
-            const otherFiles = resolveVerifyChangedFiles(cwd, other, null, { includeWorkingTree: true }) || []
+            const otherFiles = resolveVerifyChangedFiles(cwd, other, null, { includeWorkingTree: true, specBase }) || []
             const overlap = [...new Set(otherFiles.map(f => f.replace(/\\/g, '/')))]
               .filter(f => mySet.has(f))
             if (overlap.length > 0) conflicts.push({ other, overlap })
           }
           if (conflicts.length > 0) {
-            console.warn(`⚠️ 跨变更文件冲突预警：本变更（${changeName}}）与其他活跃变更改动重叠——`)
+            console.warn(`⚠️ 跨变更文件冲突预警：本变更（${changeName}）与其他活跃变更改动重叠——`)
             for (const c of conflicts) {
               console.warn(`   与 ${c.other} 重叠 ${c.overlap.length} 个文件：${c.overlap.slice(0, 5).join(', ')}${c.overlap.length > 5 ? ` …（共 ${c.overlap.length}）` : ''}`)
             }
@@ -177,7 +197,7 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
         .split('\n').filter(Boolean).map(l => l.slice(3).trim().split(' -> ').pop() || '')
         .map(p => p.replace(/^"|"$/g, '').replace(/\\/g, '/'))
         .filter(p => p && !p.startsWith('.sillyspec/'))
-      const myFiles = (await import('../verify-postcheck.js')).resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true }) || []
+      const myFiles = (await import('../verify-postcheck.js')).resolveVerifyChangedFiles(cwd, changeName, null, { includeWorkingTree: true, specBase }) || []
       const mySet = new Set(myFiles.map(f => f.replace(/\\/g, '/')))
       const foreign = mainDirty.filter(p => !mySet.has(p))
       if (foreign.length > 0) {
@@ -228,8 +248,14 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
 
   let currentIdx = steps.findIndex(s => s.status !== 'completed' && s.status !== 'skipped')
 
-  // stale 步骤视为可执行（等同于 pending）
-  if (currentIdx !== -1 && steps[currentIdx].status === 'stale') {
+  // stale/blocked 步骤视为可执行（等同于 pending）：
+  //   stale = reopen 后未重做（原语义）；blocked = 门控（deps/review.json）阻断标记。
+  // blocked 必须一并转换（坑 deps-gate-blocked-invisible 的路径①失效面）：reopen 后首个未完成
+  // 步骤若是 blocked（早前门控阻断污染），只转 stale 会让 completeStep 的 findIndex(pending)
+  // 跳过它、--done 永远撞 stale 门控报错——「逐个真实执行」指引失效。门控在 --done 时会
+  // 重新校验，此处拉回 pending 不会绕过任何校验。
+  if (currentIdx !== -1 && (steps[currentIdx].status === 'stale' || steps[currentIdx].status === 'blocked')) {
+    console.log(`⚠️  Step "${steps[currentIdx].name}" 处于 ${steps[currentIdx].status}，已拉回待执行。`)
     steps[currentIdx].status = 'pending'
     pm._write(cwd, progress, changeName)
     triggerSync(cwd, changeName, platformOpts)
@@ -488,7 +514,7 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
       const nextIdx = stageData.steps.findIndex(s => s.status === 'pending' || s.status === 'in-progress')
       if (nextIdx !== -1 && defSteps[nextIdx]) {
         console.log('')
-        await outputStep(stageName, nextIdx, defSteps, cwd, changeName, progress.project || null, platformOpts)
+        await outputStep(stageName, nextIdx, defSteps, cwd, changeName, progress.project || null, platformOpts, null, collectStageWaitHistory(progress, stageName))
       } else {
         // 所有步骤完成
         stageData.status = 'completed'
@@ -506,7 +532,7 @@ export async function runStage(pm, progress, stageName, cwd, changeName, skipApp
       }
       return
     }
-    await outputStep(stageName, currentIdx, defSteps, cwd, changeName, progress.project || null, platformOpts)
+    await outputStep(stageName, currentIdx, defSteps, cwd, changeName, progress.project || null, platformOpts, null, collectStageWaitHistory(progress, stageName))
   }
 }
 

package/src/scan-diff.js

@@ -246,8 +246,10 @@ function renderTerminal(r, { full }) {
 /** 文件归属状态字母（渲染用）：R（renameMap 命中）> A > D > M */
 function statusLetter(r, f) {
   if (r.renameMap[f]) return 'R'
-  if (r.added.includes(f)) return 'A'
-  if (r.deleted.includes(f)) return 'D'
+  // Set 惰性缓存（挂在 r 上，渲染期只建一次）：added/deleted 数组线性扫在数千文件逐条渲染时是 O(n²)
+  if (!r._statusSets) r._statusSets = { added: new Set(r.added), deleted: new Set(r.deleted) }
+  if (r._statusSets.added.has(f)) return 'A'
+  if (r._statusSets.deleted.has(f)) return 'D'
   return 'M'
 }
 

package/src/stage-contract.js

@@ -459,13 +459,26 @@ function validatePlanOutputs(cwd, changeName, context = {}) {
  * 历史教训：原正则锚定确切「## 结论」，用户写「## 验收结论：✅ PASS」不被识别。
  */
 function extractVerifyConclusion(verify) {
-  const headingRe = /^##\s[^\n]*(?:结论|conclusion|result|结果)/im
-  const headingMatch = verify.match(headingRe)
-  if (!headingMatch) return ''
-  const start = headingMatch.index
-  const slice = verify.slice(start, start + 400)
-  const kw = slice.match(/\b(PASS(?:\s+WITH\s+NOTES)?|FAIL)\b/i)
-  return kw ? kw[1].toUpperCase().replace(/\s+/g, ' ') : ''
+  // 遍历所有含关键词的二级标题，取其 400 字符窗口内含 PASS/FAIL 的那个（坑
+  // verify-conclusion-heading-hijack：旧逻辑取首个匹配，"## 测试结果"等普通标题
+  // 排在真结论前时劫持识别）。优先精确匹配「## 结论」类窄标题。
+  const headingRe = /^##\s[^\n]*(?:结论|conclusion|result|结果)/gim
+  let best = null
+  let bestPriority = -1
+  for (const headingMatch of verify.matchAll(headingRe)) {
+    const start = headingMatch.index
+    const slice = verify.slice(start, start + 400)
+    const kw = slice.match(/\b(PASS(?:\s+WITH\s+NOTES)?|FAIL)\b/i)
+    if (!kw) continue
+    // 优先级：精确含「结论/conclusion」> 宽泛含「result/结果」
+    const text = headingMatch[0].toLowerCase()
+    const priority = (/结论|conclusion/i.test(text)) ? 1 : 0
+    if (priority > bestPriority || (priority === bestPriority && !best)) {
+      best = kw[1].toUpperCase().replace(/\s+/g, ' ')
+      bestPriority = priority
+    }
+  }
+  return best || ''
 }
 
 function validateVerifyOutputs(cwd, changeName, context = {}) {
@@ -545,8 +558,11 @@ function validateVerifyOutputs(cwd, changeName, context = {}) {
         let receiptText = ''
         try {
           // 回执按变更分片（坑 verify-pids-cross-session-kill：原单份被并行会话后写覆盖），
-          // 优先读本变更分片，兼容旧单份名（升级过渡期 receipt.change 过滤仍生效）
-          const runtimeDir = join(cwd, '.sillyspec', '.runtime')
+          // 优先读本变更分片，兼容旧单份名（升级过渡期 receipt.change 过滤仍生效）。
+          // runtimeDir 与写入方 reapVerifyServices 同源解析（context.runtimeRoot > specRoot/.runtime
+          // > cwd/.sillyspec/.runtime）——平台/漂移模式下 cwd/.sillyspec 恒读不到回执
+          const runtimeDir = context.runtimeRoot
+            || join(context.specRoot || join(cwd, '.sillyspec'), '.runtime')
           const receiptPath = existsSync(join(runtimeDir, `verify-services-${changeName}.receipt.json`))
             ? join(runtimeDir, `verify-services-${changeName}.receipt.json`)
             : join(runtimeDir, 'verify-services.receipt.json')
@@ -602,9 +618,14 @@ export function archiveDestDirName(date, changeName) {
 
 /**
  * archive 完成校验：检查归档目录完整性
+ *
+ * context.specRoot（A4 同族）：平台模式下归档目录在 specRoot/changes/archive（gates.js /
+ * machine-interface.js 调 runValidators 已透传 specRoot: platformOpts?.specRoot），此前硬编码
+ * cwd/.sillyspec 平台模式恒报「归档目录缺失」。
  */
-function validateArchiveOutputs(cwd, changeName) {
-  const archiveDir = join(cwd, '.sillyspec', 'changes', 'archive')
+function validateArchiveOutputs(cwd, changeName, context = {}) {
+  const specBase = context.specRoot || join(cwd, '.sillyspec')
+  const archiveDir = join(specBase, 'changes', 'archive')
   const destDir = join(archiveDir, changeName)
 
   // 归档目录不存在 early return(引擎在存在时才跑)
@@ -620,14 +641,14 @@ function validateArchiveOutputs(cwd, changeName) {
 /**
  * archive 前置校验：所有主流程阶段完成
  */
-function validateChangeClosed(cwd, changeName) {
+function validateChangeClosed(cwd, changeName, context = {}) {
   const errors = []
   const warnings = []
 
-  // 检查前置阶段状态
-  const progressDir = join(cwd, '.sillyspec', '.runtime')
+  // context.specRoot：平台模式下变更目录在 specRoot/changes（同 validateArchiveOutputs）
+  const specBase = context.specRoot || join(cwd, '.sillyspec')
   // 这里只做文件层面的检查，DB 检查在 run.js 里做
-  const changeDir = join(cwd, '.sillyspec', 'changes', changeName)
+  const changeDir = join(specBase, 'changes', changeName)
   if (!existsSync(changeDir)) {
     errors.push(`变更目录不存在: ${changeDir}`)
     return { ok: false, errors, warnings }

package/src/stages/brainstorm.js

@@ -162,11 +162,15 @@ export const definition = {
 5. **场景压力测试**：用具体 case 逼出边界（失败重试、部分成功、历史数据、权限不足、并发修改、兼容旧配置）
 6. **前提挑战优先**：如果现有设计或代码已有简单路径，先说明"可能不该新增"
 
-**决策记录草稿**：每解决一个有实现影响的问题，生成一个稳定 ID 的记录草稿（不要把闲聊都记录进去）：
+**决策记录（增量落盘，防会话中断丢失）**：每解决一个有实现影响的问题（不要把闲聊都记录进去），**当场追加**写入 \`{SPEC_ROOT}/changes/<change-name>/decisions.md\`——不要只在对话里留草稿等「写设计文档」步统一落盘：会话随时可能中断，未落盘的决策无法跨会话恢复。落盘规则：
+
+- 文件不存在则先创建：变更目录缺失先 \`mkdir -p {SPEC_ROOT}/changes/<change-name>\`；文件头部写 YAML frontmatter（\`author: <git-user>\` / \`created_at: <now-datetime>\`）+ 标题 \`# 决策记录（Decisions）\`
+- 每条记录追加到文件末尾，格式如下：
 
 \`\`\`markdown
 ## D-001@v1: <短标题>
 - type: term | boundary | premise | architecture | compatibility | risk
+- priority: P0 | P1 | P2
 - status: accepted | rejected | superseded
 - source: user | code | docs
 - question: <被解决的问题>
@@ -176,6 +180,8 @@ export const definition = {
 - evidence: <文件路径/代码位置/用户回答轮次>
 \`\`\`
 
+- 幂等：写入前按 D-xxx@vN 查重，已存在的不重复追加；后续修正走新版本 D-001@v2 + supersedes（见 Design Grill 版本规则）
+
 ### 铁律 — 不要自问自答 / 等待用户
 - 这是人机协作步骤：提出问题后必须暂停等用户回答，**不要在输出里模拟用户回答然后说"需求已明确"**（命令由 CLI 在下方注入）
 - 需要拆分或批量模式时：列出方案并暂停等用户确认
@@ -183,12 +189,12 @@ export const definition = {
 - 2-3 轮问答即进入方案讨论；达到 maxWaitRounds=8 后必须总结已确认内容与剩余风险，不要无限追问
 
 ### 输出
-需求理解摘要（用户确认的需求点列表）+ 拆分/批量结论（如适用）+ D-xxx@vN 决策记录草稿 + 剩余风险（如有）
+需求理解摘要（用户确认的需求点列表）+ 拆分/批量结论（如适用）+ 本步新增落盘的 D-xxx@vN 清单 + 剩余风险（如有）
 
 ### 注意
 - 第一次进入此步骤时，按 A→D 顺序处理；有原型先分析，再探索，再判规模，再澄清
-- 用户通过 \`--continue --answer "回答"\` 回答后，本步骤会再次执行，此时检查是否需要追问或可以结束`,
-      outputHint: '需求理解与决策记录草稿',
+- 用户通过 \`--continue --answer "回答"\` 回答后，本步骤会再次执行，此时检查是否需要追问或可以结束；再次执行时输出只需增量汇报（新结论 + 新落盘决策），已落盘内容不要重复输出`,
+      outputHint: '需求理解与决策落盘清单',
       optional: false
     },
     {
@@ -202,6 +208,7 @@ export const definition = {
 1. 每种方案列出：核心思路、优势、劣势
 2. 如果上一步产生了 D-xxx@vN 决策记录，方案必须说明覆盖/违反哪些当前版本决策
 3. 给出推荐方案和理由
+4. 用户选定方案后，把选择结果**当场追加**到 \`{SPEC_ROOT}/changes/<change-name>/decisions.md\`（增量落盘规则同「对话式探索」步：目录/文件缺失先创建、按 D-xxx@vN 判重）：type 用 architecture、source 用 user、question 记方案取舍问题、answer 记用户所选方案与理由要点、evidence 记方案选择轮次——方案选择是本变更最关键的用户决策，必须随答随落盘，不能只留在对话里
 
 ### 铁律 — 必须等待用户选择方案
 - 列出方案对比表和推荐后必须暂停等用户选择，**不要自己说"推荐方案 A"然后当用户选了**（命令由 CLI 在下方注入）
@@ -287,9 +294,15 @@ design.md 第一行标题必须用中文：# 设计文档（Design）— <变更
 | 删除 | src/xxx/OldFile.java | 已被 xx 替代 |
 
    **字段数据流标注**（避免新增字段到 execute 才发现没透传）：当清单含「新增/修改对外字段、接口、DTO、响应体、事件 payload、配置键」时，对应行「说明」列必须交代 producer→consumer 数据流——产出方（producer）→ 每跳流转/归一化点（序列化/反序列化/字段映射/默认值兜底）→ 消费方（consumer）。漏标 = 字段在某跳 dormant（声明了却没透传），到 execute/verify 才暴露，属设计层缺口。
-   - 示例：「修改 daemon.ts：新增 budget_tokens，producer=backend/api-types.ts → ws_hub envelope 透传 → daemon.ts normalizeUsage 归一化（snake→camel）→ consumer=runtime/lease.ts 写 lease」
+   - 示例：「修改 daemon.ts：新增 budget_tokens，producer=backend/api-types.ts → ws_hub envelope 透传 → daemon.ts normalizeUsage（snake→camel）→ consumer=runtime/lease.ts 写 lease」
    - 仅改内部实现、无对外字段变动时，说明列照常写「新增 xx 方法」即可，无需数据流。
 
+   **跨仓变更写法**（本次变更涉及 local.yaml repos: 注册的其他仓时必读；纯主仓变更跳过）：
+   - 清单**按仓分段**：每个仓一个小节，标题格式固定 \`## <repo-key> 仓变更\`（如 \`## sub-grid-security 仓变更\`）。plan-postcheck 文件覆盖对账按此段头解析仓归属，写成「前端仓 / backend」等其他标题 → 对账不上
+   - 段内路径相对**该仓根**写（\`src/routes/x.js\`）；❌ 禁止带仓库名前缀（\`sub-grid-security/src/routes/x.js\`）、❌ 禁止绝对路径/盘符路径（\`C:/repo/src/...\`）——后续 TaskCard 的 allowed_paths 与 review 对账（\`git -C <仓根> diff\` 产仓根相对路径）都用同一口径，前缀/绝对路径永不命中
+   - 主仓文件放在第一个段头之前（无段头区域 = main），或单独写 \`## main 仓变更\` 段
+   - repo-key 必须是 local.yaml repos: 段已注册的键（未注册先跑 \`sillyspec local register-repo <key> <仓根路径>\`，main 隐式不用注册）
+
 7. **接口定义**：方法签名、数据结构（代码类任务必填）
 7.5. **生命周期契约表**（涉及以下关键词时必填，否则可省略）：
 
@@ -336,10 +349,11 @@ design.md 第一行标题必须用中文：# 设计文档（Design）— <变更
 1. 确认变更目录存在：\`mkdir -p {SPEC_ROOT}/changes/<change-name>\`（Windows 用 \`mkdir {SPEC_ROOT}/changes\\<变更名>\` 或 PowerShell \`New-Item -ItemType Directory -Force -Path {SPEC_ROOT}/changes/<change-name>\`）
    - 变更名格式必须为 \`YYYY-MM-DD-<简短描述>\`（如 \`2026-05-13-user-auth\`）
 2. 将确认的设计写入 \`{SPEC_ROOT}/changes/<change-name>/design.md\`
-3. 如果对话探索或方案讨论产生了实现相关决策，写入 \`{SPEC_ROOT}/changes/<change-name>/decisions.md\`：
+3. 对账整理 \`{SPEC_ROOT}/changes/<change-name>/decisions.md\`（「对话式探索」「提出方案」步已按增量规则随答落盘，本步做对账而非从零写入）：
    - decisions.md 是本次变更的决策台账，不是长期术语表
    - 只记录有实现/验收影响的决策，闲聊和低风险偏好不记录
-   - 每条记录必须有稳定版本 ID：D-001@v1、D-002@v1 ...
+   - 已落盘条目按 D-xxx@vN 判重，不重复追加；补全缺失的九字段与可选字段
+   - 前序遗漏未落盘、确有实现影响的决策（增量规则漏网的），此时补写；每条记录必须有稳定版本 ID：D-001@v1、D-002@v1 ...
    - 若后续 Design Grill 修正该决策，新记录使用 D-001@v2，并写明 supersedes: D-001@v1
    - 每条记录必须包含：type、status、source、question、answer、normalized_requirement、impacts、evidence、priority
    - 九字段之外可另加四个可选字段，按需填写、不强制全填（旧格式决策记录缺这些字段不受影响）：
@@ -572,7 +586,7 @@ created_at: <now-datetime>
 \`\`\`
 > 骨架只列任务名。plan 阶段会把展开后的清单**写回本文件**（checkbox 行带一句话名，可附 [model:xxx]/(depends_on: …) 标注；保留 frontmatter/标题/ql-xxx 等非 task-XX 行）；execute 勾选与 verify 对照都在本文件。
 
-### decisions.md 格式要求（仅在有 Grill/重大决策时生成）
+### decisions.md 格式要求（前序步骤已增量创建时对账即可；无决策的变更不生成）
 \`\`\`markdown
 ---
 author: <git-user>

package/src/stages/execute.js

@@ -717,6 +717,8 @@ export async function stampCrossRepoHeadCommits({ changeName, cwd, specBase, pla
   }
   let stamped = 0
   let skipped = 0
+  // 同仓多 task 只 spawn 一次 rev-parse（Windows 单次 spawn 30-100ms，N task × 同仓纯浪费）
+  const headCache = new Map()
   for (const f of readdirSync(tasksDir).filter(n => /^task-\d+\.md$/.test(n)).sort()) {
     const taskFile = path.join(tasksDir, f)
     let content
@@ -735,7 +737,8 @@ export async function stampCrossRepoHeadCommits({ changeName, cwd, specBase, pla
       reasons.push(`${f}: repo "${repoKey}" 无法解析 gitDir（local.yaml repos 未注册？）`)
       continue
     }
-    const head = gitQuiet(entry.gitDir, ['rev-parse', 'HEAD'])
+    if (!headCache.has(entry.gitDir)) headCache.set(entry.gitDir, gitQuiet(entry.gitDir, ['rev-parse', 'HEAD']))
+    const head = headCache.get(entry.gitDir)
     if (!head) {
       skipped++
       reasons.push(`${f}: git rev-parse HEAD 失败（${entry.gitDir}）`)
@@ -760,6 +763,22 @@ export async function stampCrossRepoHeadCommits({ changeName, cwd, specBase, pla
  */
 export function buildWavePrompt(wave, waveIndex, changeDir, worktreePath, options = {}) {
   const ctx = options.ctx || null
+  // 跨 Wave 共享缓存（性能收敛 O(W×T) → O(T)）：一次 buildExecuteSteps 期间 plan/契约矩阵/
+  // task 卡/模块卡表/design 行集不变，每 Wave 重读重解析是纯浪费（6-8 Wave × 15 task 的
+  // full 级变更 = 数百次冗余 fs + 契约矩阵全卡重扫）。缓存对象由 buildExecuteSteps 创建传入；
+  // 直接调用（tests / 单 Wave）不传 _execCache 时全部退化为即时计算，行为不变
+  const cache = options._execCache || null
+  const memo = (slot, compute) => {
+    if (!cache) return compute()
+    if (!(slot in cache)) cache[slot] = compute()
+    return cache[slot]
+  }
+  const memoMap = (slot, key, compute) => {
+    if (!cache) return compute()
+    if (!cache[slot]) cache[slot] = new Map()
+    if (!cache[slot].has(key)) cache[slot].set(key, compute())
+    return cache[slot].get(key)
+  }
   // ── Contract Matrix：检查是否有 provider/consumer 契约需要注入 ──
   let contractInjection = ''
   let prototypeInjection = ''
@@ -767,7 +786,7 @@ export function buildWavePrompt(wave, waveIndex, changeDir, worktreePath, option
     try {
       const planFile = path.join(changeDir, 'plan.md')
       if (existsSync(planFile)) {
-        const planContent = readFileSync(planFile, 'utf8')
+        const planContent = memo('plan', () => readFileSync(planFile, 'utf8'))
         // 收集本 wave 所有 task（端点注入与字段注入共用）
         const waveTasks = wave.tasks.map((t, ti) => {
           const num = String(t.index || (ti + 1)).padStart(2, '0')
@@ -775,7 +794,7 @@ export function buildWavePrompt(wave, waveIndex, changeDir, worktreePath, option
         })
 
         // 1) 端点级契约（provider/consumer via buildContractMatrix）
-        const contracts = buildContractMatrix(planContent, changeDir)
+        const contracts = memo('contracts', () => buildContractMatrix(planContent, changeDir))
         const relevantContracts = contracts.filter(c => waveTasks.includes(c.consumer))
         if (relevantContracts.length > 0) {
           contractInjection = `
@@ -802,7 +821,7 @@ ${injection}
         // 命中「provider 漏字段、consumer fallback 编造 → 运行时 403/500」这类 bug：
         // 把 consumer 期望字段 vs provider 承诺字段显式注入子代理 prompt
         for (const taskName of waveTasks) {
-          const fi = buildContractFieldInjection(changeDir, taskName)
+          const fi = memoMap('fieldInjections', taskName, () => buildContractFieldInjection(changeDir, taskName))
           if (fi) {
             contractInjection += `
 ### 子代理 ${taskName} 的字段契约注入
@@ -848,11 +867,12 @@ ${prototypes.map(p => `- \`${path.join(protoRelDir, p)}\``).join('\n')}
       // 平台模式（specRoot 异位）回退 process.cwd()——子项目目录前缀判定用，误差只降级匹配粒度
       const repoRoot = path.basename(specBase) === '.sillyspec' ? path.dirname(specBase) : process.cwd()
       const waveTaskIds = new Set(wave.tasks.map((t, ti) => `task-${String(t.index || (ti + 1)).padStart(2, '0')}`))
-      const { hasMaps, rows } = resolveChangeModuleCards({
+      // 模块卡表与 Wave 无关（按 change 全量解析后本 Wave 过滤）：memo 跨 Wave 共享
+      const { hasMaps, rows } = memo('moduleCards', () => resolveChangeModuleCards({
         cwd: repoRoot,
         specBase,
         changeName: path.basename(changeDir),
-      })
+      }))
       const hits = rows.filter(r => waveTaskIds.has(r.taskId) && r.moduleId)
       if (hasMaps && hits.length > 0) {
         const kb = n => (n > 0 ? `${(n / 1024).toFixed(1)}KB` : '?')
@@ -879,7 +899,7 @@ ${cardLines}
       const designPath = path.join(changeDir, 'design.md')
       if (existsSync(designPath)) {
         const SECTION_CHAR_LIMIT = 2400
-        const dLines = readFileSync(designPath, 'utf8').replace(/\r\n/g, '\n').split('\n')
+        const dLines = memo('designLines', () => readFileSync(designPath, 'utf8').replace(/\r\n/g, '\n').split('\n'))
         const sections = []
         let cur = null
         dLines.forEach((l, i) => {
@@ -986,13 +1006,20 @@ ${indexLines}
       return { taskNum, repo, workdir }
     })
 
-    // D-010 跨仓 task base 锡点：派发前实时 git rev-parse HEAD 落 task 卡 base_commit
-    // 仅对跨仓 task（repo≠'main'）落盘，主仓 task 锚 meta.baseHash（MultiRepoContext 已处理）
+    // D-010 跨仓 task base 锡点：派发前落 task 卡 base_commit
+    // 仅对跨仓 task（repo≠'main'）落盘，主仓 task 锚 meta.baseHash（MultiRepoContext 已处理）。
+    // worktree 模式（跨仓 worktree 隔离，坑 cross-repo-no-worktree-isolation）优先 entry.baseCommitHint
+    //（= meta.baseHash 创建时快照）——worktree HEAD 会随子代理 commit 推进，rev-parse HEAD 当 base
+    // 会把 Wave 内前序 task 的交付错算进后续 task 的 base；legacy 直写模式沿用跨仓根实时 HEAD。
+    const baseCommitCache = new Map() // 同仓多 task 只 spawn 一次
     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 (!baseCommitCache.has(entry.gitDir)) {
+        baseCommitCache.set(entry.gitDir, entry.baseCommitHint || gitQuiet(entry.gitDir, ['rev-parse', 'HEAD']))
+      }
+      const baseCommit = baseCommitCache.get(entry.gitDir)
       if (!baseCommit) continue // git 不可达已由 MultiRepoContext 构造时 fail-closed 拦截，此处置防御
       const taskFile = changeDir
         ? path.join(changeDir, 'tasks', `task-${item.taskNum}.md`)
@@ -1001,27 +1028,43 @@ ${indexLines}
       baseCommitWrites.push({ taskNum: item.taskNum, repo: item.repo, taskFile, written, baseCommit })
     }
 
-    // 跨仓 task commit 指引 + head_commit 落盘指引（D-010 回收时机）
+    // 跨仓 task commit 指引 + head_commit 落盘指引（D-010 回收时机）。
+    // worktree 模式（跨仓 worktree 隔离）：子代理在跨仓 worktree 分支改+commit，apply 阶段 CLI
+    // 统一 patch 回跨仓主工作区（与主仓同构）；legacy 直写模式保留原文案（commit 直落跨仓主干）。
+    const crossWorktreeItems = perTaskWorkdirs.filter(i => {
+      const e = i.repo !== 'main' ? ctx.resolve(i.repo) : null
+      return e && e.isWorktree
+    })
+    const crossLegacyItems = perTaskWorkdirs.filter(i => i.repo !== 'main' && !crossWorktreeItems.some(w => w.taskNum === i.taskNum))
     const crossLines = perTaskWorkdirs
       .filter(i => i.repo !== 'main')
-      .map(i => `- task-${i.taskNum} → repo \`${i.repo}\`，workdir=\`${i.workdir}\``)
+      .map(i => {
+        const e = ctx.resolve(i.repo)
+        return `- task-${i.taskNum} → repo \`${i.repo}\`，workdir=\`${i.workdir}\`${e && e.isWorktree ? '（worktree 隔离）' : ''}`
+      })
       .join('\n')
-    crossRepoCommitSection = `
-### 跨仓 task 派发与双锡点
-
-本 Wave 含跨仓 task（直接改跨仓仓主干，**不经主仓 worktree**）：
+    const crossWorktreeSection = crossWorktreeItems.length > 0 ? `
 
-${crossLines}
+**跨仓 worktree task（repo 已建 worktree 隔离）——像主仓 task 一样工作：**
+- 子代理在 workdir（跨仓 worktree）内改+commit（git add + git commit 到 worktree 当前分支），**不要碰跨仓主工作副本**。
+- apply 阶段 CLI 统一把各跨仓 worktree 的交付 patch 回对应跨仓主工作区（勿手工 apply）。
+- base 已锚 worktree meta.baseHash（创建时快照），review 的 base/head 由 CLI 按 task 卡锡点解析。` : ''
+    const crossLegacySection = crossLegacyItems.length > 0 ? `
 
 **派发跨仓 task 前（base 锡点，CLI 已在 prompt 构造时落盘）：**
 - 跨仓 task 卡 frontmatter 的 \`base_commit\` 已由 CLI 实时 \`git -C <跨仓仓根> rev-parse HEAD\` 锁定（base 锡点，约束①）。子代理在此 HEAD 上改+commit，不受同 Wave 其他 task 推进 HEAD 影响。
 
+**跨仓 task 子代理 prompt 必须注入（legacy 直写模式）：**
+> 该 task 改的是 \`<repo>\` 仓，workdir=\`<跨仓仓根>\`。**直接在该仓主干工作区改+commit（git add + git commit 到该仓主干），不经主仓 worktree、不建分支。** commit 到该仓主干即落盘，apply 阶段对跨仓 task 为 no-op（design §5.4 G1）。
+> task 卡 allowed_paths 是相对**该仓根**的路径（如 \`src/routes/x.js\`）——不带仓库名前缀（\`<repo>/src/...\` ❌）、不是绝对路径；在 workdir 下直接按相对路径定位文件。` : ''
+    crossRepoCommitSection = `
+### 跨仓 task 派发与双锡点
+
+${crossLines}${crossWorktreeSection}${crossLegacySection}
+
 **回收跨仓 task（head 锡点，CLI 自动落盘，勿手写）：**
-- 子代理完成 commit 后，正常写 review.json（verdict/notes）并勾选 checkbox 即可。execute \`--done\` 时 CLI 自动 \`git -C <跨仓仓根> rev-parse HEAD\` 写入该 task 卡 \`head_commit:\`（幂等，已存在不覆盖——你若手写了精确锚点则以你的为准）。
+- 子代理完成 commit 后，正常写 review.json（verdict/notes）并勾选 checkbox 即可。execute \`--done\` 时 CLI 自动对跨仓仓（worktree 模式=该仓 worktree，legacy=仓根）\`git rev-parse HEAD\` 写入该 task 卡 \`head_commit:\`（幂等，已存在不覆盖——你若手写了精确锚点则以你的为准）。
 - review.json 的 mechanics 字段（\`base\`/\`head\`/\`changedFiles\`）无需手算：\`base\` 取 task 卡 \`base_commit\`、\`head\` 取 task 卡 \`head_commit\`，写完跑 \`sillyspec backfill-reviews --change <变更名> --adopt\` 一键代填（verdict 保留）。
-
-**跨仓 task 子代理 prompt 必须注入：**
-> 该 task 改的是 \`<repo>\` 仓，workdir=\`<跨仓仓根>\`。**直接在该仓主干工作区改+commit（git add + git commit 到该仓主干），不经主仓 worktree、不建分支。** commit 到该仓主干即落盘，apply 阶段对跨仓 task 为 no-op（design §5.4 G1）。
 `
   }
 
@@ -1265,10 +1308,14 @@ export function buildExecuteSteps(planFilePath = null, options = {}) {
   // （D-013）。缺省=null → buildWavePrompt 退化为单仓单 worktreePath（零回归）。
   const ctx = options.ctx || null
 
+  // 跨 Wave 共享缓存：plan/契约矩阵/task 卡字段注入/模块卡表/design 行集在一次步骤表
+  // 构建期间不变，逐 Wave 重读重算是 O(W×T) 纯浪费（见 buildWavePrompt 内 memo 注释）
+  const execCache = {}
+
   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, ctx }),
+    prompt: buildWavePrompt(wave, i + 1, changeDir, worktreePath, { dispatchMode: options.dispatchMode, branch: options.branch, ctx, _execCache: execCache }),
     outputHint: `Wave ${i + 1} 执行结果`,
     optional: false
   }))

package/src/stages/knowledge.js

@@ -14,8 +14,9 @@
  *   propose  — 提议新知识（写入 proposed/）
  */
 
-import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync, statSync } from 'fs'
+import { existsSync, readFileSync, readdirSync, mkdirSync, statSync } from 'fs'
 import { join, basename } from 'path'
+import { writeAtomicSync } from '../fs-atomic.js'
 import { parseKnowledgeIndex, matchKnowledge } from '../knowledge-match.js'
 
 // ── 工具函数 ──
@@ -305,6 +306,11 @@ export async function cmdRefresh(dir, args, opts = {}) {
   const scanFiles = readdirSync(scanDir).filter(f => f.endsWith('.md'))
   const generated = []
   const overwritten = []
+  // 同 run 文件名去重（坑 knowledge-slug-collision）：slug 只由章节标题生成，不同 scan 文件
+  // 的同名章节（如各自都有「## 概述」）后者 writeFileSync 静默覆盖前者，INDEX 却登记两条
+  // 指向同一路径的条目——知识条目无声丢失。碰撞时追加 -2/-3 后缀保双份（唯一命名零扰动，
+  // 每次 refresh 按相同文件顺序重跑，后缀分配稳定）
+  const usedNames = new Set()
 
   for (const scanFile of scanFiles) {
     const scanPath = join(scanDir, scanFile)
@@ -321,7 +327,13 @@ export async function cmdRefresh(dir, args, opts = {}) {
         .replace(/^-|-$/g, '')
         .slice(0, 60)
 
-      const fileName = `${slug}.md`
+      let fileName = `${slug}.md`
+      if (usedNames.has(fileName)) {
+        let n = 2
+        while (usedNames.has(`${slug}-${n}.md`)) n++
+        fileName = `${slug}-${n}.md`
+      }
+      usedNames.add(fileName)
       const genPath = join(generatedDir, fileName)
       const isNew = !existsSync(genPath)
 
@@ -337,7 +349,8 @@ export async function cmdRefresh(dir, args, opts = {}) {
         section.body,
       ].join('\n')
 
-      writeFileSync(genPath, entryContent)
+      // INDEX/generated 是 search/validate 的解析源（跨进程读），走原子写防半截
+      writeAtomicSync(genPath, entryContent)
       generated.push({ file: `generated/${fileName}`, title: `${title} — ${section.heading}`, new: isNew })
       if (!isNew) overwritten.push(`generated/${fileName}`)
     }
@@ -358,7 +371,7 @@ export async function cmdRefresh(dir, args, opts = {}) {
   for (const g of generated) {
     indexLines.push(`- ${g.title} → [${g.file}](${g.file})`)
   }
-  writeFileSync(genIndexPath, indexLines.join('\n'))
+  writeAtomicSync(genIndexPath, indexLines.join('\n'))
 
   output(true, {
     generated_count: generated.length,
@@ -416,7 +429,7 @@ export async function cmdPropose(dir, args, opts = {}) {
     '> This is a proposed knowledge entry. Review and merge into manual/ or generated/.',
   ].join('\n')
 
-  writeFileSync(propPath, content)
+  writeAtomicSync(propPath, content)
 
   output(true, {
     id: `proposed/${slug}`,