dsh-agent-board 1.7.0 → 1.7.2

package/lib/dispatch.mjs

@@ -4,14 +4,19 @@
 // Team 模式 systemPrompt 引导段 / 预研文件上下文注入通道（packByChild + pendingPacks 首轮竞速认领）。
 import * as core from './core.mjs'
 import { readRunUsage } from './usage.mjs'
-import { TEAM_SPLIT_RULE, pushRejectLesson } from './policy.mjs'
-const { ah, cfg, claimApply, resolveApply, verifyApply, parseSections, outputText, pickDispatch, isOrphan, buildWorkerPrompt, buildVerifierPrompt, buildContextPackSection, parseAnchorPath, sliceLines, buildFileOutline, parentKickOnDispatch, LESSON_RECALL_HINT } = core
+import { splitRuleOf, pushRejectLesson } from './policy.mjs'
+const { ah, cfg, claimApply, resolveApply, verifyApply, parseSections, outputText, pickDispatch, isOrphan, buildWorkerPrompt, buildVerifierPrompt, buildContextPackSection, parseAnchorPath, sliceLines, buildFileOutline, parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, applyHookSettle, hookOn, hookSetState, gsb, pushRejection } = core
 
 export function createDispatch(ctx, state, deps) {
     const fs = ctx.fs
     var rt = deps.rt, wt = deps.wt, mutateLocked = deps.mutateLocked, kickCycle = deps.kickCycle
     var rootForSession = deps.rootForSession, sessionCwd = deps.sessionCwd, withTimeout = deps.withTimeout, runsFor = deps.runsFor, feedbackOn = deps.feedbackOn
+    // 史诗拆分总开关读取器（epicSplit，缺省 true）：与 feedbackOn 同源（session 缓存，rt() 同步）——
+    // Team 提示词组装是同步函数，只能读缓存，不能读盘。
+    var epicSplitOn = deps.epicSplitOn
     var pushSysNote = deps.pushSysNote, maybeNotify = deps.maybeNotify, notifyTaskDone = deps.notifyTaskDone
+    // 派发即回执：spawn 成功后入 45s 聚合队列的「🚀 已派发」区（老 host 未注入 → 静默跳过）
+    var notifyDispatched = deps.notifyDispatched
     // 共享状态别名（本体由 index.mjs apply 统一构建并逐模块注入）
     var dispatchedEver = state.dispatchedEver
     var badModels = state.badModels
@@ -140,6 +145,8 @@ export function createDispatch(ctx, state, deps) {
 
     async function spawnOneShot(sid, t, role) {
       var subagents = ctx.subagents; if (!subagents) return null
+      // 兜底保留（真异常时有用）：poolCycle 入口已有 root 存活早闸门，正常派发路径不会到达这里；
+      // 只有闸门外的直接调用（如 dispatch-task RPC 指定了无 root 的 sid）才会触发此报错。
       var parent = rootForSession(sid); if (!parent) { console.error('[task-board] no root agent for session ' + sid + ', skip spawn'); return null }
       var providerName = pickProvider(); if (!providerName) { console.error('[task-board] no subagent provider'); return null }
       var modelOverride = ''
@@ -156,7 +163,16 @@ export function createDispatch(ctx, state, deps) {
       }
       // user prompt 只留一行指引，内容走上下文注入区块
       var packNote = pack ? '本任务附带主窗口预研文件，已通过「上下文注入」区提供（含文件完整内容），直接基于其内容工作，不要重复读取这些文件。' : ''
-      var req = { label: role + ':' + t.id, prompt: [{ type: 'text', text: role === 'worker' ? buildWorkerPrompt(t, packNote, cfg(dsnap).feedbackEnabled) : buildVerifierPrompt(t, packNote) }], parent: parent, signal: makeSignal() }
+      // prompt 三态：worker / verifier / hook（hooks=agent run：pre 与 post 共用 buildHookPrompt，
+      // 由 phase 决定契约文案——二者都是挂在 epic 上的一次性真实 agent 运行）。
+      // hook 分支现读一次看板只为拿子任务清单；读失败退化为空清单（prompt 仍成立，绝不因此不 spawn）。
+      var promptText
+      if (role === 'hook-pre' || role === 'hook-post') {
+        var kids = []
+        try { var hsnap = await rt(sid); kids = gsb(t.id, (hsnap && hsnap.tasks) || []) } catch (_) {}
+        promptText = buildHookPrompt(t, role === 'hook-pre' ? 'pre' : 'post', kids)
+      } else promptText = role === 'worker' ? buildWorkerPrompt(t, packNote, cfg(dsnap).feedbackEnabled) : buildVerifierPrompt(t, packNote)
+      var req = { label: role + ':' + t.id, prompt: [{ type: 'text', text: promptText }], parent: parent, signal: makeSignal() }
       if (modelOverride) {
         // list-models 返回的 id 是 "provider/model" 复合格式（如 "cmss/zhanlu/glm-5.2"），
         // 但 AgentOptions 的 provider 和 model 是分开的——整串塞进 model 会报 UNKNOWN_MODEL
@@ -214,6 +230,7 @@ export function createDispatch(ctx, state, deps) {
       var errText = err ? String(err) : (res && (res.diagnostic || res.stopReason) || '')
       try {
         if (rec.role === 'worker') await settleWorker(sid, rec, output, failed, errText)
+        else if (rec.role === 'hook-pre' || rec.role === 'hook-post') await settleHook(sid, rec, output, failed, errText)
         else await settleVerifier(sid, rec, output, failed, errText)
       } catch (e) { console.error('[task-board] settle ' + rec.role + ' failed (task ' + rec.taskId + '):', String(e)) }
       // 历史会话留档：记录该次 run 的结局（完成/失败/硬超时），详情页可据此标注阶段状态
@@ -224,12 +241,35 @@ export function createDispatch(ctx, state, deps) {
       await accumulateRunUsage(sid, rec)
     }
 
-    // 把一次 run 的 token 消耗累加到任务（t.usage）：总量/输入/输出/缓存读写 + 按模型小计 + runs 计数。
+    // 本地日期 key（YYYY-MM-DD）：byDay 日账的唯一口径。
+    // 必须用本地 getters 拼——toISOString() 是 UTC，晚上 8 点后的消耗会被记到次日，
+    // 「今日消耗」在东八区会从每天 08:00 起算，直接错位。
+    function localDayKey(d) {
+      var x = d || new Date()
+      function p2(n) { return (n < 10 ? '0' : '') + n }
+      return x.getFullYear() + '-' + p2(x.getMonth() + 1) + '-' + p2(x.getDate())
+    }
+
+    // 有效消耗 = 输入 + 输出 + 缓存写（不含缓存读）。
+    // 为什么单列：本板实测累计 total 里缓存读占 94%（9.7M/10.3M），大数字被缓存读撑高约 17 倍，
+    // 与「真实花掉多少」严重脱节——有效消耗才是可比的成本口径，缓存读单列展示。
+    function effectiveOf(u) {
+      if (!u) return 0
+      return (u.input || 0) + (u.output || 0) + (u.cacheWrite || 0)
+    }
+
+    // 把一次 run 的 token 消耗累加到任务（t.usage）：总量/输入/输出/缓存读写 + 按模型小计 + runs 计数 + 日账。
     // 模型小计的 key：优先本次派发显式覆盖的模型（rec.model），否则用日志里记录的会话模型。
+    // 日账（byDay）：本次 run 整笔记到「结算时刻的本地日」——一次 run 不跨日拆分
+    // （跨零点的长 run 全算在结算日），换取实现极简与仪表盘「今日 / 近 7 天」可算。
+    // 双指标形态：byDay[day] = { t: total, e: effective }（e 是有效消耗，不含缓存读）。
+    // 老数据（number 形态，本轮之前落的日账）只在聚合端兼容：读侧按 { t: n, e: null } 处理，
+    // e 不可知就置 null（宁可展示上标 ~ 近似，也不伪造一个「有效值」）。
     async function accumulateRunUsage(sid, rec) {
       var u = null
       try { u = readRunUsage(String(rec.run.id)) } catch (_) { u = null }
       if (!u || !u.total) return
+      var eff = effectiveOf(u)
       try {
         await mutateLocked(sid, function (d) {
           var t = d.tasks.find(function (x) { return x.id === rec.taskId })
@@ -245,6 +285,28 @@ export function createDispatch(ctx, state, deps) {
           if (!t.usage.models) t.usage.models = {}
           var mk = rec.model || u.model || '(未知模型)'
           t.usage.models[mk] = (t.usage.models[mk] || 0) + u.total
+          // 日账：老任务没有 byDay 就地补（不改写老字段形态）；键是本地日 YYYY-MM-DD。
+          if (!t.usage.byDay) t.usage.byDay = {}
+          // 脏值兜底：历史/半写数据里 byDay[dk] 可能是 number（老形态）或字符串，一律收敛成对象记账
+          var dk = localDayKey()
+          var cell = t.usage.byDay[dk]
+          if (!cell || typeof cell !== 'object') cell = { t: Number(cell) || 0, e: 0 }
+          cell.t = (Number(cell.t) || 0) + u.total
+          cell.e = (Number(cell.e) || 0) + eff
+          t.usage.byDay[dk] = cell
+          // ===== run 级留账：把本次 run 的用量原样写回它在 t.runs 里的条目 =====
+          // 作用：总量口径万一再要调整（换分母/排除某类 run/按天或按模型重建），不必回头猜——
+          // 每个 run 自带五分量，任意维度都能精确重算（byDay 只是它的一个投影）。
+          // 找不到条目就跳过：t.runs 条目由 recordRunHistory 先行写入、closeRunHistory 更新结局，
+          // 正常结算路径必存在；只有手写/裁剪过的历史任务会缺，缺了也不该阻断聚合累加。
+          if (Array.isArray(t.runs)) {
+            for (var ri = t.runs.length - 1; ri >= 0; ri--) {
+              if (String(t.runs[ri] && t.runs[ri].id) === String(rec.run.id)) {
+                t.runs[ri].usage = { input: u.input || 0, output: u.output || 0, cacheRead: u.cacheRead || 0, cacheWrite: u.cacheWrite || 0, total: u.total || 0 }
+                break
+              }
+            }
+          }
           t.usage.updatedAt = new Date().toISOString()
           return { ok: true }
         })
@@ -252,7 +314,11 @@ export function createDispatch(ctx, state, deps) {
     }
 
     async function settleWorker(sid, rec, output, failed, errText) {
+      // 完成回执开关（设置区「通知」notifyDone）：在同一次持锁回调里读看板文档（零额外读盘），
+      // 缺字段/回调未跑到时保持 true——宁可多报一条，也不因读配置失败漏报完成。
+      var doneOn = true
       var result = await mutateLocked(sid, function (d) {
+        doneOn = cfg(d).notifyDone !== false
         var t = d.tasks.find(function (x) { return x.id === rec.taskId })
         if (!t) return null
         // 工具通道已处理（board_report 已推进到 verifying/resolved 或挂了 escalation）→ 只收尾
@@ -283,13 +349,17 @@ export function createDispatch(ctx, state, deps) {
       // already=true：工具通道（board_report）已推进状态并已发回执/歧义通知，settle 只负责 dispose，不再重复通知
       if (result.already) return
       if (result.escalated) maybeNotify(sid, result.task)
-      if (result.task && result.task.status === 'resolved') notifyTaskDone(sid, result.task, 'resolved')
-      if (result.blocked) notifyTaskDone(sid, result.task, 'blocked')
+      // 歧义通知（maybeNotify → notifyMainWindow）是裁决通道，不受回执开关影响：只闸下面两条完成/阻塞回执
+      if (doneOn && result.task && result.task.status === 'resolved') notifyTaskDone(sid, result.task, 'resolved')
+      if (doneOn && result.blocked) notifyTaskDone(sid, result.task, 'blocked')
       kickCycle(sid) // 结算后立刻补派
     }
 
     async function settleVerifier(sid, rec, output, failed, errText) {
+      // 完成回执开关同上：持锁回调内取 notifyDone
+      var doneOn = true
       var result = await mutateLocked(sid, function (d) {
+        doneOn = cfg(d).notifyDone !== false
         var t = d.tasks.find(function (x) { return x.id === rec.taskId })
         if (!t) return null
         if (t.status !== 'verifying' || t.escalation) return { task: t, already: true } // 工具通道已处理
@@ -312,6 +382,9 @@ export function createDispatch(ctx, state, deps) {
         verifyApply(d, t, String(rec.run.id), approved ? 'approved' : 'rejected', trimmed.slice(0, 200))
         if (!approved) {
           t.rejectCount = (t.rejectCount || 0) + 1
+          // 驳回包全量带回（task-muvg15p5）：summary + checks（逐条核对证据）落 messages，
+          // 随 buildMessages 注入重派 Worker prompt——history 里只有 200 字截断，Worker 据此无法返工
+          pushRejection(t, vsecs.verifySummary, vsecs.checks, t.verification.at, String(rec.run.id))
           // 学习飞轮 v1：Verifier 驳回 → 候选教训（场景/错误做法/来源），随 t.verification.at 判重
           pushRejectLesson(d, t, vsecs.verifySummary || trimmed, t.verification.at)
           if (t.rejectCount >= 3) { t.status = 'blocked'; ah(t, 'in-progress', 'blocked', 'system', 'verifier 驳回 x' + t.rejectCount + '，待人工裁决') }
@@ -323,17 +396,55 @@ export function createDispatch(ctx, state, deps) {
       // already=true：工具通道（board_verdict）已推进状态并已发回执，settle 只负责 dispose，不再重复通知
       if (result.already) return
       if (result.escalated) maybeNotify(sid, result.task)
-      if (result.task && result.task.status === 'resolved') notifyTaskDone(sid, result.task, 'resolved')
-      if (result.task && result.task.status === 'blocked') notifyTaskDone(sid, result.task, 'blocked')
+      if (doneOn && result.task && result.task.status === 'resolved') notifyTaskDone(sid, result.task, 'resolved')
+      if (doneOn && result.task && result.task.status === 'blocked') notifyTaskDone(sid, result.task, 'blocked')
       kickCycle(sid)
     }
 
+    // ===== hook run 结算（hooks=agent run 接线②）=====
+    // 照 worker/verifier 的结算模式：mutateLocked 持锁改状态机（状态机纯函数在 core.applyHookSettle，
+    // 单测直接打它），锁外发通知 + kickCycle 补派。
+    //   hook-pre  完成 → hooks.pre.state='done'（下轮起子任务正常放行，串行闸门打开）
+    //   hook-post 完成 → hooks.post.state='done' + epic 转 verifying（收口完成，交人验收）
+    //   失败（异常/stopReason 异常）或文本 [ESCALATE] → 该点位 state='failed' + epic 转 blocked +
+    //   escalation 挂卡（歧义上报「前置准备失败，重试/跳过/放弃」），不自动重试。
+    // 幂等：epic 已有未裁决 escalation 时只收口不覆盖（主窗口裁决前不刷屏）。
+    async function settleHook(sid, rec, output, failed, errText) {
+      var phase = rec.role === 'hook-pre' ? 'pre' : 'post'
+      var esc = /\[ESCALATE\]/i.test(output || '')
+      var runId = String(rec.run.id)
+      // 完成回执开关（notifyDone）：hook 收口把 epic 推进到 blocked/verifying 同样算完成回执，一视同仁
+      var doneOn = true
+      var result = await mutateLocked(sid, function (d) {
+        doneOn = cfg(d).notifyDone !== false
+        var p = d.tasks.find(function (x) { return x.id === rec.taskId })
+        if (!p) return null
+        return applyHookSettle(d, rec.taskId, phase, !(failed || esc), output, runId, errText)
+      })
+      if (!result) return
+      if (result.already) return
+      if (result.blocked) { maybeNotify(sid, result.task); if (doneOn) notifyTaskDone(sid, result.task, 'blocked') }
+      if (doneOn && result.closed) notifyTaskDone(sid, result.task, 'resolved')
+      kickCycle(sid) // 结算后立刻补派（pre 完成 → 子任务开跑；post 完成 → epic 进验收）
+    }
+
     // ===== 派发周期（15s 心跳 + 写入后 kickCycle 触发）=====
     async function poolCycle(sid) {
+      // root 存活早闸门（根治 no-root 刷屏，task-muuf0o7a）：无活 root 的会话板根本不进派发循环——
+      // 不读盘、不 claim、不回收、不写盘、零日志。幻影板（裸短 id 建的 tasks-<短id>.json，真实会话
+      // id 带 session- 前缀与后缀，rootForSession 永远匹配不到）或已关闭会话的残留板若进循环，
+      // 每 15s 心跳都会 pickDispatch→占位 claim→spawnOneShot 才发现无 root→console.error→占位
+      // 超时回收→下轮再来，永久 spam。死会话的 pending 卡等会话重开后自然恢复派发
+      // （这正是孤儿板接管语义），此处无需任何动作。
+      // 返回值说明：调用方（store.kickCycle / 15s 心跳）均忽略返回值，返回 undefined 签名兼容。
+      if (!rootForSession(sid)) return undefined
       var info = []
       var runs = runsFor(sid)
       var snap = await rt(sid)
       var activeW = 0, activeV = 0
+      // 角色口径：worker 计入 activeW（占 Worker 并发位）；verifier 与 hook run（hook-pre/hook-post）
+      // 统一计入 activeV——hook run 不是 Worker，不该挤占 maxWorkers 并发位，但它确实是一条在跑的 run，
+      // 必须参与「空闲快进」判定，否则 hook 跑着时重复派发的闸门会失守。
       Object.keys(runs).forEach(function (k) { if (runs[k].role === 'worker') activeW++; else activeV++ })
       // 空闲快进：无活跃任务且无活跃 run → 不写盘直接返回（心跳每 15s 跑一次，不能每次都写文件）
       var hasActive = snap.tasks.some(function (t) { return t.status === 'pending' || t.status === 'verifying' || t.status === 'in-progress' })
@@ -366,16 +477,43 @@ export function createDispatch(ctx, state, deps) {
         var picked = pickDispatch(d, capW, Math.max(0, c.maxVerifiers - activeV), runs)
         picked.pendings.forEach(function (t) { claimApply(d, t, 'spawn-pending', 'dispatch'); if (parentKickOnDispatch(d, t)) info.push('epic-kick ' + t.parentId); toSpawn.push({ role: 'worker', t: t }); info.push('dispatch ' + t.id) })
         picked.verifs.forEach(function (t) { t.verifierRun = 'spawn-pending'; t.verifierRunAt = new Date().toISOString(); toSpawn.push({ role: 'verifier', t: t }); info.push('verify ' + t.id) })
+        // ===== hooks=agent run：pre 闸门占用 + post 收口补 spawn（接线①③）=====
+        // pre：候选被 pickDispatch 的 preHookGate 拦下时，本轮不派子任务——这里改 spawn hook-pre run。
+        // 触发条件用状态机本身（state='idle' 即「已声明且从未跑过」，重启后从卡上原样恢复，不靠内存标记）；
+        // state='running' 说明已有 hook run 在跑（幂等，同一 epic 同时最多一条），'done'/'failed' 都轮不到这里。
+        // post：子任务全部了结时 core.maybeAutoCloseParent 不直接转 verifying，只置 hooks.post.pending
+        // 标记；本轮在这里看到标记就 spawn hook-post run（无活跃子任务时也能被下一次心跳收走）。
+        d.tasks.forEach(function (t) {
+          if (hookOn(t, 'pre') && t.hooks.pre.state === 'idle' && !runs[t.id]) {
+            hookSetState(t, 'pre', 'running', 'system', '派发前置 hook run')
+            toSpawn.push({ role: 'hook-pre', t: t })
+            info.push('hook-pre ' + t.id)
+          }
+          if (t.status === 'in-progress' && hookOn(t, 'post') && t.hooks.post.pending && !t.verifierRun && !runs[t.id]) {
+            t.hooks.post.pending = false
+            t.hooks.post.state = 'running'
+            t.verifierRun = 'spawn-pending' // 复用 Verifier 幂等占用位：只在 spawn 成功后换成真实 run id
+            t.verifierRunAt = new Date().toISOString()
+            toSpawn.push({ role: 'hook-post', t: t })
+            info.push('hook-post ' + t.id)
+          }
+        })
         // touches 文件级排他展示态：被拦候选写 t.waitingForTouches = [持有者任务id...]，
         // 未被拦/已派发/已落定的任务清除该字段（每心跳刷新的 UI 展示态，不参与任何派发逻辑，
         // 但必须显式清——只在写入时报字段会留下"锁已释放仍显示 🔒 等待"的永久误导）。
+        // 持锁口径的唯一出处是 core.holdsFiles（in-progress + claimedBy / verifying / resolved 都持锁，
+        // 归档才真释放——反馈 n-muupqg81u575）。这里不做任何放锁动作：verifying/resolved 卡不放锁，
+        // 故 conflicts 里出现 resolved 卡 id 是预期行为（滞留原因对用户可见，就是主窗口还没归档）；
+        // 归档动作（archive-task / task_archive）把卡改成 archived 后，下轮 tickInProgress 15s 轮
+        // 自然把等待卡放行，无需在此额外触发补派。
         var waitMap = {}
         picked.blockedTouches.forEach(function (b) { waitMap[b.id] = b.conflicts })
         d.tasks.forEach(function (t) {
           if (waitMap[t.id]) { t.waitingForTouches = waitMap[t.id]; info.push('wait-touches ' + t.id + '<-' + waitMap[t.id].join(',')) }
           else if (t.waitingForTouches) delete t.waitingForTouches
         })
-        // UI 池状态：来自活跃 run（一次性模型：没有成员名册，只有在跑的任务）
+        // UI 池状态：来自活跃 run（一次性模型：没有成员名册，只有在跑的任务）。
+        // hook run 也归「verifiers」区展示（同一格里都是非 Worker 的一次性 run）。
         d.poolStatus = { workers: [], verifiers: [] }
         Object.keys(runs).forEach(function (k) { var rc = runs[k]; d.poolStatus[rc.role === 'worker' ? 'workers' : 'verifiers'].push({ id: k, num: '-', busy: true, taskId: rc.taskId, runId: String(rc.run.id), done: 0, queueLen: 0, suspect: false, model: rc.model || '' }) })
         if (info.length > 0) { d.dispatchInfo = info.join('; '); d.dispatchInfoAt = new Date().toISOString() }
@@ -388,8 +526,12 @@ export function createDispatch(ctx, state, deps) {
         var sp = toSpawn[k]
         var rec = await spawnOneShot(sid, sp.t, sp.role)
         if (rec) {
-          // claim 占位换成真实 run id；verifier run 单独记（claimedBy 保留 worker 的，供详情页跳转会话）
-          await mutateLocked(sid, function (d) { var t = d.tasks.find(function (x) { return x.id === sp.t.id }); if (t) { if (sp.role === 'worker' && t.claimedBy === 'spawn-pending') t.claimedBy = String(rec.run.id); if (sp.role === 'verifier' && t.verifierRun === 'spawn-pending') { t.verifierRun = String(rec.run.id); t.verifierRunAt = new Date().toISOString() } }; return t }, true)
+          // claim 占位换成真实 run id；verifier/hook-post run 单独记（claimedBy 保留 worker 的，供详情页跳转会话）
+          await mutateLocked(sid, function (d) { var t = d.tasks.find(function (x) { return x.id === sp.t.id }); if (t) { if (sp.role === 'worker' && t.claimedBy === 'spawn-pending') t.claimedBy = String(rec.run.id); if ((sp.role === 'verifier' || sp.role === 'hook-post') && t.verifierRun === 'spawn-pending') { t.verifierRun = String(rec.run.id); t.verifierRunAt = new Date().toISOString() }; if (sp.role === 'hook-pre' && t.hooks && t.hooks.pre) t.hooks.pre.runId = String(rec.run.id) }; return t }, true)
+          // 派发即回执：spawn 真成功后才入队（占位阶段失败不通知）；经 deps 注入，未注入静默跳过（老 host 兼容）
+          // 回执开关（设置区「通知」）：notifyDispatch=false → 派发回执整条跳过（spawn 照常，只闭嘴）；
+          // 闸门读本轮 poolCycle 已取的 cfg 快照 c（无额外读盘），老看板缺字段 → cfg 归一为 true。
+          if (c.notifyDispatch !== false && typeof notifyDispatched === 'function') notifyDispatched(sid, sp.t, sp.role)
         } else if (sp.role === 'worker') {
           // spawn 失败 → 回 pending
           await mutateLocked(sid, function (d) { var t = d.tasks.find(function (x) { return x.id === sp.t.id }); if (t && t.status === 'in-progress' && t.claimedBy === 'spawn-pending') { t.status = 'pending'; t.claimedBy = null; t.claimedAt = null; ah(t, 'in-progress', 'pending', 'system', 'spawn 失败，回收重新排队') }; return t }, true)
@@ -398,6 +540,14 @@ export function createDispatch(ctx, state, deps) {
           // verifier spawn 失败 → 清占位，下轮 cycle 重试（占位不清会永远卡住派发）
           await mutateLocked(sid, function (d) { var t = d.tasks.find(function (x) { return x.id === sp.t.id }); if (t && t.verifierRun === 'spawn-pending') { t.verifierRun = null; delete t.verifierRunAt }; return t }, true)
           pushSysNote(sid, '任务「' + sp.t.title + '」Verifier 启动失败，下轮自动重试')
+        } else if (sp.role === 'hook-pre') {
+          // hook-pre spawn 失败 → 退回 idle + 重新置待跑标记，下轮自动重试（串行闸门保持关闭）
+          await mutateLocked(sid, function (d) { var t = d.tasks.find(function (x) { return x.id === sp.t.id }); if (t && t.hooks && t.hooks.pre && t.hooks.pre.state === 'running') { t.hooks.pre.state = 'idle'; t.hooks.pre.runId = null; t.hooks.pre.pending = true }; return t }, true)
+          pushSysNote(sid, '史诗「' + sp.t.title + '」前置 hook 启动失败，下轮自动重试')
+        } else if (sp.role === 'hook-post') {
+          // hook-post spawn 失败 → 清幂等占用 + 保留待跑标记，下轮自动重试
+          await mutateLocked(sid, function (d) { var t = d.tasks.find(function (x) { return x.id === sp.t.id }); if (t) { if (t.verifierRun === 'spawn-pending') { t.verifierRun = null; delete t.verifierRunAt } if (t.hooks && t.hooks.post && t.hooks.post.state !== 'done') t.hooks.post.pending = true }; return t }, true)
+          pushSysNote(sid, '史诗「' + sp.t.title + '」收口 hook 启动失败，下轮自动重试')
         }
       }
       return result
@@ -424,7 +574,9 @@ export function createDispatch(ctx, state, deps) {
           // 不能走 resolveRoot：该函数在每个 agent 每次 prompt 组装时同步执行，
           // resolveRoot 全表扫 agent 注册表会把宿主事件循环卡死（曾导致全局界面卡顿、用户消息延迟渲染）。
           if (!teamModeCache[String(agent.id)]) return ''
-          return '【任务看板 Team 模式已开启】\n本会话的任务看板处于 Team 模式。请遵循以下工作方式：\n1. 涉及代码改动、文件创建、命令执行等实质性工作时，优先用 task_create 提交为看板任务（由一次性 Worker/Verifier 子代理执行与验收），不要自己直接动手实现。\n2. 你仍保有全部工具能力——调研、读代码、讨论方案、回答问题时直接进行，无需提交任务。\n3. 创建任务时，务必在 description 里写清任务目标和约束；调研结论/原始需求/思路用 contextNotes 带上，调研时读过的关键文件用 contextFiles 把路径带上——两者都会通过「上下文注入」通道传给子代理（独立注入区块，不占对话流）。子代理是全新会话、无你的会话记忆，上下文不够它需要从零自行调研，效率大打折扣甚至跑偏方向。\n4. Worker 上报歧义时会通过 task_arbitrate 等待你裁决，请及时响应。驳回重派时同样：新 Worker 没有上一轮的记忆，驳回原因会在 prompt 里，但额外上下文需你在 description 里补上。\n5. Team 模式下 task_create 默认建为草稿（草稿不会被派发领取）。把所有任务的 dependsOn 依赖关系、contextNotes/contextFiles 都补完后，再逐个 task_update publish=true 统一发布。确实需要立即派发的单个任务才显式传 draft:false。\n' + TEAM_SPLIT_RULE + (feedbackOn(String(agent.id)) ? '\n' + LESSON_RECALL_HINT + '把检索到的相关历史教训写进任务的 contextNotes，让子代理少踩重复的坑。' : '')
+          // 第 6 条（拆分条款）走 epicSplit 门禁（缺省 true = 逐字不变）：关掉只是不再主动劝拆，
+          // 显式 parentId 建子卡 / 史诗自动收口 / hooks 状态机全部照常（机制不禁）。
+          return '【任务看板 Team 模式已开启】\n本会话的任务看板处于 Team 模式。请遵循以下工作方式：\n1. 涉及代码改动、文件创建、命令执行等实质性工作时，优先用 task_create 提交为看板任务（由一次性 Worker/Verifier 子代理执行与验收），不要自己直接动手实现。\n2. 你仍保有全部工具能力——调研、读代码、讨论方案、回答问题时直接进行，无需提交任务。\n3. 创建任务时，务必在 description 里写清任务目标和约束；调研结论/原始需求/思路用 contextNotes 带上，调研时读过的关键文件用 contextFiles 把路径带上——两者都会通过「上下文注入」通道传给子代理（独立注入区块，不占对话流）。子代理是全新会话、无你的会话记忆，上下文不够它需要从零自行调研，效率大打折扣甚至跑偏方向——开发类任务（代码改动/修复/特性）务必带文件调研，实测可省 Worker 10~15 分钟自行 grep 定位；未带调研上下文的开发类任务返回会附 warning。\n4. Worker 上报歧义时会通过 task_arbitrate 等待你裁决，请及时响应。驳回重派时同样：新 Worker 没有上一轮的记忆，驳回原因会在 prompt 里，但额外上下文需你在 description 里补上。\n5. Team 模式下 task_create 默认建为草稿（草稿不会被派发领取）。把所有任务的 dependsOn 依赖关系、contextNotes/contextFiles 都补完后，再逐个 task_update publish=true 统一发布。确实需要立即派发的单个任务才显式传 draft:false。' + splitRuleOf(epicSplitOn(String(agent.id))) + (feedbackOn(String(agent.id)) ? '\n' + LESSON_RECALL_HINT + '把检索到的相关历史教训写进任务的 contextNotes，让子代理少踩重复的坑。' : '')
         },
       })
       ctx.effect(function () { return disposeSection })

package/lib/health.mjs

@@ -12,12 +12,33 @@ var TOUCH_HOT_MIN = 8      // 信号 a：单路径 touches 声明次数阈值
 var TOUCH_HOT_RATIO = 0.4  // 信号 a：声明次数占窗口内「有 touches 任务」的比例阈值
 var SERIAL_MIN_TOUCH = 5   // 信号 b：有 touches 任务的最小样本数（不足则不判定，防小样本噪声）
 var SERIAL_RATIO = 2       // 信号 b：有 touches 任务滞留中位数 > 无 touches 任务的 N 倍
+var SERIAL_MIN_WAIT_MIN = 5 // 信号 b：**绝对**阈值——有 touches 侧滞留中位数不足 5min 一律不判定
+                           // （task-muupnnq5 实证：线上曾挂「0min vs 0min」告警——0.4min > 0.1min×2 满足
+                           //  相对倍数但两者都不到半分钟，亚分钟差异毫无架构意义，是纯噪声）
 var P90_LIMIT_MIN = 45     // 信号 c：resolved 任务执行时长（claimedAt→resolvedAt）p90 阈值（分钟）
 var REJECT_HOT_MIN = 2     // 信号 d：单路径累计驳回次数阈值
 var MAX_HINTS = 3          // 返回提示上限（warn 信号优先排列）
 
-// 毫秒 → 分钟（四舍五入取整，仅供文案展示）
-function toMin(ms) { return Math.round(ms / 60000) }
+// 信号 a 分母防灌水（task-muupnnq5）：这些路径被流程性挂在几乎每张开发卡上，不代表架构收敛点。
+// 「组装产物 / 守门员路径」黑名单——过滤只作用于**本健康度模块内的路径聚合**（信号 a 热度分母、信号 d 归因），
+// 不动 touches 本身语义：锁冲突、并行度判定、派发排队一概不受影响（core.mjs 的 matchOne 不读本表）。
+// 副作用（刻意接受）：挂在这些路径上的驳回也不再触发信号 d——对「产物/守门员」报警反而会掩盖真脆弱区。
+// 加名单的唯一理由必须是「流程性挂载」，不是「看着不重要」。
+var TOUCH_NOISE_PATHS = {
+  'lib/client.js': true, // 派生产物：由 lib/client/*.js 组装，改源码的卡几乎都会挂它（改它反而不对）
+  'test': true,          // 守门员目录：单测随每张开发卡走
+  'README.md': true,     // 双份 README 的根仓副本：随下次发版统一核对，不指代模块收敛点
+}
+
+// 是否为「机械随卡」噪声路径（normTouch 已归一：\ →/、去 ./、去尾 /）
+function isNoiseTouchPath(p) {
+  if (TOUCH_NOISE_PATHS[p]) return true
+  return p.indexOf('test/') === 0 // test/ 整棵子树（含 test/x.test.mjs）
+}
+
+// 毫秒 → 分钟（四舍五入取整，仅供文案展示）；不足 1 分钟显示 <1min——
+// 否则 0.4min 与 0.1min 都渲染成「0min」，告警看起来像幽灵（task-muupnnq5 线上实证）
+function toMin(ms) { var m = Math.round(ms / 60000); return m < 1 ? '<1min' : m + 'min' }
 
 // 中位数（输入任意序，内部复制排序；空数组返回 null）
 function medianOf(nums) {
@@ -36,10 +57,19 @@ function percentileOf(nums, p) {
   return v[i]
 }
 
-// pending 滞留代理：createdAt →（claimedAt 优先，否则 resolvedAt）。无法计算返回 -1。
-function waitMsOf(t) {
+// 滞留代理：createdAt →（claimedAt 优先，否则 resolvedAt）。
+// task-muupnnq5 口径补充：仍在排队（无 claimedAt 也无 resolvedAt）的 pending 卡用 **now - createdAt** 计入——
+// 「还在排队等锁」同样是等待，旧口径直接返回 -1 把它们整批丢掉（右删失），会系统性低估带 touches 任务的滞留。
+// 副作用（刻意接受）：窗口里长期无人认领的僵尸 pending 卡滞留随时间单调增长，会持续计入有/无 touches 分组；
+// 这是「锁 + 派发双重饥饿」的真实信号，不是噪声。无法计算返回 -1。
+function waitMsOf(t, now) {
   var end = t.claimedAt || t.resolvedAt
-  if (!end || !t.createdAt) return -1
+  if (!end) {
+    if (!t.createdAt) return -1
+    var pm = now - Date.parse(t.createdAt)
+    return (isNaN(pm) || pm < 0) ? -1 : pm
+  }
+  if (!t.createdAt) return -1
   var ms = Date.parse(end) - Date.parse(t.createdAt)
   return (isNaN(ms) || ms < 0) ? -1 : ms
 }
@@ -52,14 +82,14 @@ function durationMsOf(t) {
   return (isNaN(ms) || ms < 0) ? -1 : ms
 }
 
-// 任务 touches 归一化（与 core.mjs normTouch 同款口径）+ 单任务内去重；无 touches 返回 []
+// 任务 touches 归一化（与 core.mjs normTouch 同款口径）+ 单任务内去重 + 机械随卡路径过滤；无 touches 返回 []
 function normPathsOf(t) {
   var raw = Array.isArray(t.touches) ? t.touches : []
   var seen = {}, out = []
   for (var i = 0; i < raw.length; i++) {
     if (typeof raw[i] !== 'string') continue
     var p = normTouch(raw[i])
-    if (p && !seen[p]) { seen[p] = true; out.push(p) }
+    if (p && !seen[p] && !isNoiseTouchPath(p)) { seen[p] = true; out.push(p) }
   }
   return out
 }
@@ -89,6 +119,7 @@ export function computeHealthHints(tasks) {
   var waitWithout = []  // 信号 b：无 touches 任务的滞留毫秒
   var withTouchN = 0    // 窗口内有 touches 的任务数（信号 a 占比分母）
   var durations = []    // 信号 c：resolved 任务执行时长毫秒（claimedAt→resolvedAt）
+  var now = Date.now()  // 信号 b：排队中 pending 卡的右删失代理要用「现在」（一次取定，长循环内不漂移）
   for (var i = 0; i < win.length; i++) {
     var t = win[i] || {}
     var paths = normPathsOf(t)
@@ -98,7 +129,7 @@ export function computeHealthHints(tasks) {
     }
     var rc = t.rejectCount || 0
     if (rc > 0) { for (var k = 0; k < paths.length; k++) rejCounts[paths[k]] = (rejCounts[paths[k]] || 0) + rc }
-    var w = waitMsOf(t)
+    var w = waitMsOf(t, now)
     if (w >= 0) { if (paths.length) waitWith.push(w); else waitWithout.push(w) }
     var dur = durationMsOf(t)
     if (dur >= 0) durations.push(dur)
@@ -116,16 +147,17 @@ export function computeHealthHints(tasks) {
     hints.push({ level: 'warn', text: rej[0] + ' 相关任务被驳回 ' + rej[1] + ' 次——质量脆弱区，建议审查该模块' })
   }
   // --- 信号 b：串行代价代理（有 touches 任务滞留中位数显著更长 = 并行度受锁限制）---
+  // 双重闸门：相对倍数（>2×）之外还要过**绝对**阈值（≥5min），治「0min vs 0min」这类亚分钟噪声告警。
   if (waitWith.length >= SERIAL_MIN_TOUCH && waitWithout.length > 0) {
     var medW = medianOf(waitWith), medWo = medianOf(waitWithout)
-    if (medW > medWo * SERIAL_RATIO) {
-      hints.push({ level: 'info', text: '带 touches 任务平均等待明显更长（中位数 ' + toMin(medW) + 'min vs ' + toMin(medWo) + 'min），并行度受锁限制' })
+    if (medW >= SERIAL_MIN_WAIT_MIN * 60000 && medW > medWo * SERIAL_RATIO) {
+      hints.push({ level: 'info', text: '带 touches 任务平均等待明显更长（中位数 ' + toMin(medW) + ' vs ' + toMin(medWo) + '），并行度受锁限制' })
     }
   }
   // --- 信号 c：执行时长 p90（resolved 任务执行时长尾部抬升 = 粒度/架构成本恶化）---
   var p90 = percentileOf(durations, 0.9)
   if (p90 !== null && p90 > P90_LIMIT_MIN * 60000) {
-    hints.push({ level: 'info', text: '任务执行时长 p90 已达 ' + toMin(p90) + 'min——超长任务占比升高，考虑拆分粒度或检查架构热点' })
+    hints.push({ level: 'info', text: '任务执行时长 p90 已达 ' + toMin(p90) + '——超长任务占比升高，考虑拆分粒度或检查架构热点' })
   }
   return hints.slice(0, MAX_HINTS)
 }

package/lib/notify.mjs

@@ -1,7 +1,10 @@
 // dsh-agent-board — 通知层（lib/notify.mjs）
 // makeMsg（纯函数，模块级 export，rpc.mjs 直接 import）：插件来源消息构造。
 // createNotify(ctx, state, deps)：歧义上报 25s 去抖通知 / 回执批量聚合（45s 或满 5 条）+ 主窗口空闲门控 /
-// 系统异常通知队列 / 投递前按看板现状过滤过期项。共享状态全部经 state 显式注入。
+// 系统异常通知队列 / 投递前按看板现状过滤过期项（含 dispatched 派发回执的离场过滤）。共享状态全部经 state 显式注入。
+// 回执两类入口共用同一聚合队列：notifyTaskDone（完成/阻塞）+ notifyDispatched（派发即回执）。
+// 回执开关（板级 notifyDispatch/notifyDone，设置区「通知」小节）不在本模块判定——闸门在调用方
+// （dispatch.mjs 派发/结算处读 cfg 快照），这样歧义裁决通知（notifyMainWindow）天然不受开关影响。
 
     // makeMsg 支持插件来源标记（参考 dsh-notes 派发模式）：
     // form 'recall' = 背景回执（召回上下文，非指令）；'notice' = 需注意的通知（带一行 summary）
@@ -22,6 +25,9 @@ export function createNotify(ctx, state, deps) {
     var sysNotesBuf = state.sysNotesBuf
 
     // 歧义上报通知：任何模式都通知主窗口（escalation 需要人工裁决，不能静默吞掉）
+    // ⚠️ 本通道是「裁决通道」不是回执——设置区的回执开关（notifyDispatch/notifyDone）只闸下面两条
+    // 回执入队入口（notifyTaskDone/notifyDispatched 的调用方），这里绝不读开关：关掉回执提醒是嫌吵，
+    // 关掉歧义提醒会让任务永久卡在等人裁决（闸门放在调用方而非本函数，就是为了让这条通道零开关）。
     // 25s 去抖投递：主窗口 turn 进行中时 followup 只在宿主侧排队，送达时任务常已被裁决/归档（过期回声）；
     // 排队无法撤回，插件侧唯一可行的方案就是延迟 + 投递前重查看板。
     // escNotifyTimers 存每个任务最新一次调度：同一任务再次上报即顶替旧调度（旧回调身份不匹配 → 静默丢弃）；
@@ -59,18 +65,16 @@ export function createNotify(ctx, state, deps) {
     // 回执幂等去重表：key = 任务id + 类别 + 完成事件指纹（deliverable/verification/resolvedAt/末条history 时间戳）。
     // 同一完成事件被任何路径（工具直报/run 结算/未来回归）重复通知时指纹一致 → 吞掉；
     // 驳回后重做完成 → 时间戳全换新 → 指纹不同 → 正常回执。
-    function notifyTaskDone(sid, t, kind) {
-      if (!t || !isDispatched(sid, t.claimedBy)) return
-      var lastHist = (t.history && t.history.length) ? String(t.history[t.history.length - 1].timestamp || '') : ''
-      var stamp = [kind, (t.deliverable && t.deliverable.at) || '', (t.verification && t.verification.at) || '', t.resolvedAt || '', lastHist].join('|')
-      var key = t.id + ':' + stamp
+    // 回执入队（共享内核，notifyTaskDone / notifyDispatched 两条入口共用同一 45s 聚合队列）：
+    // 幂等去重表 key = 任务id + 类别指纹 + 事件时间戳（1h TTL 清超龄键）；入队后满 5 条立即冲刷，
+    // 否则挂 45s 窗口（timer 不可用则同步冲刷）。
+    function pushReceipt(sid, key, item) {
       if (receiptedKeys[key]) return
       var rkeys = Object.keys(receiptedKeys)
       if (rkeys.length > 512) { var rnow = Date.now(); for (var ri = 0; ri < rkeys.length; ri++) { if (rnow - receiptedKeys[rkeys[ri]] > 3600000) delete receiptedKeys[rkeys[ri]] } }
       receiptedKeys[key] = Date.now()
       var buf = receiptBuf[sid] || (receiptBuf[sid] = { items: [], timer: null })
-      var lastNote = (t.history && t.history.length) ? String(t.history[t.history.length - 1].note || '') : ''
-      buf.items.push({ kind: kind, title: t.title, id: t.id, summary: (t.deliverable && t.deliverable.summary) || '', note: lastNote })
+      buf.items.push(item)
       if (buf.items.length >= 5) { flushReceipts(sid); return }
       if (!buf.timer) {
         var tm = ctx.timer
@@ -78,6 +82,23 @@ export function createNotify(ctx, state, deps) {
         else flushReceipts(sid)
       }
     }
+    function notifyTaskDone(sid, t, kind) {
+      if (!t || !isDispatched(sid, t.claimedBy)) return
+      var lastHist = (t.history && t.history.length) ? String(t.history[t.history.length - 1].timestamp || '') : ''
+      var stamp = [kind, (t.deliverable && t.deliverable.at) || '', (t.verification && t.verification.at) || '', t.resolvedAt || '', lastHist].join('|')
+      var lastNote = (t.history && t.history.length) ? String(t.history[t.history.length - 1].note || '') : ''
+      pushReceipt(sid, t.id + ':' + stamp, { kind: kind, title: t.title, id: t.id, summary: (t.deliverable && t.deliverable.summary) || '', note: lastNote })
+    }
+    // 派发即回执：任务被 Worker/Verifier 领走（spawn 成功）时入同一聚合队列，flush 出「🚀 已派发」区。
+    // 为什么与完成回执同队列：派发与完成常在同一 45s 窗口内（10 秒探针卡），分两条消息会刷屏；
+    // 同一条摘要里「已派发 → 完成/阻塞」相邻呈现，人一眼看清生命周期。role = worker/verifier。
+    // 判定用 claimedBy 真值（派发回执不依赖 dispatchedEver 的 run 记账——那条判定是给完成回执区分
+    // 「派发执行 vs 主窗口手动」用的；派发回执本身只可能由派发路径调用，天然是派发任务）。
+    function notifyDispatched(sid, t, role) {
+      if (!t || !t.id || !t.claimedBy) return
+      var stamp = 'dispatched|' + String(role || 'worker') + '|' + (t.claimedAt || t.verifierRunAt || '')
+      pushReceipt(sid, t.id + ':' + stamp, { kind: 'dispatched', role: String(role || 'worker'), title: t.title, id: t.id, summary: '', note: '' })
+    }
     // 系统级异常通知队列（易失，随回执冲刷）：模型熔断/spawn 失败/孤儿回收/看门狗标记
     // taskId 可选：告警类通知（软超时提醒等）语义只对「任务仍在执行中」成立，
     // 带上任务 id 后 flush 投递前可重读看板校验，任务已落定的过期告警直接丢弃
@@ -97,9 +118,13 @@ export function createNotify(ctx, state, deps) {
       function noteOf(status) { return status === 'verifying' ? '验证中' : '进行中' }
       // 组装投递文本（入参已是过滤后的存活项，避免用已丢弃项的计数）
       function composeText(items, notes) {
-        var done = [], blocked = []
-        for (var i = 0; i < items.length; i++) { (items[i].kind === 'resolved' ? done : blocked).push(items[i]) }
-        var lines = [done.length || blocked.length ? '📋 [任务看板] 回执摘要（' + items.length + ' 条）' : '📋 [任务看板] 系统通知', '']
+        var done = [], blocked = [], dispatched = []
+        for (var i = 0; i < items.length; i++) { (items[i].kind === 'resolved' ? done : (items[i].kind === 'dispatched' ? dispatched : blocked)).push(items[i]) }
+        var lines = [items.length ? '📋 [任务看板] 回执摘要（' + items.length + ' 条）' : '📋 [任务看板] 系统通知', '']
+        if (dispatched.length) {
+          lines.push('🚀 已派发 ' + dispatched.length + ' 个：')
+          for (var d = 0; d < dispatched.length && d < 8; d++) lines.push('  · ' + dispatched[d].title + ' (' + dispatched[d].id + ') — ' + (dispatched[d].role === 'verifier' ? 'Verifier 验收中' : 'Worker 执行中'))
+        }
         if (done.length) {
           lines.push('✅ 完成 ' + done.length + ' 个：')
           for (var j = 0; j < done.length && j < 8; j++) lines.push('  · ' + done[j].title + ' (' + done[j].id + ')' + (done[j].summary ? ' — ' + done[j].summary.slice(0, 120) : ''))
@@ -135,11 +160,16 @@ export function createNotify(ctx, state, deps) {
           }
           // b. 回执项：任务已 archived（人已手动归档 = 已知悉）→ 丢弃；
           //    resolved/blocked 保留（回执是主通道，任务查不到也保留，不能因读盘失败丢回执）
+          //    dispatched（派发即回执）：入队到 flush 之间任务可能已离场（10 秒探针卡快速完成、
+          //    被人取消/归档）——任务已不在 in-progress 说明「已派发」这条时效性信息已过期，
+          //    丢弃以免与同窗口的完成回执重复刷屏（完成回执本身就是主通道，信息不丢）。
+          //    rt 读盘失败（tt 为 null）时保留，不因瞬时读盘错误吞掉派发回执。
           var keptItems = []
           for (var j = 0; j < items.length; j++) {
             var it = items[j]
             var tt = findTask(it.id)
             if (tt && tt.status === 'archived') continue
+            if (it.kind === 'dispatched' && tt && tt.status !== 'in-progress') continue
             keptItems.push(it)
           }
           // c. 过滤后全空 → 不再打扰主窗口
@@ -153,5 +183,5 @@ export function createNotify(ctx, state, deps) {
       } else deliver().catch(function (e) { console.error('[task-board] receipt flush failed:', String(e)) })
     }
 
-    return { maybeNotify: maybeNotify, notifyTaskDone: notifyTaskDone, pushSysNote: pushSysNote }
+    return { maybeNotify: maybeNotify, notifyTaskDone: notifyTaskDone, notifyDispatched: notifyDispatched, pushSysNote: pushSysNote }
 }

package/lib/policy.mjs

@@ -10,10 +10,23 @@ const { cfg, lessonText, pushLesson } = core
 //   1) task_create 工具描述里的粒度契约 TASK_SIZE_CONTRACT；
 //   2) Team 模式系统提示词第 6 条 TEAM_SPLIT_RULE（epic 父卡 + 子任务 + checkParentAuto 收尾）；
 //   3) create-task RPC / task_create 工具返回体命中时附加 suggestSplit 一行建议（不落盘、不改状态）。
+// 板级总开关 epicSplit（缺省 true，UI 在入池配置弹层「功能」小节）：**只关引导，不禁机制**。
+//   false 时的两个生效点＝上面第 2、3 条（本文件 splitRuleOf / withSplitHint 统一收口）：
+//     · splitRuleOf(false) → ''：Team 提示词第 6 条整条不注入；
+//     · withSplitHint(out, t, false) → 原样返回：不再附 suggestSplit 软提示。
+//   机制面一律不看这个开关：显式传 parentId 建子卡、检查/收口父子流转、hooks 状态机照常工作——
+//   关的是「主动劝你拆」，不是「不许你拆」。
+//   第 1 条（TASK_SIZE_CONTRACT）留在 task_create 的**静态**工具描述里：工具定义会快照进 request header
+//   （dsh-session 校验 description 必须是 string），没有按板动态能力，故不在开关范围内。
 export var TASK_SIZE_CONTRACT = '建议粒度：单任务 10~30 分钟可独立完成。超出此范围的大任务请先拆分——建一张 epic 卡（parentId 体系）再挂子任务，别整坨塞进来。'
 export var SUGGEST_SPLIT_TEXT = '任务看起来偏大（建议单任务 10~30 分钟）：考虑拆分子任务（parentId）或收窄边界'
 // Team 模式提示词第 6 条：大任务的 epic 拆分流程（父卡 pipeline=direct 不派发，子任务全 resolved 后父卡由 checkParentAuto 自动转 verifying）
 export var TEAM_SPLIT_RULE = '6. 大任务必须拆分：预计超过 30 分钟的任务，先建一张 epic 父卡（pipeline 传 direct，不派发），再拆成若干 10~30 分钟的子任务（task_create 传 parentId=父卡 id，有先后顺序的用 dependsOn 串联）。子任务全部完成后父卡会自动标记完成（checkParentAuto）。'
+// Team 提示词第 6 条的注入出口（含前导换行，调用方直接字符串相加）：
+//   epicSplit 缺省/true → '\n' + TEAM_SPLIT_RULE（与开关落地前逐字相同，零变化）；
+//   epicSplit === false → ''（条款整条不出现，编号 1~5 连续不受影响）。
+// 纯函数：只看传入布尔，不读配置、不碰 IO——dispatch 侧从缓存取 cfg(d).epicSplit 后传进来。
+export function splitRuleOf(epicSplit) { return epicSplit === false ? '' : '\n' + TEAM_SPLIT_RULE }
 // 史诗特征词：命中即视为"整坨塞进来"的典型信号（与 TASK_SIZE_CONTRACT 配套；无 /g，可安全复用）
 var EPIC_WORDS = /全量|整体|系统级|全面|重构|所有模块|整个/
 // description 长度阈值（字符）：超过它说明描述密度远超"10~30 分钟单任务"应有体量
@@ -27,7 +40,10 @@ export function suggestSplitOf(t) {
   return ''
 }
 // 统一出口：只在命中时附加字段，老调用方拿到的返回体形态完全不变（多一个可选字段而已）
-export function withSplitHint(out, t) {
+// 第三参 epicSplit（缺省 undefined = 开）：显式 false 时直接原样返回——总开关关掉后不再主动劝拆，
+// 返回体与「未命中」逐字同形（老调用方无感）。
+export function withSplitHint(out, t, epicSplit) {
+  if (epicSplit === false) return out
   var hint = suggestSplitOf(t)
   if (hint && out && typeof out === 'object') out.suggestSplit = hint
   return out