mslxdff 0.1.226 → 0.1.228

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.226",
+  "version": "0.1.228",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/chat-pipeline/index.js

@@ -101,7 +101,11 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     }
     if (!order.length) order = [""];
     const canFallback = order.length > 1;
-    const canForwardPeers = Boolean(peers) && hops < (maxHops ?? 3);
+    // hi 探针（x-mslxdff-probe:1）只问「这台机器此刻能不能打通上游」，不代表真实业务：
+    // 它绝不能再触发本机的组员/宽带接力——否则探针会跟着走完整条接力链（最坏 45s 预算），
+    // 而调用方只看它几百毫秒内活不活。组员侧就地直连，成败如实回给调用方。
+    const isProbe = String(req?.headers?.["x-mslxdff-probe"] || "") === "1";
+    const canForwardPeers = !isProbe && Boolean(peers) && hops < (maxHops ?? 3);
     mark("ordered");
 
     const reqIp = clientIp(req); // 一次解析两处用：request 事件的 ip 字段 + 回路语料的 clientIp（routes/helpers.js 取 x-forwarded-for 首段）
@@ -125,7 +129,7 @@ export function createChatPipeline({ upstream, auto, logs, peers, groups, bus, t
     const clientSession = String(req?.headers?.["x-session-affinity"] || req?.headers?.["x-session-id"] || "").trim() || null;
     // triedUrls 挂请求级并**按引用**共享：同一请求内"同一组员不重复试"的契约跨候选生效
     // （peer 阶段各分支会 spread 出上下文副本，集合在这里建一次才不会各存一份）。
-    const handlerCtx = { reqId, api, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid, sessionId: clientSession, clientIp: reqIp, triedUrls: new Set() };
+    const handlerCtx = { reqId, api, model: null, body: req?.body, hops, peers, plugins, evt, logError, logCall, logs, workbuddyUid, sessionId: clientSession, clientIp: reqIp, triedUrls: new Set(), isProbe };
     if (clientSession) evt("client-session", { reqId, sessionId: clientSession.slice(0, 24) });
 
     await engine.run({

package/src/chat-pipeline/serial-trial.js

@@ -100,7 +100,9 @@ export async function runSerialTrial(ctx, deps = {}) {
     const chatOptsArg = Object.keys(chatOpts).length ? chatOpts : undefined;
     // 空转 200（模型无输出）同模型暂停重试：默认 3 次、阶梯 [2s,8s,30s]；仅 EMPTY_MODEL_RESPONSE，
     // 429/403/500 与 fetch 异常走原有切号/failover（防烧额度）。MSLXDFF_EMPTY_TURN_RETRIES=0 关闭。
-    const emptyCfg = emptyRetryCfg();
+    // 探针（x-mslxdff-probe:1）不重试：调用方只要一个「活不活」的答案，重试阶梯会把它吊 40s。
+    const isProbe = handlerCtx?.isProbe === true;
+    const emptyCfg = isProbe ? { max: 0, steps: null, delayMs: 0 } : emptyRetryCfg();
     const raiseCap = emptyRaiseCap();
     const nudgeCfg = emptyNudgeCfg();
     let emptyRetried = 0;

package/src/cli/format.js

@@ -62,6 +62,8 @@ export function fmtEvent(e) {
       return `${head} peer check    ${e.peer} -> ${e.count ? e.healthy.join(", ") : "no healthy models"}${e.strict ? " (strict)" : ""}`;
     case "peer-request":
       return `${head} peer req      并发发出 peer=${e.peer} model=${m(e.model)} hops=${e.hops}`;
+    case "peer-probe":
+      return `${head} peer hi       备选探活 peer=${e.peer} ${e.ok ? "ok" : `fail HTTP ${e.status ?? "network"}`} model=${m(e.model)} ${e.latencyMs ? `${e.latencyMs}ms` : ""}${e.action === "skip" ? " → 跳过换下一个" : ""}`;
     case "peer-forward":
       return `${head} peer resp     收到响应 peer=${e.peer} model=${m(e.model)} ${e.ok ? "ok" : "fail"} ${e.latencyMs ? `${e.latencyMs}ms` : ""} hops=${e.hops}${e.retry ? " (retry)" : ""}`;
     case "peer-error":

package/src/peers.js

@@ -1,307 +1,345 @@
-import { loadPeers, savePeers, loadPeerErrors, savePeerErrors, loadPeerStats, savePeerStats } from "./state.js";
-
-// 组员失败冷却分级（2026-10-18 用户拍板）：
-// 非额度失败（502/5xx/超时，可能几秒就恢复）→ 短冷却 10s，到点自动重新纳入候选、继续挨个重试；
-// 额度类（连续 2 次 429）→ 长冷却 10min（额度当天不会因快重试恢复，反复撞只会白烧配额）。
-export const DEFAULT_PEER_COOLDOWN_MS = 10_000;
-export const DEFAULT_PEER_LIMIT_COOLDOWN_MS = 10 * 60_000;
-export const DEFAULT_PEER_HEAT_MS = 5 * 60_000;
-export const DEFAULT_MAX_HOPS = 3;
-export const DEFAULT_BROADBAND_STALE_MS = 90_000;
-// 连续几次连接级失败即视为"这个地址没服务"，进长冷却（不再靠 30s 短冷却反复捞回）。
-export const DEAD_FAIL_THRESHOLD = 2;
-
-const EMA_ALPHA = 0.3;
-
-export function broadbandStaleMs() {
-  const n = Number(process.env.MSLXDFF_BROADBAND_STALE_MS);
-  return Number.isInteger(n) && n > 0 ? n : DEFAULT_BROADBAND_STALE_MS;
-}
-
-export function isBroadbandStale(peer, nowMs = Date.now(), staleMs = broadbandStaleMs()) {
-  const kind = peer?.kind || (String(peer?.url || "").startsWith("relay://") ? "broadband" : "static");
-  if (kind !== "broadband") return false;
-  const lastSeen = peer?.lastSeen;
-  if (typeof lastSeen !== "number") return true; // no heartbeat yet => stale
-  return nowMs - lastSeen > staleMs;
-}
-
-export function normalizePeerUrl(url) {
-  return String(url || "").trim().replace(/\/+$/, "");
-}
-
-export function createPeersService({
-  file,
-  now = () => Date.now(),
-  cooldownMs = DEFAULT_PEER_COOLDOWN_MS,
-  limitCooldownMs = DEFAULT_PEER_LIMIT_COOLDOWN_MS,
-  heatMs = DEFAULT_PEER_HEAT_MS,
-  peers: seedPeers,
-  errors: seedErrors,
-  stats: seedStats,
-  persistPeers = (list, f = file) => savePeers(list, f ? { file: f } : {}),
-  persistErrors = (errors, f = file) => savePeerErrors(errors, f ? { file: f } : {}),
-  persistStats = (stats, f = file) => savePeerStats(stats, f ? { file: f } : {}),
-} = {}) {
-  const list = (seedPeers ?? loadPeers(file ? { file } : {}))
-    .map((p) => ({ ...p, url: normalizePeerUrl(p.url) }))
-    .filter((p) => p && p.url);
-  const lastErrorAt = { ...(seedErrors ?? loadPeerErrors(file ? { file } : {})) };
-  const stats = { ...(seedStats ?? loadPeerStats(file ? { file } : {})) };
-
-  function all() {
-    return [...list];
-  }
-
-  function add(peer) {
-    const url = normalizePeerUrl(peer?.url);
-    if (!url) return false;
-    const existing = list.find((p) => p.url === url);
-    const entry = { ...peer, url };
-    if (existing) Object.assign(existing, entry);
-    else list.push(entry);
-    persistPeers([...list]);
-    return true;
-  }
-
-  function remove(url) {
-    const target = normalizePeerUrl(url);
-    const idx = list.findIndex((p) => p.url === target);
-    if (idx < 0) return false;
-    list.splice(idx, 1);
-    persistPeers([...list]);
-    return true;
-  }
-
-  function removeByGroup(group) {
-    const before = list.length;
-    for (let i = list.length - 1; i >= 0; i--) {
-      if (list[i].group === group) list.splice(i, 1);
-    }
-    if (list.length !== before) persistPeers([...list]);
-    return before - list.length;
-  }
-
-  // 分级冷却：连续 429（streak >= 2）→ limitCooldownMs（限流恢复慢，5min 内不再考虑）；
-  // 连接级永久失败（ECONNREFUSED/ENOTFOUND，deadFails >= 2）同样进长冷却；
-  // 其他失败（网络抖动、5xx）→ cooldownMs（可能几秒恢复，给快速重试机会）。
-  function coolingWindowMs(url) {
-    if ((stats[url]?.deadFails ?? 0) >= DEAD_FAIL_THRESHOLD) return limitCooldownMs;
-    const streak = stats[url]?.streak429 ?? 0;
-    return streak >= 2 ? limitCooldownMs : cooldownMs;
-  }
-
-  // 连接级失败（端口没服务/DNS 解析不了）与"这一发不顺"是两回事：前者换多少次都一样，
-  // 现网 node-b（127.0.0.1:3500，本机根本没服务）靠 30s 短冷却 + 兜底，被反复竞速 1569 次。
-  function isConnLevelFailure(message) {
-    const s = String(message || "");
-    return /ECONNREFUSED|ENOTFOUND|ENETUNREACH|EHOSTUNREACH|ECONNRESET|fetch failed|connect (?:timeout|ETIMEDOUT)|socket hang up/i.test(s);
-  }
-
-  function isCooling(url) {
-    const win = coolingWindowMs(url);
-    if (!win) return false;
-    const err = lastErrorAt[url];
-    if (typeof err === "number" && now() - err < win) return true;
-    const peer = list.find((p) => p.url === url);
-    if (peer && isBroadbandStale(peer, now(), broadbandStaleMs())) return true;
-    return false;
-  }
-
-  function isBroadbandCooling(url) {
-    const peer = list.find((p) => p.url === url);
-    if (!peer) return false;
-    return isBroadbandStale(peer, now(), broadbandStaleMs());
-  }
-
-  function available() {
-    return list.filter((p) => !isCooling(p.url));
-  }
-
-  // A peer counts as "hot" when it succeeded recently: reuse its last model
-  // without a fresh health probe to keep the fast path fast.
-  function isHot(url, t = now()) {
-    if (isCooling(url)) return false;
-    const s = stats[url];
-    return Boolean(s?.okAt) && t - s.okAt < heatMs;
-  }
-
-  function stat(url) {
-    return stats[url] ? { ...stats[url] } : null;
-  }
-
-  function rankScore(p, t) {
-    const s = stats[p.url];
-    const hot = s?.okAt && t - s.okAt < heatMs ? 0 : 1;
-    const latency = s?.latencyMs != null ? s.latencyMs : 1_000_000;
-    const fails = s?.fails ?? 0;
-    return hot * 1_000_000_000 + latency * 1_000 + fails;
-  }
-
-  // 可用组员排序（用户 2026-10-19 决定）：**延迟最小优先**，不再「热优先」。
-  // 语义 = 「组员的额度用完后，用跟组长延迟最小的组员」——延迟是首要判据。
-  // 延迟来源（优先级从高到低）：
-  //   ① stats 里的真实请求 EMA（recordResult 记的 latencyMs）——最可信；
-  //   ② peer.heartbeatLatencyMs —— 组员**定时心跳**上报的 rtt（没跑过真实请求时也能排序）；
-  // 未测过延迟的排在有数据之后；同延迟按「最早失败优先」；都没失败过的排最后。
-  // 组长识别：本机是组员时，peers 里有 name==="leader" 的记录（cli/group-test.js 同口径）。
-  // 组长自己节点视角没有这条记录 → isLeaderPeer 恒 false，退化为纯延迟排序（正是想要的行为）。
-  function isLeaderPeer(p) {
-    return String(p?.name || "").toLowerCase() === "leader";
-  }
-
-  function peerLatency(p) {
-    const s = stats[p.url]?.latencyMs;
-    if (s != null) return s;
-    const hb = list.find((x) => x.url === p.url)?.heartbeatLatencyMs;
-    return Number.isFinite(Number(hb)) ? Number(hb) : null;
-  }
-
-  // 组员延迟升序（组长不参与），供两处复用：ordered 的第二档 + standbyChain。
-  function byLatencyAsc(a, b) {
-    const la = peerLatency(a);
-    const lb = peerLatency(b);
-    const ha = la != null, hb = lb != null;
-    if (ha !== hb) return ha ? -1 : 1;          // 有延迟数据的优先
-    if (ha && hb && la !== lb) return la - lb;  // 延迟小的先上
-    const ea = lastErrorAt[a.url];
-    const eb = lastErrorAt[b.url];
-    if (ea == null && eb == null) return 0;
-    if (ea == null) return 1;
-    if (eb == null) return -1;
-    return ea - eb;
-  }
-
-  // 用户 2026-10-20 约定：**组长恒定第一**（先榨干组长额度），组长用完再按延迟升序上组员。
-  // 之前是纯延迟排序，「9/9 走组长」只是组长恰好延迟最低的巧合（AGENTS.md 已记差距）。
-  function ordered(t = now()) {
-    return available().sort((a, b) => {
-      const la = isLeaderPeer(a), lb = isLeaderPeer(b);
-      if (la !== lb) return la ? -1 : 1; // 组长恒排第一
-      return byLatencyAsc(a, b);
-    });
-  }
-
-  /**
-   * 常驻接力链（用户 2026-10-20：永远准备一个备选，429 立即切）。
-   * IPv4 阶段：组长 → 组员(延迟升序)；IPv4 全用完才进 IPv6 阶段：先本机/组长 v6，
-   * 再按延迟升序找 hasV6 的组员。
-   * @returns {{ipv4: object[], ipv6: object[]}} 两段链，各自已排序
-   */
-  function standbyChain(t = now()) {
-    const ipv4 = available().sort((a, b) => {
-      const la = isLeaderPeer(a), lb = isLeaderPeer(b);
-      if (la !== lb) return la ? -1 : 1;
-      return byLatencyAsc(a, b);
-    });
-    // IPv6 阶段：只保留心跳自报 hasV6 的节点，同样组长优先、其余延迟升序
-    const ipv6 = ipv4.filter((p) => p.hasV6 === true);
-    return { ipv4, ipv6 };
-  }
-
-  /** 下一个备选：从链里取第一个还没试过的。这就是「永远准备好的那个」。 */
-  function nextStandby(tried, t = now()) {
-    const { ipv4, ipv6 } = standbyChain(t);
-    const skip = tried instanceof Set ? tried : new Set(tried || []);
-    return {
-      ipv4: ipv4.find((p) => !skip.has(p.url)) || null,
-      ipv6: ipv6.find((p) => !skip.has(p.url)) || null,
-    };
-  }
-
-  // Available peers ordered specifically for recovery-time retry: earliest
-  // failure first (it has had the longest to come back), never-failed last.
-  function orderedByLastError(t = now()) {
-    return available().sort((a, b) => {
-      const ea = lastErrorAt[a.url];
-      const eb = lastErrorAt[b.url];
-      if (ea == null && eb == null) return 0;
-      if (ea == null) return 1; // never-failed peers go after any that failed
-      if (eb == null) return -1;
-      return ea - eb; // earliest failure first
-    });
-  }
-
-  let cursor = 0;
-
-  // 兜底重试集合：仅"因错误冷却中"的 peer（按最早失败优先）。
-  // 场景：唯一可用节点偶发失败被冷却锁死 → 主链零候选/全败时，兜底给它一次机会；
-  // 成功会被 recordResult 清除错误记录、回归热路径，避免"明明能用的节点被 30s 冷却全灭"。
-  function coolingByLastError() {
-    const t = now();
-    return list
-      .filter((p) => {
-        const err = lastErrorAt[p.url];
-        if (typeof err !== "number") return false;
-        if ((stats[p.url]?.streak429 ?? 0) >= 2) return false; // 429 长冷却：兜底也不考虑
-        if ((stats[p.url]?.deadFails ?? 0) >= DEAD_FAIL_THRESHOLD) return false; // 连接级永久失败：兜底也不考虑（否则每次白等一次拒连）
-        return t - err < cooldownMs;
-      })
-      .sort((a, b) => (lastErrorAt[a.url] ?? 0) - (lastErrorAt[b.url] ?? 0));
-  }
-
-  function next() {
-    const avail = available();
-    if (!avail.length) return null;
-    cursor = cursor % avail.length;
-    return avail[cursor++];
-  }
-
-  // Long-lived error memory: a peer keeps its last-error timestamp until a
-  // subsequent success resets it (success clears the failure record) or the
-  // error is no longer in the persist store on next load.
-  async function recordError(url, { status, message } = {}) {
-    if (!url) return;
-    lastErrorAt[url] = now();
-    await persistErrors({ ...lastErrorAt });
-    // 连续 429 计数（仅成功清零）：第 2 次起进入长冷却——该 peer 大概率真被限流，不再频繁试它
-    if (Number(status) === 429) {
-      const prev = stats[url] || {};
-      stats[url] = { ...prev, streak429: (prev.streak429 || 0) + 1 };
-      await persistStats({ ...stats });
-    }
-    // 连接级失败计数（仅成功清零）：第 2 次起进长冷却，且不再被 coolingByLastError 兜底捞回
-    if (isConnLevelFailure(message)) {
-      const prev = stats[url] || {};
-      stats[url] = { ...prev, deadFails: (prev.deadFails || 0) + 1 };
-      await persistStats({ ...stats });
-    }
-  }
-
-  // Outcome of a forwarded request: ok updates the hot-cache (EMA latency,
-  // last successful model) and clears the error memory; failures keep the
-  // error timestamp so the retry pass can order by recovery time.
-  async function recordResult(url, { ok, latencyMs, model } = {}) {
-    if (!url) return;
-    if (ok) {
-      if (lastErrorAt[url] != null) {
-        delete lastErrorAt[url];
-        await persistErrors({ ...lastErrorAt });
-      }
-      const prev = stats[url] || {};
-      stats[url] = {
-        okAt: now(),
-        latencyMs: prev.latencyMs != null && typeof latencyMs === "number"
-          ? Math.round(prev.latencyMs * (1 - EMA_ALPHA) + latencyMs * EMA_ALPHA)
-          : (typeof latencyMs === "number" ? latencyMs : prev.latencyMs ?? 0),
-        fails: 0,
-        model: model || prev.model || "",
-        streak429: 0,
-        deadFails: 0,
-      };
-    } else {
-      const prev = stats[url] || {};
-      stats[url] = { ...prev, fails: (prev.fails || 0) + 1 };
-    }
-    await persistStats({ ...stats });
-  }
-
-  return {
-    all, add, remove, removeByGroup, isCooling, isBroadbandCooling, isBroadbandStale: (url) => {
-      const peer = list.find((p) => p.url === url);
-      return peer ? isBroadbandStale(peer, now(), broadbandStaleMs()) : false;
-    }, isHot, stat, ordered, orderedByLastError, coolingByLastError, available, next,
-    standbyChain, nextStandby, isLeaderPeer,
-    recordError, recordResult, errors: () => ({ ...lastErrorAt }), stats: () => ({ ...stats }),
-  };
-}
+import { loadPeers, savePeers, loadPeerErrors, savePeerErrors, loadPeerStats, savePeerStats } from "./state.js";
+
+// 组员失败冷却分级（2026-10-18 用户拍板）：
+// 非额度失败（502/5xx/超时，可能几秒就恢复）→ 短冷却 10s，到点自动重新纳入候选、继续挨个重试；
+// 额度类（连续 2 次 429）→ 长冷却 10min（额度当天不会因快重试恢复，反复撞只会白烧配额）。
+export const DEFAULT_PEER_COOLDOWN_MS = 10_000;
+export const DEFAULT_PEER_LIMIT_COOLDOWN_MS = 10 * 60_000;
+export const DEFAULT_PEER_HEAT_MS = 5 * 60_000;
+export const DEFAULT_MAX_HOPS = 3;
+export const DEFAULT_BROADBAND_STALE_MS = 90_000;
+// 连续几次连接级失败即视为"这个地址没服务"，进长冷却（不再靠 30s 短冷却反复捞回）。
+export const DEAD_FAIL_THRESHOLD = 2;
+// 探测失败（GET /health 连不上）视为"这个节点当前不可用"，10 分钟内不再当候选。
+// 与请求失败账分开：health 探测是**主动、零额度**的可用性判断，比"这一发不顺"更可信——
+// 现网 2026-10-20 13:27 req mvg8r7cz-b8qn：152.67.222.233:62028 早已 health timeout，
+// CLI/保热都探到了，但选路不知道，仍把它排进候选并吃满 20s 单次上限（总 27s）。
+export const DEFAULT_PEER_PROBE_DEAD_MS = 10 * 60_000;
+
+export function peerProbeDeadMs() {
+  const n = Number(process.env.MSLXDFF_PEER_PROBE_DEAD_MS);
+  return Number.isInteger(n) && n >= 0 ? n : DEFAULT_PEER_PROBE_DEAD_MS;
+}
+
+const EMA_ALPHA = 0.3;
+
+export function broadbandStaleMs() {
+  const n = Number(process.env.MSLXDFF_BROADBAND_STALE_MS);
+  return Number.isInteger(n) && n > 0 ? n : DEFAULT_BROADBAND_STALE_MS;
+}
+
+export function isBroadbandStale(peer, nowMs = Date.now(), staleMs = broadbandStaleMs()) {
+  const kind = peer?.kind || (String(peer?.url || "").startsWith("relay://") ? "broadband" : "static");
+  if (kind !== "broadband") return false;
+  const lastSeen = peer?.lastSeen;
+  if (typeof lastSeen !== "number") return true; // no heartbeat yet => stale
+  return nowMs - lastSeen > staleMs;
+}
+
+export function normalizePeerUrl(url) {
+  return String(url || "").trim().replace(/\/+$/, "");
+}
+
+export function createPeersService({
+  file,
+  now = () => Date.now(),
+  cooldownMs = DEFAULT_PEER_COOLDOWN_MS,
+  limitCooldownMs = DEFAULT_PEER_LIMIT_COOLDOWN_MS,
+  heatMs = DEFAULT_PEER_HEAT_MS,
+  peers: seedPeers,
+  errors: seedErrors,
+  stats: seedStats,
+  persistPeers = (list, f = file) => savePeers(list, f ? { file: f } : {}),
+  persistErrors = (errors, f = file) => savePeerErrors(errors, f ? { file: f } : {}),
+  persistStats = (stats, f = file) => savePeerStats(stats, f ? { file: f } : {}),
+} = {}) {
+  const list = (seedPeers ?? loadPeers(file ? { file } : {}))
+    .map((p) => ({ ...p, url: normalizePeerUrl(p.url) }))
+    .filter((p) => p && p.url);
+  const lastErrorAt = { ...(seedErrors ?? loadPeerErrors(file ? { file } : {})) };
+  const stats = { ...(seedStats ?? loadPeerStats(file ? { file } : {})) };
+
+  function all() {
+    return [...list];
+  }
+
+  function add(peer) {
+    const url = normalizePeerUrl(peer?.url);
+    if (!url) return false;
+    const existing = list.find((p) => p.url === url);
+    const entry = { ...peer, url };
+    if (existing) Object.assign(existing, entry);
+    else list.push(entry);
+    persistPeers([...list]);
+    return true;
+  }
+
+  function remove(url) {
+    const target = normalizePeerUrl(url);
+    const idx = list.findIndex((p) => p.url === target);
+    if (idx < 0) return false;
+    list.splice(idx, 1);
+    persistPeers([...list]);
+    return true;
+  }
+
+  function removeByGroup(group) {
+    const before = list.length;
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i].group === group) list.splice(i, 1);
+    }
+    if (list.length !== before) persistPeers([...list]);
+    return before - list.length;
+  }
+
+  // 分级冷却：连续 429（streak >= 2）→ limitCooldownMs（限流恢复慢，5min 内不再考虑）；
+  // 连接级永久失败（ECONNREFUSED/ENOTFOUND，deadFails >= 2）同样进长冷却；
+  // 其他失败（网络抖动、5xx）→ cooldownMs（可能几秒恢复，给快速重试机会）。
+  function coolingWindowMs(url) {
+    // 探测死亡（health 连不上）：10min 内不再考虑——比请求失败更可信的"没服务"证据
+    if (stats[url]?.probeDeadAt !== undefined && now() - stats[url].probeDeadAt < peerProbeDeadMs()) return limitCooldownMs;
+    if ((stats[url]?.deadFails ?? 0) >= DEAD_FAIL_THRESHOLD) return limitCooldownMs;
+    const streak = stats[url]?.streak429 ?? 0;
+    return streak >= 2 ? limitCooldownMs : cooldownMs;
+  }
+
+  // 连接级失败（端口没服务/DNS 解析不了）与"这一发不顺"是两回事：前者换多少次都一样，
+  // 现网 node-b（127.0.0.1:3500，本机根本没服务）靠 30s 短冷却 + 兜底，被反复竞速 1569 次。
+  function isConnLevelFailure(message) {
+    const s = String(message || "");
+    return /ECONNREFUSED|ENOTFOUND|ENETUNREACH|EHOSTUNREACH|ECONNRESET|fetch failed|connect (?:timeout|ETIMEDOUT)|socket hang up/i.test(s);
+  }
+
+  function isCooling(url) {
+    // 探测死亡（health 探不通）：10min 内不再当候选——比请求失败更可信的"没服务"证据
+    const pDead = stats[url]?.probeDeadAt;
+    if (pDead !== undefined && now() - pDead < peerProbeDeadMs()) return true;
+    const win = coolingWindowMs(url);
+    if (!win) return false;
+    const err = lastErrorAt[url];
+    if (typeof err === "number" && now() - err < win) return true;
+    const peer = list.find((p) => p.url === url);
+    if (peer && isBroadbandStale(peer, now(), broadbandStaleMs())) return true;
+    return false;
+  }
+
+  function isBroadbandCooling(url) {
+    const peer = list.find((p) => p.url === url);
+    if (!peer) return false;
+    return isBroadbandStale(peer, now(), broadbandStaleMs());
+  }
+
+  function available() {
+    return list.filter((p) => !isCooling(p.url));
+  }
+
+  // A peer counts as "hot" when it succeeded recently: reuse its last model
+  // without a fresh health probe to keep the fast path fast.
+  function isHot(url, t = now()) {
+    if (isCooling(url)) return false;
+    const s = stats[url];
+    return Boolean(s?.okAt) && t - s.okAt < heatMs;
+  }
+
+  function stat(url) {
+    return stats[url] ? { ...stats[url] } : null;
+  }
+
+  function rankScore(p, t) {
+    const s = stats[p.url];
+    const hot = s?.okAt && t - s.okAt < heatMs ? 0 : 1;
+    const latency = s?.latencyMs != null ? s.latencyMs : 1_000_000;
+    const fails = s?.fails ?? 0;
+    return hot * 1_000_000_000 + latency * 1_000 + fails;
+  }
+
+  // 可用组员排序（用户 2026-10-19 决定）：**延迟最小优先**，不再「热优先」。
+  // 语义 = 「组员的额度用完后，用跟组长延迟最小的组员」——延迟是首要判据。
+  // 延迟来源（优先级从高到低）：
+  //   ① stats 里的真实请求 EMA（recordResult 记的 latencyMs）——最可信；
+  //   ② peer.heartbeatLatencyMs —— 组员**定时心跳**上报的 rtt（没跑过真实请求时也能排序）；
+  // 未测过延迟的排在有数据之后；同延迟按「最早失败优先」；都没失败过的排最后。
+  // 组长识别：本机是组员时，peers 里有 name==="leader" 的记录（cli/group-test.js 同口径）。
+  // 组长自己节点视角没有这条记录 → isLeaderPeer 恒 false，退化为纯延迟排序（正是想要的行为）。
+  function isLeaderPeer(p) {
+    return String(p?.name || "").toLowerCase() === "leader";
+  }
+
+  function peerLatency(p) {
+    const s = stats[p.url]?.latencyMs;
+    if (s != null) return s;
+    const hb = list.find((x) => x.url === p.url)?.heartbeatLatencyMs;
+    return Number.isFinite(Number(hb)) ? Number(hb) : null;
+  }
+
+  // 组员延迟升序（组长不参与），供两处复用：ordered 的第二档 + standbyChain。
+  function byLatencyAsc(a, b) {
+    const la = peerLatency(a);
+    const lb = peerLatency(b);
+    const ha = la != null, hb = lb != null;
+    if (ha !== hb) return ha ? -1 : 1;          // 有延迟数据的优先
+    if (ha && hb && la !== lb) return la - lb;  // 延迟小的先上
+    const ea = lastErrorAt[a.url];
+    const eb = lastErrorAt[b.url];
+    if (ea == null && eb == null) return 0;
+    if (ea == null) return 1;
+    if (eb == null) return -1;
+    return ea - eb;
+  }
+
+  // 用户 2026-10-20 约定：**组长恒定第一**（先榨干组长额度），组长用完再按延迟升序上组员。
+  // 之前是纯延迟排序，「9/9 走组长」只是组长恰好延迟最低的巧合（AGENTS.md 已记差距）。
+  function ordered(t = now()) {
+    return available().sort((a, b) => {
+      const la = isLeaderPeer(a), lb = isLeaderPeer(b);
+      if (la !== lb) return la ? -1 : 1; // 组长恒排第一
+      return byLatencyAsc(a, b);
+    });
+  }
+
+  /**
+   * 常驻接力链（用户 2026-10-20：永远准备一个备选，429 立即切）。
+   * IPv4 阶段：组长 → 组员(延迟升序)；IPv4 全用完才进 IPv6 阶段：先本机/组长 v6，
+   * 再按延迟升序找 hasV6 的组员。
+   * @returns {{ipv4: object[], ipv6: object[]}} 两段链，各自已排序
+   */
+  function standbyChain(t = now()) {
+    const ipv4 = available().sort((a, b) => {
+      const la = isLeaderPeer(a), lb = isLeaderPeer(b);
+      if (la !== lb) return la ? -1 : 1;
+      return byLatencyAsc(a, b);
+    });
+    // IPv6 阶段：只保留心跳自报 hasV6 的节点，同样组长优先、其余延迟升序
+    const ipv6 = ipv4.filter((p) => p.hasV6 === true);
+    return { ipv4, ipv6 };
+  }
+
+  /** 下一个备选：从链里取第一个还没试过的。这就是「永远准备好的那个」。 */
+  function nextStandby(tried, t = now()) {
+    const { ipv4, ipv6 } = standbyChain(t);
+    const skip = tried instanceof Set ? tried : new Set(tried || []);
+    return {
+      ipv4: ipv4.find((p) => !skip.has(p.url)) || null,
+      ipv6: ipv6.find((p) => !skip.has(p.url)) || null,
+    };
+  }
+
+  // Available peers ordered specifically for recovery-time retry: earliest
+  // failure first (it has had the longest to come back), never-failed last.
+  function orderedByLastError(t = now()) {
+    return available().sort((a, b) => {
+      const ea = lastErrorAt[a.url];
+      const eb = lastErrorAt[b.url];
+      if (ea == null && eb == null) return 0;
+      if (ea == null) return 1; // never-failed peers go after any that failed
+      if (eb == null) return -1;
+      return ea - eb; // earliest failure first
+    });
+  }
+
+  let cursor = 0;
+
+  // 兜底重试集合：仅"因错误冷却中"的 peer（按最早失败优先）。
+  // 场景：唯一可用节点偶发失败被冷却锁死 → 主链零候选/全败时，兜底给它一次机会；
+  // 成功会被 recordResult 清除错误记录、回归热路径，避免"明明能用的节点被 30s 冷却全灭"。
+  function coolingByLastError() {
+    const t = now();
+    return list
+      .filter((p) => {
+        const err = lastErrorAt[p.url];
+        if (typeof err !== "number") return false;
+        if (stats[p.url]?.probeDeadAt !== undefined && now() - stats[p.url].probeDeadAt < peerProbeDeadMs()) return false; // 探测死亡：兜底也不考虑（否则每次白等一次拒连）
+        if ((stats[p.url]?.streak429 ?? 0) >= 2) return false; // 429 长冷却：兜底也不考虑
+        if ((stats[p.url]?.deadFails ?? 0) >= DEAD_FAIL_THRESHOLD) return false; // 连接级永久失败：兜底也不考虑（否则每次白等一次拒连）
+        return t - err < cooldownMs;
+      })
+      .sort((a, b) => (lastErrorAt[a.url] ?? 0) - (lastErrorAt[b.url] ?? 0));
+  }
+
+  function next() {
+    const avail = available();
+    if (!avail.length) return null;
+    cursor = cursor % avail.length;
+    return avail[cursor++];
+  }
+
+  // Long-lived error memory: a peer keeps its last-error timestamp until a
+  // subsequent success resets it (success clears the failure record) or the
+  // error is no longer in the persist store on next load.
+  async function recordError(url, { status, message } = {}) {
+    if (!url) return;
+    lastErrorAt[url] = now();
+    await persistErrors({ ...lastErrorAt });
+    // 连续 429 计数（仅成功清零）：第 2 次起进入长冷却——该 peer 大概率真被限流，不再频繁试它
+    if (Number(status) === 429) {
+      const prev = stats[url] || {};
+      stats[url] = { ...prev, streak429: (prev.streak429 || 0) + 1 };
+      await persistStats({ ...stats });
+    }
+    // 连接级失败计数（仅成功清零）：第 2 次起进长冷却，且不再被 coolingByLastError 兜底捞回
+    if (isConnLevelFailure(message)) {
+      const prev = stats[url] || {};
+      stats[url] = { ...prev, deadFails: (prev.deadFails || 0) + 1 };
+      await persistStats({ ...stats });
+    }
+  }
+
+  // Outcome of a forwarded request: ok updates the hot-cache (EMA latency,
+  // last successful model) and clears the error memory; failures keep the
+  // error timestamp so the retry pass can order by recovery time.
+  async function recordResult(url, { ok, latencyMs, model } = {}) {
+    if (!url) return;
+    if (ok) {
+      if (lastErrorAt[url] != null) {
+        delete lastErrorAt[url];
+        await persistErrors({ ...lastErrorAt });
+      }
+      const prev = stats[url] || {};
+      const next = {
+        okAt: now(),
+        latencyMs: prev.latencyMs != null && typeof latencyMs === "number"
+          ? Math.round(prev.latencyMs * (1 - EMA_ALPHA) + latencyMs * EMA_ALPHA)
+          : (typeof latencyMs === "number" ? latencyMs : prev.latencyMs ?? 0),
+        fails: 0,
+        model: model || prev.model || "",
+        streak429: 0,
+        deadFails: 0,
+      };
+      // 探测死亡标记：请求成功 = 节点活着，冷却窗口立即解除。
+      // next 本身不含 probeDeadAt 键，天然清除；这里只兜底确保没有残留。
+      stats[url] = next;
+      delete stats[url].probeDeadAt;
+    } else {
+      const prev = stats[url] || {};
+      stats[url] = { ...prev, fails: (prev.fails || 0) + 1 };
+    }
+    await persistStats({ ...stats });
+  }
+
+  // 探测死亡标记（health 连不上）：probeDeadAt 置为此刻，10min 内冷却。不反复探。
+  // recordProbeOk 在探测成功时清标记（节点回来了，冷却窗口立刻结束）。
+  async function recordProbeDead(url) {
+    if (!url) return;
+    const prev = stats[url] || {};
+    stats[url] = { ...prev, probeDeadAt: now() };
+    await persistStats({ ...stats });
+  }
+
+  async function recordProbeOk(url) {
+    if (!url) return;
+    const prev = stats[url] || {};
+    if (!("probeDeadAt" in prev)) return;
+    delete prev.probeDeadAt;
+    stats[url] = prev;
+    await persistStats({ ...stats });
+  }
+
+  return {
+    all, add, remove, removeByGroup, isCooling, isBroadbandCooling, isBroadbandStale: (url) => {
+      const peer = list.find((p) => p.url === url);
+      return peer ? isBroadbandStale(peer, now(), broadbandStaleMs()) : false;
+    }, isHot, stat, ordered, orderedByLastError, coolingByLastError, available, next,
+    standbyChain, nextStandby, isLeaderPeer,
+    recordError, recordResult, recordProbeDead, recordProbeOk, errors: () => ({ ...lastErrorAt }), stats: () => ({ ...stats }),
+  };
+}

package/src/routes/peer-probe.js

@@ -0,0 +1,53 @@
+// 组员「打一个 hi」探针：备选时打一次、轮到它时再打一次，回不来就当它不行。
+//
+// 为什么要打 hi 而不是 /health：额度只体现在真实 chat 调用上。实测（2026-10-20，本机出口已知 429）
+//   GET /health 与 GET /zen/v1/models **都照样 200**，只有 POST chat 才回 429 FreeUsageLimitError。
+// 为什么要挑在「备选」和「轮到」两个时刻：
+//   备选是上一次切换时定的，中间上一个节点可能已在大 body 上撞墙几十秒（实测 1.5MB 撞 429 要
+//   28~62s），那时有额度不代表现在还有 ⇒ 轮到它时必须再确认一次。
+// 开销：hi + max_tokens=8，拿响应头即掐断，不等正文，也不触发对端空轮重试。
+import { compatFetch, timeoutSignal } from "../compat.js";
+import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
+
+// 等 hi 的上限。超时按「没判过」处理（交主流程照常试），绝不因为探针慢就错杀一个能用的节点。
+export function peerProbeTimeoutMs(env = process.env) {
+  const n = Number(env.MSLXDFF_PEER_PROBE_TIMEOUT_MS);
+  return Number.isInteger(n) && n > 0 ? n : 10_000;
+}
+
+/**
+ * 给一个组员打一句 hi，只关心它活不活。
+ * @returns {Promise<{ok: boolean, status: number, ms: number, unknown?: boolean}>} 永不抛
+ *   ok=false 只在「明确不该再试」时给：拿到 4xx/5xx 响应。
+ *   连不上/超时一律 ok=true + unknown=true（那是主流程 forwardToPeer 的账，探针不越权判死）。
+ */
+export async function probePeer(peer, { model, timeoutMs = peerProbeTimeoutMs(), dispatcher, fetchImpl = compatFetch } = {}) {
+  const t0 = Date.now();
+  if (!peer?.url || !model) return { ok: true, status: 0, ms: 0, unknown: true };
+  const headers = {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${peer.token || ""}`,
+    "x-mslxdff-hops": "1",
+    "x-mslxdff-model-lock": model,
+    // 探针必须可识别：组员侧据此知道这是「体检」不是真实业务（不落 usage、不参与空轮重试），
+    // 日志/测试也能把它与真实转发分开，否则「一次请求打了几次组员」这类断言会被探针污染。
+    "x-mslxdff-probe": "1",
+    "Accept": "text/event-stream",
+  };
+  const share = buildShareKeysHeader(model);
+  if (share) headers[SHARE_KEYS_HEADER] = share;
+  try {
+    const res = await fetchImpl(`${String(peer.url).replace(/\/+$/, "")}/v1/chat/completions`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ model, stream: true, max_tokens: 8, messages: [{ role: "user", content: "hi" }] }),
+      signal: timeoutSignal(timeoutMs),
+      ...(dispatcher ? { dispatcher } : {}),
+    });
+    // 拿到响应头就够判了：立刻掐断，不等正文
+    try { const c = res.body?.cancel?.(); if (c && typeof c.catch === "function") c.catch(() => {}); } catch {}
+    return { ok: res.status < 400, status: res.status, ms: Date.now() - t0 };
+  } catch {
+    return { ok: true, status: 0, ms: Date.now() - t0, unknown: true };
+  }
+}

package/src/routes/peer-serial.js

@@ -45,7 +45,7 @@ export function warmPeer(peer, deps = {}) {
 export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried, deps }) {
   const {
     resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg,
-    perAttemptCap, deadline, budgetMs,
+    perAttemptCap, deadline, budgetMs, probePeer,
   } = deps;
   const warm = deps.warmPeer || warmPeer;
   const failed = [];
@@ -71,22 +71,51 @@ export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried
   const ipv4Chain = filterSlow(fresh(candidates));
   const ipv6Chain = filterSlow(fresh(v6Candidates));
 
-  // —— 预取：进循环前就把「下一个」定好，并顺手预热连接 ——
+  // —— 预取 + 探针（用户 2026-10-20 口径）——
+  // 「某个节点当备选的时候打一个 hi，准备轮到它了也打一个 hi；hi 都回不来就当它不行，直接换。」
+  // 两个 hi 都打，不做结果复用：备选是上一次切换时定的，中间可能已过了几十秒
+  // （上一个节点在大 body 上撞墙，实测 1.5MB 要 28~62s），那时活不代表现在活。
+  // 备选那个 hi 的作用是暖连接 + 提前暴露死节点，轮到时的那个才决定去留。
   let pending = null;
-  const prime = (peer) => {
+  // resolvePeerTarget 会打 /v1/models/status，别为探针白测两次：这里记住解析结果给下一轮复用。
+  const resolved = new Map(); // url -> Promise<{peer,target}|null>
+  const resolveOnce = (peer) => {
+    const hit = resolved.get(peer.url);
+    if (hit) return hit;
+    const p = Promise.resolve()
+      .then(() => resolvePeerTarget(ctx, peer))
+      .catch(() => null);
+    resolved.set(peer.url, p);
+    return p;
+  };
+  const prime = (peer, target) => {
+    if (!peer || !target || typeof probePeer !== "function") return;
+    try {
+      const p = probePeer(peer, target);
+      if (p && typeof p.then === "function") p.catch(() => {});
+    } catch { /* 预热失败不影响主流程 */ }
+  };
+  const primeAt = (peer) => {
     if (!peer) return;
-    warm(peer, deps.warmPeerDeps);
+    resolveOnce(peer)
+      .then((r) => { if (r) prime(r.peer, r.target); })
+      .catch(() => {});
   };
   const takeNext = (stage) => {
     const chain = stage === "ipv6" ? ipv6Chain : ipv4Chain;
     const p = chain.shift() || null;
-    if (p) prime(chain[0] || null); // 立即预热「再下一个」，保证永远有备选就绪
+    // 立刻给「再下一个」打 hi。模型名要现在解析——下一轮循环该它时 ctx.model 可能已变。
+    if (p) primeAt(chain[0] || null);
     return p;
   };
 
   let stage = "ipv4";
   let emptyIpv4Announced = false;
 
+  // 链头从没当过「备选」（它一上来就是主角），进入循环前先给它也打一个 hi ——
+  // 此时 ctx.model 还是本机刚失败的那个模型，解析目标与后面轮到时同源。
+  primeAt(ipv4Chain[0] || null);
+
   for (;;) {
     if (deadline > 0 && Date.now() >= deadline) {
       const remaining = ipv4Chain.length + ipv6Chain.length;
@@ -110,12 +139,33 @@ export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried
     }
     if (!pending) break;
 
-    const prepared = await resolvePeerTarget(ctx, pending);
+    const prepared = await resolveOnce(pending);
     if (!prepared) continue;
     const { peer, target } = prepared;
     tried.add(peer.url);
     const ctrl = new AbortController();
     const name = peerName(peer);
+
+    // 轮到它了：再打一个 hi。回不来就当这个备选不行，直接换下一个。
+    if (typeof probePeer === "function") {
+      const t = performance.now();
+      let r;
+      try { r = await probePeer(peer, target); } catch { r = { ok: false }; }
+      const probeMs = Math.round(performance.now() - t);
+      if (r && r.ok === false) {
+        ctx.evt("peer-probe", { peer: peer.url, name, model: target, phase: "turn", ok: false, status: r.status ?? null, latencyMs: probeMs, action: "skip" });
+        failed.push({ ok: false, peer, target, res: null, status: r.status || 502 });
+        recordLater(() => ctx.peers.recordError(peer.url, { status: r.status || 502 }));
+        recordLater(() => ctx.peers.recordResult(peer.url, { ok: false }));
+        continue;
+      }
+      ctx.evt("peer-probe", { peer: peer.url, name, model: target, phase: "turn", ok: true, status: r?.status ?? null, latencyMs: probeMs });
+      if (deadline > 0 && Date.now() >= deadline) {
+        ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽（探针后）`, budgetMs, remaining: ipv4Chain.length + ipv6Chain.length });
+        break;
+      }
+    }
+
     ctx.evt("peer-request", { peer: peer.url, name, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body), serial: 1, stage });
     if (ctx.plugins?.length) {
       runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});

