sillyspec 3.29.5 → 3.31.0

package/src/stages/plan-postcheck.js

@@ -1337,12 +1337,22 @@ export function validatePlanFeasibility(changeDir, projectRoot = null) {
     }
 
     // 3. allowed_paths 文件存在或父目录存在（仅在 projectRoot 提供时检查）
+    //    F2/F3（R5 对撞实证 2026-09-21，round5/r5-collision-ehs-attribution.md P9/N4）：
+    //    ① NEW: 前缀 = 声明待建文件（taskcard.js:129 已定合法格式），plan 时不存在是常态，
+    //    照查必假阳性（实证：plan --done 三连卡壳 + agent 读 CLI 源码考古）——跳过；
+    //    ② repo≠main 的跨仓 task 路径相对他仓根，用主仓 projectRoot 查 100% 不存在——整卡跳过；
+    //    ③ 主仓真缺失仍告警，但文案附逃生通道（教 NEW: 前缀与 repo: 字段），消灭「读源码弄懂
+    //    校验规则」的 meta 开销。
     if (projectRoot && allowedPaths.length > 0) {
+      const repoField = parseFrontmatterScalar(content, 'repo')
+      const crossRepo = repoField != null && repoField !== 'main'
       for (const p of allowedPaths) {
+        if (p.startsWith('NEW:')) continue // 待建文件：存在性检查语义不适用
+        if (crossRepo) continue // 跨仓路径按对应仓根声明，主仓根下查不到是常态（由该仓自己的执行/verify 把关）
         const fullPath = pJoin(projectRoot, p)
         const parentDir = pJoin(fullPath, '..')
         if (!existsSync(fullPath) && !existsSync(parentDir)) {
-          warnings.push(`${taskId}: allowed_paths 中的 ${p} 文件和父目录都不存在`)
+          warnings.push(`${taskId}: allowed_paths 中的 ${p} 文件和父目录都不存在——若为本次待建文件请改写为 NEW:${p}；跨仓 task 路径须配 repo: <仓别名> 字段按对应仓根书写（此项主仓存在性检查不适用）`)
         }
       }
     }
