mslxdff 0.1.213 → 0.1.215

package/package.json

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

package/src/cli/format.js

@@ -70,12 +70,22 @@ export function fmtEvent(e) {
       return `${head} peer win      选中 peer=${e.winPeer} model=${m(e.winTarget)} latency=${e.latencyMs}ms`;
     case "peer-race-lose":
       return `${head} peer lose     组员全部失败 model=${m(e.model)}`;
+    case "peer-skip-slow":
+      return `${head} peer skip     跳过过慢组员 peer=${e.peer} 历史延迟=${e.latencyMs ?? "-"}ms > ${e.capMs ?? "-"}ms`;
     case "fallback":
       return `${head} fallback      ${m(e.from)} -> ${m(e.to)} reason=${m(e.reason)}`;
     case "fallback-notice":
       return `${head} fallback!     客户端请求 ${m(e.requested)} 实际返回 ${m(e.actual)} 原因=${m(e.reason)} via=${m(e.via)} notice=${m(e.notice)}`;
     case "relay-try":
       return `${head} relay try     给宽带中继请求 target=${e.target} model=${m(e.model)} via=${e.via}`;
+    case "relay-miss":
+      return `${head} relay miss    宽带中继无候选（${e.reason || "-"}${e.candidates != null ? ` candidates=${e.candidates}` : ""}）`;
+    case "relay-received":
+      return `${head} relay recv    ${e.via === "broadband" ? "经中继" : "直连"}转给 target=${e.target} group=${e.group} model=${m(e.model)} msgs=${e.messages ?? "-"} tools=${e.tools ?? "-"} maxTok=${e.maxTokens ?? "-"}`;
+    case "relay-queued":
+      return `${head} relay queued  已入队交成员 target=${e.target} reqId=${e.reqId || "-"}`;
+    case "relay-member-result":
+      return `${head} relay result  成员回 target=${e.target} ${e.ok ? "ok" : "FAIL"} ${e.status ? `HTTP ${e.status}` : ""} ${e.ms ? `${e.ms}ms` : ""}${e.respChars ? ` resp=${e.respChars}B` : ""} ${m(e.error || e.respBody || "")}`;
     case "relay-fail":
       return `${head} relay fail    ${e.target} ${e.status ? `HTTP ${e.status}` : ""} ${m(e.message)}`;
     case "relay-ip-change":

package/src/groups.js

@@ -202,7 +202,10 @@ export function syncPeersFromMembers({ peers, members, myUrl, group, skipIds = [
     if (kind === "broadband" || String(m?.url || "").startsWith("relay://")) continue;
     const url = normalizePeerUrl(m?.url);
     if (!url || url === self) continue;
-    if (peers.add({ name: id, url, token: m?.token || "", group })) added++;
+    // 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++;
   }
   return { removed, added, total: Object.keys(members || {}).length };
 }

package/src/model-trace.js

@@ -87,6 +87,10 @@ const DECISION_FIELDS = [
   "heldOpen", "terminalForm", "requestWaitedMs", "budgetMs", "budgetOut",
   // 终局判决（ADR-0058）：取证时第一眼要看的三件——判的哪种、命中哪条判据、是否因此没问组员
   "kind", "marker", "peersSkipped",
+  // 中继/组员目标（2026-10-19）：跨机链路排障第一眼要的是**这一跳打给了谁**——target= 目标成员
+  // （url 或 relay://id）、group= 组、leaderUrl= 经谁中继；缺了这几项，relay-try/fail 只剩状态码，
+  // 看日志根本认不出是哪个组员出的问题（用户实证要求「日志要全面」）。
+  "target", "group", "leaderUrl", "candidates", "tried",
 ];
 
 function decisionKv(data = {}) {
@@ -141,6 +145,24 @@ export function formatModelTrace({ type, reqId, model, data = {}, request = null
     detail = `upstream_response status=${data.status ?? "-"} finish=${d.sawFinishReason || "-"} chunks=${d.receivedChunks ?? "-"} bytes=${d.receivedBytes ?? "-"} tools=${d.toolCalls ?? 0} chars=${d.chars ?? 0} ${usageTxt} elapsed=${data.totalMs ?? "-"}ms${data.upstream ? ` upstream=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}`;
   } else if (type === "result" || type === "client-response") {
     detail = `client status=${data.status ?? "-"} via=${data.via || "-"} actual=${data.actual || model || "-"} fallback=${data.fallback?.fallback ? 1 : 0} total=${totalMs ?? data.durationMs ?? "-"}ms${data.upstream ? ` upstream=${data.upstream}` : ""}${data.account ? ` account=${data.account}` : ""}${data.pick ? ` pick=${data.pick}` : ""}`;
+  } else if (type === "relay-try") {
+    detail = `指定宽带中继 target=${data.target || "?"} group=${data.group || "-"} via=${data.via || "-"}`;
+  } else if (type === "relay-received") {
+    detail = `中继收到 转给 target=${data.target || "?"} group=${data.group || "-"} via=${data.via || "-"} msgs=${data.messages ?? "-"} tools=${data.tools ?? "-"} maxTok=${data.maxTokens ?? "-"}`;
+  } else if (type === "relay-queued") {
+    detail = `已入队交成员 target=${data.target || "?"} reqId=${data.reqId || "-"}`;
+  } else if (type === "relay-member-result") {
+    detail = `成员回 target=${data.target || "?"} ${data.ok ? "ok" : "FAIL"}${data.status ? ` status=${data.status}` : ""}${data.ms ? ` ${data.ms}ms` : ""}${data.respChars ? ` resp=${data.respChars}B` : ""} ${safeText(data.error || data.respBody || "", 200)}`;
+  } else if (type === "relay-fail") {
+    detail = `中继失败 target=${data.target || "?"} group=${data.group || "-"} via=${data.via || "-"}${data.status ? ` status=${data.status}` : ""} ${safeText(data.message || "")}`;
+  } else if (type === "relay-miss") {
+    detail = `宽带中继无候选可试（全部候选未通/无存活成员，交回本地兜底）`;
+  } else if (type === "peer-race-start") {
+    detail = `组员竞速开始 peers=${data.peers ?? "-"}`;
+  } else if (type === "peer-budget-out") {
+    detail = `组员竞速预算用尽 reason=${safeText(data.reason || "", 80)} budgetMs=${data.budgetMs ?? "-"} remaining=${data.remaining ?? "-"}`;
+  } else if (type === "peer-skip-slow") {
+    detail = `跳过过慢组员 peer=${data.peer || "?"} 历史延迟=${data.latencyMs ?? "-"}ms > 上限=${data.capMs ?? "-"}ms`;
   } else detail = safeText(`${decisionKv(data)} ${data.message || data.error || ""}`, 200);
   return `[${base.time}] [req=${base.req}] [model=${base.model}] [stage=${base.stage}] ${detail}`;
 }

package/src/peers.js

@@ -138,22 +138,32 @@ export function createPeersService({
     return hot * 1_000_000_000 + latency * 1_000 + fails;
   }
 
-  // Available peers ordered for failover: hot peers (recent success) first —
-  // the winner of the last race is reused next. Everyone else is ordered by
-  // when they last failed, earliest first: a peer that failed longer ago has
-  // had more time to recover, so it is tried before a more recent failure.
-  // Peers with no recorded error go after any that failed.
+  // 可用组员排序（用户 2026-10-19 决定）：**延迟最小优先**，不再「热优先」。
+  // 语义 = 「组员的额度用完后，用跟组长延迟最小的组员」——延迟是首要判据。
+  // 延迟来源（优先级从高到低）：
+  //   ① stats 里的真实请求 EMA（recordResult 记的 latencyMs）——最可信；
+  //   ② peer.heartbeatLatencyMs —— 组员**定时心跳**上报的 rtt（没跑过真实请求时也能排序）；
+  // 未测过延迟的排在有数据之后；同延迟按「最早失败优先」；都没失败过的排最后。
+  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;
+  }
+
   function ordered(t = now()) {
     return available().sort((a, b) => {
-      const hotA = stats[a.url]?.okAt && t - stats[a.url].okAt < heatMs ? 0 : 1;
-      const hotB = stats[b.url]?.okAt && t - stats[b.url].okAt < heatMs ? 0 : 1;
-      if (hotA !== hotB) return hotA - hotB;
+      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; // never-failed peers go after any that failed
+      if (ea == null) return 1;
       if (eb == null) return -1;
-      return ea - eb; // earliest failure first
+      return ea - eb;
     });
   }
 

package/src/routes/groups-relay.js

@@ -3,7 +3,22 @@ import { DEFAULT_MAX_HOPS } from "../peers.js";
 import { enqueueRelay, dequeueRelayForPoll, resolveRelay, subscribeStream, unsubscribeStream } from "./relay-queue.js";
 import { compatFetch } from "../compat.js";
 
+/** 请求规模摘要（给中继日志用）：消息数/角色分布/工具数/maxTokens/model —— 排障第一眼要看清"转了什么"。 */
+function relayReqSummary(b = {}) {
+  const msgs = Array.isArray(b?.messages) ? b.messages : [];
+  const roles = {};
+  for (const m of msgs) roles[String(m?.role || "?")] = (roles[String(m?.role || "?")] || 0) + 1;
+  return { model: b?.model || "-", stream: b?.stream === true, messages: msgs.length, roles, tools: Array.isArray(b?.tools) ? b.tools.length : 0, maxTokens: Number(b?.max_tokens ?? b?.max_completion_tokens) || null };
+}
+
+/** 响应正文摘要（供中继日志）：单行化 + 截断，只为让人看出上游回的是什么。 */
+function snippet(v, n = 300) {
+  const s = typeof v === "string" ? v : JSON.stringify(v);
+  return String(s || "").replace(/\s+/g, " ").slice(0, n);
+}
+
 export async function heartbeatHandler({ req, res, groups, bus, logs }) {
+  const tRecv = Date.now();
   const auth = /^Bearer (.+)$/.exec(req.headers["authorization"] || "");
   if (!auth) return json(res, 401, { error: "bearer token required" });
   let body;
@@ -22,9 +37,19 @@ export async function heartbeatHandler({ req, res, groups, bus, logs }) {
       if (m) {
         m.publicIp = ip;
         m.lastSeen = Date.now();
-        try { groups.upsertMember(groupName, { memberName: targetId, url: m.url, token: m.token, kind: "broadband", publicIp: ip, lastSeen: m.lastSeen }); } catch {}
+        // 延迟采样（心跳即可得，无需真实请求）：
+        //   rttMs  = 成员自己量的「上一轮心跳往返」（它到组长的网络路径）
+        //   serverMs = 组长这一侧从收到到处理完的耗时
+        // 两者取有值的那个写进成员记录，供选路按「延迟最小优先」排序（routes/peers.js ordered）。
+        const reportedRtt = Number(body?.rttMs);
+        const memberRtt = Number.isFinite(reportedRtt) && reportedRtt >= 0 ? Math.round(reportedRtt) : null;
+        if (memberRtt != null) m.latencyMs = memberRtt;
+        try {
+          groups.upsertMember(groupName, { memberName: targetId, url: m.url, token: m.token, kind: "broadband", publicIp: ip, lastSeen: m.lastSeen, ...(memberRtt != null ? { latencyMs: memberRtt } : {}) });
+        } catch {}
       }
-      const evtData = { ts: Date.now(), type: "relay-heartbeat", member: targetId, ip, lastSeen: m?.lastSeen, group: groupName };
+      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 };
       if (bus) bus.emit(evtData);
       logs?.appendEvent?.(evtData);
     }
@@ -169,10 +194,15 @@ export async function forwardHandler({ req, res, groups, bus, logs, token }) {
   const targetMember = Object.values(members).find((m) => m.url === target) || Object.entries(members).find(([id]) => id === target)?.[1];
   if (!targetMember) return json(res, 404, { error: `target ${target} not found in group ${groupName}` });
   const isBb = targetMember.kind === "broadband" || String(targetMember.url).startsWith("relay://");
+  const reqSummary = relayReqSummary(body.body || body);
+  const fwdEvt = (type, extra) => { const e = { ts: Date.now(), type, group: groupName, target, hops, ...extra }; try { logs?.appendEvent?.(e); } catch {} try { bus?.emit?.(e); } catch {} };
+  // 组长「收到」：谁让我转给谁、转的是什么规模 —— 中继全流程的第一条日志
+  fwdEvt("relay-received", { via: isBb ? "broadband" : "direct", reqId: body.reqId || null, ...reqSummary });
   if (!isBb) {
     // 标记走直连：**在 fetch 之前**就设，这样直连失败（catch 里的 502）也带着它——
     // 那正是最需要区分的一跳（组长直连该成员不通 vs 宽带成员回报失败，两者的 body 可能一模一样）。
     res.setHeader("x-mslxdff-relay-via", "direct");
+    const t0 = Date.now();
     try {
       const fwdBody = body.body || body;
       const r = await compatFetch(`${targetMember.url}/v1/chat/completions`, {
@@ -180,41 +210,49 @@ export async function forwardHandler({ req, res, groups, bus, logs, token }) {
         headers: { "Content-Type": "application/json", "Authorization": `Bearer ${targetMember.token || ""}`, "x-mslxdff-hops": String(hops + 1), "x-mslxdff-model-lock": fwdBody.model || "", "Accept": "text/event-stream" },
         body: JSON.stringify(fwdBody),
       });
-      const evtData = { ts: Date.now(), type: "relay-forward", target, via: "direct", group: groupName, hops };
-      if (bus) bus.emit(evtData);
-      logs?.appendEvent?.(evtData);
-      res.statusCode = r.status;
-      if (r.headers.get("content-type")?.includes("text/event-stream")) {
+      const isSSE = r.headers.get("content-type")?.includes("text/event-stream");
+      if (isSSE) {
+        // 流式直连：没法先读全 body 再转发，就记「已建立」+ 状态码
+        fwdEvt("relay-forward", { via: "direct", ok: r.status < 400, status: r.status, ms: Date.now() - t0, detail: "stream 直连建立" });
+        res.statusCode = r.status;
         res.setHeader("Content-Type", "text/event-stream");
         if (r.body) for await (const c of r.body) res.write(c);
         res.end();
       } else {
         const txt = await r.text();
+        // 直连非流式：把上游回的正文摘要也记下（这就是「组员回了什么」）
+        fwdEvt("relay-forward", { via: "direct", ok: r.status < 400, status: r.status, ms: Date.now() - t0, respChars: txt.length, respBody: snippet(txt) });
+        res.statusCode = r.status;
         res.setHeader("Content-Type", r.headers.get("content-type") || "application/json");
         res.end(txt);
       }
       return;
     } catch (err) {
+      fwdEvt("relay-forward", { via: "direct", ok: false, status: 502, ms: Date.now() - t0, error: errMsg(err) });
       return json(res, 502, { error: errMsg(err) });
     }
   }
   const reqId = body.reqId || `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
   const fwdBody = body.body || { model: body.model, messages: body.messages, stream: body.stream };
-  const evtData = { ts: Date.now(), type: "relay-forward", target, via: "leader", group: groupName, hops, reqId, model: fwdBody.model };
-  if (bus) bus.emit(evtData);
-  logs?.appendEvent?.(evtData);
   const staleMs = Number(process.env.MSLXDFF_BROADBAND_STALE_MS) > 0 ? Number(process.env.MSLXDFF_BROADBAND_STALE_MS) : 90_000;
   if (typeof targetMember.lastSeen === "number" && Date.now() - targetMember.lastSeen > staleMs) {
     res.setHeader("x-mslxdff-relay-via", "broadband");
+    fwdEvt("relay-member-result", { reqId, ok: false, status: 502, error: "broadband member stale (no heartbeat)" });
     return json(res, 502, { error: "broadband member stale (no heartbeat)" });
   }
   // 标记走的是宽带中继：下游据此一眼分清「组长直连失败(502 fetch failed)」vs「宽带成员回报的失败」，
   // 两者响应体可能都是 {"error":"fetch failed"}，只有这个头能区分（成员侧已把真实原因写进 errors.log）。
   res.setHeader("x-mslxdff-relay-via", "broadband");
+  const tFwd = Date.now();
+  // 组长「已交给成员」：入队即记 —— 成员有没有真正收到，由成员侧那条 relay-task-recv 佐证
+  fwdEvt("relay-queued", { reqId, via: "broadband" });
   try {
     const resultPromise = enqueueRelay({ group: groupName, target: targetMember.url, reqId, body: fwdBody, hops });
     const result = await resultPromise;
     if (result && typeof result.status === "number") {
+      const rb = result.body == null ? "" : (typeof result.body === "string" ? result.body : JSON.stringify(result.body));
+      // 组长「收到成员回什么」：状态码 + 正文摘要 + 耗时 —— 中继全流程的收尾日志
+      fwdEvt("relay-member-result", { reqId, ok: result.status < 400, status: result.status, ms: Date.now() - tFwd, respChars: rb.length, respBody: snippet(rb) });
       res.statusCode = result.status;
       if (result.status >= 500) res.setHeader("x-mslxdff-relay-member-status", String(result.status));
       if (result.headers) for (const [k, v] of Object.entries(result.headers)) res.setHeader(k, v);
@@ -224,8 +262,10 @@ export async function forwardHandler({ req, res, groups, bus, logs, token }) {
       } else res.end();
       return;
     }
+    fwdEvt("relay-member-result", { reqId, ok: true, status: 200, ms: Date.now() - tFwd, respBody: snippet(result) });
     return json(res, 200, result);
   } catch (err) {
+    fwdEvt("relay-member-result", { reqId, ok: false, status: 504, ms: Date.now() - tFwd, error: errMsg(err) || "relay timeout" });
     return json(res, 504, { error: errMsg(err) || "relay timeout" });
   }
 }

package/src/routes/peer-serial.js

@@ -0,0 +1,99 @@
+// 组员串行选路（用户 2026-10-19 决定：不竞速）。
+//
+// 为什么改：并发赛跑会同时占用多个组员的额度/连接，慢节点还会拖住整批；而用户要的语义是
+// 「本机额度用完 → 用延迟最小的组员」，延迟小的先上、不行再下一个。串行让这条优先级真正生效。
+//
+// 本模块只做「按序试」这件事，其余（画目标、转发、记账、事件名）从 peers.js 注入，避免循环依赖。
+export const PEER_SERIAL = true;
+
+/**
+ * 串行试候选：一次只打一个，成功即返回；失败顺位试下一个。
+ *
+ * @param {object} p
+ * @param {Array}  p.candidates        已按「延迟最小优先」排好的组员
+ * @param {object} p.ctx               请求上下文（evt/peers/body/hops/plugins/peerErrors/triedUrls…）
+ * @param {Set}    p.tried             已试过的 url 集合
+ * @param {object} p.deps              { resolvePeerTarget, forwardToPeer, peerName, recordLater,
+ *                                       summarizeRequest, runHook, errMsg, perAttemptCap, deadline, budgetMs }
+ * @returns {Promise<null | {peer, target, res, latencyMs}>}
+ */
+export async function serialTryPeers({ candidates, ctx, tried, deps }) {
+  const {
+    resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg,
+    perAttemptCap, deadline, budgetMs,
+  } = deps;
+  const failed = [];
+  // 延迟上限过滤：历史延迟超过「单次尝试上限」的组员直接跳过（它大概率又超时）。
+  // 只在**还有别的候选**时才跳过，避免把唯一可用的节点也跳没了。
+  const ranked = candidates.filter((p) => {
+    let lat = null;
+    try {
+      // 与 ordered() 同源：先看真实请求 EMA，再回落到心跳上报的 rtt
+      lat = ctx.peers?.stat?.(p.url)?.latencyMs ?? p.heartbeatLatencyMs ?? null;
+      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; // 只剩它 → 仍然试
+    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++) {
+    if (deadline > 0 && Date.now() >= deadline) {
+      ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽`, budgetMs, remaining: ranked.length - i });
+      break;
+    }
+    const prepared = await resolvePeerTarget(ctx, ranked[i]);
+    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 });
+    if (ctx.plugins?.length) {
+      runHook(ctx.plugins, "peer:beforeForward", { reqId: ctx.reqId, peer: peer.url, model: target, hops: ctx.hops + 1 }).catch(() => {});
+    }
+    const remainingMs = deadline > 0 ? deadline - Date.now() : 0;
+    // 单个组员的等待上限 = min(阶段剩余预算, 单次尝试上限)。单次上限保证黑洞节点
+    // 不会吃掉整个阶段（否则延迟最小的好组员轮不到）。
+    const waitMs = deadline > 0 ? Math.max(1, Math.min(perAttemptCap, remainingMs)) : perAttemptCap;
+    const t0 = performance.now();
+    const res = await forwardToPeer(peer, ctx.body, target, ctx.hops, ctrl, waitMs);
+    const latencyMs = Math.round(performance.now() - t0);
+    const isErr = res instanceof Error;
+    const status = isErr ? 502 : res.status;
+    if (ctx.plugins?.length) {
+      runHook(ctx.plugins, "peer:result", { reqId: ctx.reqId, peer: peer.url, model: target, ok: !(isErr || status >= 400), status, latencyMs }).catch(() => {});
+    }
+    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-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; // 串行：试下一个
+    }
+    ctx.evt("peer-forward", { peer: peer.url, name, model: target, hops: ctx.hops + 1, latencyMs, ok: true, status });
+    return { peer, target, res, latencyMs };
+  }
+
+  // 全败：补读失败响应体（诊断 + 调用者详情）
+  await Promise.all(failed.map(async (o) => {
+    if (!o.res || typeof o.res !== "object" || o.res instanceof Error) return;
+    try {
+      const snip = String(await Promise.race([
+        o.res.clone().text(),
+        new Promise((r) => { const t = setTimeout(() => r(""), 600); t.unref?.(); }),
+      ])).replace(/\s+/g, " ").slice(0, 300);
+      if (!snip) return;
+      if (Array.isArray(ctx.peerErrors)) {
+        const rec = ctx.peerErrors.find((x) => x.peer === o.peer.url && x.status === o.status && !x.message);
+        if (rec) rec.message = snip;
+      }
+      ctx.evt("peer-error", { peer: o.peer.url, name: peerName(o.peer), model: o.target, status: o.status, message: `body=${snip}` });
+    } catch {}
+  }));
+  return null;
+}

package/src/routes/peers.js

@@ -4,6 +4,7 @@ import { errMsg } from "./helpers.js";
 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";
 
 // peer 阶段总预算：三批候选（ordered / orderedByLastError / coolingByLastError）共享同一个
 // 截止时间，而不是每批各吃满一次等头超时。实测最坏路径是三批串行各 30s（≈90s），
@@ -34,6 +35,15 @@ function peerConnectTimeoutMs() {
   return Number.isInteger(n) && n > 0 ? n : DEFAULT_PEER_CONNECT_TIMEOUT_MS;
 }
 
+// 单组员等待上限（串行模式下逐个体生效，MSLXDFF_PEER_ATTEMPT_TIMEOUT_MS，缺省 20s）。
+// 为什么必须限：串行是「一个失败才试下一个」，若一个黑洞节点吃满 120s（bodyTimeout），
+// 后面延迟更小的好组员根本轮不到——实测 172.93.221.187 常 38~44s 才回/被 abort。
+// 20s 足以覆盖正常首包，又不会让一个坏节点吃掉整个阶段预算；可用 env 调。
+function peerAttemptTimeoutMs() {
+  const n = Number(process.env.MSLXDFF_PEER_ATTEMPT_TIMEOUT_MS);
+  return Number.isInteger(n) && n > 0 ? n : 20_000;
+}
+
 // peer 阶段总预算（MSLXDFF_PEER_RACE_BUDGET_MS，0=不限）：一次 peer 阶段（同批或若干批候选）
 // 共享同一个截止时刻。调用方用 peerStageCtx() 起一个阶段，别把 deadline 挂在整个请求上下文上——
 // 否则前一个候选把预算吃光，后一个候选一进 peer 阶段就直接放弃。
@@ -249,6 +259,10 @@ function peerName(peer) {
   return String(peer?.name || "").trim() || null;
 }
 
+// 组员试法：**串行**（用户 2026-10-19 决定：不竞速）。实现在 ./peer-serial.js，
+// 本文件只保留调度与并发版（PEER_SERIAL=false 时的旧路径）。
+export { PEER_SERIAL };
+
 export async function racePeerCandidates(candidates, ctx) {
   const tried = (ctx.triedUrls ??= new Set());
   const fresh = candidates.filter((p) => !tried.has(p.url));
@@ -256,6 +270,15 @@ export async function racePeerCandidates(candidates, ctx) {
   // 没传的阶段（单批调用）不带预算——保持旧行为，不外溢到整条请求。
   const budgetMs = ctx.peerRaceBudgetMs ?? 0;
   const deadline = Number(ctx.peerRaceDeadline) || 0;
+
+  // 串行：按 candidates 的既有次序（调用方已按「延迟最小优先」排好）逐个试。
+  if (PEER_SERIAL) {
+    return serialTryPeers({
+      candidates: fresh, ctx, tried,
+      deps: { resolvePeerTarget, forwardToPeer, peerName, recordLater, summarizeRequest, runHook, errMsg, perAttemptCap: peerAttemptTimeoutMs(), deadline, budgetMs },
+    });
+  }
+
   for (let i = 0; i < fresh.length; i += PEER_RACE_LIMIT) {
     if (deadline > 0 && Date.now() >= deadline) {
       ctx.evt("peer-budget-out", { peer: null, reason: `peer 阶段总预算 ${budgetMs}ms 用尽`, budgetMs, remaining: fresh.length - i });

package/src/routes/relay-queue.js

@@ -140,7 +140,10 @@ export async function tryBroadbandRelay({ groups, token: myToken, model, body, h
         }
       } catch {}
     }
-    if (!allCandidates.length) return null;
+    if (!allCandidates.length) {
+      evt?.("relay-miss", { reqId, model, reason: "no-candidates", candidates: 0 });
+      return null;
+    }
     for (const cand of allCandidates) {
       try {
         evt?.("relay-try", { reqId, model, via: cand.via, target: cand.target, group: cand.group });

package/src/runtime/broadband.js

@@ -24,6 +24,11 @@ export function createBroadbandExec({ token, upstream, logs, log = console.log,
     const t0 = Date.now();
     const model = String(body?.model || "");
     const fl = withOutputFloor(body); // 首发输出额度托底：leader 转来的 body 不经 pipeline，成员侧自托（评审 P1）
+    // 成员「收到任务」：谁转来的、是什么规模、转给谁 —— 中继全流程在**成员这一跳**的入口日志。
+    // 没有它，组长侧只知道"入队了"，无从确认成员是否真收到、收到的是什么（用户实证要求「日志要全面」）。
+    const nMsgs = Array.isArray(body?.messages) ? body.messages.length : 0;
+    const nTools = Array.isArray(body?.tools) ? body.tools.length : 0;
+    log(`broadband task recv: group=${g.name} req=${reqId} from leader=${g.leaderUrl} model=${model} messages=${nMsgs} tools=${nTools}`);
     if (fl !== body) log(`output-floor(broadband): req=${reqId} ${(body?.max_tokens ?? body?.max_completion_tokens)}→${(fl.max_tokens ?? fl.max_completion_tokens)}`);
     try {
       const upRes = await upstream.chat(fl);
@@ -92,20 +97,30 @@ export function startBroadband({ token, upstream, logs, log = console.log }) {
     return true;
   })();
   const execAndPost = createBroadbandExec({ token, upstream, logs, log });
+  // 心跳往返延迟：成员侧自己量「上一轮 heartbeat 的 RTT」，随下一次心跳上报给组长。
+  // 组长侧据此排序「谁的延迟更低」（选路=延迟最小优先，见 routes/peers.js 的 ordered）。
+  // 用上一轮而不是本轮的原因：本轮 RTT 要等响应回来才知道，来不及带在这次请求里。
+  const hbRtt = new Map(); // group name -> ms
   const doHeartbeat = async () => {
     for (const g of broadbandGroups()) {
       try {
+        const t0 = Date.now();
         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 }),
+          body: JSON.stringify({ name: g.name, group: g.name, rttMs: hbRtt.get(g.name) ?? null }),
           signal: timeoutSignal(5000),
         });
+        const rtt = Date.now() - t0;
+        hbRtt.set(g.name, rtt);
         if (!res.ok) {
           const txt = await res.text().catch(() => "");
           log(`broadband heartbeat ${g.name}: ${res.status} ${txt.slice(0, 100)}`);
+        } else {
+          log(`broadband heartbeat ${g.name}: ok rtt=${rtt}ms`);
         }
       } catch (err) {
+        hbRtt.delete(g.name);
         log(`broadband heartbeat ${g.name}: failed — ${errMsg(err)}`);
       }
     }

package/src/upstream-engine/index.js

@@ -46,10 +46,22 @@ export function createUpstreamEngine(opts = {}) {
         const via = useResponses ? "@ai-sdk/openai · responses" : "@ai-sdk/openai-compatible · chat";
         try { console.error(`[upstream-engine] sdk 引擎生效（${via}）`); } catch {}
       }
-      // 保留 legacy 的匿名重试语义（仅 !anonFirst 配置下存在）；G1a 起 free-429 的**请求内 v6 换出口**
-      // 也走这条委派——重试环在 legacy.chat 里，SDK 通道撞 429 不委派就等于把换出口的额度白白留给下一发。
-      // 无 rotateFor 的 dispatcher（直连/WARP）且 anonFirst 时维持旧行为（不重复打流量）。
-      if (res.status === 429 && isFreeModel(body?.model) && (!anonFirst || typeof dispatcher?.rotateFor === "function")) return legacy.chat(body);
+      // 保留 legacy 的匿名重试语义（仅 !anonFirst 配置下存在）；free-429 的**请求内 v6 换出口**
+      // 也走这条委派——重试环在 legacy.chat 里。
+      // ⚠ 顺序契约（用户 2026-10-19）：先借人（组员/组长，用对方 IPv4 出口），全都用完才换出口。
+      //   故 v6 换出口**默认关**，只有显式 MSLXDFF_V6_INREQUEST_ROTATE=1 才委派；
+      //   默认把 429 原样返回，交给 chat-pipeline 去试组员/组长。
+      const v6RotateOn = (() => {
+        const raw = process.env.MSLXDFF_V6_INREQUEST_ROTATE;
+        if (raw === undefined || raw === null || raw === "") return false;
+        const s = String(raw).trim().toLowerCase();
+        return !(s === "0" || s === "false" || s === "off" || s === "no");
+      })();
+      const canRotate = v6RotateOn && typeof dispatcher?.rotateFor === "function";
+      // 原语义：撞 429 且是 free 模型，且（非匿名首试 或 有 v6 池可换址）⇒ 委派 legacy 重试环。
+      // 新语义：**只有显式开启 v6 请求内换址时才委派**；默认 429 原样返回，交给上层去借人
+      // （组员/组长，用对方 IPv4 出口），符合用户 2026-10-19 的「先借人再换出口」顺序。
+      if (res.status === 429 && isFreeModel(body?.model) && (anonFirst ? canRotate : v6RotateOn)) return legacy.chat(body);
       return res;
     } catch (e) {
       if (e && e._sdkLoadFailed) {

package/src/upstream.js

@@ -188,14 +188,24 @@ export function createUpstreamClient({
       try { console.error(`[free-lane] resp model=${body?.model} status=${res.status} ct=${res.headers?.get?.("content-type") || ""}`); } catch {}
     }
 
-    // G1a（ADR-0061）**请求内**榨干 v6 出口池：free 模型撞出口池级 429 时，await dispatcher 换一个新
-    // 源地址、在**同一请求内**重发——额度按出口 IP 计，本节点 v6 池里的其余地址这一发就该用上，
-    // 而不是把 429 退回客户端/组长、留给"下一个请求"。
+    // 请求内换出口（v6 池）：撞 429 时在同一请求里换源地址重发。
+    //
+    // ⚠ 顺序契约（用户 2026-10-19 明确）：**先借人，再换出口**。
+    //   429 ⇒ ① 先走组员/组长接力（用**对方的 IPv4 出口**）；② 全都没得用/都失败，
+    //   才轮到 WARP / IPv6 换出口拿"新的自然额度"。WARP/IPv6 是另一层兜底，不该抢在借人之前。
+    //   故本功能**默认关闭**，需要时才显式开：MSLXDFF_V6_INREQUEST_ROTATE=1（原 ADR-0061 行为）。
+    //   关闭时 429 原样交回上层 → chat-pipeline 去试组员/组长，符合用户要的顺序。
     // 边界（探测实证过的硬约束）：① 仅头部即 429 才换（不碰半开的 200 流）；② 429 错误体已被
     // transport 非流分支读尽，无连接泄漏；③ 每轮换的是 session 粘的那个槽（swap 原地换 addr/e.agent，
     // 粘性映射不失效）；④ 次数上限防 429 风暴空烧认领地址；⑤ 无 rotateFor 的 dispatcher（直连/WARP）
     // 条件短路——WARP 换出口=重注册设备 6s~600s，在请求内做只会白等，**设计上排除**。
-    if (freeLane && res.status === 429 && typeof transport.dispatcher?.rotateFor === "function") {
+    const inRequestRotateOn = (() => {
+      const raw = process.env.MSLXDFF_V6_INREQUEST_ROTATE;
+      if (raw === undefined || raw === null || raw === "") return false; // 缺省关：先借人
+      const s = String(raw).trim().toLowerCase();
+      return !(s === "0" || s === "false" || s === "off" || s === "no");
+    })();
+    if (inRequestRotateOn && freeLane && res.status === 429 && typeof transport.dispatcher?.rotateFor === "function") {
       const maxRot = envIntOrZero("MSLXDFF_V6_INREQUEST_RETRIES", 3); // 0 = 关掉请求内换出口
       let rotated = 0;
       while (res.status === 429 && rotated < maxRot) {