dsh-agent-board 1.9.0 → 1.9.1

package/lib/dispatch.mjs

@@ -61,6 +61,8 @@ 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
@@ -86,7 +88,8 @@ export function createDispatch(ctx, state, deps) {
     }
     function syncModelHealth(sid, model, cooldownOverride) {
       var e = healthEntry(sid, model), until = typeof cooldownOverride === 'number' ? cooldownOverride : cooldownLive(model)
-      e.state = e.observed === 'healthy' ? 'healthy' : 'unknown'
+      // task-mvrqdw4k：degraded 派生（状态优先级 circuit > cooldown > degraded > healthy/unknown——覆盖臂在下方，顺序即优先级）
+      e.state = e.observed === 'healthy' ? 'healthy' : (e.observed === 'degraded' ? 'degraded' : 'unknown')
       e.note = e.observedNote || '尚无健康信号'
       delete e.until
       if (until) { e.state = 'cooldown'; e.until = until; e.note = e.cooldownNote || '模型冷却中' }
@@ -99,11 +102,26 @@ export function createDispatch(ctx, state, deps) {
       var e = healthEntry(sid, model), at = new Date().toISOString()
       var latency = Number(opts.latencyMs)
       e.lastSeen = at
-      e.observed = ok ? 'healthy' : 'unknown'
+      // ③ 探测超时/预算耗尽只更新 note（判定保留，task-mvsv8zym）：observed/state/latencyMs/recentRuns
+      // 全部保持原值——避免已 healthy/degraded 条目被超时倒退成 unknown（超时非模型健康信号）。
+      if (opts.preserveObserved) {
+        if (opts.probe) {
+          e.lastProbe = at
+          e.observedNote = '主动探测超时（慢模型，判定保留）' + (opts.note ? '：' + opts.note : '')
+          e.note = e.observedNote
+        }
+        return syncModelHealth(sid, model)
+      }
+      // task-mvrqdw4k：探测空响应分治——ok=true 🟢健康；opts.degraded 🟡降级（链路存活，供应商怪癖，
+      // 只由探测降级存活臂置入）；其余照旧 unknown（失败臂）。被动 run 观察臂语义逐字不变。
+      e.observed = ok ? 'healthy' : (opts.degraded ? 'degraded' : 'unknown')
       if (isFinite(latency) && latency >= 0) e.latencyMs = Math.round(latency)
       if (opts.probe) {
         e.lastProbe = at
-        e.observedNote = ok ? '主动探测通过' : ('主动探测失败' + (opts.note ? '：' + opts.note : ''))
+        e.observedNote = ok ? '主动探测通过'
+          : (opts.degraded
+              ? '主动探测：链路存活但极简请求零内容（EMPTY_RESPONSE 供应商怪癖）' + (opts.note ? '：' + opts.note : '')
+              : '主动探测失败' + (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)
@@ -154,21 +172,91 @@ export function createDispatch(ctx, state, deps) {
       } catch (_) {}
       return until
     }
+    // ===== 模型目录获取（task-mvd3li6 目录失效闸数据源）：与 rpc.mjs enumModels 同源（llm.listProviders+listModels）=====
+    // 返回 { "provider/model": true } 目录映射；null = 目录不可得 → 目录闸整体跳过（保守语义③，不误伤）：
+    //   ① llm 服务缺失/缺 listProviders/listModels 方法（老宿主）；② listProviders 未返回数组或抛错；
+    //   ③ 任一 provider 的 listModels 抛错或未返回数组（部分枚举=目录不完整，宁可跳过闸也不误杀在册模型）；
+    //   ④ 枚举结果为空（退化形态：网关零模型时全候选都会被误判目录外，同样保守跳过）。
+    // 每次 spawnOneShot/续跑闸现取一次（刻意不缓存：模型从宿主配置删除/改名要当轮生效，缓存会放走已删模型）。
+    async function modelDirectory() {
+      var llm = ctx.get && ctx.get('llm')
+      if (!llm || typeof llm.listProviders !== 'function' || typeof llm.listModels !== 'function') return null
+      var providers = null
+      try { providers = llm.listProviders() } catch (_) { return null }
+      if (!Array.isArray(providers)) return null
+      var out = {}
+      for (var i = 0; i < providers.length; i++) {
+        try {
+          var models = await llm.listModels(providers[i].id)
+          if (!Array.isArray(models)) return null
+          for (var j = 0; j < models.length; j++) { if (models[j] && models[j].id) out[providers[i].id + '/' + models[j].id] = true }
+        } catch (_) { return null } // 任一 provider 枚举失败 → 目录不完整 → 保守跳过（不误伤）
+      }
+      if (!Object.keys(out).length) return null
+      return out
+    }
+    // 存在闸谓词（同步；dir=modelDirectory() 结果）：目录可得且模型不在目录 → true（配置已失效）。
+    // dir 为 null（目录不可得）恒 false——闸整体跳过，只留连败软闸生效。
+    function outOfDir(modelId, dir) { return !!(dir && modelId && !dir[modelId]) }
+    // ===== 目录失效留痕（task-mvd3li6）：取模候选不在当前模型目录 → 卡 messages 记「配置已失效」，per 模型去重 =====
+    // 同模型重复取模只记一条（防每轮重派刷屏，与冷却嗅探「未后延零留痕」同纪律）；
+    // 顺带在健康表 observedNote 落同款分态（GUI 健康点可读出「为什么被跳过」）。写卡失败静默吞掉
+    // （留痕是附属动作，绝不阻断取模主流程）。
+    async function traceStaleModel(sid, taskId, model) {
+      if (!model) return
+      console.error('[task-board] 配置已失效：' + model + '（已从模型目录移除），取模跳过该候选')
+      try {
+        var he = healthEntry(sid, model)
+        if (he.observedNote !== '配置已失效（已从模型目录移除）') { he.observedNote = '配置已失效（已从模型目录移除）'; he.note = he.observedNote }
+      } catch (_) {}
+      try {
+        await mutateLocked(sid, function (d) {
+          var t2 = d.tasks.find(function (x) { return x.id === taskId })
+          if (!t2) return null
+          if (!Array.isArray(t2.messages)) t2.messages = []
+          var text = '⚠️ 配置已失效：' + model + '（已从模型目录移除），本 run 取模跳过'
+          for (var i = t2.messages.length - 1; i >= 0; i--) {
+            if (t2.messages[i] && t2.messages[i].kind === 'stale-model' && t2.messages[i].text === text) return null // 已记过，零改动零留痕
+          }
+          t2.messages.push({ kind: 'stale-model', text: text, at: new Date().toISOString(), by: 'system' })
+          return { ok: true }
+        }, true) // skipKick：只是留痕，不踢 poolCycle
+      } catch (_) {}
+    }
     // ===== 备用模型链健康判定（task-mvnqxlpn）：不在 badModels 熔断名单且不在 modelCooldown 冷却期 =====
     // 两张表各管各的（熔断=连续失败布尔，冷却=额度窗口时间戳），任一命中即不健康。
     // 消费点=spawnOneShot 取模链：候选被判不健康时先扫板级 fallbackModels 找首个健康者（链本身逐项过本检查）。
-    function healthyModel(sid, modelId) {
+    // ===== 健康面拓宽（task-mvd3li6）：在既有熔断/冷却双闸之上增读 modelHealth 聚合表 =====
+    //   ① 近期连败软闸：聚合表 recentRuns（近 5 次 run 成败，settleRunRecord 每次结算喂给）≥2 且全败 →
+    //      不健康（软熔断：不落 badModels 黑名单，仅取模/续跑跳过）。一次成功即复位——recentRuns 滚动
+    //      窗口本就有归零语义（成功条目进窗「全败」即不成立），确认复用零新增簿记。原形：glm-5.2
+    //      「78s 报错一次+挂死一次」病了还被优先调度/续跑——第二次派发即被本闸拦下改走健康取模链。
+    //   ② 目录失效闸：dir 可得且模型不在目录（已从宿主配置删除/改名）→ 视为不健康跳过。
+    // dir 为可选第三参：既有调用点（不带 dir）= 目录闸跳过，行为逐字不变（零回归）。
+    function healthyModel(sid, modelId, dir) {
       if (!modelId) return false
       var h = syncModelHealth(sid, modelId)
       if (h.state === 'circuit') return false
       if (h.state === 'cooldown') return false
+      // task-mvrqdw4k：degraded（🟡空响应降级存活）刻意不拦——探测管可调性，模型仍可被路由选用；
+      // 行为质量另有 recentRuns 连败软闸兜底（下方），探测放宽不放跑真坏模型。
+      if (outOfDir(modelId, dir)) return false
+      var rr = h.recentRuns
+      if (Array.isArray(rr) && rr.length >= 2) {
+        var allBad = true
+        for (var i = 0; i < rr.length; i++) { if (rr[i] && rr[i].ok) { allBad = false; break } }
+        if (allBad) return false
+      }
       return true
     }
     // 扫备用链找首个健康模型（保持链序=主窗口配置的能力水位优先级）；链尽/空链返回 ''。
-    function pickHealthyFallback(sid, fbList) {
+    // task-mvd3li6 起 async + dir + taskId：链上目录外模型跳过并留痕（traceStaleModel，per 模型去重）；
+    // 目录不可得（dir 缺省/null）零留痕，行为与旧签名逐字一致（既有调用点零回归）。
+    async function pickHealthyFallback(sid, fbList, dir, taskId) {
       if (!Array.isArray(fbList)) return ''
       for (var fi = 0; fi < fbList.length; fi++) {
-        if (healthyModel(sid, fbList[fi])) return fbList[fi]
+        if (outOfDir(fbList[fi], dir)) { await traceStaleModel(sid, taskId, fbList[fi]); continue }
+        if (healthyModel(sid, fbList[fi], dir)) return fbList[fi]
       }
       return ''
     }
@@ -179,15 +267,46 @@ export function createDispatch(ctx, state, deps) {
     //   ② activation 异常兜底臂：「子会话 activation 异常：…」（spawn 机制/provider 面失败，同属开工前）。
     // worker 自己的失误（空输出/超时中断/文本降级失败）不算——好模型不该为 worker 的错误背锅。
     var WORKER_MODEL_CIRCUIT_AFTER = 3 // 连续 N 次模型面失败才拉黑（与 worker 三连败阻塞同一三击口径）
+    // ===== 挂死零产出检测常量（task-mvqcoz9l）=====
+    // 原形（2026-10-27 降级实测）：glm-5.2 续跑挂上「连接开着永不响应」形态——会话不死（死会话哨兵
+    // listChildren 查不出）、不报错（无 settle 事件）、零产出（日志零增长 7 分钟），running 假相直到
+    // 人工终止。熔断/冷却/哨兵全部够不着它（哨兵只盖「会话不在目录」，这里盖「会话在但不干活」）。
+    // 判死口径：连续 HUNG_ZERO_GROWTH_ROUNDS 轮（≈40 ≈ 600s/15s 心跳）日志零增长 **且距基线
+    // ≥600s 墙钟地板**——poolCycle 不只心跳驱动，每次写盘都 kickCycle（写风暴下轮数可在 1s
+    // 内跑完），纯轮数会对刚 spawn 的 run 秒判；双闸 = 「≥40 轮零增长且真跨 600s 墙钟」。
+    // 常量化暂不开放配置（实证再调）。
+    // ===== 挂死墙钟阈值定稿（task-mvrt9tn5 二度校准）：固定 600s，放弃延迟缩放 =====
+    // 三轮生产误杀实证（2026-10-28）：①慢网关模型长生成段 180s+ 零日志被 180s 闸误杀；
+    // ②kimi-k3（健康表实测延迟 2s 的快模型）正常干活 10 分钟同样被 180s 闸误杀（=3×2s 地板）——
+    // 结论：延迟（首 token 速度）与「长生成静默时长」无关，慢模型慢在长生成，快模型做大任务
+    // 同样有 3 分钟+ 无日志窗口，3×latencyMs 缩放（task-mvrg3962）方向作废。定稿：墙钟地板直接
+    // 600s（10 分钟，对齐观测到的最长正常静默），删延迟缩放（简化，也根除「3×0s=0s 假精确回落」
+    // 的延迟数据缺失洞）。轮数闸按墙钟换算常量化：600s/15s 心跳 ≈ 40 轮。判死语义不变：
+    // 600s 零增长 + 轮数达线才判（真挂死 7 分钟实证，600s 仍能抓住，只是晚 3 分钟——可接受）。
+    // 熔断喂连击/重派链路均不动。
+    var HUNG_WALL_FLOOR_MS = 600000
+    var HUNG_ZERO_GROWTH_ROUNDS = 40 // ≈ HUNG_WALL_FLOOR_MS / 15s 心跳：轮数半边与墙钟半边同尺度（写风暴防秒判语义保留）
+    // 挂死检测 v2：assistant-stream 帧活性优先，日志双闸只兜无帧流/不可映射的旧路径。
+    // 120s 只标疑似不杀；600s 才走既有判死结算。帧时间戳只在内存刷新，持久化仅承担 sweep 基线与状态转换。
+    var HUNG_FRAME_SUSPECT_MS = 120000
+    var HUNG_FRAME_KILL_MS = 600000
+    var HUNG_KILL_PREFIX = 'run 挂死：' // 判死失败文本前缀（进 isModelKillFailure 白名单 = 计入熔断连击）
+    var HUNG_CIRCUIT_WHY = '挂死零产出（会话日志字节持续不涨），已熔断' // 挂死触发的熔断文案分态（挂死≠秒拆）
+    // 挂死型模型面失败识别：判死结算的错误文本（HUNG_KILL_PREFIX 开头）与宿主秒拆/activation 异常
+    // 同属模型面故障——计入熔断连击（feedModelFailure）。文案避开冷却嗅探关键词（连接/超时/网关等），
+    // 挂死只进连击，不登记冷却（冷却表与熔断表语义分治）。
+    function isHungKillFailure(errText) { return String(errText || '').indexOf(HUNG_KILL_PREFIX) === 0 }
     function isModelKillFailure(errText) {
       var s = String(errText || '')
+      if (isHungKillFailure(s)) return true
       if (s.indexOf('子会话被宿主拆除（stopReason: ') === 0) return s.indexOf('子会话被宿主拆除（stopReason: completed') !== 0
       return s.indexOf('子会话 activation 异常：') === 0
     }
     // 连击 +1；达 N 且尚未拉黑 → badModels 落黑名单（取模链/降档候选的既有熔断判定照常消费，零新分支）
     // + 健康表 circuit + 系统通知（不带 taskId：与验收熔断通知同口径，不受任务回执冲刷丢弃）。
+    // why 可选（task-mvqcoz9l）：挂死触发的熔断文案分态（挂死≠秒拆），缺省=既有秒拆文案（既有调用点零回归）。
     // 返回是否本次调用触发拉黑（测试/留痕用）。
-    function feedModelFailure(sid, model) {
+    function feedModelFailure(sid, model, why) {
       if (!model) return false
       var k = modelKey(sid, model)
       var n = (modelFailStreak[k] || 0) + 1
@@ -195,16 +314,97 @@ export function createDispatch(ctx, state, deps) {
       if (n < WORKER_MODEL_CIRCUIT_AFTER) return false
       if (!badModels[k]) {
         badModels[k] = true
-        markModelCircuit(sid, model, '连续 ' + n + ' 次 spawn/续跑即被宿主拆除（模型失败），已熔断')
-        pushSysNote(sid, '模型 ' + model + ' 连续 ' + n + ' 次 spawn/续跑即被宿主秒拆（模型失败），已熔断——后续取模链跳过该模型')
+        markModelCircuit(sid, model, why || ('连续 ' + n + ' 次 spawn/续跑即被宿主拆除（模型失败），已熔断'))
+        pushSysNote(sid, '模型 ' + model + ' ' + (why || ('连续 ' + n + ' 次 spawn/续跑即被宿主秒拆（模型失败），已熔断')) + '——后续取模链跳过该模型')
       }
       return true
     }
     // 连击归零：任一可归因 run 正常完成即证明模型链路恢复（settleRunRecord completed 路径调用）
     function resetModelFailure(sid, model) { if (model) delete modelFailStreak[modelKey(sid, model)] }
-    // ===== 主动模型嗅探：llm.stream 极短直调（无子代理/系统提示/工具，maxTokens=1）=====
+    // ===== 主动模型嗅探：llm.stream 极短直调（无子代理/系统提示/工具，首探 maxTokens=1）=====
     // finish=stop/max-tokens 等均证明模型链路可用；error/aborted/无 finish 才算失败。失败文本复用既有冷却登记，
     // 但不改 badModels 熔断判定。同模型全局只在飞一次，15s 硬超时带 AbortSignal，绝不阻塞 poolCycle 派发。
+    // ===== 空响应重试（task-mvrfp1rj）+ 错误码分治（task-mvrqdw4k 用户拍板）：探测只裁存活性 =====
+    // 实证（cmss/zhanlu 系 glm-5.2、deepseek-v4.1-flash）：maxTokens=1 的极简请求被供应商以「terminal stop
+    // 零内容块」退回，宿主 adapter 归成 EMPTY_RESPONSE 错误（逐字文案，宿主 checkout grep 实测）：
+    //   ① dsh-llm-pi-ai mapStopReason：model "<m>" returned a completed response with no content
+    //   ② dsh-llm-deepseek          ：DeepSeek Messages returned no content
+    // 可用性实证（task-mvrqdw4k 三重，决定性）：v4.1-flash 正产出当轮对话、两次「失败」皆我方固定 60s 挂死闸
+    // 误杀（已修为自适应）——它是慢不是死，纯空响应=供应商怪癖，不该判死。
+    // 校准口径（用户拍板·错误码分治矩阵）：
+    //   ① 首探 maxTokens=1（最省 token；一次通即证明链路可用）；
+    //   ② 首探「空响应」→ 自动以 maxTokens=8 重试一次（给模型吐 token 的余地，消掉 length 截断型空响应大头）；
+    //   ③ 重试有内容 → 🟢 探测通过（存活 = 可调用）；
+    //   ④ 重试仍空 → 按文本/码信号分治（classifyEmptyResponse）：纯空响应=🟡 degraded 存活（链路通，供应商
+    //      怪癖）——observeModel 记降级不记失败、不喂冷却嗅探、路由仍可选用；额度/凭据/连接信号=真错，维持
+    //      失败臂照旧 observeModel 失败 + 喂冷却嗅探（quota 文本优先级高于空响应判定，⑬b/⑬d 契约保留）；
+    //   ⑤ 真错误/aborted/超时/无 finish 语义逐字不变，且不触发重试（一次定性，省一次请求也省一次误判）。
+    // 放宽不放跑真坏模型（闭环论证）：额度真耗尽有两条独立通道——①宿主直接抛 QUOTA_EXCEEDED（探测即降级）；
+    // ②若网关伪装成空响应，真派发 run 会失败 → recentRuns 软闸（≥2 全败）跳过它——探测管可调性、行为闸管质量。
+    // 边界：只动探测判定/健康状态派生/UI 映射与断言；探测调度节奏（probeNextAt/probeIntervalMin）与熔断联动不动。
+    var PROBE_MAX_TOKENS = 1        // 首探极简：1 token 证链路通
+    var PROBE_MAX_TOKENS_RETRY = 8  // 空响应重试：给模型吐 token 的余地
+    var PROBE_ATTEMPT_TIMEOUT_MS = 20000 // 每次尝试独立超时（task-mvsv8zym：两次尝试各拿满 20s，非共享递减——
+    // 旧 15s 共享预算下慢模型首探耗 ~10s 后重试只剩残余必超时，被我方预算饿死误记成模型失败）。
+    // 总上限 40s 不违反「绝不阻塞 poolCycle」：探测经 maybeProbeModels 后台异步跑（不 await 进派发主链）。
+    // EMPTY_RESPONSE 识别（双路）：结构化 code 优先（宿主 finish.failure.code，常量见 dsh-llm/lib/types/error.js），
+    // 文本特征兜底（兼容只给 message 的旧宿主/网关包装文本）。只认「completed 但零内容」；
+    // 429/连接/超时等真错误文本一律 false，走既有失败臂（冷却登记口径不变）。
+    function isEmptyResponse(code, text) {
+      if (String(code || '') === 'EMPTY_RESPONSE') return true
+      return /no content/i.test(String(text || ''))
+    }
+    // 错误码分治信号（task-mvrqdw4k）：宿主把额度/凭据问题单独编码（QUOTA_EXCEEDED_CODE/INVALID_CREDENTIAL_CODE
+    // 与 EMPTY_RESPONSE_CODE 并列导出），网关包装文本同样带字样——空响应文本/码命中额度/凭据/连接信号 → 真错，
+    // 维持失败臂（冷却嗅探接管）；纯空响应（无任何真错信号）→ 🟡degraded 存活（供应商怪癖：链路通但极简请求零内容）。
+    var QUOTA_SIGNAL_RE = /429|RATE_LIMIT|QUOTA_EXCEEDED|rate.?limit|限额|额度|quota/i
+    var CREDENTIAL_SIGNAL_RE = /INVALID_CREDENTIAL|\b401\b|invalid[ _-]?api[ _-]?key|unauthorized|凭据|凭证/i
+    // 空响应分治：返回 'degraded'（纯空响应=链路存活）| 'fail'（额度/凭据/连接信号=真错，走失败臂）。
+    // 判定顺序：额度 > 凭据 > 连接 > degraded（与 parseModelCooldown 先限流后连接的保守口径一致）。
+    function classifyEmptyResponse(code, text) {
+      var s = String(text || ''), c = String(code || '')
+      if (QUOTA_SIGNAL_RE.test(s) || /QUOTA/i.test(c)) return 'fail'
+      if (CREDENTIAL_SIGNAL_RE.test(s) || /CREDENTIAL/i.test(c)) return 'fail'
+      if (CONNECTIVITY_RE.test(s)) return 'fail'
+      return 'degraded'
+    }
+    // 单次探测请求：返回 { status:'ok' } | { status:'empty', text, code } | { status:'fail', text }
+    //   | { status:'timeout', text }（task-mvsv8zym：超时单列形态，不再与真错误混记 fail——
+    //     超时可能只是慢模型+我方预算约束，由上层按首次尝试判定落定或保留既有观测）。
+    // attemptMs = 单次尝试独立超时（每尝试各拿满全额预算，非共享递减；task-mvsv8zym）。
+    // 每次尝试独立 AbortController/计时器；probeAbort 指向当前在飞尝试（dispose 时统一 abort）。
+    async function probeOnce(llm, model, maxTokens, attemptMs) {
+      var ac = new AbortController(), timedOut = false, disposeTimer = null
+      var attempt = Math.max(1, Number(attemptMs) || 0)
+      var slash = model.indexOf('/')
+      try {
+        if (ctx.timer && typeof ctx.timer.timeout === 'function') disposeTimer = ctx.timer.timeout(function () { timedOut = true; ac.abort() }, attempt)
+        else { var nativeTimer = setTimeout(function () { timedOut = true; ac.abort() }, attempt); disposeTimer = function () { clearTimeout(nativeTimer) } }
+        probeAbort[model] = ac
+        var stream = llm.stream({ provider: model.slice(0, slash), model: model.slice(slash + 1), messages: [{ role: 'user', content: [{ type: 'text', text: 'ping' }] }], maxTokens: maxTokens, signal: ac.signal })
+        var finished = false, failure = '', failureCode = ''
+        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 || '模型探测失败')
+            failureCode = String((reason.failure && reason.failure.code) || '')
+          }
+        }
+        if (timedOut) return { status: 'timeout', text: 'probe timeout ' + Math.round(attempt) + 'ms' }
+        if (!finished) return { status: 'fail', text: '模型探测流未返回 finish' }
+        if (failure) return isEmptyResponse(failureCode, failure) ? { status: 'empty', text: failure, code: failureCode } : { status: 'fail', text: failure }
+        return { status: 'ok' }
+      } catch (e) {
+        // 抛错形态（provider 直接 throw LlmError）：code 可能带 EMPTY_RESPONSE，文本兜底同一谓词
+        if (timedOut) return { status: 'timeout', text: 'probe timeout ' + Math.round(attempt) + 'ms' }
+        var text = String(e && e.message || e)
+        return isEmptyResponse(e && e.code, text) ? { status: 'empty', text: text, code: String(e && e.code || '') } : { status: 'fail', text: text }
+      } finally {
+        try { if (typeof disposeTimer === 'function') disposeTimer() } catch (_) {}
+      }
+    }
     async function probeModel(sid, model) {
       if (probeDisposed) return null
       if (probeInFlight[model]) return probeInFlight[model]
@@ -212,54 +412,92 @@ export function createDispatch(ctx, state, deps) {
       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 started = Date.now()
       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 || '模型探测失败')
+          var outcome = await probeOnce(llm, model, PROBE_MAX_TOKENS, PROBE_ATTEMPT_TIMEOUT_MS)
+          if (outcome.status === 'timeout') {
+            // ③ 首探即超时（task-mvsv8zym）：无重试（⑬e 契约保留），且不覆盖既有观测——只更新 note
+            // （判定保留）：超时可能只是慢模型+我方预算约束，已 healthy/degraded 条目不倒退成 unknown。
+            observeModel(sid, model, false, { probe: true, preserveObserved: true, note: String(outcome.text || '').slice(0, 300) })
+            return false
           }
-          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)
+          if (outcome.status === 'empty') {
+            // 空响应 = 唯一触发重试的形态（真错误/超时/无 finish 一次定性，不重试）
+            if (probeDisposed) {
+              // 探测已停（dispose 中断）：无重试机会，仍按错误码分治落定（停机是我方调度约束，非模型健康信号）
+              var budgetText = '空响应且探测已停（不重试，零内容）：' + outcome.text
+              outcome = classifyEmptyResponse(outcome.code, outcome.text) === 'degraded'
+                ? { status: 'degraded', text: budgetText }
+                : { status: 'fail', text: budgetText }
+            } else {
+              var first = outcome
+              outcome = await probeOnce(llm, model, PROBE_MAX_TOKENS_RETRY, PROBE_ATTEMPT_TIMEOUT_MS)
+              // 重试仍空 = 按错误码分治（task-mvrqdw4k 用户拍板）：纯空响应=🟡degraded 存活（供应商怪癖，链路通）
+              // ——不喂冷却、路由仍可选用；额度/凭据/连接信号=真错，维持失败臂（quota 文本优先级高于空响应判定，
+              // ⑬b/⑬d 契约保留）。文案标明重试口径便于排查与嗅探归因。
+              if (outcome.status === 'empty') {
+                var emptyText = 'maxTokens=' + PROBE_MAX_TOKENS_RETRY + ' 重试仍空（EMPTY_RESPONSE）：' + outcome.text
+                outcome = classifyEmptyResponse(outcome.code, outcome.text) === 'degraded'
+                  ? { status: 'degraded', text: emptyText }
+                  : { status: 'fail', text: emptyText }
+              } else if (outcome.status === 'timeout') {
+                // ② 重试超时≠失败（task-mvsv8zym）：每尝试独立 20s 预算仍耗尽=慢模型，沿用首次尝试判定落定
+                // ——与「探测已停」分支同原则（我方预算/停机约束非模型健康信号，L407-412 对称补齐）：
+                // 首探纯空响应→🟡degraded；首探文本带额度/凭据/连接信号→fail（嗅探接管）。
+                var firstVerdict = classifyEmptyResponse(first.code, first.text)
+                outcome = firstVerdict === 'degraded'
+                  ? { status: 'degraded', text: '重试预算耗尽（慢模型），沿用首探判定：' + String(first.text || '') }
+                  : { status: 'fail', text: '重试预算耗尽（慢模型），沿用首探判定：' + String(first.text || '') }
+              }
+            }
+          }
+          if (outcome.status === 'ok') {
+            observeModel(sid, model, true, { probe: true, latencyMs: Date.now() - started })
+            return true
+          }
+          if (outcome.status === 'degraded') {
+            // 🟡 降级存活臂（task-mvrqdw4k）：记存活不记失败——observeModel 落 degraded 派生态；
+            // 不调 sniffModelCooldown（冷却表零登记）；recentRuns 不动（探测本就不进 recentRuns，观察臂已隔开）。
+            observeModel(sid, model, false, { probe: true, degraded: true, latencyMs: Date.now() - started, note: String(outcome.text || '').slice(0, 300) })
+            return 'degraded'
+          }
+          var text = String(outcome.text || '模型探测失败').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
+        } catch (e) {
+          // 兜底臂（probeOnce 自吞错，理论不可达）：语义与旧实现逐字一致
+          var failText = String(e && e.message || e).slice(0, 300)
+          observeModel(sid, model, false, { probe: true, latencyMs: Date.now() - started, note: failText })
+          if (!probeDisposed) { try { await sniffModelCooldown(sid, '', model, failText) } 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 }
+      if (!c.probeEnabled) return { disabled: true, models: models, probed: 0, degraded: 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
+      if (!llm || typeof llm.stream !== 'function') return { disabled: false, unavailable: true, models: models, probed: 0, degraded: 0 }
+      var probed = 0, healthy = 0, degraded = 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
+        var outcome = await probeModel(sid, models[m])
+        if (outcome === null) continue
         if (before) probed++
-        if (ok === true) healthy++
+        // task-mvrqdw4k：probeModel 三态消费——true=🟢存活、'degraded'=🟡降级存活（供应商怪癖）、false=失败
+        if (outcome === true) healthy++
+        else if (outcome === 'degraded') degraded++
       }
-      return { disabled: false, models: models, probed: probed, healthy: healthy }
+      return { disabled: false, models: models, probed: probed, healthy: healthy, degraded: degraded }
     }
     // 15s 调度心跳驱动间隔闸：配置变化立即重排，探测在后台跑，不 await 进派发主链。
     function maybeProbeModels(sid, d) {
@@ -541,6 +779,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 +791,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 +811,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 +848,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 +872,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 +1015,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 分钟零结算实证），
@@ -945,9 +1194,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 会话不在线，无法授权续跑' }
@@ -1181,17 +1435,25 @@ export function createDispatch(ctx, state, deps) {
     // 三分支：verdict=split → applyDecomposeProposal 物化（幂等清旧批 draft 提案）+ 源卡摘要消息 + 通知；
     //         verdict=keep → 源卡记「无需拆分：rationale」；
     //         run 失败 / structured 缺失 / 提案畸形 → 源卡记失败原因 + 通知（源卡与旧提案批都不动）。
-    // 通知走 pushSysNote 且**不带 taskId**：源卡停在 draft/pending，带 taskId 的系统通知会在回执冲刷时
-    // 被「任务仍在执行中」过滤器整行丢弃（notify.mjs deliver 段）——提案到位是必须送达的信号。
+    // 通知（task-mvrqiu6x）：split/keep 成功改走 notifyDecomposed（pushReceipt 聚合内核出「🧩 已拆解」分区，
+    // 受 notifyDone 开关约束）——源卡按设计停在 draft/pending，旧实现借 pushSysNote 系统通道绕行
+    // 「带 taskId 会被仍在执行中过滤器丢弃」的墙，代价是成功信号伪装成「⚠️ 系统异常」；
+    // 失败分支保持 pushSysNote 🚨 不变（异常就该是异常）。
     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
+      var srcTitle = ''
+      // 完成回执开关（设置区「通知」notifyDone，task-mvrqiu6x）：同一次持锁回调里读看板文档（零额外读盘，
+      // 与 settleWorker/settleVerifier 写法一致）；缺字段 → cfg 归一为 true，宁可多报不漏报。
+      var doneOn = true
       try {
         applied = await mutateLocked(sid, function (d) {
           var t = d.tasks.find(function (x) { return x.id === rec.taskId })
           if (!t) return null
+          srcTitle = t.title
+          doneOn = cfg(d).notifyDone !== false
           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' })
@@ -1205,9 +1467,14 @@ export function createDispatch(ctx, state, deps) {
         }, 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))
+        // 拆解官正式回执：走 notifyDecomposed（「🧩 已拆解」聚合分区，notifyDone 闸门同完成回执口径；
+        // 源卡 messages 的「🧩 拆解提案已就位/无需拆分」留痕已由 applyDecomposeProposal 落卡，
+        // 关开关时留痕照旧不丢）——成功信号不再借系统通道伪装异常。
+        if (applied && applied.ok && applied.verdict === 'split') {
+          if (doneOn && typeof notifyDecomposed === 'function') notifyDecomposed(sid, { sourceId: rec.taskId, sourceTitle: srcTitle, verdict: 'split', children: applied.children, reason: '' })
+        } else if (applied && applied.ok && applied.verdict === 'keep') {
+          if (doneOn && typeof notifyDecomposed === 'function') notifyDecomposed(sid, { sourceId: rec.taskId, sourceTitle: srcTitle, verdict: 'keep', children: [], reason: structured ? String(structured.rationale == null ? '' : structured.rationale).trim().slice(0, 150) : '' })
+        } 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)) }
     }
 
@@ -1531,12 +1798,47 @@ export function createDispatch(ctx, state, deps) {
         })
       } catch (e) { console.error('[task-board] agent/status 处理失败:', String(e)) }
     }