package/src/routes/peers.js

@@ -5,6 +5,7 @@ import { runHook } from "../plugins.js";
 import { buildShareKeysHeader, SHARE_KEYS_HEADER } from "../providers/share-keys.js";
 import { compatFetch, timeoutSignal, getUndici } from "../compat.js";
 import { serialTryPeers, PEER_SERIAL } from "./peer-serial.js";
+import { probePeer, peerProbeTimeoutMs } from "./peer-probe.js";
 import { overForwardLimit, contextGuardMessage } from "../chat-pipeline/context-guard.js";
 
 // peer 阶段总预算：三批候选（ordered / orderedByLastError / coolingByLastError）共享同一个
@@ -252,6 +253,13 @@ export async function racePeerCandidates(candidates, ctx) {
         perAttemptCap: peerAttemptTimeoutMs(), deadline, budgetMs,
         // 连接预热：对「下一个备选」提前打 /health，复用 chat 的同一连接池（见 warmPeerHealth 注释）
         warmPeer: (peer) => { if (peer?.url) warmPeerHealth(peer.url, { timeoutMs: 1500 }).catch(() => {}); },
+        // 用户 2026-10-20：备选时打一个 hi、轮到它时再打一个 hi，hi 回不来就换下一个。
+        // 走 getPeerDispatcher 的**同一条连接池**（与 chat 转发复用 socket，裸 fetch 热的是另一条等于白热）。
+        probePeer: (peer, model) => probePeer(peer, {
+          model: model || null,
+          timeoutMs: peerProbeTimeoutMs(),
+          dispatcher: getPeerDispatcher(),
+        }),
       },
     });
   }

