sillyspec 3.26.2 → 3.26.4

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}
 ### 任务摘要（按需读取完整蓝图）
 为每个任务启动子代理时，**只需告知任务目标和蓝图文件路径，让子代理按需读取**：
 
@@ -627,6 +801,9 @@ ${taskSummary}
 2. 蓝图文件路径（让子代理自行读取详情）
 3. 编码铁律：先读后写、TDD、不编造方法、只做蓝图里写的事、遵守边界处理规则、不超出 allowed_paths
 4. 如存在模块文档（.sillyspec/docs/*/modules/），按需读取涉及模块的 <module>.md 参考接口约定和数据流
+5. 任务含测试代码时，把下方「测试用例设计」整段复制进子代理 prompt，要求子代理按此设计测试用例
+
+{{include: testcase-design}}
 
 ### Wave 开始前
 1. 读取 design.md 的「非目标」与「兼容策略」章节（如存在），确保子代理不超范围、不破坏旧逻辑
@@ -680,7 +857,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 +906,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
   }))

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/stages/quick.js

@@ -50,9 +50,11 @@ export const definition = {
 ### 操作
 1. 先读后写：调用已有方法前 \`cat\` 源文件确认签名，\`grep\` 确认方法存在
 2. 写代码完成任务
-3. 如涉及逻辑变更，建议写单元测试验证（不强制，纯配置/文档/小改动可跳过）
+3. 如涉及逻辑变更，建议写单元测试验证（不强制，纯配置/文档/小改动可跳过）；写测试时按下方「测试用例设计」检查
 4. **不要做无谓的全量编译/构建。** 但——跑针对性的单元测试始终允许且鼓励（见 step3）；若本任务就是修测试/构建/基础设施本身，跑测试/构建即验收，应当跑，不算"编译"
 
+{{include: testcase-design}}
+
 ### 输出
 实现摘要 + 修改文件列表
 

package/src/stages/verify.js

@@ -214,7 +214,7 @@ PASS / PASS WITH NOTES / FAIL
 ## 探针结果
 - 未实现标记扫描：...
 - 关键词覆盖：...
-- 测试覆盖：...
+- 测试覆盖（含断言有效性抽查）：...
 - 决策追踪覆盖：...
 - API 契约对账：...
 - 代码删除对账：声明修改/新增却被整文件删除 = 高风险；清单未列出的删除 = 未声明（CLI 会用 git diff --name-status HEAD advisory 复核，仅 warn 不阻断——是否 FAIL blocker 由你诚实判定）