+    // 可映射帧流的会话 id：continuable 用 childId；activation 一次性 run 在创建时显式记录 childId。
+    // 老 start 的 provider run id 不是会话身份，frameSessionId 为空，sweep 自动保留日志双闸。
+    function frameSessionIdOf(rec) {
+      if (!rec) return ''
+      return String(rec.continuable ? (rec.childId || '') : (rec.frameSessionId || ''))
+    }
+    var frameStreamSeen = false // 本 host 生命周期是否见过任意 assistant-stream 帧（薄桩/mock 零帧时全局兜底）
+    function onAssistantFrame(payload) {
+      try {
+        if (!payload || !payload.frame) return
+        var agent = payload.agent
+        var cid = agent ? String((agent.session && agent.session.id) || agent.id || '') : ''
+        if (!cid) return
+        frameStreamSeen = true
+        var table = state.activeRuns
+        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.settled) return
+            var mapped = frameSessionIdOf(rec)
+            // 事件本身就是身份证据：手工重建/旧形态 rec 若 id 命中，也可安全建立映射；
+            // 老 start 的 provider run id 通常不命中，保持日志闸。
+            if (!mapped && String(rec.id || '') === cid) { rec.frameSessionId = cid; mapped = cid }
+            if (mapped !== cid) return
+            // start/chunk/end 全算活；chunk 不过滤 chunk.type，reasoning-delta 同样刷新。只进内存，绝不逐帧写盘。
+            rec.lastFrameAt = Date.now()
+            rec.frameDirty = true // sweep 据此识别“本轮前有新帧”；不能拿持久基线与时间戳比大小（E2E 会倒推基线）
+          })
+        })
+      } catch (e) { console.error('[task-board] agent/assistant-stream 处理失败:', String(e)) }
+    }
     // 注册（cordis 标准事件订阅）：返回的 disposer 交给 ctx.effect 回收。
     // 老宿主/测试桩上没有 ctx.on 时静默跳过——派发照常，只是没有事件结算通道（一次性路径本就不需要）。
     if (typeof ctx.on === 'function') {
       try {
         ctx.effect(function () { return ctx.on('agent/status', onAgentStatus) })
       } catch (e) { console.error('[task-board] agent/status 订阅失败:', String(e)) }
+      try {
+        ctx.effect(function () { return ctx.on('agent/assistant-stream', onAssistantFrame) })
+      } catch (e) { console.error('[task-board] agent/assistant-stream 订阅失败:', String(e)) }
     }
 
     async function settleWorker(sid, rec, output, failed, errText) {
@@ -1561,7 +1863,7 @@ export function createDispatch(ctx, state, deps) {
           // = 模型面失败，计入熔断连击——原形 task-mvoutja4：glm-5.3-flash 秒拆 ×3 不计入 badModels，
           // 熔断永不触发，档位链每轮重派都再选同一个坏模型。连续 3 次才拉黑（熔断语义不变：badModels
           // 落黑名单 → 取模链跳过 + 健康表 circuit）；worker 自己的失误不计，成功 run 归零（settleRunRecord）。
-          if (rec.model && isModelKillFailure(errText)) feedModelFailure(sid, rec.model)
+          if (rec.model && isModelKillFailure(errText)) feedModelFailure(sid, rec.model, isHungKillFailure(errText) ? HUNG_CIRCUIT_WHY : undefined)
           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 }
@@ -1906,6 +2208,131 @@ export function createDispatch(ctx, state, deps) {
       return swept.length
     }
 
+    // ===== 挂死零产出检测（task-mvqcoz9l）：在跑 worker/verifier run 日志字节零增长判死重派+喂熔断 =====
+    // 原形（2026-10-27 降级实测）：glm-5.2 续跑挂上「连接开着永不响应」形态——会话不死（死会话哨兵
+    // listChildren 查不出）、不报错（无 settle 事件）、零产出（日志零增长 7 分钟），running 假相直到
+    // 人工终止。熔断/冷却/哨兵全部够不着它。修法：每轮对在跑 worker/verifier run 比对会话日志字节数
+    // （logSizeOf）与 run 留档的 lastLogBytes（新字段，每轮写回）：连续 HUNG_ZERO_GROWTH_ROUNDS 轮
+    // 零增长且距基线 ≥600s 墙钟地板（固定值，task-mvrt9tn5 二度校准：延迟缩放作废）→ 判定挂死：settleRun 失败臂（记「挂死零产出」，errText
+    // 前缀 HUNG_KILL_PREFIX 进 isModelKillFailure 白名单）+ 计入该模型熔断连击（挂死=模型面故障）+
+    // 卡重派（settleWorker 失败臂回 pending / settleVerifier 失败臂重排审查）。活体增长即清零计数。
+    // 边界（宁少勿多）：
+    //   ① 只盖 worker/verifier 在跑 rec（!settled）——decomposer/hook 产出形态不同，不进本检测；
+    //   ② 留档行缺失（rec 刚 spawn、recordRunHistory 未落盘）→ 无锚点跳过，下轮再判，绝不在无锚点时判死；
+    //   ③ 首见 lastLogBytes 只记基线不计数（老数据无字段同理）——绝不在第一眼把可能真在跑的 run 判死；
+    //   ④ 活体增长（size>prev）即清零计数+刷新基线（零增长窗口重新起算）——正常 run 行为零变化；
+    //   ⑤ 字节预读在锁外（logSizeOf 走 findRunLog/statSync），比对与计数在锁内（与留档行同一次原子写）；
+    //   ⑥ 判死结算在锁外：settleRun 自带认领守卫（runsFor[taskId]!==rec 早退）+ 自己的锁段——结算通道
+    //      抢先（事件/上报/终止）则跳过，绝不重复判死；幂等（判死后 rec 摘表，下轮零候选）。
+    //   ⑦ 返回本轮判死条数（0=无候选/无判死；调用方据此决定要不要重读快照）。
+    async function hungZeroOutputSweep(sid, runs, snap) {
+      var cands = []
+      Object.keys(runs).forEach(function (k) {
+        var rec = runs[k]
+        if (rec && !rec.settled && (rec.role === 'worker' || rec.role === 'verifier')) cands.push(rec)
+      })
+      if (!cands.length || !snap || snap.__noPersist || !Array.isArray(snap.tasks)) return 0
+      // ⑤ 字节预读在锁外且只服务兜底候选：帧流已生效且 rec 可映射时不再读日志。
+      var sizes = {}
+      cands.forEach(function (rec) {
+        if (frameStreamSeen && frameSessionIdOf(rec)) return
+        sizes[String(rec.id)] = logSizeOf(String(rec.childId || rec.id))
+      })
+      var hung = [], hungWhy = {}
+      await mutateLocked(sid, function (d) {
+        if (!d || !Array.isArray(d.tasks)) return null
+        var any = false
+        cands.forEach(function (rec) {
+          try {
+            var rid = String(rec.id)
+            var t = null
+            for (var i = 0; i < d.tasks.length; i++) { if (d.tasks[i] && d.tasks[i].id === rec.taskId) { t = d.tasks[i]; break } }
+            if (!t || !Array.isArray(t.runs)) return // ② 卡不存在/无留档：无锚点不判
+            var row = null
+            for (var j = t.runs.length - 1; j >= 0; j--) {
+              var r0 = t.runs[j]
+              if (r0 && String(r0.id) === rid && r0.outcome === 'running') { row = r0; break } // 本轮在跑的那条（同 id 首派+续跑取最新）
+            }
+            if (!row) return // ② 留档缺失：无锚点不判
+            // ===== v2 帧活性主路径：全局见过帧 + 本 rec 有可映射会话 id 才启用 =====
+            // 薄桩/mock/老 host 零帧，或老 start provider run id 不可映射 → 直接落下方原日志双闸，存量语义逐字不变。
+            if (frameStreamSeen && frameSessionIdOf(rec)) {
+              var nowFrame = Date.now()
+              var lastFrameAt = Number(rec.lastFrameAt || 0)
+              var frameSince = typeof row.frameSilenceSince === 'number' ? row.frameSilenceSince : 0
+              // 事件只置内存 dirty，sweep 消费后才算“帧恢复”：删持久基线；静默未满 600s 时同步清疑似标卡。
+              // 刻意不比较 frameSince < lastFrameAt——E2E 倒推持久基线也满足该大小关系，会把判死编排误吃成恢复。
+              var hadFrame = rec.frameDirty === true
+              rec.frameDirty = false
+              if (hadFrame) {
+                var recoverySilence = frameSince ? nowFrame - frameSince : 0
+                if (frameSince) { delete row.frameSilenceSince; any = true }
+                if (t.stuckSince && recoverySilence < HUNG_FRAME_KILL_MS) {
+                  delete t.stuckSince
+                  ah(t, t.status, t.status, String(rec.id), 'assistant 帧恢复（静默不足 600s），清除疑似卡顿标记')
+                  any = true
+                }
+                return
+              }
+              // 零帧 sweep：基线取最近帧，未见过本会话帧则取 startedAt；仅基线缺失时写，安静轮不刷盘。
+              // E2E 可 patchBoard 倒推 frameSilenceSince（虚拟时钟推不动 Date.now），与旧日志基线同款可测性。
+              if (!frameSince) {
+                frameSince = lastFrameAt || Number(rec.startedAt || nowFrame)
+                row.frameSilenceSince = frameSince
+                any = true
+              }
+              var frameSilentMs = nowFrame - frameSince
+              if (frameSilentMs >= HUNG_FRAME_KILL_MS) {
+                hung.push(rec)
+                hungWhy[rid] = HUNG_KILL_PREFIX + '帧静默 ' + Math.round(HUNG_FRAME_KILL_MS / 1000) + 's，判挂死按模型面故障结算重派'
+                return
+              }
+              if (frameSilentMs >= HUNG_FRAME_SUSPECT_MS && !t.stuckSince) {
+                t.stuckSince = nowFrame
+                ah(t, t.status, t.status, String(rec.id), '🟡 疑似卡顿：assistant 帧静默 ' + Math.round(HUNG_FRAME_SUSPECT_MS / 1000) + 's（仅标卡，不终止）')
+                any = true
+              }
+              return
+            }
+            var size = sizes[rid]
+            var prev = typeof row.lastLogBytes === 'number' ? row.lastLogBytes : null
+            if (prev === null) { row.lastLogBytes = size; row.zeroGrowthSince = Date.now(); any = true; return } // ③ 首见只记基线
+            if (size > prev) { // ④ 活体增长：清零计数 + 刷新基线（零增长窗口重新起算）
+              row.lastLogBytes = size; row.zeroGrowthSince = Date.now()
+              if (row.zeroGrowthRounds) delete row.zeroGrowthRounds
+              any = true; return
+            }
+            row.zeroGrowthRounds = (row.zeroGrowthRounds || 0) + 1
+            any = true
+            var since = typeof row.zeroGrowthSince === 'number' ? row.zeroGrowthSince : 0
+            // 墙钟闸（task-mvrt9tn5 定稿）：固定 600s 地板——延迟与长生成静默时长无关（三连误杀实证），不再读健康表缩放
+            if (row.zeroGrowthRounds >= HUNG_ZERO_GROWTH_ROUNDS && since && Date.now() - since >= HUNG_WALL_FLOOR_MS) hung.push(rec)
+          } catch (e) { console.error('[task-board] 挂死检测判定失败 (run ' + (rec && rec.id) + '):', String(e)) }
+        })
+        return any ? d : null // 无改动返回 null → 不写盘（安静板纪律；有活跃 run 时主锁本就每轮写池快照，增量零额外写）
+      }, true) // skipKick：本轮已是 poolCycle；判死结算自会 kick（settleWorker 尾部）
+      // ⑥ 判死结算在锁外：失败臂（记「挂死零产出」）+ 熔断连击 + 卡重派。errText 避开冷却嗅探关键词，
+      // 挂死只进连击不进冷却（settleWorker 失败臂 sniffModelCooldown 对该文本零命中）。
+      var killed = 0
+      for (var hi = 0; hi < hung.length; hi++) {
+        var hrec = hung[hi]
+        try {
+          if (hrec.settled || runsFor(sid)[hrec.taskId] !== hrec) continue // 结算通道已抢先，不重复判
+          killed++
+          // 判死文案带出实际生效阈值（task-mvrt9tn5）：固定值直述「阈值 600s」——不引用健康表延迟，
+          // 也不再有「3×0s」假精确 / 「地板值，无实测延迟」分态（缩放已删，阈值对任何模型同值）。
+          var wallTxt = Math.round(HUNG_WALL_FLOOR_MS / 1000) + 's'
+          // 帧路径只换诊断文案；settleRun 失败臂、HUNG_KILL_PREFIX、熔断与重派链全部复用。
+          var why = hungWhy[String(hrec.id)] || (HUNG_KILL_PREFIX + '连续 ' + HUNG_ZERO_GROWTH_ROUNDS + ' 轮会话日志零增长（零产出），超挂死墙钟阈值 ' + wallTxt + '，判挂死按模型面故障结算重派')
+          console.log('[task-board] 挂死零产出判死（' + sid + '）：task ' + hrec.taskId + ' run ' + hrec.id + ' ' + why)
+          // err 传裸字符串（settleRun 只做 !!err / String(err)）：new Error 会被 String(err) 包上
+          // 'Error: ' 前缀，isModelKillFailure 的前缀锚定（index 0）失效 → 熔断连击漏喂。
+          await settleRun(sid, hrec, null, why)
+        } catch (e) { console.error('[task-board] 挂死判死结算失败 (task ' + hrec.taskId + '):', String(e)) }
+      }
+      return killed
+    }
+
     // ===== 幽灵占位回收（池冻结根修，task-muwlepg6）=====
     // 病根（活体实证）：活跃表项（rec）的**唯一**摘除点是各结算通道（事件通道 settleRun /
     // 上报通道 settleReportedRun / 手动终止）。任何一条漏走（worker 经 board_report 完成但当时
@@ -2037,6 +2464,13 @@ export function createDispatch(ctx, state, deps) {
         // 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 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，