dsh-agent-board 1.9.0 → 1.9.2

package/lib/dispatch.mjs

@@ -3,52 +3,43 @@
 // token 消耗累加 / poolCycle 派发周期（孤儿回收+占位 claim+池快照）/ 15s 心跳 / 插件卸载清理 /
 // Team 模式 systemPrompt 引导段 / 预研上下文瘦身清单（调研笔记全文 + 文件清单，随首条 prompt 一次性注入）/
 // 可续跑 Worker（continuable：硬超时 interrupt 留存 + 重派 sendMessage 冷复活续跑 + 失败回退 fresh spawn）。
+// 拆分第 7 刀 task-mvt8c1yx-7：usage 水位（localDayKey/effectiveOf/seekSeqOf/num0/hasUsageRecorded）/
+// accumulateRunUsage / 重启 reconcile（reconcileRoot）/ 僵尸留档清扫（sweepZombieRuns）/ 幽灵占位回收
+// （recIsLive/reapGhostRecs）搬至 lib/settle.mjs——poolCycleBody 三挂点与 return API 的 accumulateRunUsage
+// 重指 settle 实例（reconcile 域闭包 deps withTimeout/armTimeouts/logSizeOf 随工厂入参注入 settle）。
 import { statSync } from 'node:fs'
 import * as core from './core.mjs'
-import { readRunUsage, findRunLog, readLogBytes, readLogFrames } from './usage.mjs'
-import { splitRuleOf, pushRejectLesson, DECOMPOSE_SCHEMA, buildDecomposerPrompt, applyDecomposeProposal, TEAM_DECOMPOSE_FLOW } from './policy.mjs'
-const { ah, cfg, claimApply, resolveApply, verifyApply, lateVerdictApply, lateNoticeFp, parseSections, outputText, pickDispatch, isOrphan, buildWorkerPrompt, buildVerifierPrompt, buildContextPackSection, parseContextFileEntry, parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, applyHookSettle, hookOn, hookSetState, gsb, pushRejection, depsSatisfied, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER, opsLogLine } = core
+import { findRunLog } from './usage.mjs'
+import { splitRuleOf, DECOMPOSE_SCHEMA, buildDecomposerPrompt, TEAM_DECOMPOSE_FLOW } from './policy.mjs'
+import { createHung } from './hung.mjs'
+import { createSettle } from './settle.mjs'
+// 模型健康域（拆分第 2 刀 task-mvt8c1yx-2 + 第 3 刀 task-mvt8c1yx-3 + 第 4 刀 task-mvt8c1yx-4）：冷却嗅探纯函数
+// （parseModelCooldown/hhmmOf/modelKey）、健康表/冷却登记/模型目录/备用链健康判定/熔断连击工厂（createModelHealth）、
+// 主动探测域（probeOnce/probeModel/probeConfiguredModels/maybeProbeModels/探测态/disposeProbe）全量已拆至
+// lib/model-health.mjs（叶子模块，与健康同域；health→hung 单向 import 无环，cfg 由 core 直接 import）。
+// hhmmOf/modelKey 在本文件不搬区段（降档留痕/熔断键）仍有调用点——单源 import 同源使用；CONNECTIVITY_RE 随第 4 刀迁出（唯一代码消费点 classifyEmptyResponse 同域随迁），本文件不再 import。
+// applyDecomposeProposal/pushRejectLesson 与 isHungKillFailure/HUNG_CIRCUIT_WHY 随第 6 刀（task-mvt8c1yx-6）
+// 搬至 lib/settle.mjs 消费（角色结算搬移），本文件不再 import。
+import { parseModelCooldown, createModelHealth, hhmmOf, modelKey } from './model-health.mjs'
+const { ah, cfg, claimApply, pickDispatch, isOrphan, buildWorkerPrompt, buildVerifierPrompt, buildContextPackSection, parseContextFileEntry, parentKickOnDispatch, LESSON_RECALL_HINT, buildHookPrompt, hookOn, hookSetState, gsb, depsSatisfied, VERIFIER_PERSONA, VERIFIER_TOOL_FILTER, opsLogLine } = core
 
 // ===== 模型冷却嗅探：限流（task-mvneq4kk）+ 连接/网关故障短窗（task-mvnx8hnm）=====
-// 纯函数：两类报错形态识别，返回 { until, parsed, kind }，均不命中返回 null。
-// ① 限流形态（kind='rate-limit'，行为与 C5 落地逐字一致）：命中 /429|RATE_LIMIT|rate.?limit|限额|额度/i；
-//    尝试解析「YYYY-MM-DD HH:mm:ss 重置」（中文，glm 原形事故实证形态）或「reset(s) at/on YYYY-MM-DD HH:mm:ss」
-//    （英文）样式时间 → until 时间戳（按本地时区构造，与供应商报错文案口径一致）；解析不到时间 →
-//    until = now + 30min（保守缺省）。
-// ② 连接/网关形态（kind='connectivity'）：命中 CONNECTIVITY_RE → until = now + 10min 固定短窗
-//    （连接故障多为瞬时，短窗自动恢复——比限流缺省 30min 短；固定不开放配置，要配置化等实证再开）。
-// 判定顺序：先限流后连接（两类关键词并存的文本按限流处理，窗口更保守）。
-// 英文裸词 timeout 刻意不在连接形态内（只认 ETIMEDOUT errno 形态）——供应商「provider timeout after 30s」
-// 类软性报错与 withTimeout 的「label timeout Nms」硬超时文本都不进冷却（C5 既有断言锁定该口径）。
-var RATE_LIMIT_RE = /429|RATE_LIMIT|rate.?limit|限额|额度/i
-var RATE_RESET_ZH_RE = /(\d{4})-(\d{1,2})-(\d{1,2})[ T](\d{1,2}):(\d{1,2}):(\d{1,2})\s*重置/
-var RATE_RESET_EN_RE = /resets?(?:\s+at|\s+on)?\s+(\d{4})-(\d{1,2})-(\d{1,2})[ T](\d{1,2}):(\d{1,2}):(\d{1,2})/i
-var RATE_LIMIT_DEFAULT_MS = 30 * 60000
-var CONNECTIVITY_RE = /ENOTFOUND|ECONNREFUSED|ETIMEDOUT|ECONNRESET|EAI_AGAIN|fetch failed|network|socket|502|503|504|网关|连接|超时/i
-var CONNECTIVITY_COOLDOWN_MS = 10 * 60000
-export function parseModelCooldown(errText) {
-  var s = String(errText || '')
-  if (RATE_LIMIT_RE.test(s)) {
-    var m = s.match(RATE_RESET_ZH_RE) || s.match(RATE_RESET_EN_RE)
-    if (m) {
-      var ts = new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]), Number(m[6])).getTime()
-      if (isFinite(ts)) return { until: ts, parsed: true, kind: 'rate-limit' }
-    }
-    return { until: Date.now() + RATE_LIMIT_DEFAULT_MS, parsed: false, kind: 'rate-limit' }
-  }
-  if (CONNECTIVITY_RE.test(s)) return { until: Date.now() + CONNECTIVITY_COOLDOWN_MS, parsed: false, kind: 'connectivity' }
-  return null
-}
-// 兼容层（task-mvnx8hnm）：旧导出名保留为别名，既有调用点（测试/潜在宿主消费方）零改动
+// 纯函数域（常量/parseModelCooldown/hhmmOf/modelKey）与健康表/冷却登记（createModelHealth）已拆至
+// lib/model-health.mjs（拆分第 2 刀 task-mvt8c1yx-2，叶子模块——上方 import 同源使用）。
+// 此处保留兼容层（task-mvnx8hnm）：旧导出名保留，既有调用点（测试/潜在宿主消费方）零改动——
+// parseRateLimit 与 parseModelCooldown 同一绑定（test/rate-limit-cooldown.test.mjs L68 断言引用相等）。
+export { parseModelCooldown }
 export var parseRateLimit = parseModelCooldown