package/src/runtime/keep-warm.js

@@ -1,120 +1,135 @@
-// 保热心跳（用户 2026-10-18 拍板）：每 ≤120s 主动访问一次「每个组员 + 每个在 picks 的上游供应商」，
-// 保持连接热度，防「久未使用 → 首发 fetch failed / 上游冷启动 26s」。
-//
-// ⚠ 必须用**与 chat 完全相同的那条连接池**，否则白热（用户 2026-10-18 纠正）：
-//   - 组员 → warmPeerHealth()（getPeerDispatcher，正是 peer 转发复用的池）；
-//   - 供应商 → provider.preheat()（各家 preheat 经各自 agent/extDispatcher 打自己的 models 端点，
-//     与 chat 同池：opencode 走 v6/warp 池、generic/custom 走各自 agent）。
-//   绝不能裸 compatFetch / directProbe——那热的是全局池的 socket，真流量复用的是另一条，等于没热。
-//
-// 为什么需要它（现网取证 2026-10-18 16:16，req mvdjwol5-aysc）：三个组员同时 `fetch failed`（TCP 都没建立），
-// 根因是两端 keep-alive 打架——服务端 Node 默认 5s 掐闲置连接，而组长 undici 池账面 30s 内以为 socket 还活着，
-// 复用死 socket 即失败。已把服务端 keepAliveTimeout 提到 65s（server.js）治本；本心跳是**补强**：
-// ① 间隔 120s < 家里 NAT/防火墙更短的空闲回收窗（很多路由 60~120s 就丢映射，单靠 65s keep-alive 挡不住）；
-// ② 顺带让上游对我们出口保持"温热"（opencode 实测固定 session 1.2s、冷机器 26s+）。
-//
-// 零额度消耗（全部经各家 preheat：GET models / GET /health，不打 chat）。永不抛，只记事件。
-import { warmPeerHealth } from "../routes/peers.js";
-
-export function keepWarmIntervalMs(env = process.env) {
-  const n = Number(env.MSLXDFF_KEEP_WARM_MS);
-  return Number.isInteger(n) && n >= 0 ? n : 120_000; // 0 = 关闭
-}
-
-/**
- * 从 picks 里算出要保热的「供应商头」集合：裸 id（无 `/`）归 opencode（免费池）；带前缀取首段。
- * 只保留出现过的供应商，天然覆盖"每个在 picks 的接口"。opencode 恒排第一（免费池是主力、最该保热）。
- * @param {string[]} picks
- * @returns {string[]} 供应商 id 列表（含 "opencode"），已去重、opencode 置顶
- */
-export function providerHeadsFromPicks(picks = []) {
-  const heads = new Set();
-  for (const id of picks) {
-    const s = String(id || "").trim();
-    if (!s) continue;
-    heads.add(s.includes("/") ? s.slice(0, s.indexOf("/")) : "opencode");
-  }
-  const out = [...heads];
-  if (out.includes("opencode")) return ["opencode", ...out.filter((h) => h !== "opencode")];
-  return out;
-}
-
-/**
- * 单轮保热：组员各 warmPeerHealth、picks 供应商各 preheat。返回汇总（供事件取证）。绝不抛。
- * @param {{peers:{url:string}[], picks:string[], byId?:Map<string,{preheat?:Function}>, upstream?:{preheat?:Function},
- *          warmPeer?:Function, evt?:Function}} deps
- */
-export async function warmOnce({
-  peers = [],
-  picks = [],
-  byId = null,
-  upstream = null,
-  warmPeer = warmPeerHealth,
-  evt = () => {},
-} = {}) {
-  const staticPeers = peers.filter((p) => p?.url && !String(p.url).startsWith("relay://")); // broadband 走 relay 队列，不直连
-  let peerOk = 0, peerFail = 0;
-  for (const p of staticPeers) {
-    try {
-      const r = await warmPeer(String(p.url));
-      if (r?.ok) peerOk += 1; else peerFail += 1;
-    } catch { peerFail += 1; }
-  }
-  const heads = providerHeadsFromPicks(picks);
-  let provOk = 0, provFail = 0, provSkip = 0;
-  for (const head of heads) {
-    try {
-      // 供应商预热一律走它自己的 preheat（chat 同池）。opencode 特判：**多 provider 装配**下
-      // providers 数组里含 opencode，直接 byId 取；单 provider 模式下 byId 为空，退回 upstream.preheat。
-      const inst = byId?.get?.(head);
-      const preheat = inst?.preheat || (head === "opencode" ? upstream?.preheat : null);
-      if (typeof preheat !== "function") { provSkip += 1; continue; } // 本地号型/无域名供应商：本就没有可保热的域
-      const r = await preheat.call(inst || upstream);
-      if (r?.ok) provOk += 1; else provFail += 1;
-    } catch { provFail += 1; }
-  }
-  evt("keep-warm", { peers: staticPeers.length, peerOk, peerFail, providers: heads.length, provOk, provFail, provSkip });
-  return { peers: staticPeers.length, peerOk, peerFail, providers: heads.length, provOk, provFail, provSkip };
-}
-
-/**
- * daemon 装配：起一个 unref 的定时器，每 keepWarmIntervalMs 跑一轮 warmOnce。
- * 关（=0）返回 null。依赖注入以便测试；生产用 setupProviders 的 ctx（providers/upstream/peers）。
- */
-export function startKeepWarm({
-  peers,
-  providers = [],
-  upstream,
-  env = process.env,
-  evt = () => {},
-  logs,
-  loadModelPicks,
-  warmPeer = warmPeerHealth,
-} = {}) {
-  const interval = keepWarmIntervalMs(env);
-  if (interval === 0) return null;
-  const byId = new Map((providers || []).map((p) => [p.id, p]));
-  const emit = (type, data) => {
-    const entry = { ts: Date.now(), type, ...data };
-    try { evt(type, data); } catch {}
-    try { logs?.appendEvent?.(entry); } catch {}
-  };
-  const runTick = async () => {
-    try {
-      const picks = loadModelPicks ? loadModelPicks() : [];
-      await warmOnce({
-        peers: peers?.all?.() || [],
-        picks: Array.isArray(picks) ? picks : [],
-        byId,
-        upstream,
-        warmPeer,
-        evt: emit,
-      });
-    } catch { /* 保热永不影响主链路 */ }
-  };
-  console.log(`[keep-warm] enabled: every ${Math.round(interval / 1000)}s 经 chat 同池访问每个组员(/health) + 每个 picks 供应商(preheat) 保热，设 MSLXDFF_KEEP_WARM_MS=0 关`);
-  void runTick(); // 启动即热一次，别等第一个间隔
-  const timer = setInterval(() => { void runTick(); }, interval);
-  timer.unref?.();
-  return { stop: () => clearInterval(timer), interval, tick: runTick };
-}
+// 保热心跳（用户 2026-10-18 拍板）：每 ≤120s 主动访问一次「每个组员 + 每个在 picks 的上游供应商」，
+// 保持连接热度，防「久未使用 → 首发 fetch failed / 上游冷启动 26s」。
+//
+// ⚠ 必须用**与 chat 完全相同的那条连接池**，否则白热（用户 2026-10-18 纠正）：
+//   - 组员 → warmPeerHealth()（getPeerDispatcher，正是 peer 转发复用的池）；
+//   - 供应商 → provider.preheat()（各家 preheat 经各自 agent/extDispatcher 打自己的 models 端点，
+//     与 chat 同池：opencode 走 v6/warp 池、generic/custom 走各自 agent）。
+//   绝不能裸 compatFetch / directProbe——那热的是全局池的 socket，真流量复用的是另一条，等于没热。
+//
+// 为什么需要它（现网取证 2026-10-18 16:16，req mvdjwol5-aysc）：三个组员同时 `fetch failed`（TCP 都没建立），
+// 根因是两端 keep-alive 打架——服务端 Node 默认 5s 掐闲置连接，而组长 undici 池账面 30s 内以为 socket 还活着，
+// 复用死 socket 即失败。已把服务端 keepAliveTimeout 提到 65s（server.js）治本；本心跳是**补强**：
+// ① 间隔 120s < 家里 NAT/防火墙更短的空闲回收窗（很多路由 60~120s 就丢映射，单靠 65s keep-alive 挡不住）；
+// ② 顺带让上游对我们出口保持"温热"（opencode 实测固定 session 1.2s、冷机器 26s+）。
+//
+// 零额度消耗（全部经各家 preheat：GET models / GET /health，不打 chat）。永不抛，只记事件。
+import { warmPeerHealth } from "../routes/peers.js";
+
+export function keepWarmIntervalMs(env = process.env) {
+  const n = Number(env.MSLXDFF_KEEP_WARM_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 120_000; // 0 = 关闭
+}
+
+/**
+ * 从 picks 里算出要保热的「供应商头」集合：裸 id（无 `/`）归 opencode（免费池）；带前缀取首段。
+ * 只保留出现过的供应商，天然覆盖"每个在 picks 的接口"。opencode 恒排第一（免费池是主力、最该保热）。
+ * @param {string[]} picks
+ * @returns {string[]} 供应商 id 列表（含 "opencode"），已去重、opencode 置顶
+ */
+export function providerHeadsFromPicks(picks = []) {
+  const heads = new Set();
+  for (const id of picks) {
+    const s = String(id || "").trim();
+    if (!s) continue;
+    heads.add(s.includes("/") ? s.slice(0, s.indexOf("/")) : "opencode");
+  }
+  const out = [...heads];
+  if (out.includes("opencode")) return ["opencode", ...out.filter((h) => h !== "opencode")];
+  return out;
+}
+
+/**
+ * 单轮保热：组员各 warmPeerHealth、picks 供应商各 preheat。返回汇总（供事件取证）。绝不抛。
+ * @param {{peers:{url:string}[], picks:string[], byId?:Map<string,{preheat?:Function}>, upstream?:{preheat?:Function},
+ *          warmPeer?:Function, evt?:Function}} deps
+ */
+export async function warmOnce({
+  peers = [],
+  picks = [],
+  byId = null,
+  upstream = null,
+  warmPeer = warmPeerHealth,
+  markProbe = null, // (url, ok) => void：探测结果写进 peer 冷却账（health 探不通 ⇒ 10min 不当候选）
+  evt = () => {},
+} = {}) {
+  const staticPeers = peers.filter((p) => p?.url && !String(p.url).startsWith("relay://")); // broadband 走 relay 队列，不直连
+  const safeMark = (url, ok) => {
+    try {
+      const p = markProbe?.(url, ok);
+      if (p && typeof p.catch === "function") p.catch(() => {});
+    } catch { /* 记账失败不影响保热 */ }
+  };
+  let peerOk = 0, peerFail = 0;
+  for (const p of staticPeers) {
+    try {
+      const r = await warmPeer(String(p.url));
+      if (r?.ok) { peerOk += 1; safeMark(String(p.url), true); }
+      else { peerFail += 1; safeMark(String(p.url), false); }
+    } catch { peerFail += 1; safeMark(String(p.url), false); }
+  }
+  const heads = providerHeadsFromPicks(picks);
+  let provOk = 0, provFail = 0, provSkip = 0;
+  for (const head of heads) {
+    try {
+      // 供应商预热一律走它自己的 preheat（chat 同池）。opencode 特判：**多 provider 装配**下
+      // providers 数组里含 opencode，直接 byId 取；单 provider 模式下 byId 为空，退回 upstream.preheat。
+      const inst = byId?.get?.(head);
+      const preheat = inst?.preheat || (head === "opencode" ? upstream?.preheat : null);
+      if (typeof preheat !== "function") { provSkip += 1; continue; } // 本地号型/无域名供应商：本就没有可保热的域
+      const r = await preheat.call(inst || upstream);
+      if (r?.ok) provOk += 1; else provFail += 1;
+    } catch { provFail += 1; }
+  }
+  evt("keep-warm", { peers: staticPeers.length, peerOk, peerFail, providers: heads.length, provOk, provFail, provSkip });
+  return { peers: staticPeers.length, peerOk, peerFail, providers: heads.length, provOk, provFail, provSkip };
+}
+
+/**
+ * daemon 装配：起一个 unref 的定时器，每 keepWarmIntervalMs 跑一轮 warmOnce。
+ * 关（=0）返回 null。依赖注入以便测试；生产用 setupProviders 的 ctx（providers/upstream/peers）。
+ */
+export function startKeepWarm({
+  peers,
+  providers = [],
+  upstream,
+  env = process.env,
+  evt = () => {},
+  logs,
+  loadModelPicks,
+  warmPeer = warmPeerHealth,
+} = {}) {
+  const interval = keepWarmIntervalMs(env);
+  if (interval === 0) return null;
+  const byId = new Map((providers || []).map((p) => [p.id, p]));
+  const emit = (type, data) => {
+    const entry = { ts: Date.now(), type, ...data };
+    try { evt(type, data); } catch {}
+    try { logs?.appendEvent?.(entry); } catch {}
+  };
+  const runTick = async () => {
+    try {
+      const picks = loadModelPicks ? loadModelPicks() : [];
+      await warmOnce({
+        peers: peers?.all?.() || [],
+        picks: Array.isArray(picks) ? picks : [],
+        byId,
+        upstream,
+        warmPeer,
+        // 探测结果写进冷却账：health 连不上 ⇒ 10min 不当候选（防"探到了但选路不知道"——现网 2026-10-20 13:27）
+        markProbe: async (url, ok) => {
+          try {
+            if (ok) await peers?.recordProbeOk?.(url);
+            else await peers?.recordProbeDead?.(url);
+          } catch { /* 记账失败不影响保热 */ }
+        },
+        evt: emit,
+      });
+    } catch { /* 保热永不影响主链路 */ }
+  };
+  console.log(`[keep-warm] enabled: every ${Math.round(interval / 1000)}s 经 chat 同池访问每个组员(/health) + 每个 picks 供应商(preheat) 保热，设 MSLXDFF_KEEP_WARM_MS=0 关`);
+  void runTick(); // 启动即热一次，别等第一个间隔
+  const timer = setInterval(() => { void runTick(); }, interval);
+  timer.unref?.();
+  return { stop: () => clearInterval(timer), interval, tick: runTick };
+}