@@ -1621,6 +1631,322 @@ export function assessWaveStructure({ existingWaves, topoWaves, depMap, wavePath
   return { mergeablePairs, error, advisory }
 }
 
+// ═══════════════════════════════════════════════════════════════
+// 并批 advisory（B-③ / FR-01，2026-09-21-r5-efficiency-batch1 task-01）
+// ═══════════════════════════════════════════════════════════════
+
+/** task id 归一补零（`task-1` → `task-01`，与卡片/注册表/Wave 引用口径一致，坑 wave-ref-unpadded 家族） */
+function padTaskRef(id) {
+  return String(id).trim().replace(/^task-(\d+)$/i, (_, n) => `task-${n.padStart(2, '0')}`)
+}
+
+/**
+ * 解析并批成员串：`task-01+task-02` / `task-01,task-02` / `01+02`（depends_on 式数字简写）。
+ * 混合分隔符（+ ＋ , ， ; ；）通吃；返回补零 id 数组（无法解析的 token 丢弃）。
+ */
+function parseBatchMemberList(text) {
+  if (text == null) return []
+  return String(text)
+    .split(/[+＋,，;；]/)
+    .map(s => s.trim().replace(/['"`]/g, ''))
+    .filter(Boolean)
+    .map(tok => {
+      const m = tok.match(/^(?:task-)?(\d+)$/i)
+      return m ? `task-${m[1].padStart(2, '0')}` : null
+    })
+    .filter(Boolean)
+}
+
+/**
+ * 解析 plan.md Wave 段任务分组 + 批标注行（行扫描口径同 parseTaskWavesFromPlan /
+ * execute.js parseWavesFromPlan：`## Wave N` 进段、非 Wave 标题退出段）。
+ *
+ * 批标注行两形态（规范形态由 plan.js stepGeneratePlan prompt 钉死）：
+ *   ① `> batch: task-01+task-02`——Wave 段内 blockquote 行，**不替代** `- task-XX` 纯 ID
+ *      引用行（execute 只按纯 ID 行收任务，批标注行对既有解析器全部惰性——零阻断面）；
+ *   ② `- task-01 + task-02（batch）`——列表项多 ID `+` 拼接（agent 即兴写法，语义无歧义宽收）。
+ *
+ * @param {string} planMdText
+ * @returns {Array<{waveNo:number, tasks:string[], groups:string[][], batchIntent:boolean, clean:boolean}>}
+ *   tasks       补零任务 id（纯 ID 行 + 旧 checkbox 行兼容收，同既有双正则口径）
+ *   groups      批标注解析出的成员组（未与 Wave 任务对账，对账归主函数）
+ *   batchIntent 有任何并批意图信号（可解析标注 / 含 batch/并批/同批 字样的存疑行）→ 判定①不再提示
+ *   clean       无存疑 task 列表行、无 <2 成员的标注 → 判定②才评估（宁缺勿假）
+ */
+function parseBatchWavesFromPlanText(planMdText) {
+  const waves = []
+  let cur = null
+  for (const line of String(planMdText || '').replace(/\r\n?/g, '\n').split('\n')) {
+    const wm = line.match(/^#+\s*Wave\s+(\d+)/i)
+    if (wm) {
+      cur = { waveNo: parseInt(wm[1], 10), tasks: [], groups: [], batchIntent: false, clean: true }
+      waves.push(cur)
+      continue
+    }
+    if (/^#+\s/.test(line)) { cur = null; continue } // 非 Wave 标题退出当前段（同既有解析守卫）
+    if (!cur) continue
+    // 批标注形态①：`> batch: task-01+task-02`
+    const bm = line.match(/^>\s*batch\s*[:：]\s*(.+)$/i)
+    if (bm) {
+      cur.batchIntent = true
+      const members = parseBatchMemberList(bm[1])
+      if (members.length >= 2) cur.groups.push(members)
+      else cur.clean = false
+      continue
+    }
+    // 批标注形态②：`- task-01 + task-02（batch）`（多 ID `+` 拼接的列表项）
+    const lb = line.match(/^[-*]\s+(task-\d+(?:\s*[+＋]\s*task-\d+)+)\s*(?:[（(]\s*batch\s*[）)])?\s*$/i)
+    if (lb) {
+      cur.batchIntent = true
+      const members = parseBatchMemberList(lb[1])
+      if (members.length >= 2) cur.groups.push(members)
+      else cur.clean = false
+      continue
+    }
+    // 纯 ID 引用行（新契约）与旧 checkbox 行（同 parseTaskWavesFromPlan 双正则口径）
+    const tm = line.match(/^[-*]\s+(?:\[[ x]\]\s*)?(task-\d+)\s*[:：\s]*$/i)
+      || line.match(/^[-*]\s*\[[ x]\]\s*(task-\d+)\b/i)
+    if (tm) { cur.tasks.push(padTaskRef(tm[1])); continue }
+    // 含 task id 但不匹配任何已知形态的列表行 → 并批信息存疑（判定②跳过；含并批字样则
+    // 同时视为并批意图挡①）。说明文字等非列表行忽略，不参与任务集合与并批判定。
+    if (/^[-*]\s+.*task-\d+/i.test(line)) {
+      cur.clean = false
+      if (/batch|并批|同批/i.test(line)) cur.batchIntent = true
+      continue
+    }
+  }
+  return waves
+}
+
+/**
+ * 汇总单卡并批判定要件（纯函数，复用本文件既有解析器先例——parseTargetFiles / parseAllowedPaths /
+ * parseDependsOn / parseTaskContracts / parseTaskFrontmatter）：
+ *   fileSet          文件面（parseTargetFiles 优先；缺失回退 parseAllowedPaths——存量卡兼容；两者皆无 → null 不可判）
+ *   deps             depends_on（补零）
+ *   expectsProviders expects_from 的 provider 任务集（补零；Wave 内命中 = 契约链）
+ *   batchMembers     卡 frontmatter `batch:` 字段成员（数组成员或 `task-01+task-02` 串皆收；<2 成员不供信息）
+ *
+ * M3（2026-09-21-r5-efficiency-batch2 task-03）起导出：execute.js buildWavePrompt 推荐分组
+ * 与本文件 checkBatchAdvisory 共用此 facts 收集（单一实现无二源——导出是复用需要，非新逻辑）。
+ */
+export function collectCardBatchFacts(content) {
+  const text = String(content || '')
+  let fileSet = null
+  const tf = parseTargetFiles(text)
+  if (!tf.missing && tf.entries.length > 0) {
+    fileSet = new Set(tf.entries.map(e => e.path))
+  } else {
+    const ap = parseAllowedPaths(text)
+    if (ap.length > 0) fileSet = new Set(ap)
+  }
+  const deps = parseDependsOn(text).map(padTaskRef)
+  const { expectsFrom } = parseTaskContracts(text)
+  const expectsProviders = Object.keys(expectsFrom || {}).map(padTaskRef)
+  let batchMembers = null
+  try {
+    const parsed = parseTaskFrontmatter(text)
+    if (parsed.ok && parsed.fm && parsed.fm.batch != null) {
+      const raw = Array.isArray(parsed.fm.batch) ? parsed.fm.batch : [parsed.fm.batch]
+      const uniq = [...new Set(raw.flatMap(v => parseBatchMemberList(String(v))))]
+      if (uniq.length >= 2) batchMembers = uniq
+    }
+  } catch { /* 坏卡不供并批信息（fail-open，advisory 面不抛错） */ }
+  return { fileSet, deps, expectsProviders, batchMembers }
+}
+
+/**
+ * recommendWaveGroups —— M3 PLAN 粒度派发默认化的推荐分组纯函数（FR-03 / D-003@v1，
+ * 2026-09-21-r5-efficiency-batch2 task-03）。按第 1 批三条件（allowed_paths/target_files
+ * 两两正交 / 组内无 provides-expects_from 契约链（含 depends_on，双向）/ 组 ≤3）贪心预计算
+ * 分组；checkBatchAdvisory 判定①文案与 execute.js buildWavePrompt 派发段共用本函数（无二源）。
+ *
+ * 护栏不变式（与 checkBatchAdvisory 两判定同口径：并批后整 Wave 批数 ≥ min(3, 任务数)）：
+ * 并批预算 = n − min(3,n)，每把一个 task 并入已有组消耗 1 预算，预算耗尽后余 task 独立成组；
+ * n≤3 时预算为 0 恒全单例（任何并批必违反 min(3,N)=N——推荐不得自触判定②）。
+ * files=null（卡缺失/字段全无，正交不可判）→ 恒单例（宁缺勿假）。
+ *
+ * 确定性：按输入序贪心（先开组后补组、组满 3 或不相容即让位），同输入恒同输出；
+ * 非数组输入返回 []（纯机械容错，不 throw）。
+ *
+ * @param {Array<{id:string, files:Iterable<string>|null, deps?:string[], expectsProviders?:string[]}>} tasks
+ *   id 接受未补零形态（内部 padTaskRef 归一）；deps/expectsProviders 缺省视为无链。
+ * @returns {string[][]} 全量 partition（含单例组，组内按输入序）——调用方以
+ *   groups.some(g => g.length >= 2) 判定有无推荐（无则零注入/零文案）。
+ */
+export function recommendWaveGroups(tasks) {
+  if (!Array.isArray(tasks)) return []
+  const list = tasks.map(t => ({
+    id: padTaskRef(t?.id ?? ''),
+    files: t?.files == null ? null : new Set([...t.files].map(String)),
+    deps: new Set((t?.deps || []).map(padTaskRef)),
+    expects: new Set((t?.expectsProviders || []).map(padTaskRef)),
+  }))
+  const n = list.length
+  let budget = n - Math.min(3, n) // 并批预算：分组后批数 = n - 已消耗预算 ≥ min(3,n) 恒成立
+  const chainBetween = (a, b) =>
+    a.deps.has(b.id) || b.deps.has(a.id) || a.expects.has(b.id) || b.expects.has(a.id)
+  const filesDisjoint = (a, b) => {
+    for (const p of a.files) if (b.files.has(p)) return false
+    return true
+  }
+  const groups = []
+  for (const t of list) {
+    let placed = false
+    if (t.files != null && budget > 0) {
+      for (const g of groups) {
+        if (g.length >= 3) continue // 帽值：组 ≤3
+        if (g.some(m => m.files == null || !filesDisjoint(m, t) || chainBetween(m, t))) continue
+        g.push(t)
+        budget -= 1
+        placed = true
+        break
+      }
+    }
+    if (!placed) groups.push([t])
+  }
+  return groups.map(g => g.map(t => t.id))
+}
+
+/**
+ * checkBatchAdvisory —— plan 并批默认的 postcheck 机械提醒（B-③ / FR-01，warning 级 advisory）。
+ *
+ * 两判定（同口径不变式：并批后整 Wave 批数 ≥ min(3, 该 Wave 任务数)）：
+ *   ① batch_orthogonal_unbundled：Wave 任务两两文件正交（无共享 target_files——缺失回退
+ *      allowed_paths 判、无 Wave 内 depends_on 链、无 Wave 内 expects_from 契约链）且无任何
+ *      并批信号（plan.md 批标注行 / task 卡 batch 字段）→ 提示默认并批（2–4 任务/批）。
+ *      阈值 N≥4：N≤3 时任何并批都违反护栏 min(3,N)=N（未并批已是唯一合规形态），提示只会
+ *      制造 ①↔② 打架的 nag 环；B-③ 实证收益场景（R4-S-F）为 5 任务级。
+ *   ② wave_inflight_below_floor：有**可解析且无冲突**的并批信息，批数（多成员组数 + 未分组
+ *      单任务数）< min(3, 任务数) → 护栏缺口提示（墙钟回退风险，warning 可显式接受）。
+ *      解析不出 / 组间冲突 / 越界（成员不在本 Wave）→ 跳过（宁缺勿假，绝不猜批数）。
+ *
+ * @param {object} opts
+ * @param {string} opts.tasksMdText tasks.md 注册表文本（任务唯一真相——声明集非空时过滤 Wave
+ *   段里未声明的陈旧引用，防虚增任务数扰动两判定；空/无声明则不过滤）
+ * @param {string} opts.planMdText  plan.md 文本（Wave 段分组 + 批标注行）
+ * @param {object|Map<string,string>} [opts.taskCards] taskId → 卡片全文（Record 或 Map 皆收）
+ * @returns {Array<{level:'warning', code:'batch_orthogonal_unbundled'|'wave_inflight_below_floor', message:string}>}
+ *   恒为数组（0..n 条，单次调用多 Wave 可各出一条）；调用方只准并入 warnings 通道——
+ *   红线：绝不进 errors（门禁阻断语义零变化）。
+ */
+export function checkBatchAdvisory({ tasksMdText, planMdText, taskCards } = {}) {
+  const advisories = []
+  const waves = parseBatchWavesFromPlanText(planMdText)
+  if (waves.length === 0) return advisories
+
+  // 注册表过滤（2026-08-20-task-truth-unify：tasks.md 是任务唯一真相）
+  const declared = new Set()
+  for (const line of String(tasksMdText || '').replace(/\r\n?/g, '\n').split('\n')) {
+    const m = line.match(/^[-*]\s*\[[ xX]\]\s*(task-\d+)\b/i)
+    if (m) declared.add(padTaskRef(m[1]))
+  }
+
+  const cards = new Map()
+  const cardEntries = taskCards instanceof Map
+    ? [...taskCards.entries()]
+    : (taskCards && typeof taskCards === 'object' ? Object.entries(taskCards) : [])
+  for (const [id, content] of cardEntries) cards.set(padTaskRef(id), collectCardBatchFacts(content))
+
+  for (const w of waves) {
+    const waveTasks = [...new Set(w.tasks)].filter(t => declared.size === 0 || declared.has(t))
+    const n = waveTasks.length
+    if (n < 2) continue
+    const waveSet = new Set(waveTasks)
+
+    // ── 并批信息对账：plan 批标注 × 卡 batch 字段 → 组。越界（成员不在本 Wave——跨 Wave /
+    //    幻觉引用）或组间冲突（同任务进两组）→ 本 Wave ②跳过（宁缺勿假）；此时必有并批
+    //    意图信号（组来自批标注行或卡 batch 字段），①也不再提示。──
+    let conflicted = false
+    const rawGroups = []
+    const seenKeys = new Set()
+    const pushGroup = (members) => {
+      const key = [...members].sort().join('+')
+      if (seenKeys.has(key)) return // 同组多卡重复声明 / 双源同组 → 去重
+      seenKeys.add(key)
+      rawGroups.push(members)
+    }
+    for (const members of w.groups) {
+      if (members.some(m => !waveSet.has(m))) { conflicted = true; continue }
+      pushGroup(members)
+    }
+    let cardBatchIntent = false
+    for (const t of waveTasks) {
+      const c = cards.get(t)
+      if (!c || !c.batchMembers) continue
+      cardBatchIntent = true
+      if (c.batchMembers.some(m => !waveSet.has(m))) { conflicted = true; continue }
+      pushGroup(c.batchMembers)
+    }
+    const owner = new Set()
+    let overlap = false
+    for (const g of rawGroups) {
+      for (const t of g) {
+        if (owner.has(t)) { overlap = true; break }
+        owner.add(t)
+      }
+      if (overlap) break
+    }
+    if (conflicted || overlap) continue
+
+    const batchIntent = w.batchIntent || cardBatchIntent
+    const batchCount = rawGroups.length + (n - owner.size)
+    const floor = Math.min(3, n)
+
+    // ── 判定①：文件正交但全未并批 ──
+    if (!batchIntent && n >= 4) {
+      const facts = waveTasks.map(t => cards.get(t) || null)
+      const knowable = facts.every(f => f && f.fileSet)
+      const chainFree = facts.every(f => f
+        && !f.deps.some(d => waveSet.has(d))
+        && !f.expectsProviders.some(p => waveSet.has(p)))
+      let fileDisjoint = true
+      if (knowable && chainFree) {
+        outer:
+        for (let i = 0; i < facts.length; i++) {
+          for (let j = i + 1; j < facts.length; j++) {
+            for (const p of facts[i].fileSet) {
+              if (facts[j].fileSet.has(p)) { fileDisjoint = false; break outer }
+            }
+          }
+        }
+      }
+      if (knowable && chainFree && fileDisjoint) {
+        // M3（batch2 task-03）：判定①附推荐分组清单——同一纯函数 recommendWaveGroups
+        // 无二源（该分支内任务两两正交无链，分组差异只来自帽值与批数护栏预算）。
+        const recGroups = recommendWaveGroups(waveTasks.map((t, i) => ({
+          id: t,
+          files: facts[i].fileSet,
+          deps: facts[i].deps,
+          expectsProviders: facts[i].expectsProviders,
+        })))
+        const recLine = recGroups.some(g => g.length >= 2)
+          ? `；CLI 预计算推荐分组：${recGroups.map(g => `[${g.join(',')}]`).join(' / ')}`
+          : ''
+        advisories.push({
+          level: 'warning',
+          code: 'batch_orthogonal_unbundled',
+          message: `Wave ${w.waveNo} 内 ${n} 个任务文件两两正交（无共享 target_files、无 depends_on / provides-expects_from 契约链）` +
+            `但全部未并批——默认并批可摊平 execute 扇出的重复上下文重建（B-③）：2–4 任务/批，` +
+            `Wave 段内加批标注行（如 "> batch: task-01+task-02"，不替代 - task-XX 纯 ID 引用行），` +
+            `并批后整 Wave 批数保持 ≥ min(3, ${n})${recLine}`,
+        })
+      }
+    }
+
+    // ── 判定②：批数护栏缺口（解析不出并批信息时跳过——宁缺勿假）──
+    if (batchIntent && w.clean && rawGroups.length > 0 && batchCount < floor) {
+      advisories.push({
+        level: 'warning',
+        code: 'wave_inflight_below_floor',
+        message: `Wave ${w.waveNo} 并批后批数 ${batchCount} < min(3, ${n})（该 Wave 任务数）——` +
+          `在飞子代理数低于护栏下限，有墙钟回退风险；建议拆为 ≥ ${floor} 批（如 5 任务 → 2+2+1 三批而非 3+2 两批）。` +
+          `护栏为 warning 提示可显式接受：S-F 型小任务（token 优先于墙钟）可保持现批并在 plan.md 注明接受`,
+      })
+    }
+  }
+  return advisories
+}
+
 /**
  * plan_level 第二把尺子（不接管，仅 warning）：design 文件清单数 / 模块跨度 / task 数
  * 与声明档位比对。fail-open（design/map 读取失败 → null 零输出）。
@@ -1854,6 +2180,31 @@ export async function executePlanPostcheck(context) {
     }
   } catch { /* fail-open */ }
 
+  // ── 1h. 并批 advisory（B-③ / FR-01，warning 不阻断——R5 效率批 task-01）──
+  // 正交未并批提示 + 批数护栏提示，只进 warnings 输出通道（printSectionWarnings 先例），
+  // 绝不进 failures/errors——红线：门禁阻断语义零变化。fail-open：读取/解析异常整体跳过。
+  try {
+    const batchAdvPlanPath = pJoin(changeDir, 'plan.md')
+    if (existsSync(batchAdvPlanPath)) {
+      const batchAdvTasksMdPath = pJoin(changeDir, 'tasks.md')
+      const batchAdvTasksDir = pJoin(changeDir, 'tasks')
+      const batchAdvCards = {}
+      if (existsSync(batchAdvTasksDir)) {
+        for (const f of readdirSync(batchAdvTasksDir).filter(f => /^task-\d+\.md$/.test(f))) {
+          const cardContent = readFileSync(pJoin(batchAdvTasksDir, f), 'utf8')
+          const cardId = parseTaskId(cardContent, f)
+          if (cardId) batchAdvCards[cardId] = cardContent
+        }
+      }
+      const batchAdvisories = checkBatchAdvisory({
+        tasksMdText: existsSync(batchAdvTasksMdPath) ? readFileSync(batchAdvTasksMdPath, 'utf8') : '',
+        planMdText: readFileSync(batchAdvPlanPath, 'utf8'),
+        taskCards: batchAdvCards,
+      })
+      printSectionWarnings('并批', batchAdvisories.map(a => `[${a.code}] ${a.message}`))
+    }
+  } catch { /* fail-open：advisory 面任何异常不阻断 */ }
+
   // ── 聚合输出：一轮 --done 暴露全部失败项（坑6③）──
   if (failures.length > 0) {
     console.error(`\n❌ plan postcheck 失败（${failures.length} 类问题，已全部列出——一次修复后重跑，无需逐个迭代）：`)

package/src/stages/plan.js

@@ -154,6 +154,23 @@ const stepGeneratePlan = {
 > tasks.md 格式：\`- [ ] task-01: 一句话任务名\`（execute 从这里解析任务清单）
 > plan.md Wave 段格式：\`- task-01\`（纯 ID 引用，execute 据此分组）
 
+> **拆分粒度纪律（D-006@v1 / FR-11，R7 实证：18 卡细拆给反仪式变更预付协议税）**：
+> - **默认「实现+单测同卡」**——测试与实现放同一任务卡（TDD 同任务），不单独开「测试卡」「验收 Wave」；纯验收类动作（跑全量回归）并入相关实现卡的 acceptance/verify。
+> - **禁止仪式卡**：「纯接线」「纯 module-map 录入」「纯全量回归绿」不独立成卡——此类收尾动作写进相关实现卡的 implementation 与 acceptance（几行接线并入实现，module-map 录入并入该片最后一张实现卡）。
+> - **「同 Wave 文件不相交」语义澄清**：该约束防并行子代理同文件互写（调度约束），**不要求**把测试/接线/录入拆成独立任务——同一张卡携带多个文件（实现+测试+module-map）完全合法，约束只作用于 Wave 内**多任务之间**的 allowed_paths 交集。
+> - 拆分对齐「可独立验收的能力边界」而非「工序步骤」——一个能力（实现+接线+单测+登记）通常=一张卡；协议成本与任务卡数线性挂钩，卡片数是税。
+
+> **并批默认（B-③，同 Wave 文件正交任务默认并批——摊平 execute 扇出的重复上下文重建，R4-S-F 实证 5 任务 2 批收益）**：
+> - 文件正交（无共享 target_files、无 provides/expects_from 契约链、无 depends_on 依赖）的同 Wave 任务默认并批 2–4 任务/批；批标注写在 Wave 段内独立行（\`> batch: task-01+task-02\`，一段多行即多批），**不替代** \`- task-XX\` 纯 ID 引用行（execute 只按纯 ID 行收任务，漏写 ID 行 = 任务不进 execute）；任务数 ≤3 的 Wave 不并批（任何并批都违反下条批数护栏）
+> - 并批后整 Wave 批数 ≥ min(3, 该 Wave 任务数)（N≥3 即至少 3 批——批大小上界由此不变式约束：5 任务 → 2+2+1 三批而非 3+2 两批），保 Wave 在飞子代理数 ≥3、防墙钟回退
+> - 并批不跨风险级（P0 不与 P2 混批，批内风险级不一致时按最高级拆批）；plan-postcheck 的并批提示是 warning 级护栏——S-F 型小任务（token 优先于墙钟）可显式接受（在 plan.md 相应 Wave 段注明「接受并批护栏提示」即放行，不阻断）
+
+> **执行模式声明（execution_mode，M4——2026-09-23 R8 对撞后缺省翻转：main 直写为缺省）**：
+> - plan.md frontmatter 加 \`execution_mode: main | dispatch\` 键，**缺省不写 = main**（主代理直写）；翻转依据=对撞双实证派发税（R7：直写进码 7′ vs 派发 70′；R8：同规模任务 execute 80′（6 子代理+编排）vs 单上下文进码 14′，3.6×——子代理冷启动上下文重建 + 伪并行 + 小任务全额派发开销）
+> - 仅当满足判据才显式声明 \`execution_mode: dispatch\`：**任务真可并行**（Wave 内任务文件正交且墙钟可压缩）× **单任务规模大**（预估 >30min）× **上下文需分片**（单会话将撞压缩线）；不满足或拿不准一律缺省 main（误用 main 只损失并行收益，不损失任何防线与审查；误用 dispatch 白付 2-3× 墙钟与 token）
+> - main 下 execute Wave 步渲染直写指引（逐任务：读卡→worktree 内实现→每任务 commit→锚点→review write→下一任务），派发段/子代理工作目录段/并发帽段/推荐分组段全抑制；worktree 隔离/写入守卫/review.json/verify 门禁与 dispatch 完全一致（只换执行宿主，不换防线）
+> - 直写只免「实现」派发（2026-09-23 R9 教训）：Stage Review（tier=independent）仍派独立子代理——降级自审损失审查实效（R8 基线实证审查抓过真缺口）；测试跑批输出落文件只取摘要——长输出全文进上下文是单会话 token 累积大头（R9 verify 段 13.8M 输入的大头来源）
+
 ---
 
 #### plan_level = none
@@ -187,6 +204,7 @@ plan_level: none
 \`\`\`markdown
 ---
 plan_level: light
+execution_mode: main  # dispatch=子代理派发（判据见「执行模式声明」；缺省 main 直写——R7/R8 对撞实证）
 ---
 
 # 轻量计划（Light Plan）：<需求简述>
@@ -226,6 +244,7 @@ light 计划的约束：
 \`\`\`markdown
 ---
 plan_level: full
+execution_mode: main  # dispatch=子代理派发（判据见「执行模式声明」；缺省 main 直写——R7/R8 对撞实证）
 ---
 
 # 实现计划（Plan）
@@ -350,7 +369,6 @@ plan.md 审查通过后、进入 execute 前，若 plan_level=full（跨模块/
 tier: {REVIEW_TIER}（{REVIEW_TIER_REASON}）
 - tier=self（ceremony 档 S0/S1）：当前 agent 直接执行下方审查清单——S0=CLI 清单核验；S1=CLI 清单核验+定向探针抽查（对最高风险条目定向读源码验证）。轻仪是风险定价的正常形态而非偷懒豁免，清单机械项一条不省
 - tier=independent（ceremony 档 S2/S3）：必须用 Agent tool 启动独立的计划审查子代理（独立上下文，不共享你生成 plan 时的分析与倾向），由子代理执行下方审查清单并输出 review.json——S2=单轮；S3=两轮独立评审（视角互补，第二轮聚焦首轮未决项）
-  宿主环境无 Agent tool 可用（调用报 Unknown agent / Available agents: none）→ 不卡死（降级兜底，仅评审通道全不可用时）：主代理切换为审查者角色自审替代，reviewerNotes 首行记录「降级：环境无子代理可用」，逐条结论附源码锚点（file:line 或 grep/read 证据）补偿独立性。
 - 仪式按 risk 计价，plan_level 仅编排：agent 自报 plan_level=full 而 CLI 判档 S0/S1 时，CLI 强制轻仪执行并在注入文案留审计痕（强制轻仪说明行随 tier 注入）——不因「计划写得完整」进入 independent×2，勿自行升仪对抗定价
 
 ### 审查清单（读取 plan.md 的 plan_level，逐条核对）
@@ -363,6 +381,7 @@ ${REVIEW_CHECKLISTS.plan.map((item) => '- [ ] ' + item).join('\n')}
 prompt 要点：
 1. **材料包是评审基准面**：checklist 逐条只对包作答；包外文件可定向查证但须列明（禁全量扫读）；包不足以作答→cannot_verify＋requiredEvidence 列缺件。plan.md 本体可读（审查对象），design.md 只读包内 digest＋点名锚（不是全文）。
 2. 执行上方审查清单，每条给 pass/gap/fail + 证据
+> 🚪 **评审豁免（2026-09-26-review-unsupervised-exit）**：若本会话环境**无嵌套派发能力**（无 Agent/Task 类子代理工具）——不产 review.json、**不做自审表演**；改为在变更目录写一行声明文件 review-unsupervised.md（内容含 unsupervised 字样+时间+一句环境说明），Stage Review 门见声明即放行并留痕（声明随归档；Task Review 层已退役 2026-09-26-task-review-retire）。有派发能力时本豁免不适用（真独立评审仍优待）。
 3. 输出 review.json(CLI Stage Review Gate 将硬校验,契约如下 —— schema + 完整示例 + docHash 算法,照抄改值):
 {REVIEW_JSON_CONTRACT}
 4. verdict=fail 时在 reviewerNotes 写明阻断项
@@ -449,9 +468,12 @@ related_tests:                           # 可选。当本 task 改动会导致
 
 ⚠️ 生成卡片前先确认 plan.md 已满足（否则下一步 postcheck 会硬拦，导致返工重编号/重分 Wave）：
 - **共享文件须分 Wave**：若多个 task 的 allowed_path 含同一文件，plan.md 必须把它们分到不同「## Wave N」（同 Wave 共享文件会被 execute 强制并行，子代理互相覆盖；postcheck 拦同 Wave 共享）
+  （注意：该约束只限制 Wave 内**多任务之间**的文件交集——同一张卡携带实现+测试+module-map 多文件合法，勿为规避此约束把测试/接线拆成独立卡，见步骤 2 拆分粒度纪律）
 - **task id 从 1 连续**：task-01、task-02、task-03… 不能跳号或重号（postcheck 校验 id 连续性，gap 会拦）
 这两条是跨 task 全局约束，子代理只写单卡看不到全局——你（主 agent）分派子代理前必须先在 plan.md 里确认 Wave 划分与编号正确。
 
+卡片粒度对齐 plan.md/tasks.md 的任务数——plan 未拆出的收尾动作不为仪式另立卡。
+
 ⚠️ **TaskCard 必备字段（缺一 postcheck 直接阻断）：** id、title（英文）、**title_zh（中文标题，必填）**、allowed_paths、goal、implementation、acceptance、verify、constraints。骨架已由 taskcard CLI 预生成（含 title_zh 占位），子代理只需 Edit 填值，不要删除任何必备字段。
 
 可选字段 **target_files**（本 task 计划要改动的文件清单；骨架已预置 \`target_files: []\` 占位行，按任务计划 Edit 填值，无明确文件级意图保留 []）：✅ 精确仓根相对路径 \`src/foo.js\`、计划新建文件 \`NEW:src/bar.js\`；❌ \`src/**\`（glob）、\`src/dir/\`（目录前缀）、绝对路径。语义区分：target_files=计划要动的具体文件，allowed_paths=权限范围。

package/src/stages/quick.js

@@ -1,7 +1,7 @@
 export const definition = {
   name: 'quick',
-  title: '快速任务',
-  description: '跳过完整流程，直接做',
+  title: '快速任务（已退役，仅存量在途会话收尾）',
+  description: 'quick 通道已退役（v3.31.0 起拒绝新会话）；新工作走轻量变更 flow start',
   auxiliary: true,
   steps: [
     {
@@ -61,6 +61,7 @@ step 3 --done 审计会把 src 核心文件（CLI / 状态机 / 注入框架等
 2. 写代码完成任务
 3. 如涉及逻辑变更，建议写单元测试验证（不强制，纯配置/文档/小改动可跳过）；写测试时按下方「测试用例设计」检查
 4. **不要做无谓的全量编译/构建。** 但——跑针对性的单元测试始终允许且鼓励（见 step3）；若本任务就是修测试/构建/基础设施本身，跑测试/构建即验收，应当跑，不算"编译"
+5. **长输出跑批纪律（token 减负）**：全量/多文件测试的输出重定向落文件（如 \`> .runtime/test-out.log 2>&1\`），上下文只回看尾部摘要与失败段（\`tail -50\` / \`grep -E "FAIL|✗|Error"\`）——长输出全文进上下文是 token 累积大头（R9 实证单会话 verify 段 13.8M 输入的大头来源）
 
 {{include: testcase-design}}
 
@@ -86,6 +87,13 @@ step 3 --done 审计会把 src 核心文件（CLI / 状态机 / 注入框架等
 ### 📌 收尾确认
 - 本步骤是最后一步，完成后 quick 会话即结束（--change 传递见首步 sessionId 说明）
 
+### 📚 收口输出的转达义务（知识可见性契约，2026-09-23）
+\`--done\` 收口输出里若出现以下任一块，**必须在你的最终回复中原文转达用户**（CLI 输出用户不可见，你的转述是用户看到它们的唯一通道）：
+- 「📚/⚠️ 知识收件箱」横幅——uncategorized 待审知识清单（标题 + 条数原样带出）；
+- 「📚 待归类提议」——本条 quick 的归类建议（归类与否由用户裁）；
+- 「📚 quick 资产尾」——蒸馏出的 FR/决策资产及去处。
+未出现则不提及（不得编造）。
+
 ### ⚠️ 结果摘要模板（必填，CLI 会校验结构）
 
 🔧 **推荐四参数形式**（CLI 自动合成结构化模板，杜绝嵌套冒号/缺字段/截断规则踩坑）：

package/src/stages/verify.js

@@ -59,6 +59,8 @@ export const definition = {
       name: '加载规范并锚定',
       prompt: `加载规范文件并确认。
 
+> 💡 **长会话税提示（2026-09-26-verify-gate-restrictfiles，R18 实证）**：若本会话已跨 brainstorm/plan/execute 多阶段（上下文已重），建议**新开会话跑 verify**（sillyspec run verify --change <名> 续跑，上下文重置）——verify 段轮均成本是 brainstorm 段的 3-4 倍，主因是每轮重读全历史；新会话只带工件进场，同动作成本立降。
+
 ### 操作
 1. 读取 proposal.md、design.md、tasks.md、requirements.md、plan.md
 2. 如果存在 decisions.md，必须读取并提取所有当前版本 D-xxx@vN 决策 ID
@@ -73,7 +75,7 @@ export const definition = {
 6. 标注每个文件的存在/不存在状态
 
 ### Execute Evidence 传递检查
-7. 检查 verify-required-evidence.json 是否存在（由 execute 阶段 Task Review Gate 写入）
+7. 检查 verify-required-evidence.json 是否存在（历史兼容读：该文件由退役前的 execute Task Review Gate 写入，2026-09-26-task-review-retire 起停写——在场则消费，缺席=无 cannot_verify 任务）
    - 路径：变更目录下的 verify-required-evidence.json
    - 文件 schema：\`{ items: [{ task, verdict, evidence: string[] }] }\`——顶层是 \`items\`，每项的 \`evidence\` 是字符串数组（不是 \`requiredEvidence\` 键）
    - 如果存在 → 逐项读取 \`items\`，对每个 cannot_verify 任务逐条核对其 \`evidence\` 数组是否已满足
@@ -100,7 +102,7 @@ export const definition = {
     },
     {
       name: '逐项检查任务',
-      prompt: `对照 tasks.md（任务注册表唯一真相）检查每个任务完成状态。勾选唯一写入者是 CLI（review write 落盘即按 review.json verdict 勾选，execute --done 时 autoCheckPlanFromReviews 兜底；P2-f 起 agent 不再手勾），本阶段只读对照、不改勾。
+      prompt: `对照 tasks.md（任务注册表唯一真相）检查每个任务完成状态。勾选由 agent 在任务完成（实现+测试绿+wt-commit）时手动写入（2026-09-26 Task Review 退役起，同 thin 工作单元语义），本阶段只读对照、不改勾。
 
 ### 勾选状态（CLI 注入，勿手数）
 {TASKS_CHECKBOX}