-// 冷却消息「至 HH:mm」格式化（本地时区）
-function hhmmOf(ts) { var d = new Date(ts); return ('0' + d.getHours()).slice(-2) + ':' + ('0' + d.getMinutes()).slice(-2) }
 
 export function createDispatch(ctx, state, deps) {
     // 宿主 fs 句柄与「会话工作区解析根」随预研注入瘦身退役（task-muvjs392）：派发侧不再读盘——
     // 清单只给「路径:L行号 — 一句用途」，文件内容由 Worker 自己用 read 工具按行号范围自取。
     var rt = deps.rt, mutateLocked = deps.mutateLocked, kickCycle = deps.kickCycle
     var rootForSession = deps.rootForSession, withTimeout = deps.withTimeout, runsFor = deps.runsFor, feedbackOn = deps.feedbackOn
+    // 挂死检测实例（拆分第 1 刀 task-mvt8c1yx）：常量/帧活性/零产出清扫已拆至 lib/hung.mjs（叶子模块）。
+    // logSizeOf 仍在 createDispatch 内；settleRun 已拆至 settle.mjs，此处以懒闭包重指 settle 实例；
+    // createHung 本身不立即调用 settleRun，下方 health 初始化后即完成 settle 实例接线。
+    var hung = createHung({ state: state, mutateLocked: mutateLocked, runsFor: runsFor, logSizeOf: logSizeOf, settleRun: function () { return settle.settleRun.apply(null, arguments) } })
     // 会话日志根（可选注入）：usage 增量结算（卡3）必须「真读真日志」才测得出重复计账——
     // 生产不注入（usage.mjs 回退 os.homedir()），单测注入临时目录（否则只能开子进程改 HOME，
     // 而同进程改 os.homedir 会污染整个测试进程）。老宿主/老测试桩无此依赖 → undefined，行为不变。
@@ -61,218 +52,47 @@ export function createDispatch(ctx, state, deps) {
     var notifyLateApprove = (typeof deps.notifyLateApprove === 'function') ? deps.notifyLateApprove : null // 迟到复核 notice 级通知（三连根修②，未接线 → 静默跳过）
     // 派发即回执：spawn 成功后入 45s 聚合队列的「🚀 已派发」区（老 host 未注入 → 静默跳过）
     var notifyDispatched = deps.notifyDispatched
+    // 拆解官回执（task-mvrqiu6x）：拆解官落定 split/keep → 「🧩 已拆解」聚合分区（老 host 未注入 → 静默跳过）
+    var notifyDecomposed = deps.notifyDecomposed
     // 共享状态别名（本体由 index.mjs apply 统一构建并逐模块注入）
     var dispatchedEver = state.dispatchedEver
     var badModels = state.badModels
-    // 冷却表（task-mvneq4kk 限流 / task-mvnx8hnm 连接故障）：与 badModels 同生命周期（纯内存不持久化，
-    // 重启即清——额度重置窗口本就短，连接短窗 10min 更短）。语义分治：badModels=连续失败熔断（布尔），
-    // modelCooldown=窗口冷却（until 时间戳），两张表各管各的（连接类冷却只进本表，不动熔断判定）。
-    // key = 模型 id（provider/model 复合串）：限流是账户级额度窗口、连接故障是网关面，都不按会话分键。
-    // 缺字段就地补（测试桩/老宿主兼容，与 poolHealthFor 同例）。
-    var modelCooldown = state.modelCooldown || (state.modelCooldown = {})
-    // 统一健康表（task-mvoulhm7）：内部按会话分桶，避免 sid|model 熔断信号串板；get-tasks 公开为 {modelId:entry}。
-    // observed=最近主动探测/run 的基础状态，冷却与熔断是覆盖态；调度仍只认这两种覆盖态，未知不等于不可用。
-    var modelHealth = state.modelHealth || (state.modelHealth = {})
-    // 熔断连击表（task-mvowb2hc 洞①）：sid|model → 连续「模型面失败」次数（纯内存不持久化，与
-    // badModels/modelCooldown 同生命周期，重启即清）。语义：只有「会话被宿主/激活机制在开工前杀掉」
-    // 这类模型面失败才计数（worker 自己的失误——空输出/超时等——不算），连续 N 次才拉黑进 badModels
-    // （熔断语义不变：拉黑后链跳过 + 健康表 circuit）；任一可归因 run 正常完成即归零（settleRunRecord）。
-    var modelFailStreak = state.modelFailStreak || (state.modelFailStreak = {})
-    var probeInFlight = {}, probeAbort = {}, probeNextAt = {}, probeDisposed = false
-    function healthBucket(sid) { return modelHealth[sid] || (modelHealth[sid] = {}) }
-    function healthEntry(sid, model) {
-      var b = healthBucket(sid)
-      return b[model] || (b[model] = { state: 'unknown', observed: 'unknown', lastProbe: null, lastSeen: null, note: '尚无健康信号', observedNote: '尚无健康信号', recentRuns: [] })
-    }
-    function syncModelHealth(sid, model, cooldownOverride) {
-      var e = healthEntry(sid, model), until = typeof cooldownOverride === 'number' ? cooldownOverride : cooldownLive(model)
-      e.state = e.observed === 'healthy' ? 'healthy' : 'unknown'
-      e.note = e.observedNote || '尚无健康信号'
-      delete e.until
-      if (until) { e.state = 'cooldown'; e.until = until; e.note = e.cooldownNote || '模型冷却中' }
-      if (badModels[modelKey(sid, model)]) { e.state = 'circuit'; e.note = e.circuitNote || '连续失败，模型熔断中' }
-      return e
-    }
-    function observeModel(sid, model, ok, opts) {
-      if (!model || probeDisposed) return null
-      opts = opts || {}
-      var e = healthEntry(sid, model), at = new Date().toISOString()
-      var latency = Number(opts.latencyMs)
-      e.lastSeen = at
-      e.observed = ok ? 'healthy' : 'unknown'
-      if (isFinite(latency) && latency >= 0) e.latencyMs = Math.round(latency)
-      if (opts.probe) {
-        e.lastProbe = at
-        e.observedNote = ok ? '主动探测通过' : ('主动探测失败' + (opts.note ? '：' + opts.note : ''))
-      } else {
-        e.recentRuns.push({ ok: !!ok, at: at, latencyMs: isFinite(latency) && latency >= 0 ? Math.round(latency) : null })
-        if (e.recentRuns.length > 5) e.recentRuns = e.recentRuns.slice(-5)
-        var passed = e.recentRuns.filter(function (r) { return r.ok }).length
-        e.observedNote = (ok ? '最近 run 成功' : '最近 run 失败') + '（近 ' + e.recentRuns.length + ' 次 ' + passed + ' 次成功）'
-      }
-      e.note = e.observedNote
-      return syncModelHealth(sid, model)
-    }
-    function markModelCircuit(sid, model, note) {
-      var e = healthEntry(sid, model)
-      e.circuitNote = note || '连续验收失败，模型熔断中'
-      return syncModelHealth(sid, model)
-    }
-    // 冷却期判定：返回冷却截止 ts（0=不在冷却）；过期项惰性清除（读路径顺手删，无需 sweeper）
-    function cooldownLive(model) {
-      var until = modelCooldown[model]
-      if (!until) return 0
-      if (Date.now() >= until) { delete modelCooldown[model]; return 0 }
-      return until
-    }
-    // 冷却嗅探登记：两条登记路径共用（①spawn extras 回退臂 e/e2 文本 ②settleWorker 失败臂 errText——
-    // activation.result 拆除兜底臂带上来的诊断文本也走②）。max 收敛：多次报错只延不缩
-    // （带重置时间的精确值与 30min/10min 缺省并存时取更晚者）；截止未后延则零改动零留痕（防重复报错刷屏）。
-    // 留痕分态（task-mvnx8hnm）：限流=「额度冷却至 HH:mm」，连接/网关=「连接故障短冷却 10 分钟」——
-    // 卡 messages 各记一条 kind='cooldown'，排查时一眼分清「额度没了」与「连不上」。
-    // 写卡失败静默吞掉（留痕是附属动作，绝不阻断 spawn 回退/失败结算主流程）。返回冷却截止 ts，未命中 null。
-    async function sniffModelCooldown(sid, taskId, model, errText) {
-      if (!model) return null
-      var hit = parseModelCooldown(errText)
-      if (!hit) return null
-      if (hit.until <= (modelCooldown[model] || 0)) { syncModelHealth(sid, model, modelCooldown[model]); return modelCooldown[model] }
-      modelCooldown[model] = hit.until
-      var until = modelCooldown[model]
-      var he = healthEntry(sid, model)
-      he.cooldownNote = hit.kind === 'connectivity' ? ('连接/网关故障，冷却至 ' + hhmmOf(until)) : ('额度限流，冷却至 ' + hhmmOf(until))
-      syncModelHealth(sid, model, until)
-      if (hit.kind === 'connectivity') console.error('[task-board] 模型 ' + model + ' 连接/网关故障，短冷却 10 分钟至 ' + new Date(until).toISOString())
-      else console.error('[task-board] 模型 ' + model + ' 命中 RATE_LIMIT 限流，冷却至 ' + new Date(until).toISOString() + '（' + (hit.parsed ? '重置时间解析' : '缺省 30min') + '）')
-      try {
-        await mutateLocked(sid, function (d) {
-          var t = d.tasks.find(function (x) { return x.id === taskId })
-          if (!t) return null
-          if (!Array.isArray(t.messages)) t.messages = []
-          t.messages.push({ kind: 'cooldown', text: hit.kind === 'connectivity' ? ('🔌 模型 ' + model + ' 连接故障短冷却 10 分钟（至 ' + hhmmOf(until) + '）') : ('⏳ 模型 ' + model + ' 额度冷却至 ' + hhmmOf(until)), at: new Date().toISOString(), by: 'system' })
-          return { ok: true }
-        }, true) // skipKick：只是留痕，不踢 poolCycle
-      } catch (_) {}
-      return until
-    }
-    // ===== 备用模型链健康判定（task-mvnqxlpn）：不在 badModels 熔断名单且不在 modelCooldown 冷却期 =====
-    // 两张表各管各的（熔断=连续失败布尔，冷却=额度窗口时间戳），任一命中即不健康。
-    // 消费点=spawnOneShot 取模链：候选被判不健康时先扫板级 fallbackModels 找首个健康者（链本身逐项过本检查）。
-    function healthyModel(sid, modelId) {
-      if (!modelId) return false
-      var h = syncModelHealth(sid, modelId)
-      if (h.state === 'circuit') return false
-      if (h.state === 'cooldown') return false
-      return true
-    }
-    // 扫备用链找首个健康模型（保持链序=主窗口配置的能力水位优先级）；链尽/空链返回 ''。
-    function pickHealthyFallback(sid, fbList) {
-      if (!Array.isArray(fbList)) return ''
-      for (var fi = 0; fi < fbList.length; fi++) {
-        if (healthyModel(sid, fbList[fi])) return fbList[fi]
-      }
-      return ''
-    }
-    // ===== 熔断连击喂给（task-mvowb2hc 洞①）：模型面失败判别 + 连击计数 + 三连拉黑 =====
-    // 模型面失败 = 会话被宿主/激活机制在开工前杀掉，两条来源文本都在本文件内确定：
-    //   ① activation.result 拆除兜底臂：「子会话被宿主拆除（stopReason: X，…）」（stopReason=completed
-    //      的收尾性拆除不算——那是正常完成的副产物，不是模型失败）；
-    //   ② activation 异常兜底臂：「子会话 activation 异常：…」（spawn 机制/provider 面失败，同属开工前）。
-    // worker 自己的失误（空输出/超时中断/文本降级失败）不算——好模型不该为 worker 的错误背锅。
-    var WORKER_MODEL_CIRCUIT_AFTER = 3 // 连续 N 次模型面失败才拉黑（与 worker 三连败阻塞同一三击口径）
-    function isModelKillFailure(errText) {
-      var s = String(errText || '')
-      if (s.indexOf('子会话被宿主拆除（stopReason: ') === 0) return s.indexOf('子会话被宿主拆除（stopReason: completed') !== 0
-      return s.indexOf('子会话 activation 异常：') === 0
-    }
-    // 连击 +1；达 N 且尚未拉黑 → badModels 落黑名单（取模链/降档候选的既有熔断判定照常消费，零新分支）
-    // + 健康表 circuit + 系统通知（不带 taskId：与验收熔断通知同口径，不受任务回执冲刷丢弃）。
-    // 返回是否本次调用触发拉黑（测试/留痕用）。
-    function feedModelFailure(sid, model) {
-      if (!model) return false
-      var k = modelKey(sid, model)
-      var n = (modelFailStreak[k] || 0) + 1
-      modelFailStreak[k] = n
-      if (n < WORKER_MODEL_CIRCUIT_AFTER) return false
-      if (!badModels[k]) {
-        badModels[k] = true
-        markModelCircuit(sid, model, '连续 ' + n + ' 次 spawn/续跑即被宿主拆除（模型失败），已熔断')
-        pushSysNote(sid, '模型 ' + model + ' 连续 ' + n + ' 次 spawn/续跑即被宿主秒拆（模型失败），已熔断——后续取模链跳过该模型')
-      }
-      return true
-    }
-    // 连击归零：任一可归因 run 正常完成即证明模型链路恢复（settleRunRecord completed 路径调用）
-    function resetModelFailure(sid, model) { if (model) delete modelFailStreak[modelKey(sid, model)] }
-    // ===== 主动模型嗅探：llm.stream 极短直调（无子代理/系统提示/工具，maxTokens=1）=====
-    // finish=stop/max-tokens 等均证明模型链路可用；error/aborted/无 finish 才算失败。失败文本复用既有冷却登记，
-    // 但不改 badModels 熔断判定。同模型全局只在飞一次，15s 硬超时带 AbortSignal，绝不阻塞 poolCycle 派发。
-    async function probeModel(sid, model) {
-      if (probeDisposed) return null
-      if (probeInFlight[model]) return probeInFlight[model]
-      var llm = ctx.get && ctx.get('llm')
-      if (!llm || typeof llm.stream !== 'function') return null
-      var slash = model.indexOf('/')
-      if (slash <= 0 || slash === model.length - 1) return null
-      var started = Date.now(), ac = new AbortController(), timedOut = false, disposeTimer = null
-      var promise = (async function () {
-        try {
-          if (ctx.timer && typeof ctx.timer.timeout === 'function') disposeTimer = ctx.timer.timeout(function () { timedOut = true; ac.abort() }, 15000)
-          else { var nativeTimer = setTimeout(function () { timedOut = true; ac.abort() }, 15000); disposeTimer = function () { clearTimeout(nativeTimer) } }
-          var stream = llm.stream({ provider: model.slice(0, slash), model: model.slice(slash + 1), messages: [{ role: 'user', content: [{ type: 'text', text: 'ping' }] }], maxTokens: 1, signal: ac.signal })
-          var finished = false, failure = ''
-          for await (var chunk of stream) {
-            if (!chunk || chunk.type !== 'finish') continue
-            finished = true
-            var reason = chunk.reason || {}
-            if (reason.kind === 'error' || reason.kind === 'aborted') failure = String((reason.failure && reason.failure.message) || reason.kind || '模型探测失败')
-          }
-          if (!finished) throw new Error('模型探测流未返回 finish')
-          if (failure) throw new Error(failure)
-          observeModel(sid, model, true, { probe: true, latencyMs: Date.now() - started })
-          return true
-        } catch (e) {
-          var text = timedOut ? 'probe timeout 15000ms' : String(e && e.message || e).slice(0, 300)
-          observeModel(sid, model, false, { probe: true, latencyMs: Date.now() - started, note: text })
-          if (!probeDisposed) { try { await sniffModelCooldown(sid, '', model, text) } catch (_) {} }
-          return false
-        } finally {
-          try { if (typeof disposeTimer === 'function') disposeTimer() } catch (_) {}
-          delete probeInFlight[model]
-          delete probeAbort[model]
-        }
-      })()
-      probeInFlight[model] = promise
-      probeAbort[model] = ac
-      return promise
-    }
-    async function probeConfiguredModels(sid, d) {
-      var c = cfg(d), models = core.configuredModelIds(d)
-      for (var i = 0; i < models.length; i++) syncModelHealth(sid, models[i])
-      if (!c.probeEnabled) return { disabled: true, models: models, probed: 0 }
-      var llm = ctx.get && ctx.get('llm')
-      if (!llm || typeof llm.stream !== 'function') return { disabled: false, unavailable: true, models: models, probed: 0 }
-      var probed = 0, healthy = 0
-      for (var m = 0; m < models.length; m++) {
-        if (probeDisposed) break
-        var before = probeInFlight[models[m]] ? false : true
-        var ok = await probeModel(sid, models[m])
-        if (ok === null) continue
-        if (before) probed++
-        if (ok === true) healthy++
-      }
-      return { disabled: false, models: models, probed: probed, healthy: healthy }
-    }
-    // 15s 调度心跳驱动间隔闸：配置变化立即重排，探测在后台跑，不 await 进派发主链。
-    function maybeProbeModels(sid, d) {
-      var c = cfg(d), now = Date.now()
-      if (!c.probeEnabled) { probeNextAt[sid] = 0; return }
-      var llm = ctx.get && ctx.get('llm')
-      if (!llm || typeof llm.stream !== 'function') return
-      var planKey = String(c.probeIntervalMin)
-      if (probeNextAt[sid] && probeNextAt[sid].plan === planKey && now < probeNextAt[sid].at) return
-      if (!probeNextAt[sid] || probeNextAt[sid].plan !== planKey) probeNextAt[sid] = { at: 0, plan: planKey }
-      probeNextAt[sid] = { at: now + c.probeIntervalMin * 60000, plan: planKey }
-      probeConfiguredModels(sid, d).catch(function (e) { console.error('[task-board] 模型健康探测失败（下周期重试）:', String(e)) })
-    }
+    // 冷却表/健康表/熔断连击表（modelCooldown/modelHealth/modelFailStreak 惰性初始化，原「缺字段就地补」
+    // 同款）已拆至 lib/model-health.mjs（拆分第 2 刀 task-mvt8c1yx-2 + 第 3 刀 task-mvt8c1yx-3）：工厂内
+    // 就地补缺字段（state 共享同一引用，语义逐字不变），见下方 health 实例。
+    // 探测态（probeInFlight/probeAbort/probeNextAt/probeDisposed）已随第 4 刀（task-mvt8c1yx-4）迁入
+    // lib/model-health.mjs 工厂内部——卸载入口收敛为 health.disposeProbe()（下方卸载 effect 回调只调它）。
+    // 健康域实例（拆分第 2 刀 task-mvt8c1yx-2 + 第 3 刀 task-mvt8c1yx-3 + 第 4 刀 task-mvt8c1yx-4）：健康表/
+    // 冷却登记/冷却期判定/模型目录/备用链健康判定/熔断连击/主动探测（probeOnce/probeModel/probeConfiguredModels/
+    // maybeProbeModels/disposeProbe）函数集已拆至 lib/model-health.mjs（state 共享同一引用——
+    // modelHealth/modelCooldown/badModels/modelFailStreak 语义逐字不变；各表惰性初始化在工厂内就地补）。
+    // 卸载闸随第 4 刀收敛进工厂（probeDisposed 成为其内部状态，disposeProbe() 为唯一卸载入口）——本侧不再
+    // 注入 disposed 读取器；ctx/pushSysNote 随第 3 刀注入（modelDirectory 的 llm 目录获取 / feedModelFailure
+    // 的系统通知 / 探测域的 llm.stream 直调与 timer）。
+    var health = createModelHealth({ state: state, mutateLocked: mutateLocked, ctx: ctx, pushSysNote: pushSysNote })
+    // 整列别名（拆分第 2/3/4 刀）：既有调用点文本不动（降低 diff 风险），函数集统一来自 health 工厂实例。
+    // markModelCircuit/isModelKillFailure/feedModelFailure 随第 6 刀由 settle.mjs 经 opts.health 实例解构
+    // （角色结算搬移，本文件仅 spawnOneShot 的 sniffModelCooldown 回退臂仍消费）；sniffModelCooldown 保留。
+    const { healthBucket, healthEntry, syncModelHealth, cooldownLive, sniffModelCooldown, modelDirectory, outOfDir, traceStaleModel, healthyModel, pickHealthyFallback, probeConfiguredModels, maybeProbeModels, disposeProbe } = health
+    // 结算主干实例（拆分第 5 刀；拆分第 6 刀 task-mvt8c1yx-6）：四个角色结算已搬入 settle.mjs
+    // （settleRun 分路模块内直调，roles 懒注入撤掉），工厂入参补通知类 deps（未接线 → 静默跳过的
+    // 守卫写法随行）——spawnOneShot 的 activation 拆除臂两调用点改重指 settle.settleWorker（下方）。
+    var settle = createSettle({
+      state: state, ctx: ctx, runsFor: runsFor, mutateLocked: mutateLocked,
+      rootForSession: rootForSession, health: health, rt: rt, sessionsRoot: sessionsRoot,
+      closeRunHistory: closeRunHistory, resumeTarget: resumeTarget,
+      poolHealthFor: poolHealthFor, withTimeout: withTimeout, armTimeouts: armTimeouts, logSizeOf: logSizeOf,
+      pushSysNote: pushSysNote, maybeNotify: maybeNotify, notifyTaskDone: notifyTaskDone,
+      notifyLateReject: notifyLateReject, notifyLateApprove: notifyLateApprove,
+      notifyDecomposed: notifyDecomposed, kickCycle: kickCycle
+    })
+    // 主动探测域（拆分第 4 刀 task-mvt8c1yx-4 全量迁入 lib/model-health.mjs）：PROBE_MAX_TOKENS/
+    // PROBE_MAX_TOKENS_RETRY/PROBE_ATTEMPT_TIMEOUT_MS/QUOTA_SIGNAL_RE/CREDENTIAL_SIGNAL_RE 常量与
+    // task-mvrfp1rj/task-mvrqdw4k/task-mvsv8zym 校准注释、isEmptyResponse/classifyEmptyResponse 分治
+    // 纯函数、probeOnce/probeModel/probeConfiguredModels/maybeProbeModels 探测编排、探测态
+    // （probeInFlight/probeAbort/probeNextAt/probeDisposed）与统一卸载入口 disposeProbe 均已随迁
+    // （cfg 由 core 直接 import、ctx 经工厂注入）——本文件保留两个接线点：poolCycle 的 maybeProbeModels
+    // 间隔闸调用（下方）与插件卸载 effect 的 disposeProbe 回调（文件尾）。
     // 「上下文注入」区块通道的按子代理会话缓存表 + 首轮竞速认领队列随该通道一起退役（task-muvjs392）：
     // 瘦身清单直接进首条 prompt，不再需要注入段命中与父子归属认领（并行 spawn 认领错包的潜伏 bug 一并消灭）。
     var knownSessions = state.knownSessions
@@ -302,7 +122,8 @@ export function createDispatch(ctx, state, deps) {
     // activeRuns / dispatchedEver 容器本体在 state（index.mjs 统一构建）；runsFor/isDispatched 在 session 层
 
     // 模型熔断：带覆盖模型的 run 若立即失败（如 UNKNOWN_MODEL——模型在当前网关没配置），记入坏名单回退父级
-    function modelKey(sid, model) { return sid + '|' + model }
+    // modelKey（sid|model 复合键）已拆至 lib/model-health.mjs（拆分第 2 刀 task-mvt8c1yx-2，单源导出——
+    // 熔断名单与健康表熔断判定共用同一键式，上方 import 同源使用）。
 
     var _cachedProvider = null
     function pickProvider() {
@@ -541,6 +362,10 @@ export function createDispatch(ctx, state, deps) {
       var dsnap = await rt(sid)
       if (role === 'worker' || role === 'verifier') {
         var roleKey = role === 'verifier' ? 'verifier' : 'worker'
+        // 目录失效闸数据源（task-mvd3li6）：取一次当前模型目录（llm.listProviders+listModels，与 rpc enumModels
+        // 同源）；null=目录不可得（llm 缺失老宿主/枚举异常/空目录）→ 目录闸整体跳过不误伤（保守语义③，
+        // 既有熔断/冷却/连败软闸照常生效，行为不因宿主能力缺失而变）。
+        var dir = await modelDirectory()
         var cands = []
         var tm = typeof t.model === 'string' ? t.model.trim() : ''
         if (tm) cands.push([tm, 'card'])
@@ -549,12 +374,13 @@ export function createDispatch(ctx, state, deps) {
         var laneCfg = cfg(dsnap).laneModels
         if (sz && laneCfg[sz]) {
           // 档位槽=有序数组（task-mvnxckhq 同档优先序，第一位=首选）：槽内按序取第一个**健康**模型
-          // （healthyModel 双闸：不过 badModels 熔断、不在 modelCooldown 冷却期；偏好序非故障序——
+          // （healthyModel 四闸：不过 badModels 熔断、不在 modelCooldown 冷却期、目录可得时不在目录外
+          // 【目录失效闸 task-mvd3li6】、近期连败未达软闸线【连败软闸 task-mvd3li6】；偏好序非故障序——
           // 首选病即次选赢，不降级不绕链）。槽内全病 → 以首项为代表照常入链，由既有熔断/冷却分支
           // 照旧消费 fallbackModels → 降档 → parent（既有链逐字不动）；空数组槽位=不命中，降下一级。
           var lvList = Array.isArray(laneCfg[sz][roleKey]) ? laneCfg[sz][roleKey] : []
           var lv = ''
-          for (var li = 0; li < lvList.length; li++) { if (healthyModel(sid, lvList[li])) { lv = lvList[li]; break } }
+          for (var li = 0; li < lvList.length; li++) { if (healthyModel(sid, lvList[li], dir)) { lv = lvList[li]; break } }
           if (!lv && lvList.length) lv = lvList[0] // 槽内全病：首项代表入链（既有熔断/冷却分支照旧兜底）
           if (lv) cands.push([lv, 'lane'])
         }
@@ -568,9 +394,13 @@ export function createDispatch(ctx, state, deps) {
         // 留痕：命中即 run.modelSource='fallback' + 卡 messages 记「原模型 X 冷却/熔断，切备用 Y」。
         var fbList = cfg(dsnap).fallbackModels
         for (var mi = 0; mi < cands.length; mi++) {
+          // ===== 目录失效闸（task-mvd3li6）：候选不在当前模型目录（已从宿主配置删除/改名）→ 跳过该候选 =====
+          // 覆盖卡级特例/档位/板级全路径——卡级特例只豁免健康闸（连败软闸/熔断/冷却），**不豁免存在闸**
+          // （原形：本体板已删除的失效模型钉在卡级特例上还在被派）。目录不可得（dir=null）→ 整体跳过不误伤。
+          if (outOfDir(cands[mi][0], dir)) { await traceStaleModel(sid, t.id, cands[mi][0]); continue }
           if (badModels[modelKey(sid, cands[mi][0])]) {
             // 熔断候选：先扫备用链找首个健康者（链本身逐项过健康检查），命中即切备用（不再降下一跳）
-            var fbHit = pickHealthyFallback(sid, fbList)
+            var fbHit = await pickHealthyFallback(sid, fbList, dir, t.id)
             if (fbHit) {
               console.error('[task-board] model ' + cands[mi][0] + ' (' + cands[mi][1] + ' 级) circuited, switch to fallback ' + fbHit)
               try {
@@ -601,7 +431,7 @@ export function createDispatch(ctx, state, deps) {
           if (cdUntil) {
             var cdFrom = modelOverride
             // 冷却候选：同样先扫备用链找首个健康者，链尽才走 C5 降档链
-            var fbCd = pickHealthyFallback(sid, fbList)
+            var fbCd = await pickHealthyFallback(sid, fbList, dir, t.id)
             if (fbCd) {
               modelOverride = fbCd
               modelSource = 'fallback'
@@ -625,6 +455,7 @@ export function createDispatch(ctx, state, deps) {
               var dmList = dl && Array.isArray(dl[roleKey]) ? dl[roleKey] : []
               for (var dmi = 0; dmi < dmList.length; dmi++) {
                 var dm = dmList[dmi]
+                if (outOfDir(dm, dir)) { console.error('[task-board] cooldown 降档候选 ' + dm + ' 不在当前模型目录（配置已失效），继续降档'); await traceStaleModel(sid, t.id, dm); continue }
                 if (badModels[modelKey(sid, dm)]) { console.error('[task-board] cooldown 降档候选 ' + dm + ' 熔断中，继续降档'); continue }
                 if (cooldownLive(dm)) { console.error('[task-board] cooldown 降档候选 ' + dm + ' 同在冷却期，继续降档'); continue }
                 cdPicked = dm; break
@@ -767,7 +598,8 @@ export function createDispatch(ctx, state, deps) {
       // hold 终止据此 dispose 销毁子会话（老契约路径无 activation，act=null，保持 interrupt 留存）。
       var rec = useContinuable
         ? { id: childId, childId: childId, continuable: true, ran: false, run: null, act: actForSettle, role: role, taskId: t.id, startedAt: Date.now(), model: modelOverride, modelSource: modelSource, size: laneSize || undefined, settled: false }
-        : { id: String(run.id), run: run, role: role, taskId: t.id, startedAt: Date.now(), model: modelOverride, modelSource: modelSource, size: laneSize || undefined, settled: false }
+        // activation 的 run.id=act.childId，可接 assistant-stream；老 start 的 run.id=provider run id，留空走日志闸。
+        : { id: String(run.id), frameSessionId: hasActivationApi(subagents) ? String(run.id) : '', run: run, role: role, taskId: t.id, startedAt: Date.now(), model: modelOverride, modelSource: modelSource, size: laneSize || undefined, settled: false }
       // ===== 新宿主 continuable 结算兜底臂（v0.2.1 实证 2026-10-24：activation.result 只认拆除落定）=====
       // 原形：rate-limit 子会话 turn/end error → 管理器拆除 activation → result 落定——
       // 但 agent/status 事件面在 v0.2.1 的 Scoped 事件体系下对插件全局订阅不再可达（子会话死亡 8 分钟零结算实证），
@@ -775,10 +607,11 @@ export function createDispatch(ctx, state, deps) {
       // （正常完成 parked-idle 不落定、不误伤续跑）——把它接上就是失败/拆除场景的零事件依赖结算通道。
       // rec.settled 首胜旗与事件/超时/上报三通道共用：先到先结，后到被挡。
       // 归属不变式（task-mvnyk55n 驳回根修）：「rec 被摘出 runsFor 活跃表 ⇒ 摘除点已同步立
-      // rec.settled」对全部摘除路径成立（落闸弃权 646 / 续跑弃权 838 / settleRun 各入口
-      // finish 698·事件 1299 / settleReportedRun 1262 / 幽灵清扫 1735 / doTerminate 摘表即立——
+      // rec.settled」对全部摘除路径成立（落闸弃权臂 / 续跑弃权臂 / settleRun 的 finish 臂与事件臂
+      // （lib/settle.mjs）/ settleReportedRun（lib/settle.mjs）/ 幽灵清扫 / doTerminate 摘表即立——
       // 后者正是本次补上的缺口：hold 终止的 dispose 落定 result 时本臂若抢结，会把手动终止
       // 误记成 Worker 失败）。因此本臂的 settled 判即归属守卫，无需再判表项在否。
+      // （各臂按函数名定位；本文件历次拆分后行号持续漂移，此注释不再钉行号。）
       if (useContinuable && actForSettle && actForSettle.result && typeof actForSettle.result.then === 'function') {
         actForSettle.result.then(function (res) {
           if (rec.settled) return
@@ -787,11 +620,12 @@ export function createDispatch(ctx, state, deps) {
           // diagnostic 截断放宽 120→400（task-mvneq4kk）：glm 等供应商的 429 报错「限额将在 YYYY-MM-DD HH:mm:ss
           // 重置」结构化文本常超 120 字符，截太短会把重置时间切掉 → RATE_LIMIT 嗅探只能退 30min 缺省。
           var errText = '子会话被宿主拆除（stopReason: ' + stopReason + (res && res.diagnostic ? '，' + String(res.diagnostic).slice(0, 400) : '') + '）'
-          settleWorker(sid, rec, '', true, errText).catch(function (e) { console.error('[task-board] activation 拆除结算失败 (task ' + rec.taskId + '):', String(e)) })
+          // settleWorker 调用点重指 settle.settleWorker（拆分第 6 刀：函数已搬入 settle.mjs，从工厂返回集导出）
+          settle.settleWorker(sid, rec, '', true, errText).catch(function (e) { console.error('[task-board] activation 拆除结算失败 (task ' + rec.taskId + '):', String(e)) })
         }, function (err) {
           if (rec.settled) return
           rec.settled = true
-          settleWorker(sid, rec, '', true, '子会话 activation 异常：' + String(err && err.message || err).slice(0, 200)).catch(function (e) { console.error('[task-board] activation 异常结算失败 (task ' + rec.taskId + '):', String(e)) })
+          settle.settleWorker(sid, rec, '', true, '子会话 activation 异常：' + String(err && err.message || err).slice(0, 200)).catch(function (e) { console.error('[task-board] activation 异常结算失败 (task ' + rec.taskId + '):', String(e)) })
         })
       }
       // ⚠️ spawn 返回 → 登记 rec 必须**零 await**（既有纪律）：continuable 子会话的 running→idle 事件
@@ -865,7 +699,7 @@ export function createDispatch(ctx, state, deps) {
       var startedAt = rec.startedAt
       var softMs = c.softTimeoutMin * 60000
       var hardMs = c.hardTimeoutMin * 60000
-      function finish(res, err) { if (rec.settled) return; rec.settled = true; settleRun(sid, rec, res, err) }
+      function finish(res, err) { if (rec.settled) return; rec.settled = true; settle.settleRun(sid, rec, res, err) }
       function disarmTimeouts() {
         if (rec.timersDisarmed) return
         rec.timersDisarmed = true
@@ -945,9 +779,14 @@ export function createDispatch(ctx, state, deps) {
       // 已被熔断/冷却时照样续跑（实证：病模型续跑 38 分钟零产出）。修：续跑前查目标会话模型健康
       // （badModels 熔断 + modelCooldown 冷却，healthyModel 双闸同款），病模型 → 放弃续跑返回 fallback，
       // 调用方落回 fresh spawn 走健康取模链（链自动跳过病模型），原因随 resume-fallback 消息留档。
+      // task-mvd3li6 起健康面拓宽同款适用：近期连败软闸（recentRuns ≥2 全败）+ 目录失效闸（原模型
+      // 已从模型目录移除，续跑也救不回已删模型）一并拦下；目录不可得（dir=null）时目录闸跳过不误伤。
       var origModel = resumeModelOf(t)
-      if (origModel && !healthyModel(sid, origModel)) {
-        return { fallback: '续跑放弃：原模型 ' + origModel + ' 熔断/冷却中（续跑健康闸）——改走健康取模链重跑' }
+      if (origModel) {
+        var dir = await modelDirectory()
+        if (!healthyModel(sid, origModel, dir)) {
+          return { fallback: '续跑放弃：原模型 ' + origModel + ' 熔断/冷却/近期连败或配置已失效（续跑健康闸）——改走健康取模链重跑' }
+        }
       }
       var parent = rootForSession(sid)
       if (!parent) return { fallback: 'root 会话不在线，无法授权续跑' }
@@ -1082,7 +921,7 @@ export function createDispatch(ctx, state, deps) {
           }
           rec.settled = true // 先立旗：堵迟到的 idle/超时臂重入（与事件臂同一纪律）
           console.error('[task-board] 续跑会话已不存在（sendMessage 后活跃目录未命中，死会话哨兵），立即失败重派 task ' + rec.taskId + ' child ' + rec.childId)
-          settleRun(sid, rec, null, new Error('续跑会话已不存在（sendMessage 后未在活跃目录命中，死会话哨兵）'))
+          settle.settleRun(sid, rec, null, new Error('续跑会话已不存在（sendMessage 后未在活跃目录命中，死会话哨兵）'))
         }
         var q
         try { q = subagents.listChildren(sid) } catch (e) { return }
@@ -1094,895 +933,38 @@ export function createDispatch(ctx, state, deps) {
       rec.deathDispose = function () { try { if (typeof h === 'function') h() } catch (_) {} }
     }
 
-    // run 结算：保证收尾；工具通道（board_report/board_verdict）已推进状态的话文本路径跳过
-    // ===== 结算收尾三件套（task-muwkhqf8）=====
-    // 无论从哪条入口进来（事件通道 settleContinuable / 上报通道 board_report），run 记录的收尾动作
-    // 必须一致：①关 run 结局（closeRunHistory）②usage 落账（seq 水位线增量）③摘除软/硬超时臂。
-    // 三条各自幂等：重复结算（idle 事件重入 / 上报与事件双通道先后到达）不二次关账、不二次记账。
-    // ===== 结算≠停止根修（task-mv8wuznb，ontology 实证 2026-10-15：卡 02:02 已 resolved、verdict 已落账，
-    // verifier 子会话却持续写盘空转到 10:16 被主窗口手杀——8 小时空烧）=====
-    // 病根：一次性 run 的 settle 只关账（dispose 只释放本地 run 句柄，不停子会话的 agent loop）——
-    // verifier 调完 board_verdict 后 turn 未结束（继续探索/循环），会话持续空转烧 token。
-    // 一次性子代理「结算即销毁」是设计语义，这里补齐销毁的半步：结算落定后对该 run 的子会话补一枪
-    // interrupt（与 endContinuable 同款 authority 形状，fire-and-return 同步发信号即返回）。
-    // 挂载点取 settleRunRecord 末尾 = 所有一次性落定路径的唯一汇合点（settleRun 的
-    // completed/failed/incomplete、幽灵回收 reapGhostRecs 的收尾都经这里）——含事故原形
-    // 「board_verdict 落账 → 卡 resolved → rec 下轮被幽灵回收」那条（rec 在表外时 settleRun 根本跑不到）。
-    // 边界（零改动）：hook 点位不在本卡范围；重复 interrupt 无害（取消信号幂等）。continuable 豁免经
-    // task-mvbeallq 收紧：原「continuable 即跳」过宽（无续跑位的残影借豁免续跑），现仅「续跑位真在
-    // 本 child 手上」才放行，其余 continuable 落定同样补停——收紧细则与竞态论证见函数头注释。
-    // 失败只 console.error：结算已落定，残留空转只影响 token 不影响正确性（与 terminate 的 killFail
-    // 告警分级不同——那是用户显式要杀，这里是收尾补强）。
-    async function stopSettledOneShot(sid, rec) {
-      if (!rec || !rec.id) return
-      if (rec.role !== 'verifier' && rec.role !== 'worker') return // 只对 verifier 与 worker 动手
-      var subagents = ctx.subagents
-      if (!subagents || typeof subagents.interrupt !== 'function') return // 老宿主/老测试桩无此能力：逐字不变
-      var parent = rootForSession(sid)
-      if (!parent) return // 无活 root 可授权（root 已死/重建窗口）→ 跳过，结算语义不受影响
-      // ===== continuable 豁免收紧（task-mvbeallq，残影治理①）=====
-      // 原闸门「rec.continuable 即跳」过宽：continuable 但**已无续跑位**的落定——completed（resumeTarget
-      // 只认超时/失败结局）/ noResume 落旗（reap 失败）/ 卡面最新 worker 留档已被更新的 run 取代
-      // （池故障后主窗口重派了新 Worker）——借豁免续跑就是残影（ontology 实证：旧子会话残影续跑 5 分钟
-      // 逐文件推进，与新 Worker 差点同批文件互踩）。interrupt 对 continuable 只打断 turn、不销毁会话
-      // （endContinuable 同款语义），补停安全。豁免只剩「续跑位真在本 child 手上」两种形态：
-      //   ① 本卡活跃表已有接管**同一子会话**的新 rec——续跑在途，此刻打断会杀掉刚复活的新 turn。
-      //      （续跑路径纪律：sendMessage 返回后**零 await**先登记 rec 再追加续跑留档，故新 turn 全程
-      //      被本形态覆盖；不同 id 的新 rec=fresh spawn 新 Worker，不豁免——旧残影照停。）
-      //   ② 锁外新鲜快照上 resumeTarget 仍指向本 child——续跑位未被消费，下轮重派会冷复活它。
-      //      （豁免判定必须读新鲜快照：结算刚关账，只有自己内存里的 rec 不足以判定留档次序——
-      //      幽灵回收路径上卡面可能已有更新的 worker 留档。）
-      // 两形态之外一律补停；快照读不到（t=null）按「无续跑位」处理——宁停勿留残影。
-      if (rec.continuable) {
-        var cur = runsFor(sid)[rec.taskId]
-        if (cur && String(cur.id) === String(rec.id)) return // ① 续跑在途（新 rec 接管同一子会话）
-        var t = null
-        try {
-          var dsnap = await rt(sid)
-          if (dsnap && Array.isArray(dsnap.tasks)) { for (var ti = 0; ti < dsnap.tasks.length; ti++) { if (dsnap.tasks[ti] && dsnap.tasks[ti].id === rec.taskId) { t = dsnap.tasks[ti]; break } } }
-        } catch (_) { t = null }
-        if (t && resumeTarget(t) === String(rec.id)) return // ② 续跑位在手：留存会话供冷复活
-      }
-      try {
-        subagents.interrupt(String(rec.id), { kind: 'ancestor', agent: parent })
-      } catch (e) {
-        console.error('[task-board] 一次性 run 结算后 interrupt 子会话失败（会话可能仍在空转，只影响 token）task ' + rec.taskId + ' child ' + rec.id + ':', String(e))
-      }
-    }
-
-    async function settleRunRecord(sid, rec, opts) {
-      // ① 结局落卡：failed → 有 err 记 timeout/error，无 err 记 incomplete（与一次性路径口径一致）；
-      //    成功 → completed。noResume 旗随 rec.resumeBlocked（interrupt 失败）落卡。
-      try {
-        await closeRunHistory(sid, rec.taskId, String(rec.id), opts.outcome, rec.continuable ? { noResume: rec.resumeBlocked === true } : null)
-      } catch (e) { console.error('[task-board] closeRunHistory 收尾失败 (task ' + rec.taskId + '):', String(e)) }
-      // 统一健康表被动面：每个可归因 run 落定都记最近 5 次成败与本次延迟；父模型 id 不可知则跳过。
-      if (rec.model) observeModel(sid, rec.model, opts.outcome === 'completed', { latencyMs: Math.max(0, Date.now() - Number(rec.startedAt || Date.now())) })
-      // 熔断连击归零（task-mvowb2hc 洞①）：连击只在「连续」语义内计数——任一可归因 run 正常完成
-      // 即证明模型链路恢复，清零重新计数（失败落定不动连击，也归不了零）。
-      if (rec.model && opts.outcome === 'completed') resetModelFailure(sid, rec.model)
-      // ② usage 落账：读该次 run 的 v4 日志聚合（水位线增量），累加到任务。放在状态推进之后：
-      //    统计是附加信息，读日志失败/无 usage 时静默跳过，绝不影响结算语义。
-      //    Worker 失败重试、驳回重做都会各走一次 settleRun，因此多轮消耗天然累加（runs 计数）。
-      try { await accumulateRunUsage(sid, rec) } catch (e) { console.error('[task-board] usage 收尾失败 (task ' + rec.taskId + '):', String(e)) }
-      // ③ 摘除两级超时臂：软臂不再刷假告警，硬臂不再对已结算的闲置会话补一枪 interrupt。
-      try { if (typeof rec.disarm === 'function') rec.disarm() } catch (_) {}
-      // ② settle 通道心跳（运行时健康自检）：三件套各自幂等且各自 catch 永不抛，
-      // 走到这里即「一次成功结算活动」——rpc 侧据此判定「结算通道 >30min 无活动」黄条。
-      poolHealthFor(sid).settleLastOkAt = Date.now()
-      // ④ 结算≠停止根修（task-mv8wuznb）：落定后主动 interrupt 子会话，堵「结算≠停止」空转洞。
-      // task-mvbeallq 起改 async（continuable 豁免收紧需读锁外快照算 resumeTarget）——interrupt 本身
-      // 仍是同步信号 fire-and-return；闸门与 try/catch 全在函数内/调用处，绝不阻断/改变结算语义；
-      // 续跑位在手的 continuable 与 hook 在函数内被原样放行（豁免边界见函数头注释）。
-      try { await stopSettledOneShot(sid, rec) } catch (e) { console.error('[task-board] 结算后补停子会话异常（不影响结算）task ' + rec.taskId + ':', String(e)) }
-    }
-
-    // ===== 拆解官结算（task-mvnenrwk）：host 读 result.structured 物化 draft 子卡 =====
-    // 三分支：verdict=split → applyDecomposeProposal 物化（幂等清旧批 draft 提案）+ 源卡摘要消息 + 通知；
-    //         verdict=keep → 源卡记「无需拆分：rationale」；
-    //         run 失败 / structured 缺失 / 提案畸形 → 源卡记失败原因 + 通知（源卡与旧提案批都不动）。
-    // 通知走 pushSysNote 且**不带 taskId**：源卡停在 draft/pending，带 taskId 的系统通知会在回执冲刷时
-    // 被「任务仍在执行中」过滤器整行丢弃（notify.mjs deliver 段）——提案到位是必须送达的信号。
-    async function settleDecompose(sid, rec, res, err) {
-      var failed = !!err || (res && res.stopReason && res.stopReason !== 'completed')
-      var errText = err ? String(err) : (res && (res.diagnostic || res.stopReason) || '')
-      var structured = (res && res.structured && typeof res.structured === 'object') ? res.structured : null
-      var applied = null
-      try {
-        applied = await mutateLocked(sid, function (d) {
-          var t = d.tasks.find(function (x) { return x.id === rec.taskId })
-          if (!t) return null
-          if (!Array.isArray(t.messages)) t.messages = []
-          if (failed) {
-            t.messages.push({ kind: 'decompose', text: '🧩 拆解官 run 失败（' + String(errText || '未知错误').slice(0, 200) + '）——源卡未改动，可重试 task_decompose', at: new Date().toISOString(), by: 'system' })
-            return { ok: false, failed: true }
-          }
-          if (!structured) {
-            t.messages.push({ kind: 'decompose', text: '🧩 拆解官未返回结构化提案（structured 缺失，可能宿主/provider 不支持 outputSchema）——源卡未改动，可重试 task_decompose', at: new Date().toISOString(), by: 'system' })
-            return { ok: false, failed: true }
-          }
-          return applyDecomposeProposal(d, t, structured, new Date().toISOString())
-        }, true) // skipKick：物化的是 draft 子卡（不参与派发），无需踢 poolCycle
-      } catch (e) { console.error('[task-board] settle decompose failed (task ' + rec.taskId + '):', String(e)); applied = null }
-      try {
-        if (applied && applied.ok && applied.verdict === 'split') pushSysNote(sid, '🧩 拆解提案已就位（' + applied.children.length + ' 张草稿子卡，源卡 ' + rec.taskId + '），确认后逐张 publish')
-        else if (applied && applied.ok && applied.verdict === 'keep') pushSysNote(sid, '🧩 拆解官判定源卡（' + rec.taskId + '）无需拆分，理由已落源卡消息')
-        else pushSysNote(sid, '🚨 拆解官 run 未产出可用提案（源卡 ' + rec.taskId + '）：' + String((applied && applied.error) || errText || 'structured 缺失').slice(0, 200))
-      } catch (e) { console.error('[task-board] decompose notify failed:', String(e)) }
-    }
-
-    async function settleRun(sid, rec, res, err) {
-      if (runsFor(sid)[rec.taskId] !== rec) return // 已被 terminate 等路径处理
-      delete runsFor(sid)[rec.taskId]
-      // 收尾分路（卡2）：一次性 run 走 dispose（既有语义逐字不变）；continuable 走 interrupt——
-      // **只打断当前 turn，不销毁子会话**（Activation/未认领收件箱/已发布后代全部保留），
-      // idle 后仍可被 sendMessage 冷复活，这正是重派续跑的前提。
-      try {
-        if (rec.continuable) await endContinuable(sid, rec)
-        else await rec.run.dispose()
-      } catch (_) {}
-      var output = outputText(res)
-      var failed = !!err || (res && res.stopReason && res.stopReason !== 'completed')
-      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 if (rec.role === 'decomposer') await settleDecompose(sid, rec, res, err)
-        else await settleVerifier(sid, rec, output, failed, errText)
-      } catch (e) { console.error('[task-board] settle ' + rec.role + ' failed (task ' + rec.taskId + '):', String(e)) }
-      // 历史会话留档 + usage + 超时臂收尾：三件套抽到 settleRunRecord（上报通道共用同一实现）。
-      // 结局同时是**续跑资格**的唯一依据（continuable + timeout/error|incomplete → 下次重派改续跑），
-      // noResume 旗（interrupt 失败）一并落卡，让重派直接回退 fresh spawn。
-      // ⚠️ 位置在状态推进**之后**：rec.resumeBlocked 由 endContinuable 在推进前写好，这里读到的才是终值。
-      await settleRunRecord(sid, rec, { outcome: failed ? (err ? 'timeout/error' : 'incomplete') : 'completed' })
-    }
-
-    // ===== 可续跑 Worker 的 turn 结算（task-muw5gnhv 卡1；卡2 加续跑基线）=====
-    // 与一次性路径的关系：任务推进语义**完全复用** settleWorker（board_report 工具优先、文本兜底同构），
-    // 差别只在「怎么知道 turn 完了」与「怎么收尾」：
-    //   · 一次性：run.result 落定 → settleRun(res,err)（有结构化结果/失败原因）；
-    //   · continuable：没有 run.result，只能靠 host 事件 agent/status 的 running→idle 观测 turn 结束
-    //     （见 onAgentStatus）。因此这里没有 res：输出文本从子会话 v4 日志尾部的 assistant/message 兜底读；
-    //     日志读不到且文本为空时按失败结算（走 pending 重试），**绝不当成「空完成」推进到 verifying**——
-    //     否则一次「没跑起来就 idle」的事件会把任务误判为有交付物。
-    // 收尾三件套（关 run 结局 / usage 落账 / 摘超时臂）不在本函数里单独写一遍，而是随 settleRun →
-    // settleRunRecord 一起做——它与上报通道（board_report → settleReportedRun）共用同一实现
-    // （task-muwkhqf8）：两条入口只是「谁来触发」，收尾口径必须只有一套。
-    async function settleContinuable(sid, rec) {
-      if (runsFor(sid)[rec.taskId] !== rec) return // 已被 terminate/硬超时等路径认领
-      var text = ''
-      // 续跑轮（rec.baselineBytes>0）只读基线之后的字节：本轮没写东西就是空文本 → 按失败重排，
-      // 不会把上一轮（被中断那次）残留的助手文本冒充成本轮交付物（同一条失败臂，语义不变）。
-      try { text = childSessionOutput(rec.childId, rec.baselineBytes) } catch (e) { console.error('[task-board] continuable 输出读取失败 (' + rec.childId + '):', String(e)) }
-      if (!text.trim()) console.error('[task-board] continuable child ' + rec.childId + ' idle 但未读到 assistant 文本，按失败结算（任务 ' + rec.taskId + '）')
-      await settleRun(sid, rec, { output: [{ type: 'text', text: text }], stopReason: text.trim() ? 'completed' : 'error' }, null)
-    }
-
-    // continuable 子会话的收尾（卡2：**interrupt 留存，不销毁**）——
-    // 失败/硬超时结算时只发一个取消信号打断当前 turn：Activation、未认领的收件箱、已发布后代全部保留，
-    // 子会话 idle 后仍能被 sendMessage 冷复活（Step2 续跑的前提）；一次性路径的 dispose 不动。
-    // authority 形状取 dsh-subagent 的 SubagentInterruptAuthority：{kind:'ancestor', agent: 活的直接父 Agent}；
-    // 该调用同步 fire-and-return（发完取消信号即返回，目标可能到下一个可观察点才真正停下）。
-    // interrupt 失败（会话已死 / 权限不符 / 宿主无此能力）→ **绝不阻断结算**：任务照常回 pending 重排；
-    // 只给 rec 立 resumeBlocked 旗 → 该 run 落 noResume 标记，重派时直接 fresh spawn（不空唤醒、不卡死）。
-    async function endContinuable(sid, rec) {
-      if (!rec || !rec.childId) return rec
-      var subagents = ctx.subagents
-      if (!subagents || typeof subagents.interrupt !== 'function') return rec
-      var parent = rootForSession(sid)
-      if (!parent) { rec.resumeBlocked = true; return rec }
-      try {
-        subagents.interrupt(rec.childId, { kind: 'ancestor', agent: parent })
-      } catch (e) {
-        rec.resumeBlocked = true
-        console.error('[task-board] interrupt 失败，该子会话不再续跑（重派回退 fresh spawn）child ' + rec.childId + ':', String(e))
-      }
-      return rec
-    }
-
-    // 读子会话 v4 日志尾部的助手文本（continuable 路径的文本兜底通道）：
-    // 与 rpc.mjs agent-activity 同一套 helper/事件形状（assistant/message.content[].text），
-    // 只是这里要的是**最后一条完整助手文本**（供 settleWorker 解析分段格式 / [ESCALATE]）。
-    // 只读尾部 2MB：回复在末尾，整份读大日志会拖慢结算路径；读不到一律返回 ''（调用方按失败处理）。
-    // minBytes > 0（续跑轮）：只读文件该偏移之后的字节——帧从新到旧，切在半帧上的那一帧由
-    // readLogFrames 逐帧 catch 降级丢弃；本轮没产出任何助手文本就返回 ''（走「空文本按失败」）。
-    function childSessionOutput(childId, minBytes) {
-      if (!childId) return ''
-      // 与 logSizeOf/readRunUsage 同源：显式带上 sessionsRoot（生产注入 undefined → 回退 os.homedir()，
-      // 与本次改造前逐字一致；单测注入临时目录时才读得到真日志——此前漏传会让「文本兜底」这一路永远读空）。
-      var log = findRunLog(childId, sessionsRoot)
-      if (!log) return ''
-      var tail = 2 * 1024 * 1024
-      if (typeof minBytes === 'number' && minBytes > 0) {
-        var sz = 0
-        try { sz = statSync(log).size || 0 } catch (_) { sz = 0 }
-        if (sz <= minBytes) return '' // 续跑基线之后一个字节都没写 → 本轮没有交付物
-        tail = sz - minBytes
-      }
-      var buf = readLogBytes(log, tail)
-      if (!buf) return ''
-      var frames = readLogFrames(buf, 0)
-      var out = ''
-      for (var fi = 0; fi < frames.length; fi++) {
-        var evs = frames[fi]
-        for (var i = 0; i < evs.length; i++) {
-          var e = evs[i]; var dta = (e && e.data) || {}
-          if (!e || e.type !== 'assistant/message') continue
-          var msg = dta.message || {}
-          var blocks = Array.isArray(msg.content) ? msg.content : []
-          var parts = []
-          for (var b = 0; b < blocks.length; b++) { if (blocks[b] && blocks[b].type === 'text' && blocks[b].text) parts.push(String(blocks[b].text)) }
-          if (parts.length) out = parts.join('\n') // 帧从新到旧：最后命中覆盖前值 → 得到最新一条助手文本
-        }
-      }
-      return out
-    }
-
-    // 本地日期 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)
-    }
-
-    // ===== usage 增量水位线（卡3 Step1）：这一轮该从哪个 seq 之后继续累加 =====
-    // 读同一 rec.id 的历史 runs 条目上落的水位线（runs[i].usageSeq = 上次结算时该会话日志的 maxSeq）。
-    // 为什么锚在 runs 条目而不是内存表：重启后内存表清零而卡上留档还在，续跑轮才能接着上次水位；
-    // 且同一 childId 的多次派发各占一条 runs（resume 轮追加新条目），水位随条目天然分段、互不串账。
-    // ⚠️ 倒序找到「同 id 的条目」还不能停：**续跑轮的新条目与旧条目同 id**（同一会话），新条目此时
-    // 还没结算过、usageSeq 未设——必须继续往前找第一条**已结算过**（usageSeq > 0）的条目，否则水位线
-    // 恒为 0 → 每轮都把整份日志重算一遍（本实现踩过的坑，实测总量双倍 25 而非 15）。
-    // 一条都没有（首次结算 / 手写裁剪过的老任务）→ 0 = 全量累加（与本次改造前逐字一致）。
-    function seekSeqOf(snap, taskId, runId) {
-      try {
-        var tasks = (snap && snap.tasks) || []
-        for (var ti = 0; ti < tasks.length; ti++) {
-          var t = tasks[ti]
-          if (!t || t.id !== taskId || !Array.isArray(t.runs)) continue
-          for (var ri = t.runs.length - 1; ri >= 0; ri--) {
-            var r = t.runs[ri]
-            if (!r || String(r.id) !== String(runId)) continue
-            var w = num0(r.usageSeq)
-            if (w > 0) return w
-          }
-        }
-      } catch (_) {}
-      return 0
-    }
-    // 水位线字段兜底成非负数字（脏值/老形态一律当 0 = 全量，宁可多记也不误丢）
-    function num0(v) { var n = Number(v); return isFinite(n) && n > 0 ? n : 0 }
-
-    // 该 run 记录是否已落过 usage（usageRecorded 旗）：倒序找同 id 的条目，见旗即真。
-    // 判据为什么要**同一 childId 复用**（而不是只认最新条目）：continuable 的续跑轮与首轮共用同一个
-    // 子会话 id，closeRunHistory 会把每一轮的条目都更新成终局——「最新那条」在续跑轮结算时正是本轮
-    // 新建的那条（usageRecorded 未置，照常记账）。真重复结算（事件通道与上报通道都来/上报后 idle 补到）
-    // 时最新条目就是那份已记账的旧条目 → 见旗即跳过。两处语义互斥，同一判据够用，不需要另立新字段。
-    function hasUsageRecorded(snap, taskId, runId) {
-      try {
-        var tasks = (snap && snap.tasks) || []
-        for (var ti = 0; ti < tasks.length; ti++) {
-          var t = tasks[ti]
-          if (!t || t.id !== taskId || !Array.isArray(t.runs)) continue
-          for (var ri = t.runs.length - 1; ri >= 0; ri--) {
-            var r = t.runs[ri]
-            if (!r || String(r.id) !== String(runId)) continue
-            return r.usageRecorded === true // 同 id 的最新条目就是本轮该结算的那条
-          }
-        }
-      } catch (_) {}
-      return false
-    }
+    // 拆解官结算（settleDecompose）已拆至 lib/settle.mjs（拆分第 6 刀 task-mvt8c1yx-6）：
+    // settleRun 分路模块内直调，本文件不再持有角色结算函数（settleWorker/settleVerifier/settleHook 同批搬出）。
 
-    // 把一次 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（宁可展示上标 ~ 近似，也不伪造一个「有效值」）。
-    // 增量口径（卡3 Step1）：结算前先读一次看板取该 run 的历史水位线（seekSeqOf），只把这之后的
-    // assistant/message 增量计入；累加时把本份日志的 maxSeq 一并落到该 runs 条目上（下一轮从这继续）。
-    // one-shot 路径（每 run 独立日志、永远找得到自己的条目且首次无水位）→ 行为逐字不变：全量累加一次。
-    async function accumulateRunUsage(sid, rec) {
-      var u = null
-      var since = 0
-      try {
-        var snap0 = await rt(sid)
-        since = seekSeqOf(snap0, rec.taskId, rec.id)
-        // 幂等（task-muwkhqf8）：该条 run 记录已落过账 → 直接跳过。为什么需要它：continuable 的 run 现在有
-        // 两条结算入口（事件通道 + board_report 上报通道），且两条可能在「先读到快照、后持锁写」的窗口里
-        // 交错——只靠水位线挡不住同一次结算被记两笔（两次都读到同一旧快照）。旗与累加在同一持有锁回调里
-        // 写，读序天然串行。判据只看**同 id 的最新条目**（见 hasUsageRecorded：续跑轮新条目未置旗，照常记账）。
-        if (hasUsageRecorded(snap0, rec.taskId, rec.id)) return
-        u = readRunUsage(String(rec.id), sessionsRoot, since)
-      } 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 })
-          if (!t) return null
-          if (!t.usage) t.usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0, runs: 0, models: {} }
-          // 逐字段兜底 0：脏数据（半写/老形态）也不会把 NaN 带进看板（NaN 会让工具输出的 lossless-JSON 校验拒整条结果）
-          t.usage.input = (t.usage.input || 0) + u.input
-          t.usage.output = (t.usage.output || 0) + u.output
-          t.usage.cacheRead = (t.usage.cacheRead || 0) + u.cacheRead
-          t.usage.cacheWrite = (t.usage.cacheWrite || 0) + u.cacheWrite
-          t.usage.total = (t.usage.total || 0) + u.total
-          t.usage.runs = (t.usage.runs || 0) + 1
-          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 更新结局，
-          // 正常结算路径必存在；只有手写/裁剪过的历史任务会缺，缺了也不该阻断聚合累加。
-          // 置位 usageRecorded = 该条 run 已落账（幂等旗，见函数头注释与 hasUsageRecorded）：
-          // 与累加同一次持有锁写，读侧据此挡住「同一结算被两条入口各记一笔」。
-          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.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 }
-                // 水位线落卡（卡3 Step1）：本份日志已结算到 maxSeq；续跑轮再结算时只认这之后的帧。
-                // 只增不减（max 收敛）：异常情况下读到较小值也不让水位倒退（倒退＝把已结算帧再记一遍）。
-                t.runs[ri].usageSeq = Math.max(num0(t.runs[ri].usageSeq), num0(u.maxSeq))
-                t.runs[ri].usageRecorded = true
-                // 模型补落账（task-muxhshfu 记分卡卡1①）：派发未显式覆盖模型时条目 model=''，
-                // 而日志 request/context 里记着真实模型（u.model，与任务级 u.models 小计同源）——
-                // 结算时顺手回填，记分卡卡2 的「模型×场景」聚合就不必再走按任务级占比摊派的近似路径。
-                // 只填空不覆盖：派发显式覆盖的模型名优先（aggregateUsageSummary 模型 key 同一优先序）。
-                if (!t.runs[ri].model && u.model) t.runs[ri].model = String(u.model)
-                break
-              }
-            }
-          }
-          t.usage.updatedAt = new Date().toISOString()
-          return { ok: true }
-        })
-      } catch (e) { console.error('[task-board] usage accumulate failed (task ' + rec.taskId + '):', String(e)) }
-    }
-
-    // ===== 上报通道结算入口（task-muwkhqf8 回归修复的第二条入口）=====
-    // 病根：continuable Worker 的 run 记录此前**只有事件通道**会收尾（agent/status 的 running→idle →
-    // settleContinuable → settleRun）。但 Worker 通过 board_report 工具上报完成时，任务状态已被工具通道
-    // 推进到 verifying/resolved——此时若该 turn 的 idle 事件没被观测到（rec.ran 二次守卫挡下的伪 idle、
-    // 驱动未接上的冷窗口、宿主重启、idle 事件丢失），run 记录就永久停在 outcome='running'：
-    //   ① 软超时臂对它误报（实证：已完成的 run 收到「worker 已运行 30 分钟仍未完成」）；
-    //   ② usage 不落账（仪表盘漏计这轮消耗）；
-    //   ③ 硬超时臂到期还对一条早已结算的闲置会话补一枪 interrupt（噪音 + 误导）。
-    // 解法：board_report/board_verdict 把任务推进到落定态（verifying/resolved）时，顺带调本函数——
-    // 对**该任务当前的 continuable Worker rec**补做收尾三件套（关 run 结局 / usage 落账 / 摘超时臂），
-    // 与事件通道共用 settleRunRecord（同一实现，杜绝两条路各写一套口径）。
-    // 三点边界：
-    //   · 只认 continuable 且 role==='worker' 的活跃 rec：verifier/hook 是一次性 run。它们的 run.result
-    //     落定后 settleRun 会照常收尾；手动终止路径**刻意**不关 run（保留 running = 不留续跑资格），此处不碰。
-    //   · 摘除活跃表项：任务已落定，这张卡不该再占 Worker 并发位；否则 poolCycle 的 activeW 会把它算成
-    //     在跑的 Worker（幽灵占位）。子会话由 settleRunRecord 末尾的 stopSettledOneShot 补停
-    //     （task-mvbeallq：completed 落定天然无续跑位——resumeTarget 只认超时/失败结局——「续跑豁免」
-    //     留下的就是残影续跑窗；补停只打断 turn 不销毁会话，与 endContinuable 同款语义）。
-    //   · 幂等：closeRunHistory 只关 outcome==='running' 的条目、accumulateRunUsage 认 usageRecorded 旗、
-    //     rec.disarm 幂等——重复上报 / 上报后 idle 事件补到，都不会二次关账或二次记账。
-    // 老宿主/没接线的调用方：deps 里没有这个函数时 rpc 侧静默跳过，行为与本次改造前逐字一致。
-    async function settleReportedRun(sid, taskId, opts) {
-      var rec = runsFor(sid)[taskId]
-      if (!rec || !rec.continuable || rec.role !== 'worker') return false
-      if (runsFor(sid)[rec.taskId] !== rec) return false
-      delete runsFor(sid)[rec.taskId] // 与 settleRun 同口径：先摘活跃表项，堵住并发重入
-      rec.settled = true
-      await settleRunRecord(sid, rec, { outcome: (opts && opts.outcome) || 'completed' })
-      return true
-    }
+    // usage 水位与落账（localDayKey/effectiveOf/seekSeqOf/num0/hasUsageRecorded/accumulateRunUsage）已拆至
+    // lib/settle.mjs（拆分第 7 刀 task-mvt8c1yx-7）：settleRunRecord 改模块内直调，return API 的
+    // accumulateRunUsage 懒绑定重指 settle 实例（index.mjs 消费面零变化）。
 
-    // ===== host 事件订阅：agent/status（continuable Worker 的 turn 结算触发器，task-muw5gnhv 卡1）=====
-    // 事件契约（host Event 目录实证）：'agent/status'(payload: { agent, status: 'idle'|'running' })。
-    // 「子代理 turn 完成」在事件面就是 running→idle；continuable 没有 run.result promise，故这是唯一可靠的
-    // 结算信号。订阅形态：ctx.on（本插件 host 侧首个事件订阅点），一律走 ctx.effect 回收——
-    // 插件卸载/HMR 重载时监听器必须随之注销，否则重载后同一事件会被多份旧闭包重复结算（重复结算虽被
-    // rec.settled / runsFor 认领双重挡住，但旧闭包里过期的 state 引用本身就是内存泄漏）。
-    // 二次守卫 rec.ran：只有**观测到过 running** 的 rec 才允许被 idle 结算。理由：startContinuable 返回后
-    // 子会话可能先报一个瞬时 idle（驱动尚未接上/冷复活窗口），若拿它结算，任务会以「空文本」被推进/回退。
-    // 真实 turn 必然先 running 后 idle，因此该守卫只挡伪 idle，不挡正常结算。
-    function onAgentStatus(payload) {
-      try {
-        // ⚠️ 不能在此只放行 idle：running 事件正是 rec.ran 的唯一来源（见下方守卫），
-        // 早退会让 rec.ran 永远 false → idle 永远不结算（任务只能等硬超时）——本实现踩过的坑。
-        var status = payload && payload.status
-        if (status !== 'idle' && status !== 'running') return
-        var agent = payload.agent
-        // 身份来源修正（2026-10-06 热修，活体实证）：dsh-agent 的 Agent 接口**没有 id 字段**——
-        // 被驱动的会话才是身份（agent.session.id）。此前读 agent.id 恒 undefined → cid='' 早退，
-        // 事件结算通道从卡1上线起从未真正触发（所有结算全靠 run.result / board_report 通道顶着）。
-        // agent.id 作兜底保留（防未来内核补上该字段时形状分叉）。
-        var cid = agent ? String((agent.session && agent.session.id) || agent.id || '') : ''
-        if (!cid) return
-        var table = state.activeRuns
-        // 事件按会话 id 命中活跃 rec：continuable rec 的 childId 就是子会话 id（= agent.session.id），
-        // 故这里是 O(1) 的 rec.childId 比对，不做任何 agent 注册表扫描。
-        Object.keys(table).forEach(function (sid) {
-          var rr = table[sid]; if (!rr) return
-          Object.keys(rr).forEach(function (k) {
-            var rec = rr[k]
-            if (!rec || !rec.continuable || rec.childId !== cid) return
-            if (status === 'running') { rec.ran = true; return }
-            if (!rec.ran || rec.settled) return
-            rec.settled = true // 先立旗：堵住硬超时臂与重复事件的并发重入
-            settleContinuable(sid, rec).catch(function (e) { console.error('[task-board] settleContinuable failed (task ' + rec.taskId + '):', String(e)) })
-          })
-        })
-      } catch (e) { console.error('[task-board] agent/status 处理失败:', String(e)) }
-    }
+    // 帧活性追踪（frameSessionIdOf/frameStreamSeen/onAssistantFrame）已拆至 lib/hung.mjs（拆分第 1 刀 task-mvt8c1yx），
+    // 事件订阅改挂 hung.onAssistantFrame 实例方法（下方）。
     // 注册（cordis 标准事件订阅）：返回的 disposer 交给 ctx.effect 回收。
     // 老宿主/测试桩上没有 ctx.on 时静默跳过——派发照常，只是没有事件结算通道（一次性路径本就不需要）。
     if (typeof ctx.on === 'function') {
       try {
-        ctx.effect(function () { return ctx.on('agent/status', onAgentStatus) })
+        ctx.effect(function () { return ctx.on('agent/status', settle.onAgentStatus) })
       } catch (e) { console.error('[task-board] agent/status 订阅失败:', String(e)) }
-    }
-
-    async function settleWorker(sid, rec, output, failed, errText) {
-      // 冷却嗅探②（continuable 死子路径）：失败结算文本命中限流/连接故障 → 本 run 所用模型登记冷却表。
-      // activation.result 拆除兜底臂带上来的诊断文本（含「限额将在 … 重置」/ ENOTFOUND 等）也走这里。
-      // rec.model 空 = 父模型（id 不可知）无法归因，跳过；badModels 熔断语义不受影响（两张表各管各的）。
-      if (failed && rec.model) await sniffModelCooldown(sid, rec.taskId, rec.model, 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）→ 只收尾
-        if (t.status !== 'in-progress' || t.escalation) return { task: t, already: true }
-        if (failed) {
-          // 失败原因落卡（截断 300）：卡片详情页可直接查看最近失败原因，排查三连败不再靠猜
-          t.lastError = String(errText || '').slice(0, 300)
-          t.retryCount = (t.retryCount || 0) + 1
-          // ===== 宿主秒拆喂熔断（task-mvowb2hc 洞①）：spawn/续跑后即被宿主拆除（stopReason:error）
-          // = 模型面失败，计入熔断连击——原形 task-mvoutja4：glm-5.3-flash 秒拆 ×3 不计入 badModels，
-          // 熔断永不触发，档位链每轮重派都再选同一个坏模型。连续 3 次才拉黑（熔断语义不变：badModels
-          // 落黑名单 → 取模链跳过 + 健康表 circuit）；worker 自己的失误不计，成功 run 归零（settleRunRecord）。
-          if (rec.model && isModelKillFailure(errText)) feedModelFailure(sid, rec.model)
-          if (t.retryCount >= 3) { var ps = t.status; t.status = 'blocked'; ah(t, ps, 'blocked', String(rec.id), 'worker 失败 x' + t.retryCount + '（' + String(errText).slice(0, 120) + '），待人工介入'); return { task: t, blocked: true } }
-          var ps2 = t.status; t.status = 'pending'; t.claimedBy = null; t.claimedAt = null; ah(t, ps2, 'pending', String(rec.id), 'worker 失败（' + String(errText).slice(0, 80) + '），重新排队 (' + t.retryCount + '/3)')
-          return { task: t, retry: true }
-        }
-        if (/\[ESCALATE\]/i.test(output || '')) {
-          t.escalation = { question: output.slice(0, 2000), at: new Date().toISOString(), by: String(rec.id) }
-          if (!Array.isArray(t.messages)) t.messages = []
-          t.messages.push({ kind: 'escalation', text: output.slice(0, 4000), at: t.escalation.at, by: String(rec.id) })
-          ah(t, 'in-progress', 'in-progress', String(rec.id), 'worker 上报歧义（文本通道），待主窗口裁决')
-          return { task: t, escalated: true }
-        }
-        // 文本降级路径：分段格式上报
-        var secs = parseSections(output)
-        delete t.retryCount; delete t.stuckSince; delete t.lastError // 成功路径：失败计数/卡死标记/最近失败原因一并清除
-        t.deliverable = { summary: secs.summary || output.slice(0, 600), changes: secs.changes || '', selfTest: secs.selfTest || '', diff: (secs.diff || '').slice(0, 4000), at: new Date().toISOString(), by: String(rec.id) }
-        resolveApply(d, t, String(rec.id), 'verifying', output || 'Worker 完成', 'worker 文本上报完成')
-        return { task: t }
-      })
-      if (!result) return
-      // already=true：工具通道（board_report）已推进状态并已发回执/歧义通知，settle 只负责 dispose，不再重复通知
-      if (result.already) return
-      if (result.escalated) maybeNotify(sid, result.task)
-      // 歧义通知（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.escalation) return { task: t, already: true }
-        if (t.status !== 'verifying') {
-          // 迟到落账（验收时序三洞 ③）：verifier 结论落到已落定卡（主窗口抢批/归档早于本 run 结算）不再静默丢弃。
-          // 但「工具通道已处理」= board_verdict 已由本 run 自己落账（t.verification.by === rec.id）→ 保持 already。
-          if (t.status === 'resolved' || t.status === 'archived' || t.status === 'cancelled') {
-            if (t.verification && String(t.verification.by) === String(rec.id)) return { task: t, already: true }
-            var ltrim = (output || '').trim()
-            var lvm = ltrim.match(/^[ \t>*#\-\s]*(APPROVED|REJECTED)\b/im)
-            if (failed || !lvm) return { task: t, already: true } // 无有效结论，不落 late
-            var lapproved = lvm[1].toUpperCase() === 'APPROVED'
-            var lsecs = parseSections(ltrim)
-            var lr = lateVerdictApply(t, lapproved ? 'approved' : 'rejected', lsecs.verifySummary || ltrim.slice(0, 600), lsecs.checks || '', lsecs.userTest, new Date().toISOString(), String(rec.id), cfg(d).verifyUserGuide)
-            if (lr && lr.invalid) return { task: t, already: true } // 三连根修①：非法 verdict 零落账（防御——本路径 verdict 恒来自正则解析）
-            return { task: t, late: true, lateRejected: lr.lateRejected && lr.wasApproved }
-          }
-          return { task: t, already: true }
-        }
-        var trimmed = (output || '').trim()
-        var vm = trimmed.match(/^[ \t>*#\-\s]*(APPROVED|REJECTED)\b/im)
-        if (failed || !vm) {
-          // 失败原因落卡（截断 300）：verifier 故障/输出无法判定的原因留在卡片上供排查
-          t.lastError = String(errText || 'verifier 未给出有效结论（输出格式异常）').slice(0, 300)
-          // 失败/空输出/无法判定：verifyRetries 计数，>=3 转人工验收（deliverable 已完成，是 verifier 故障不是任务故障）
-          if (failed && rec.model) {
-            badModels[modelKey(sid, rec.model)] = true
-            // 熔断文案分态（task-mv73ym2k，实证 n-mv6ezj6vary4）：错误串含 UNKNOWN_MODEL = 模型 id 非法
-            // （mistake 类：配置写错，模型无辜）——与「连续验收失败」（quality 类）区分，不归一堆。
-            var modelIllegal = /UNKNOWN_MODEL/i.test(String(errText || ''))
-            markModelCircuit(sid, rec.model, modelIllegal ? '模型 id 配置非法，已熔断' : '验收连续失败，已熔断')
-            pushSysNote(sid, modelIllegal
-              ? '模型 ' + rec.model + ' 配置非法（不在可用清单），已熔断回退父级模型——请经 list-models 选合法 id 重配'
-              : '模型 ' + rec.model + ' 验收连续失败，已熔断回退父级模型')
-          }
-          t.verifyRetries = (t.verifyRetries || 0) + 1
-          if (t.verifyRetries >= 3) { t.escalation = { question: 'Verifier 连续 ' + t.verifyRetries + ' 次未能给出有效结论（' + (failed ? String(errText).slice(0, 150) : '输出格式异常') + '）。交付物已完成，请人工验收：看板详情页直接通过/驳回，或 task_verify 裁决。', at: new Date().toISOString(), by: 'system' }; ah(t, 'verifying', 'verifying', 'system', 'verifier 故障，转人工验收'); return { task: t, escalated: true } }
-          ah(t, 'verifying', 'verifying', 'system', 'verifier 未给出有效结论，重新排队审查 (' + t.verifyRetries + '/3)')
-          return { task: t, retry: true }
-        }
-        var approved = vm[1].toUpperCase() === 'APPROVED'
-        var vsecs = parseSections(trimmed)
-        delete t.stuckSince; delete t.verifyRetries; delete t.lastError // 成功给出结论：卡死标记/重试计数/最近失败原因一并清除
-        t.verification = { verdict: approved ? 'approved' : 'rejected', summary: vsecs.verifySummary || trimmed.slice(0, 600), checks: vsecs.checks || '', at: new Date().toISOString(), by: String(rec.id) }
-        // 自测指南落账（verifyUserGuide 开关门禁，task-muxyyvg0）：开关开且解析出「## 自测指南」段才挂
-        // userTest；缺段/开关关 → 字段不挂（client 详情块与报告「本版自测清单」段整块不渲染）
-        if (cfg(d).verifyUserGuide !== false && vsecs.userTest) t.verification.userTest = vsecs.userTest
-        verifyApply(d, t, String(rec.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.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 + '，待人工裁决') }
-          else { t.status = 'pending'; t.claimedBy = null; t.claimedAt = null; ah(t, 'in-progress', 'pending', 'system', '驳回重派：新 Worker 将携带驳回原因继续') }
-        }
-        return { task: t, approved: approved }
-      })
-      if (!result) return
-      // already=true：工具通道（board_verdict）已推进状态并已发回执，settle 只负责 dispose，不再重复通知
-      if (result.already) return
-      // 迟到通知分态（三连根修②③，task-mvf7nve8）：rejected 且卡已 approved → err 级「🚨 迟到驳回」+
-      // healthHint（banner 只 rejected 亮）；approved → notice 级「✅ 迟到复核：维持原判」。
-      // 同指纹（taskId+by+verdict，poolHealth.lastLateNotice）已投过 → 跳过，零重复通知。
-      if (result.late) {
-        var __phL = poolHealthFor(sid)
-        var __fpL = lateNoticeFp(result.task)
-        var __onceL = __phL.lastLateNotice !== __fpL
-        if (__onceL) __phL.lastLateNotice = __fpL
-        if (result.lateRejected) {
-          __phL.lateRejectNote = { taskId: result.task.id, at: Date.now() } // banner 幂等 sticky，不受去重闸影响
-          if (__onceL && notifyLateReject) notifyLateReject(sid, result.task)
-        } else if (__onceL && notifyLateApprove && result.task.lateVerdict && result.task.lateVerdict.verdict === 'approved') {
-          notifyLateApprove(sid, result.task)
-        }
-        return
-      }
-      if (result.escalated) maybeNotify(sid, result.task)
-      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.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 进验收）
-    }
-
-    // ===== 重启 reconcile（卡3 Step2）：host 重启后把活跃 continuable Worker 的观测重新挂回来 =====
-    // 问题：continuable Worker 的 rec 只活在内存（state.activeRuns）——host 重启把它清零，而子会话
-    // 本身是**持久子会话**，可能正跑得好好（或刚跑完一轮）。此时任务停在 in-progress 却没人认领：
-    // 既不会被 agent/status 结算（表里没 rec），又不会被孤儿回收（isOrphan 的 2 分钟门槛＋它确实
-    // 有 claimedBy），只能干等——重启一次就白挂一个 Worker 位。
-    // 解法（一次，per host 生命周期）：对本会话板上「in-progress 且无活跃 rec」的任务查 listChildren(root)，
-    //   · 该 childId 仍在列 → 判定存活：重建 rec 观测（agent/status 监听本来就在，登记即可续上），
-    //     基线取**当前日志字节数**（重启前那轮的产出已落盘，不该冒充重启后的新交付物），重挂两级超时臂；
-    //   · 不在列 → 会话已死：走「硬超时等价物」——失败结算的等价动作（回 pending 重排 + 留历史），
-    //     不占用 Worker 并发位，等下一轮 poolCycle 正常重派（续跑资格由卡上 runs 留档决定）。
-    // 三道门禁：①只对 role=worker + continuable + 结局停在 running 的 run（一次性 run 没有可找回的会话）；
-    // ②per host 生命周期只做一次（state.reconcileDone）——重复做会把用户手动终止的卡又挂回去；
-    // ③listChildren 不可用（老宿主/测试桩）→ 整段跳过，行为逐字不变。
-    // 已知边界（有意不做，交给既有机制）：重启**之后**才被中断的那一轮，reconcile 追不回它的结局——
-    // 硬超时臂已在重建时重挂，到点照常结算。
-    async function reconcileRoot(sid) {
-      if (!state.reconcileDone) state.reconcileDone = {} // 老宿主/测试桩没建这个容器：就地补（不清空已有标记）
-      if (state.reconcileDone[sid]) return
-      state.reconcileDone[sid] = true
-      var subagents = ctx.subagents
-      if (!subagents || typeof subagents.listChildren !== 'function') return
-      var runs = runsFor(sid)
-      var snap = null
-      try { snap = await rt(sid) } catch (_) { return }
-      // 候选：in-progress + 在跑占位已换成真实 run id + 无活跃 rec + 最后一条 worker run 是 continuable
-      // 且结局仍停在 running（已落 timeout/error 的卡由重派路径自己处理，不在此处抢跑）。
-      var cands = []
-      var list = (snap && snap.tasks) || []
-      for (var i = 0; i < list.length; i++) {
-        var t = list[i]
-        if (!t || t.status !== 'in-progress' || t.escalation) continue
-        if (runs[t.id]) continue
-        if (!t.claimedBy || t.claimedBy === 'spawn-pending') continue
-        if (resumeTarget(t) !== '') continue // 结局已落超时/失败 → 归重派续跑路径，reconcile 不掺和
-        var last = null
-        var trs = Array.isArray(t.runs) ? t.runs : []
-        for (var ri = trs.length - 1; ri >= 0; ri--) { if (trs[ri] && trs[ri].role === 'worker') { last = trs[ri]; break } }
-        if (!last || last.continuable !== true || last.outcome !== 'running') continue
-        if (String(last.id) !== String(t.claimedBy)) continue // 卡上留档与占位不一致：状态可疑，不动
-        cands.push(t)
-      }
-      // ===== 孤儿一次性子会话补停（task-mv8wuznb ②，重启场景）=====
-      // 卡已落定（resolved/cancelled/archived）而 verifier/一次性 worker 的 run 留档仍 running 无
-      // endedAt：重启把内存 rec 清零后，结算收尾（stopSettledOneShot）的 interrupt 再也打不到它——
-      // 若子会话仍活在宿主目录（下方 listChildren 命中），顺手 interrupt 停掉（「结算即销毁」的重启补课，
-      // 实证：verifier 空转 8h 的会话若中途遇 host 重启，苏醒后照旧空烧）。
-      // 只停会话、不动卡面：running 留档的关账归 sweepZombieRuns（每轮都跑，就排在本函数之后）。
-      // continuable worker 豁免（留存会话供续跑是设计语义；在飞卡的 continuable 由上方候选①重建观测）。
-      var orphans = []
-      for (var oi = 0; oi < list.length; oi++) {
-        var ot = list[oi]
-        if (!ot || (ot.status !== 'resolved' && ot.status !== 'cancelled' && ot.status !== 'archived')) continue
-        var ors = Array.isArray(ot.runs) ? ot.runs : []
-        for (var oj = 0; oj < ors.length; oj++) {
-          var orun = ors[oj]
-          if (!orun || orun.outcome !== 'running' || orun.endedAt) continue
-          if (orun.role !== 'verifier' && !(orun.role === 'worker' && orun.continuable !== true)) continue
-          orphans.push(String(orun.id))
-        }
-      }
-      if (!cands.length && !orphans.length) return
-      // 存活判定：listChildren 列出的就是「活的子会话」。带超时保护（查询挂死也不能拖住心跳）。
-      var kids = null
       try {
-        var q = subagents.listChildren(sid)
-        kids = (typeof withTimeout === 'function') ? await withTimeout(q, 5000, 'reconcile listChildren') : await q
-      } catch (e) {
-        console.error('[task-board] reconcile listChildren 失败（本轮跳过，卡片留在 in-progress 等人工处理）:', String(e))
-        return
-      }
-      var alive = {}
-      var kidList = Array.isArray(kids) ? kids : []
-      for (var k = 0; k < kidList.length; k++) {
-        var c = kidList[k]; if (!c) continue
-        var cid = String(c.sessionId || c.id || '')
-        if (cid) alive[cid] = true
-      }
-      var c2 = cfg(snap)
-      var found = 0, lost = 0
-      for (var ci = 0; ci < cands.length; ci++) {
-        var tc = cands[ci]
-        var childId = String(tc.claimedBy)
-        if (alive[childId]) {
-          // ① 存活：重建 rec（与 spawnOneShot 的 continuable 形态逐字同构）→ 重挂两级超时臂。
-          //    ran:false —— 重启前的 running 事件已经错过，等下一个真 running 事件到来才允许 idle 结算
-          //    （rec.ran 二次守卫的既有语义：宁可等，也不拿一个可能已在跑的会话的空文本当交付物）。
-          var rec = { id: childId, childId: childId, continuable: true, restored: true, ran: false, run: null, role: 'worker', taskId: tc.id, startedAt: Date.now(), model: '', settled: false, baselineBytes: logSizeOf(childId) }
-          runs[tc.id] = rec
-          if (!dispatchedEver[sid]) dispatchedEver[sid] = {}
-          dispatchedEver[sid][childId] = true
-          armTimeouts(sid, rec, tc, c2)
-          found++
-          // 系统消息只留一行（重启是低频事件，且这行是「为什么它还在跑」的唯一解释来源）
-          pushSysNote(sid, '任务「' + tc.title + '」的 Worker 子会话已在重启后找回（续跑观测已恢复，硬超时 ' + c2.hardTimeoutMin + ' 分钟后照常结算）', tc.id)
-        } else lost++
-      }
-      if (found || lost) console.log('[task-board] 重启 reconcile（' + sid + '）：找回活跃续跑 Worker ' + found + ' 个，' + lost + ' 个子会话已死转回 pending')
-      // ② 会话已死：硬超时等价物（失败结算的等价动作）——回 pending 重排 + 留一行 history + 落结局。
-      //    放在**锁外**统一做（一次持锁批量处理，避免逐张写盘打断派发周期）。
-      if (lost) {
-        try {
-          await mutateLocked(sid, function (d) {
-            d.tasks.forEach(function (t) {
-              if (t.status !== 'in-progress' || runs[t.id] || !t.claimedBy || t.claimedBy === 'spawn-pending') return
-              var last = null
-              var trs = Array.isArray(t.runs) ? t.runs : []
-              for (var ri = trs.length - 1; ri >= 0; ri--) { if (trs[ri] && trs[ri].role === 'worker') { last = trs[ri]; break } }
-              if (!last || last.continuable !== true || last.outcome !== 'running') return
-              if (String(last.id) !== String(t.claimedBy) || alive[String(t.claimedBy)]) return
-              var ps = t.status
-              t.status = 'pending'; t.claimedBy = null; t.claimedAt = null
-              t.lastError = 'host 重启后 Worker 子会话已不存在（reconcile 未找回），任务回收重排'
-              last.outcome = 'timeout/error'; last.endedAt = new Date().toISOString()
-              ah(t, ps, 'pending', 'system', '重启后执行会话已丢失，回收重新排队')
-              return
-            })
-            return { ok: true }
-          }, true)
-        } catch (e) { console.error('[task-board] reconcile 死会话回收失败:', String(e)) }
-      }
-      // 孤儿一次性子会话补停（task-mv8wuznb ②）：只打「仍在活跃目录」的——不在目录 = 会话已死，
-      // 杀无可杀（留档归 sweepZombieRuns 关账）；无 interrupt 能力/无活 root → 静默跳过；
-      // 单条失败只 console.error，不拖住本轮 reconcile 的其它动作。
-      var stopped = 0
-      if (orphans.length && typeof subagents.interrupt === 'function') {
-        var oroot = rootForSession(sid)
-        if (oroot) {
-          for (var oi2 = 0; oi2 < orphans.length; oi2++) {
-            var oid = orphans[oi2]
-            if (!alive[oid]) continue
-            try { subagents.interrupt(oid, { kind: 'ancestor', agent: oroot }); stopped++ }
-            catch (e) { console.error('[task-board] reconcile 孤儿一次性子会话 interrupt 失败（' + oid + '）:', String(e)) }
-          }
-        }
-      }
-      if (stopped) console.log('[task-board] 重启 reconcile（' + sid + '）：补停落定卡孤儿一次性子会话 ' + stopped + ' 个')
+        ctx.effect(function () { return ctx.on('agent/assistant-stream', hung.onAssistantFrame) })
+      } catch (e) { console.error('[task-board] agent/assistant-stream 订阅失败:', String(e)) }
     }
 
-    // ===== 僵尸 run 留档清扫（task-mv22z61v）：关账「落定卡上的 running 无 endedAt 留档」+ 清卡面认领位 =====
-    // 事故（用户实证）：0.4.1/0.4.5 时代老卡，宿主多次重启后 run 留档停在 outcome:'running' 无 endedAt +
-    // 卡面 verifierRun/claimedBy 残留指向死会话。归档门禁 activeRunOf 的卡面兜底（liveEntry 认 claimedBy/
-    // verifierRun 匹配的 running 留档）把它们误判活跃 → archive 永久拒。mv1pqy27 的 doTerminate 状态无关
-    // 清理只覆盖「rec 在内存表」场景；重启后 rec 消失 + 卡已落定的组合落入盲区（resolved 无分支，什么都不清），
-    // 且没有任何工具能关一条无 rec 的 run 留档本体。
-    // 修法：扫描本板卡片的 runs[]，凡 outcome==='running' 且无 endedAt 且该 run id 不在内存活跃表（runsFor）
-    // 且所属卡已落定（resolved/cancelled/archived）→ 关账（endedAt=now，outcome 改 'stale-closed'，注记
-    // note='host 重启僵尸留档清扫'）+ 清对应卡面认领位（verifierRun/claimedBy 若指向它）。
-    // 边界（宁少勿多）：
-    //   ① 只对落定卡做——在飞卡的 running 留档是 reconcile / 结算通道的辖区，别越界；
-    //   ② 无活跃 rec 才扫——内存表里仍活着（!settled）的 run 留给结算通道 / reapGhostRecs 关账（它们用
-    //      'completed'/'timeout-error' 等真结局，而非这里的 'stale-closed'，口径更准）；
-    //   ③ 幂等——关账后 outcome!=running，二次运行零改动；回调无改动时返回 null 不写盘（沿用空闲快进的
-    //      「不写盘」纪律，安静板不因清扫产生 15s 心跳写盘）；
-    //   ④ 留痕——history 行 + console 一行（有产出时）。
-    // 'stale-closed' 是既有枚举之外的新结局值：详情页/聚合端对未知 outcome 一律按「已结束（有 endedAt）」
-    // 兜底展示，不会把它误判成 running（running 的判据是 outcome==='running' 且无 endedAt，二者已同时改写）。
-    async function sweepZombieRuns(sid, snap) {
-      if (!snap || snap.__noPersist || !Array.isArray(snap.tasks)) return 0 // 瞬时读盘失败/空板：跳过，不写盘
-      // 预扫快照：有候选（落定卡 + running 无 endedAt 留档）才进锁写；否则零 mutateLocked 调用——
-      // 空板/安静板走空闲快进「不写盘」的纪律不受清扫破坏（每 15s 心跳也不能因清扫多出一次写盘调用）。
-      var hasCandidate = false
-      for (var pi = 0; pi < snap.tasks.length && !hasCandidate; pi++) {
-        var pt = snap.tasks[pi]
-        if (!pt || (pt.status !== 'resolved' && pt.status !== 'cancelled' && pt.status !== 'archived')) continue
-        var prs = Array.isArray(pt.runs) ? pt.runs : []
-        for (var pj = 0; pj < prs.length; pj++) { if (prs[pj] && prs[pj].outcome === 'running' && !prs[pj].endedAt) { hasCandidate = true; break } }
-      }
-      if (!hasCandidate) return 0
-      var runs = runsFor(sid)
-      var swept = []
-      await mutateLocked(sid, function (d) {
-        if (!d || !Array.isArray(d.tasks)) return null
-        var any = false
-        d.tasks.forEach(function (t) {
-          if (!t) return
-          if (t.status !== 'resolved' && t.status !== 'cancelled' && t.status !== 'archived') return // 只清扫已落定卡
-          if (!Array.isArray(t.runs)) return
-          var cardChanged = false
-          t.runs.forEach(function (r) {
-            if (!r || r.outcome !== 'running' || r.endedAt) return // 只关「还开着且无 endedAt」的条目
-            var rid = String(r.id)
-            var rec = runs[t.id]
-            if (rec && !rec.settled && String(rec.id) === rid) return // 内存活跃表里还活着 → 结算通道辖区，不扫
-            r.outcome = 'stale-closed'
-            r.endedAt = new Date().toISOString()
-            r.note = 'host 重启僵尸留档清扫'
-            if (t.verifierRun === rid) { t.verifierRun = null; delete t.verifierRunAt }
-            if (t.claimedBy === rid) { t.claimedBy = null; t.claimedAt = null }
-            swept.push(t.id + '/' + rid + '/' + (r.role || '?'))
-            cardChanged = true
-          })
-          if (cardChanged) { ah(t, t.status, t.status, 'system', '僵尸 run 留档已关账（host 重启清扫）'); any = true }
-        })
-        return any ? d : null // 无改动返回 null → 不写盘（安静板不因清扫产生心跳写盘）
-      }, true) // skipKick：本轮已是 poolCycle，无需再踢
-      if (swept.length) console.log('[task-board] 僵尸 run 留档清扫 ' + swept.length + ' 条：' + swept.join(', '))
-      return swept.length
-    }
+    // Worker run 结算（settleWorker）已拆至 lib/settle.mjs（拆分第 6 刀 task-mvt8c1yx-6）：spawnOneShot
+    // 的 activation 拆除兜底臂/异常臂两调用点已改重指 settle.settleWorker（工厂返回集导出）。
+    // Verifier run 结算（settleVerifier）已拆至 lib/settle.mjs（拆分第 6 刀 task-mvt8c1yx-6）：
+    // 验收三连熔断（verifyRetries>=3 转人工）/ 迟到落账 lateVerdictApply / 驳回 pushRejection+pushRejectLesson
+    // 链路随源码搬移，语义零变化。
+    // hook run 结算（settleHook）已拆至 lib/settle.mjs（拆分第 6 刀 task-mvt8c1yx-6）：
+    // 状态机纯函数仍在 core.applyHookSettle（单测直接打它），锁外通知 + kickCycle 补派随源码搬移。
 
-    // ===== 幽灵占位回收（池冻结根修，task-muwlepg6）=====
-    // 病根（活体实证）：活跃表项（rec）的**唯一**摘除点是各结算通道（事件通道 settleRun /
-    // 上报通道 settleReportedRun / 手动终止）。任何一条漏走（worker 经 board_report 完成但当时
-    // 还没有上报通道接线、伪 idle 被 rec.ran 守卫挡下、冷窗口、插件热重载丢回调）都会让 rec
-    // 永久留在 state.activeRuns 里，而它同时是四个判定的输入：
-    //   ① activeW → capW = max(0, maxWorkers - activeW)：残留数 ≥ maxWorkers 时 capW 恒 0 →
-    //      **整池 Worker 自动派发全停**（实测板：5 个残留 + 1 个真在跑 → activeW=6 > maxWorkers=3 → capW=0，
-    //      9 张 pending 卡一张都派不出去）；
-    //   ② pickDispatch 的 busyTaskIds（= 本表）→ 该卡自己永远进不了 Verifier 派发（verifying 卡永不 spawn）；
-    //   ③ isOrphan 的 !runs[t.id] → 该卡永不被孤儿回收（in-progress 死卡持着 touches 锁堵住后续卡）；
-    //   ④ poolStatus 快照 → UI 上「幽灵 Worker 卡 busy」。
-    // 四者叠加 = 「poolCycle 整体冻结，force dispatch-task 手动通道却正常」——手动通道
-    // （rpc dispatch-task → spawnOneShot）不经 capW / busyTaskIds 闸门，故症状完全吻合。
-    // 修法：不动任何结算语义，只做**表项 GC**——每轮 cycle 在算活跃度之前，用「卡面证据」核对每个 rec：
-    // 卡已不存在、或卡的状态已不可能是该 rec 的在跑态（worker 不在 in-progress / verifier 不在 verifying /
-    // hook 状态不是 running）、或卡的认领位已换成别的 run id → 该 rec 已失效，立刻摘除。
-    // 摘除是**同步**的（先删表项，本轮 activeW/busyTaskIds 立刻干净、派发当轮恢复），随后用与两条
-    // 结算通道**同一个** settleRunRecord 补一次收尾（结局 / usage / 摘超时臂，三者各自幂等）——
-    // 不另立第二套口径，也不重复记账（usageRecorded 旗与「只关还开着的条目」双保险）。
-    // 边界（宁少勿多，绝不动真在跑的表项）：
-    //   · 卡面读不到（__noPersist 空板 / tasks 非数组）→ 整段跳过：瞬时读盘失败不能把真 Worker 当幽灵杀；
-    //   · 只认卡面证据，**不认** rec.settled——settled=true 的表项可能正被结算通道认领中
-    //     （onAgentStatus 先立旗、同一次同步块里才摘表项），此刻抢先摘除会让 settleRun 的认领守卫
-    //     早退、把这一轮的交付物整份丢掉；
-    //   · 单条判定/收尾各自 try/catch：一条脏数据只影响该条，不拖死本轮其它回收与派发。
-    function recIsLive(t, rec) {
-      if (!t || !rec) return false // 卡已不存在（板被重建/换工作区）→ 表项无主
-      if (rec.role === 'worker') {
-        // Worker 只在 in-progress 活着；claimedBy 为空 = 占位没落座/已被清（僵尸态）
-        if (t.status !== 'in-progress' || !t.claimedBy) return false
-        if (t.claimedBy !== 'spawn-pending' && String(t.claimedBy) !== String(rec.id)) return false // 认领位已换人（terminate 后重派）
-        return true
-      }
-      if (rec.role === 'verifier') {
-        if (t.status !== 'verifying') return false
-        if (t.verifierRun && t.verifierRun !== 'spawn-pending' && String(t.verifierRun) !== String(rec.id)) return false
-        return true
-      }
-      if (rec.role === 'hook-pre') return t.status === 'in-progress' && hookOn(t, 'pre') && t.hooks.pre.state === 'running'
-      if (rec.role === 'hook-post') return t.status === 'in-progress' && hookOn(t, 'post') && t.hooks.post.state === 'running'
-      // 拆解官（task-mvnenrwk）：挂在 draft/pending 源卡上且全程不动卡面状态——源卡仍在草稿/待办即真在跑；
-      // 卡被删除/翻走（如人工强制派发进 in-progress）→ 表项失效，按幽灵回收（迟到结算被 settled 旗挡下）。
-      if (rec.role === 'decomposer') return t.status === 'draft' || t.status === 'pending'
-      // 未知角色（前向兼容）：只要卡还在跑态就留着，等卡落定后由这里回收——不在未知形态上做激进判定
-      return t.status === 'in-progress' || t.status === 'verifying'
-    }
-    // 返回本轮摘除条数（调用方据此决定要不要重读盘——收尾写盘会让本轮快照过期）
-    async function reapGhostRecs(sid, snap) {
-      if (!snap || snap.__noPersist || !Array.isArray(snap.tasks)) return 0
-      var runs = runsFor(sid)
-      var tasks = snap.tasks
-      var reaped = []
-      Object.keys(runs).forEach(function (k) {
-        var rec = runs[k]
-        if (!rec) return
-        try {
-          var t = null
-          for (var i = 0; i < tasks.length; i++) { if (tasks[i] && tasks[i].id === rec.taskId) { t = tasks[i]; break } }
-          if (recIsLive(t, rec)) return
-          delete runs[k] // 先摘表项：本轮 activeW / busyTaskIds / poolStatus 立刻不再被它污染
-          try { if (typeof rec.disarm === 'function') rec.disarm() } catch (_) {} // 摘两级超时臂（幂等）
-          rec.settled = true // 堵住迟到的结算通道（settleRun 的认领守卫会早退，不会二次推进任务）
-          // 结局口径：卡已落定（resolved/archived/cancelled）或已交验收（verifying）→ 这轮 Worker 交付
-          // 确实完成了；卡还在跑态但认领位换了人/卡丢了 → 结局不可知，记 incomplete（与一次性路径的
-          // 「无 err 的失败」同口径，且据此保留续跑资格由重派路径判断）。
-          var closed = t.status === 'resolved' || t.status === 'archived' || t.status === 'cancelled' || t.status === 'verifying'
-          reaped.push({ rec: rec, outcome: closed ? 'completed' : 'incomplete' })
-        } catch (e) { console.error('[task-board] 幽灵表项判定失败（本轮跳过该条）:', String(e)) }
-      })
-      if (!reaped.length) return 0
-      for (var r = 0; r < reaped.length; r++) {
-        try { await settleRunRecord(sid, reaped[r].rec, { outcome: reaped[r].outcome }) }
-        catch (e) { console.error('[task-board] 幽灵表项收尾失败 (task ' + reaped[r].rec.taskId + '):', String(e)) }
-      }
-      console.log('[task-board] 回收失效活跃表项（幽灵占位）' + reaped.length + ' 个：' + reaped.map(function (x) { return String(x.rec.taskId) + '/' + String(x.rec.role) + '/' + x.outcome }).join(', '))
-      return reaped.length
-    }
+    // 重启 reconcile（reconcileRoot）/ 僵尸留档清扫（sweepZombieRuns）/ 幽灵占位回收（recIsLive/reapGhostRecs）
+    // 已拆至 lib/settle.mjs（拆分第 7 刀 task-mvt8c1yx-7）：poolCycleBody 三个挂点改经 settle 实例调用
+    // （reconcile 域闭包 deps withTimeout/armTimeouts/logSizeOf 随工厂入参注入，dispatchedEver 由 state 别名同源）。
+    // 挂死零产出检测（hungZeroOutputSweep）已拆至 lib/hung.mjs（拆分第 1 刀 task-mvt8c1yx），poolCycleBody 改经 hung.hungZeroOutputSweep 调用。
 
     // ===== 派发周期（15s 心跳 + 写入后 kickCycle 触发）=====
     // 结构（池冻结防御，task-muwlepg6）：入口 root 闸门 → 读盘 → 本轮主体（poolCycleBody）整段包 try。
@@ -2021,22 +1003,29 @@ export function createDispatch(ctx, state, deps) {
       // 重启 reconcile（卡3 Step2）：只在本 host 生命周期的首轮 cycle 做一次（内部有 reconcileDone 标记）。
       // 位置取舍：root 闸门必须是第一件事（无活 root 的板零 IO），所以本段只能排在早退闸门与 rt 读盘之后；
       // 而重建出来的 rec 仍在本轮被读到（活跃计数 / 池状态快照都在下面才求值），语义不受影响。
-      try { await reconcileRoot(sid) } catch (e) { console.error('[task-board] reconcile 失败:', String(e)) }
+      try { await settle.reconcileRoot(sid) } catch (e) { console.error('[task-board] reconcile 失败:', String(e)) }
       // 僵尸 run 留档清扫（task-mv22z61v）：位置在 reconcile 之后、幽灵回收与空闲快进之前。
       // 落定卡的僵尸留档无活跃 rec，reconcile（只在飞卡）/reapGhostRecs（只清内存表项）都管不到它，
       // 而它若留在 running 会卡死 archive；安静板（只有已落定卡）会走空闲快进早退，清扫必须排在其前才能兜到。
-      try { await sweepZombieRuns(sid, snap) } catch (e) { console.error('[task-board] 僵尸留档清扫失败:', String(e)) }
+      try { await settle.sweepZombieRuns(sid, snap) } catch (e) { console.error('[task-board] 僵尸留档清扫失败:', String(e)) }
       // 幽灵占位回收（池冻结根修）：必须排在活跃度计数与 pickDispatch 之前——残留表项正是把 capW 拉到 0、
       // 并把卡挡在 Verifier 派发之外的元凶（见 reapGhostRecs 头注释）。收尾会写盘（结局/usage），
       // 故有回收时重读一次快照——否则下面空闲快进的 stalePool/staleInfo 判定会拿旧快照误判（写盘已归一进锁）。
       var reapedN = 0
-      try { reapedN = await reapGhostRecs(sid, snap) } catch (e) { console.error('[task-board] 幽灵占位回收失败（本轮跳过，派发照常）:', String(e)) }
+      try { reapedN = await settle.reapGhostRecs(sid, snap) } catch (e) { console.error('[task-board] 幽灵占位回收失败（本轮跳过，派发照常）:', String(e)) }
       if (reapedN > 0) {
         try { snap = await rt(sid) } catch (_) {}
         // ③ 幽灵回收可视化（运行时健康自检）：本轮回收 >0 留一条一次性记录（90s 保鲜），
         // rpc get-tasks 读到即在「架构健康」区亮一条 info 并消费——幽灵回收从此在 GUI 可见。
         poolHealthFor(sid).reapNote = { n: reapedN, at: Date.now() }
       }
+      // 挂死零产出检测（task-mvqcoz9l）：位置在幽灵回收之后、活跃度计数与派发决策之前——
+      // 判死结算把 rec 摘出活跃表（activeW 当轮即干净、空出的并发位本轮即可被 pickDispatch 复用），
+      // 卡面由失败臂翻回 pending，同一轮即可重派；判死结算会写盘（关账/落卡），有判死时重读快照——
+      // 否则下方空闲快进的 stalePool/staleInfo 判定会拿旧快照误判（与幽灵回收同款纪律）。
+      var hungN = 0
+      try { hungN = await hung.hungZeroOutputSweep(sid, runs, snap) } catch (e) { console.error('[task-board] 挂死零产出检测失败（本轮跳过）:', String(e)) }
+      if (hungN > 0) { try { snap = await rt(sid) } catch (_) {} }
       var activeW = 0, activeV = 0
       // 角色口径：worker 计入 activeW（占 Worker 并发位）；verifier 与 hook run（hook-pre/hook-post）
       // 统一计入 activeV——hook run 不是 Worker，不该挤占 maxWorkers 并发位，但它确实是一条在跑的 run，
@@ -2317,8 +1306,10 @@ export function createDispatch(ctx, state, deps) {
     // state.activeRuns = {} 等价）。原位清空是必要的——runsFor(sid) 返回的是每会话子对象，
     // 只换顶层容器会把这些子对象连同里面的 rec 一起漏掉。
     ctx.effect(function () { return function () { Object.keys(state.activeRuns).forEach(function (psid) { var rr = state.activeRuns[psid]; Object.keys(rr).forEach(function (k) { try { var r0 = rr[k]; if (r0 && r0.run) r0.run.dispose(); if (r0) r0.settled = true } catch (_) {} ; delete rr[k] }) }); state.activeRuns = {}; state.reconcileDone = {} } })
-    // 卸载同时停主动嗅探： AbortSignal 取消在飞请求，迟到结果不再写健康表；已有被动表随 host 状态一并废弃。
-    ctx.effect(function () { return function () { probeDisposed = true; Object.keys(probeAbort).forEach(function (model) { try { probeAbort[model].abort() } catch (_) {} }); probeNextAt = {} } })
+    // 卸载同时停主动嗅探（拆分第 4 刀重指）：注册仍在本侧执行，回调只调 health 工厂暴露的 disposeProbe()
+    // （AbortSignal 取消在飞请求 + 清 probeNextAt 间隔闸表 + 落 probeDisposed 卸载闸，三步操作逐字一致；
+    // 迟到结果不再写健康表，已有被动表随 host 状态一并废弃）。
+    ctx.effect(function () { return function () { disposeProbe() } })
     // Host 侧调度心跳：每 15s 对所有已知会话跑 poolCycle（客户端轮询只是触发器之一，面板关闭/后台节流时照常运转）
     ;(function () { var tm = ctx.timer; if (!tm) return; var disposeTick = tm.interval(function () { var cutoff = Date.now() - 1800000; Object.keys(knownSessions).forEach(function (sid) { if (knownSessions[sid] < cutoff) delete knownSessions[sid]; else poolCycle(sid).catch(function () {}) }) }, 15000); ctx.effect(function () { return disposeTick }) })()
 
@@ -2360,5 +1351,7 @@ export function createDispatch(ctx, state, deps) {
 
     // resumeTarget 一并透出（task-mv6c7cbo）：rpc 侧 doIntervene 在无活跃 rec 时靠它细分
     // 「续跑窗口 / 真无 run」两态（纯读 t.runs 零 IO，同一函数两处复用，不另写第二套口径）。
-    return { poolCycle: poolCycle, spawnOneShot: spawnOneShot, accumulateRunUsage: accumulateRunUsage, settleReportedRun: settleReportedRun, readContextPack: readContextPack, closeRunHistory: closeRunHistory, resumeTarget: resumeTarget, probeConfiguredModels: probeConfiguredModels, maybeProbeModels: maybeProbeModels }
+    // return API（拆分第 7 刀）：accumulateRunUsage 随源码搬至 settle.mjs（工厂内直调），key 名不变、
+    // 懒绑定重指 settle 实例（上方已接线；rpc 侧手动终止关账消费面零变化）。
+    return { poolCycle: poolCycle, spawnOneShot: spawnOneShot, accumulateRunUsage: function () { return settle.accumulateRunUsage.apply(null, arguments) }, settleReportedRun: settle.settleReportedRun, readContextPack: readContextPack, closeRunHistory: closeRunHistory, resumeTarget: resumeTarget, probeConfiguredModels: probeConfiguredModels, maybeProbeModels: maybeProbeModels }
 }