mslxdff 0.1.219 → 0.1.221

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.219",
+  "version": "0.1.221",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {
@@ -9,6 +9,8 @@
   "scripts": {
     "start": "node bin/mslxdff.js",
     "test": "node --test --test-concurrency=1 test/*.test.js",
+    "test:scoped": "node scripts/test-scoped.js",
+    "test:all": "node --test --test-concurrency=1 test/*.test.js",
     "docs:check": "node scripts/docs-check.js"
   },
   "engines": {

package/src/groups.js

@@ -205,7 +205,10 @@ export function syncPeersFromMembers({ peers, members, myUrl, group, skipIds = [
     // heartbeatLatencyMs：组长在**心跳**里量的成员延迟（成员上报 rttMs）。选路 `ordered()` 在没有
     // 真实请求 EMA 时回落到它——这就是「组员定时上报的过程中就知道谁延迟更低」。
     const hbLat = Number.isFinite(Number(m?.latencyMs)) && Number(m.latencyMs) >= 0 ? Number(m.latencyMs) : null;
-    if (peers.add({ name: id, url, token: m?.token || "", group, ...(hbLat != null ? { heartbeatLatencyMs: hbLat } : {}) })) added++;
+    // hasV6：该成员自己在心跳里报的「我有可用 IPv6 出口池」。IPv4 链全用完时才进 v6 阶段，
+    // 靠这个标记筛「谁的 v6 额度还能用」（见 routes/peer-serial.js 的 v6 阶段）。
+    const hasV6 = m?.hasV6 === true;
+    if (peers.add({ name: id, url, token: m?.token || "", group, hasV6, ...(hbLat != null ? { heartbeatLatencyMs: hbLat } : {}) })) added++;
   }
   return { removed, added, total: Object.keys(members || {}).length };
 }

package/src/peers.js

@@ -144,6 +144,12 @@ export function createPeersService({
   //   ① 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;
@@ -151,20 +157,56 @@ export function createPeersService({
     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 = 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;
+      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
@@ -259,6 +301,7 @@ export function createPeersService({
       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 }),
   };
 }

package/src/routes/groups-relay.js

@@ -44,12 +44,16 @@ export async function heartbeatHandler({ req, res, groups, bus, logs }) {
         const reportedRtt = Number(body?.rttMs);
         const memberRtt = Number.isFinite(reportedRtt) && reportedRtt >= 0 ? Math.round(reportedRtt) : null;
         if (memberRtt != null) m.latencyMs = memberRtt;
+        // hasV6：成员自报「我这台有没有可用的 IPv6 出口池」。IPv4 链全用完后的 v6 阶段靠它筛候选
+        // （先组长 v6 → 再按延迟升序找有 v6 的组员）。
+        const hasV6 = body?.hasV6 === true;
+        m.hasV6 = hasV6;
         try {
-          groups.upsertMember(groupName, { memberName: targetId, url: m.url, token: m.token, kind: "broadband", publicIp: ip, lastSeen: m.lastSeen, ...(memberRtt != null ? { latencyMs: memberRtt } : {}) });
+          groups.upsertMember(groupName, { memberName: targetId, url: m.url, token: m.token, kind: "broadband", publicIp: ip, lastSeen: m.lastSeen, hasV6, ...(memberRtt != null ? { latencyMs: memberRtt } : {}) });
         } catch {}
       }
       const serverMs = Date.now() - tRecv;
-      const evtData = { ts: Date.now(), type: "relay-heartbeat", member: targetId, ip, lastSeen: m?.lastSeen, rttMs: Number.isFinite(Number(body?.rttMs)) ? Number(body.rttMs) : null, serverMs, group: groupName };
+      const evtData = { ts: Date.now(), type: "relay-heartbeat", member: targetId, ip, lastSeen: m?.lastSeen, rttMs: Number.isFinite(Number(body?.rttMs)) ? Number(body.rttMs) : null, hasV6: body?.hasV6 === true, serverMs, group: groupName };
       if (bus) bus.emit(evtData);
       logs?.appendEvent?.(evtData);
     }

package/src/routes/peer-health.js

@@ -0,0 +1,59 @@
+// 组员健康探测与缓存：拉对方的 /v1/models/status，拿「该组员当前健康可用的模型」。
+// 从 routes/peers.js 拆出（2026-10-20）：那个文件已到 20KB 硬闸，健康探测这块自洽
+// （只依赖 compatFetch），拆走后 peers.js 回到闸内，也更好单测。
+import { compatFetch, timeoutSignal } from "../compat.js";
+
+const PEER_STATUS_TIMEOUT_MS = 2_000;
+
+function peerHealthTtlMs() {
+  const n = Number(process.env.MSLXDFF_PEER_HEALTH_TTL_MS);
+  return Number.isInteger(n) && n >= 0 ? n : 30_000;
+}
+
+const healthCache = new Map(); // url -> { at, data }
+const healthInflight = new Map(); // url -> Promise
+
+export function clearPeerHealthCache() {
+  healthCache.clear();
+  healthInflight.clear();
+}
+
+export async function peerHealthyModels(peer, { timeoutMs = PEER_STATUS_TIMEOUT_MS, fetchImpl = compatFetch } = {}) {
+  const key = peer?.url || "";
+  const ttl = peerHealthTtlMs();
+  if (ttl > 0) {
+    const hit = healthCache.get(key);
+    if (hit && Date.now() - hit.at < ttl) return hit.data;
+    const inflight = healthInflight.get(key);
+    if (inflight) return inflight;
+  }
+  const p = (async () => {
+    try {
+      const res = await fetchImpl(`${peer.url}/v1/models/status`, {
+        headers: {
+          "Authorization": `Bearer ${peer.token || ""}`,
+          "Accept": "application/json",
+        },
+        signal: timeoutSignal(timeoutMs),
+      });
+      if (!res.ok) return [];
+      const j = await res.json().catch(() => ({}));
+      return (j.data || [])
+        .filter((m) => m && typeof m.id === "string" && m.status === "normal")
+        .map((m) => m.id);
+    } catch {
+      return [];
+    }
+  })();
+  if (ttl > 0) {
+    healthInflight.set(key, p);
+    try {
+      const data = await p;
+      healthCache.set(key, { at: Date.now(), data });
+      return data;
+    } finally {
+      healthInflight.delete(key);
+    }
+  }
+  return p;
+}

package/src/routes/peer-serial.js

@@ -1,31 +1,58 @@
-// 组员串行选路（用户 2026-10-19 决定：不竞速）。
+// 组员串行选路（用户 2026-10-19 决定：不竞速；2026-10-20 升级为**常驻热备**）。
 //
-// 为什么改：并发赛跑会同时占用多个组员的额度/连接，慢节点还会拖住整批；而用户要的语义是
-// 「本机额度用完 → 用延迟最小的组员」，延迟小的先上、不行再下一个。串行让这条优先级真正生效。
+// 两种模式下都必须满足的语义：
+//   「本机额度用完 → 用延迟最小的组员」，但**组长恒定第一**（先榨干组长额度），
+//   组长也满了才按延迟升序逐个组员顶上。
 //
-// 本模块只做「按序试」这件事，其余（画目标、转发、记账、事件名）从 peers.js 注入，避免循环依赖。
+// 2026-10-20 用户要求「永远准备一个备选，429 立即切」：
+//   ① 进循环前就**预取**下一个候选（不是每次现排序）；
+//   ② 切换成功后**立即再预取**下一个；
+//   ③ 对预取的备选做**连接预热**（轻量 /health 建连），切过去时连接已在池里，省掉建连 RTT。
+//
+// IPv4 全用完 → 进 IPv6 阶段：先组长 v6，再按延迟升序找 hasV6 的组员。
+//
+// 本模块只做「按序试 + 预取」这件事，其余（画目标、转发、记账、事件名）从 peers.js 注入，避免循环依赖。
 export const PEER_SERIAL = true;
 
 /**
- * 串行试候选：一次只打一个，成功即返回；失败顺位试下一个。
+ * 连接预热：对备选节点发一个极轻的请求，只为让 undici 连接池里提前建好 TCP/TLS 连接。
+ * 失败静默——预热只是提速，不是前置条件；真发请求时该失败还是会失败。
+ * @param {object} peer  目标 peer（需 url）
+ * @param {object} deps  { warmFetch?, timeoutMs? }
+ */
+export function warmPeer(peer, deps = {}) {
+  const { warmFetch, timeoutMs = 1500 } = deps;
+  if (!peer?.url || typeof warmFetch !== "function") return Promise.resolve();
+  try {
+    const p = warmFetch(`${peer.url}/health`, { method: "GET", timeoutMs });
+    if (p && typeof p.catch === "function") p.catch(() => {});
+  } catch { /* 预热失败不影响主流程 */ }
+  return Promise.resolve();
+}
+
+/**
+ * 串行试候选（预取 + 预热版）：一次只打一个，成功即返回；失败顺位试下一个。
  *
  * @param {object} p
- * @param {Array}  p.candidates        已按「延迟最小优先」排好的组员
+ * @param {Array}  p.candidates        已排好序的组员（组长第一、其余延迟升序）
+ * @param {Array}  [p.v6Candidates]    IPv4 全用完后的 v6 阶段候选（同样已排序）
  * @param {object} p.ctx               请求上下文（evt/peers/body/hops/plugins/peerErrors/triedUrls…）
  * @param {Set}    p.tried             已试过的 url 集合
- * @param {object} p.deps              { resolvePeerTarget, forwardToPeer, peerName, recordLater,
+ * @param {object} p.deps              { resolvePeerTarget, forwardToPeer, warmPeer, peerName, recordLater,
  *                                       summarizeRequest, runHook, errMsg, perAttemptCap, deadline, budgetMs }
  * @returns {Promise<null | {peer, target, res, latencyMs}>}
  */
-export async function serialTryPeers({ candidates, ctx, tried, deps }) {
+export async function serialTryPeers({ candidates, v6Candidates = [], ctx, tried, deps }) {
   const {
     resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg,
     perAttemptCap, deadline, budgetMs,
   } = deps;
+  const warm = deps.warmPeer || warmPeer;
   const failed = [];
+
   // 延迟上限过滤：历史延迟超过「单次尝试上限」的组员直接跳过（它大概率又超时）。
   // 只在**还有别的候选**时才跳过，避免把唯一可用的节点也跳没了。
-  const ranked = candidates.filter((p) => {
+  const filterSlow = (list) => list.filter((p) => {
     let lat = null;
     try {
       // 与 ordered() 同源：先看真实请求 EMA，再回落到心跳上报的 rtt
@@ -33,23 +60,63 @@ export async function serialTryPeers({ candidates, ctx, tried, deps }) {
       if (lat != null) lat = Number(lat);
     } catch { lat = null; }
     if (lat == null || !Number.isFinite(lat) || lat <= perAttemptCap) return true;
-    if (candidates.length <= 1) return true; // 只剩它 → 仍然试
+    if (list.length <= 1) return true; // 只剩它 → 仍然试
     ctx.evt("peer-skip-slow", { peer: p.url, name: peerName(p), latencyMs: lat, capMs: perAttemptCap });
     return false;
   });
 
-  for (let i = 0; i < ranked.length; i++) {
+  // 两段链：先 IPv4（组长→组员延迟升序），IPv4 全败才进 IPv6（同样组长优先 + hasV6 过滤）。
+  // 只保留本次还没试过的。
+  const fresh = (list) => list.filter((p) => !tried.has(p.url));
+  const ipv4Chain = filterSlow(fresh(candidates));
+  const ipv6Chain = filterSlow(fresh(v6Candidates));
+
+  // —— 预取：进循环前就把「下一个」定好，并顺手预热连接 ——
+  let pending = null;
+  const prime = (peer) => {
+    if (!peer) return;
+    warm(peer, deps.warmPeerDeps);
+  };
+  const takeNext = (stage) => {
+    const chain = stage === "ipv6" ? ipv6Chain : ipv4Chain;
+    const p = chain.shift() || null;
+    if (p) prime(chain[0] || null); // 立即预热「再下一个」，保证永远有备选就绪
+    return p;
+  };
+
+  let stage = "ipv4";
+  let emptyIpv4Announced = false;
+
+  for (;;) {
     if (deadline > 0 && Date.now() >= deadline) {
-      ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽`, budgetMs, remaining: ranked.length - i });
+      const remaining = ipv4Chain.length + ipv6Chain.length;
+      ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽`, budgetMs, remaining });
       break;
     }
-    const prepared = await resolvePeerTarget(ctx, ranked[i]);
+    pending = takeNext(stage);
+    // IPv4 链走空 → 切 IPv6 阶段（用户约定：所有正常 IPv4 额度用完才动 v6）
+    if (!pending && stage === "ipv4") {
+      stage = "ipv6";
+      if (!ipv6Chain.length) {
+        if (!emptyIpv4Announced) {
+          emptyIpv4Announced = true;
+          ctx.evt("peer-v6-stage", { entered: false, reason: ipv4Chain.length ? "ipv4 未走空" : "无 hasV6 候选" });
+        }
+        break;
+      }
+      ctx.evt("peer-v6-stage", { entered: true, candidates: ipv6Chain.length });
+      pending = takeNext("ipv6");
+      if (!pending) break;
+    }
+    if (!pending) break;
+
+    const prepared = await resolvePeerTarget(ctx, pending);
     if (!prepared) continue;
     const { peer, target } = prepared;
     tried.add(peer.url);
     const ctrl = new AbortController();
     const name = peerName(peer);
-    ctx.evt("peer-request", { peer: peer.url, name, model: target, hops: ctx.hops + 1, payload: summarizeRequest(ctx.body), serial: i + 1 });
+    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(() => {});
     }
@@ -68,14 +135,14 @@ export async function serialTryPeers({ candidates, ctx, tried, deps }) {
     if (isErr || status >= 400) {
       const msg = isErr ? errMsg(res).slice(0, 200) : null;
       if (Array.isArray(ctx.peerErrors)) ctx.peerErrors.push({ peer: peer.url, status, message: msg });
-      ctx.evt("peer-attempt", { peer: peer.url, name, model: target, hops: ctx.hops + 1, latencyMs, ok: false, status, message: msg });
+      ctx.evt("peer-attempt", { peer: peer.url, name, model: target, hops: ctx.hops + 1, latencyMs, ok: false, status, message: msg, stage });
       ctx.evt("peer-error", { peer: peer.url, name, model: target, status, message: msg });
       failed.push({ ok: false, peer, target, res, status });
       recordLater(() => ctx.peers.recordError(peer.url, { status, message: msg }));
       recordLater(() => ctx.peers.recordResult(peer.url, { ok: false }));
-      continue; // 串行：试下一个
+      continue; // 串行：试下一个（预取的下一个已经在路上）
     }
-    ctx.evt("peer-forward", { peer: peer.url, name, model: target, hops: ctx.hops + 1, latencyMs, ok: true, status });
+    ctx.evt("peer-forward", { peer: peer.url, name, model: target, hops: ctx.hops + 1, latencyMs, ok: true, status, stage });
     return { peer, target, res, latencyMs };
   }
 

package/src/routes/peers.js

@@ -126,58 +126,10 @@ export function stripCallerBoundReasoning(body) {
   return changed ? { ...body, messages: out } : body;
 }
 
-function peerHealthTtlMs() {
-  const n = Number(process.env.MSLXDFF_PEER_HEALTH_TTL_MS);
-  return Number.isInteger(n) && n >= 0 ? n : 30_000;
-}
-
-const healthCache = new Map(); // url -> { at, data }
-const healthInflight = new Map(); // url -> Promise
-
-export function clearPeerHealthCache() {
-  healthCache.clear();
-  healthInflight.clear();
-}
-
-export async function peerHealthyModels(peer, { timeoutMs = PEER_STATUS_TIMEOUT_MS, fetchImpl = compatFetch } = {}) {
-  const key = peer?.url || "";
-  const ttl = peerHealthTtlMs();
-  if (ttl > 0) {
-    const hit = healthCache.get(key);
-    if (hit && Date.now() - hit.at < ttl) return hit.data;
-    const inflight = healthInflight.get(key);
-    if (inflight) return inflight;
-  }
-  const p = (async () => {
-    try {
-      const res = await fetchImpl(`${peer.url}/v1/models/status`, {
-        headers: {
-          "Authorization": `Bearer ${peer.token || ""}`,
-          "Accept": "application/json",
-        },
-        signal: timeoutSignal(timeoutMs),
-      });
-      if (!res.ok) return [];
-      const j = await res.json().catch(() => ({}));
-      return (j.data || [])
-        .filter((m) => m && typeof m.id === "string" && m.status === "normal")
-        .map((m) => m.id);
-    } catch {
-      return [];
-    }
-  })();
-  if (ttl > 0) {
-    healthInflight.set(key, p);
-    try {
-      const data = await p;
-      healthCache.set(key, { at: Date.now(), data });
-      return data;
-    } finally {
-      healthInflight.delete(key);
-    }
-  }
-  return p;
-}
+// 健康探测与缓存已拆到 ./peer-health.js（本文件受 20KB 硬闸约束）。
+// 这里 import 后再 re-export：既要给本文件内部函数用，也要保持既有 import 方无需改动。
+import { clearPeerHealthCache, peerHealthyModels } from "./peer-health.js";
+export { clearPeerHealthCache, peerHealthyModels };
 
 // controller 由调用方持有：赛跑 winner 确定后可主动 abort 其余 in-flight，
 // 避免迟到流挂满 bodyTimeout（并给对方省下无用负载）。
@@ -273,9 +225,23 @@ export async function racePeerCandidates(candidates, ctx) {
 
   // 串行：按 candidates 的既有次序（调用方已按「延迟最小优先」排好）逐个试。
   if (PEER_SERIAL) {
+    // 常驻热备（用户 2026-10-20）：IPv4 链走空后进 IPv6 阶段。
+    // v6 候选 = 心跳自报 hasV6 的节点（组长优先、其余延迟升序），由 peers.standbyChain 产出。
+    // 兼容：ctx.peers 可能是测试注入的假对象，缺 standbyChain 时 v6 阶段自然为空。
+    let v6Candidates = [];
+    try {
+      v6Candidates = ctx.peers?.standbyChain?.().ipv6 ?? [];
+    } catch { v6Candidates = []; }
     return serialTryPeers({
-      candidates: fresh, ctx, tried,
-      deps: { resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg, perAttemptCap: peerAttemptTimeoutMs(), deadline, budgetMs },
+      candidates: fresh,
+      v6Candidates,
+      ctx, tried,
+      deps: {
+        resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg,
+        perAttemptCap: peerAttemptTimeoutMs(), deadline, budgetMs,
+        // 连接预热：对「下一个备选」提前打 /health，复用 chat 的同一连接池（见 warmPeerHealth 注释）
+        warmPeer: (peer) => { if (peer?.url) warmPeerHealth(peer.url, { timeoutMs: 1500 }).catch(() => {}); },
+      },
     });
   }
 

package/src/runtime/broadband.js

@@ -101,6 +101,15 @@ export function startBroadband({ token, upstream, logs, log = console.log }) {
   // 组长侧据此排序「谁的延迟更低」（选路=延迟最小优先，见 routes/peers.js 的 ordered）。
   // 用上一轮而不是本轮的原因：本轮 RTT 要等响应回来才知道，来不及带在这次请求里。
   const hbRtt = new Map(); // group name -> ms
+  // 本机 IPv6 出口池是否可用：心跳里带 hasV6，组长据此知道「谁的 v6 额度还能用」。
+  // 只有本机真的建起了带地址的 v6 池才算 true（空池/未检测到前缀 = false）。
+  const v6Available = () => {
+    try {
+      const d = upstream?.dispatcher;
+      const slots = d?.stats?.().slots;
+      return Array.isArray(slots) && slots.some((s) => s.addr && !s.cooling);
+    } catch { return false; }
+  };
   const doHeartbeat = async () => {
     for (const g of broadbandGroups()) {
       try {
@@ -108,7 +117,7 @@ export function startBroadband({ token, upstream, logs, log = console.log }) {
         const res = await compatFetch(`${g.leaderUrl}/v1/groups/relay/heartbeat`, {
           method: "POST",
           headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
-          body: JSON.stringify({ name: g.name, group: g.name, rttMs: hbRtt.get(g.name) ?? null }),
+          body: JSON.stringify({ name: g.name, group: g.name, rttMs: hbRtt.get(g.name) ?? null, hasV6: v6Available() }),
           signal: timeoutSignal(5000),
         });
         const rtt = Date.now() - t0;