mslxdff 0.1.178 → 0.1.180

package/package.json

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

package/src/warp-pool/index.js

@@ -7,7 +7,8 @@ import { createHealthMonitor } from "./health.js";
 import { ensureDir, loadNodes, removeNode, saveNode } from "./nodes.js";
 import { registerWarpDevice } from "./register.js";
 import { ensureBinary, probeTunnel, resolveAsset, startTunnel, writeTunnelConf } from "./wireproxy.js";
-import { createReviver, labelExits } from "./revive.js";
+import { createReviver, labelExits, tailReason } from "./revive.js";
+import { portInUse, reclaimPort, waitPortFree } from "./ports.js";
 import { wireRotation } from "./identity.js";
 
 /** 重拨节流：连续失败指数退避。网络不通的机器绝不能让重注册把 CF 刷到 429。 */
@@ -37,6 +38,9 @@ export function createWarpPool({
   ensureBin = ensureBinary,
   start = startTunnel,
   probe = probeTunnel,
+  reclaim = reclaimPort,
+  inUse = portInUse,
+  waitFree = waitPortFree,
   now = Date.now,
   rnd = Math.random,
   wait = (ms) => new Promise((r) => setTimeout(r, ms)),
@@ -55,18 +59,31 @@ export function createWarpPool({
   async function reviveTunnel(port) {
     if (closed) return false;
     const node = loadNodes(cfg.dir, [port])[0];
-    if (!node) return false;
-    await bringUp(node);
-    return tunnels.has(port);
+    if (!node) {
+      log(`[warp-pool] :${port} 放弃复活：磁盘上没有该节点的身份（node-${port}.json 缺失或缺私钥）`);
+      return false;
+    }
+    try {
+      await bringUp(node);
+    } catch (e) {
+      log(`[warp-pool] :${port} 复活起隧道失败：${String(e?.message || e)}`);
+      return false;
+    }
+    return true; // 真活没活由 createReviver 在 settleMs 后用 isAlive 复查，这里不许冒充成功
   }
-  const reviver = createReviver({ revive: reviveTunnel, log });
+  const reviver = createReviver({ revive: reviveTunnel, isAlive: (port) => { const t = tunnels.get(port); return !!t && t.alive !== false; }, log });
   let binPath = "";
   let closed = false;
   let lastRedialAt = 0;
   let redialGapMs = REDIAL_MIN_GAP_MS;
 
   // 兜底清理：Node 退出不会回收 spawn 的子进程，daemon 突然退出时同步杀掉隧道。
+  // 同时置 closed：否则「杀子进程 → onExit → 立刻复活」会在退出过程中再 spawn 出一批孤儿（真机：每次重启漏一批）。
   process.once("exit", () => {
+    closed = true;
+    try {
+      reviver.stop();
+    } catch {}
     for (const t of tunnels.values()) {
       try {
         t.stop();
@@ -74,21 +91,29 @@ export function createWarpPool({
     }
   });
 
+  /** 起一条隧道的完整动作：确认不是重复起 → 清残留 → 写 conf → 等端口真空出来 → spawn → 记表。 */
   async function bringUp(node) {
+    if (tunnels.has(node.port)) return; // 已归我们管：绝不再清残留（reclaim 会把自己这条隧道当残留杀掉）
+    await reclaim({ dir: cfg.dir, port: node.port, log }); // 清上一代孤儿（daemon 被强杀时子进程不会自己退）
     writeTunnelConf(cfg.dir, node);
-    if (tunnels.has(node.port)) return;
+    // SIGTERM 之后套接字要几百毫秒才释放，这期间连得上 ≠ 别人的进程占着——先等它真空出来再判
+    if (!(await waitFree(node.port, { inUse }))) {
+      throw new Error(`端口 :${node.port} 被非本池进程占着，拒绝再起（硬起只会 bind 失败、无限重启刷屏）；查明：ss -ltnp | grep :${node.port}`);
+    }
     const t = start({
       binPath,
       dir: cfg.dir,
       port: node.port,
       log,
-      onExit: ({ port, code }) => {
+      onExit: ({ port, code, signal, tail }) => {
         tunnels.delete(port);
-        log(`[warp-pool] 隧道 :${port} 退出（code=${code}），尝试复活`);
-        void reviver.onExit(port);
+        const why = tailReason(tail) || "进程没留下任何输出";
+        log(`[warp-pool] :${port} 隧道意外退出（退出码 ${code}${signal ? `，信号 ${signal}` : ""}）：${why}`);
+        if (!closed) void reviver.onExit(port); // 收摊中就别复活了，否则退出过程里又 spawn 出一批孤儿
       },
     });
     tunnels.set(node.port, t);
+    log(`[warp-pool] :${node.port} 隧道已起：HTTP 代理 http://127.0.0.1:${node.port} → 经 WARP 出网（pid ${t.pid ?? "?"}）`);
   }
 
   // 429 ＝ 上游按出口 IP 计的名额耗尽 ⇒ 换一台设备的身份换出口（换身份＝换桶）。
@@ -101,6 +126,35 @@ export function createWarpPool({
     log,
   });
 
+  /** 探活闸门参数：刚起的隧道要等 WireGuard 握手完成才通（真机：一起来就探 ⇒ 4 条全没通 ⇒ 池为空、WARP 白开）。 */
+  const PROBE_SETTLE_MS = 2_000;
+  const PROBE_ATTEMPTS = 2;
+
+  /**
+   * 入池前的实测闸门：给握手留时间 → 逐个探活 → 探不通的绝不进池。
+   * 为什么必须有：wireproxy 进程活着但隧道转不动流量时，请求会挂到超时（比直连更糟）。
+   * @returns {Promise<Array<object>>} 通过探活的节点
+   */
+  async function probeGate(list) {
+    const live = [];
+    await wait(PROBE_SETTLE_MS);
+    for (const n of list) {
+      if (!tunnels.has(n.port)) continue;
+      let r = { ok: false };
+      for (let i = 1; i <= PROBE_ATTEMPTS; i++) {
+        r = await probe({ port: n.port, baseUrl, path: cfg.probePath });
+        if (r.ok) break;
+        if (i < PROBE_ATTEMPTS) await wait(PROBE_SETTLE_MS);
+      }
+      if (r.ok) {
+        live.push(n);
+        log(`[warp-pool] :${n.port} 探通（HTTP ${r.status}），进池`);
+      } else {
+        log(`[warp-pool] :${n.port} 探了 ${PROBE_ATTEMPTS} 次都不通（${r.status || r.error || "?"}），不进池：进池会把请求挂到超时，比直连更糟`);
+      }
+    }
+    return live;
+  }
   async function bootstrap() {
     if (closed) return;
     ensureDir(cfg.dir);
@@ -110,14 +164,14 @@ export function createWarpPool({
       const why = !cfg.bin && !resolveAsset()
         ? `本平台（${process.platform}-${process.arch}）无预编译 wireproxy，如需启用请设 MSLXDFF_WARP_BIN`
         : String(e?.message || e);
-      log(`[warp-pool] 出口池跳过：${why}`);
+      log(`[warp-pool] 出口池本次跳过（不启用，请求走直连）：${why}`);
       return;
     }
     if (closed) return;
 
     // 1. 复用磁盘上已注册的节点
     let nodes = loadNodes(cfg.dir, cfg.ports);
-    log(`[warp-pool] 已有节点 ${nodes.length}/${cfg.count}`);
+    log(`[warp-pool] 复用磁盘上已注册的身份 ${nodes.length}/${cfg.count} 个（端口 ${cfg.ports.join(", ")}；缺的现场注册）`);
 
     // 2. 补足：逐个注册（拉长间隔，避免 CF 注册限流与同网段撞车）
     const used = new Set(nodes.map((n) => n.port));
@@ -131,9 +185,9 @@ export function createWarpPool({
         const node = nodeFromReg(port, reg, now);
         saveNode(cfg.dir, node);
         nodes.push(node);
-        log(`[warp-pool] 注册节点 :${port}（v6=${reg.v6}）`);
+        log(`[warp-pool] 注册新身份 :${port} 成功（设备 v6=${reg.v6}，WireGuard 密钥对在本地生成）`);
       } catch (e) {
-        log(`[warp-pool] 注册节点 :${port} 失败：${String(e?.message || e)}`);
+        log(`[warp-pool] :${port} 注册身份失败，本轮跳过这个端口：${String(e?.message || e)}`);
       }
     }
 
@@ -142,23 +196,17 @@ export function createWarpPool({
       try {
         await bringUp(n);
       } catch (e) {
-        log(`[warp-pool] 起隧道 :${n.port} 失败：${String(e?.message || e)}`);
+        log(`[warp-pool] :${n.port} 起隧道失败，这个端口本轮不可用：${String(e?.message || e)}`);
       }
     }
 
-    // 入池前实测探活：WARP 握手不通时 wireproxy 进程照样在跑却转不动流量（挂到超时），那种节点进池会黑洞全部请求
-    const live = [];
-    for (const n of nodes) {
-      if (!tunnels.has(n.port)) continue;
-      const r = await probe({ port: n.port, baseUrl, path: cfg.probePath });
-      if (r.ok) live.push(n);
-      else log(`[warp-pool] 节点 :${n.port} 隧道未通（${r.status || r.error || "?"}），不进池`);
-    }
+    // 入池前实测探活：WARP 握手没完成时 wireproxy 在跑却转不动流量（请求会挂到超时），那种节点进池会黑洞全部请求
+    const live = await probeGate(nodes);
     if (live.length) {
       await dispatcher.setNodes(live.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
-      log(`[warp-pool] 出口池就绪：${live.length} 个节点`);
+      log(`[warp-pool] 出口池就绪：${live.length} 条隧道可用（选路策略 ${cfg.strategy}${cfg.rotate ? "，撞 429 会自动换身份换出口" : ""}）`);
     } else {
-      log("[warp-pool] 无可用节点，保持直连");
+      log("[warp-pool] 没有一条隧道探通 ⇒ 池为空，全部请求照旧直连（不影响可用性，只是没多出口）");
     }
 
     // 5. 出口取证：把每台设备的真实出口地址打进日志（免费版 WARP 的 IPv4 是共享 NAT，N 台设备很可能折叠成同一个出口）
@@ -199,10 +247,15 @@ export function createWarpPool({
         }
         await wait(gapMs(cfg, rnd));
       }
-      if (!closed && [...tunnels.keys()].length) {
-        // 重拨确实把隧道拉起来了 ⇒ 退避复位
-        redialGapMs = REDIAL_MIN_GAP_MS;
-        await dispatcher.setNodes([...tunnels.keys()].map((port) => ({ port, uri: `http://127.0.0.1:${port}` })));
+      if (!closed && tunnels.size) {
+        // 重拨起来的隧道同样要过闸门：没过探活的隧道进池 = 把请求挂到超时（原先这里直接 setNodes，等于绕过闸门）
+        const alive = await probeGate([...tunnels.keys()].map((port) => ({ port })));
+        if (alive.length) {
+          redialGapMs = REDIAL_MIN_GAP_MS; // 确实有隧道能通 ⇒ 退避复位
+          await dispatcher.setNodes(alive.map((n) => ({ port: n.port, uri: `http://127.0.0.1:${n.port}` })));
+        } else {
+          log("[warp-pool] 重拨后仍没有一条隧道探通，保持直连（等下一轮健康检查）");
+        }
       }
     },
   });
@@ -221,6 +274,7 @@ export function createWarpPool({
       if (closed) return;
       closed = true;
       monitor.stop();
+      reviver.stop();
       for (const t of tunnels.values()) {
         try {
           t.stop();

package/src/warp-pool/ports.js

@@ -0,0 +1,122 @@
+// warp-pool · 端口占用与「上一代进程残留」清理（2026-10-16 组长 VPS 真机事故后新增）。
+//
+// 事故：daemon 被强杀（WMI TerminateProcess / taskkill /F）时 `process.once("exit")` 钩子不执行，
+// wireproxy 子进程变成孤儿，继续占着 127.0.0.1:10800+ 这些端口。新 daemon 再起隧道就 bind 失败
+// （wireproxy 立刻退出 code=1），而旧代码把「spawn 成功」当成「复活成功」⇒ 无限重启、日志刷屏、
+// 且该端口的隧道永远起不来。治本是「起隧道前先把自家残留清掉」，并「端口被别人占着就别硬起」。
+import { readFileSync, readdirSync } from "node:fs";
+import { connect } from "node:net";
+import { nodePaths } from "./nodes.js";
+
+/** /proc/<pid>/cmdline 是 NUL 分隔的字节串；切成参数数组（丢掉结尾空串）。 */
+export function parseCmdline(buf) {
+  return String(buf == null ? "" : buf).split("\0").filter((s) => s !== "");
+}
+
+/**
+ * 该进程是不是「正在跑我们这条 conf」的 wireproxy。
+ * 判据刻意收紧（argv 里得有 wireproxy 这个可执行文件名，且 conf 路径逐字相等），
+ * 免得误杀别人的进程。缺一不可。
+ */
+export function isOurWireproxy(argv, conf) {
+  const list = Array.isArray(argv) ? argv : [];
+  const isBin = list.some((a) => /(^|[\\/])wireproxy(\.exe)?$/i.test(a));
+  return isBin && list.includes(conf);
+}
+
+function defaultPids() {
+  try {
+    return readdirSync("/proc").filter((f) => /^\d+$/.test(f)).map(Number);
+  } catch {
+    return [];
+  }
+}
+
+function defaultCmdline(pid) {
+  try {
+    return parseCmdline(readFileSync(`/proc/${pid}/cmdline`));
+  } catch {
+    return [];
+  }
+}
+
+/** 进程是否还在（信号 0 = 只做存在性检查，不真发信号）。 */
+export function pidAlive(pid, kill = process.kill) {
+  try {
+    kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 清掉「占着该端口那条 conf」的上一代 wireproxy。返回被清理的 pid 列表。
+ * 非 Linux 直接返回 []（读不到 /proc，别拿别的平台做危险猜测）。
+ * @param {{ dir: string, port: number, log?: Function, platform?: string,
+ *           pids?: Function, cmdline?: Function, kill?: Function, sleep?: Function, waitRounds?: number }} opts
+ */
+export async function reclaimPort({
+  dir,
+  port,
+  log = () => {},
+  platform = process.platform,
+  pids = defaultPids,
+  cmdline = defaultCmdline,
+  kill = process.kill,
+  sleep = (ms) => new Promise((r) => setTimeout(r, ms)),
+  waitRounds = 15,
+} = {}) {
+  if (platform !== "linux") return [];
+  const conf = nodePaths(dir, port).conf;
+  const targets = pids().filter((pid) => isOurWireproxy(cmdline(pid), conf));
+  if (!targets.length) return [];
+
+  log(
+    `[warp-pool] 端口 :${port} 发现上一代 wireproxy 残留（pid ${targets.join(", ")}）：` +
+      `daemon 被强杀时子进程不会自己退出，它会一直占着端口让新隧道 bind 失败。先清掉再起。`,
+  );
+  for (const pid of targets) {
+    try {
+      kill(pid, "SIGTERM");
+    } catch {}
+  }
+  for (let i = 0; i < waitRounds && targets.some((p) => pidAlive(p, kill)); i++) await sleep(100);
+  for (const pid of targets.filter((p) => pidAlive(p, kill))) {
+    try {
+      kill(pid, "SIGKILL");
+    } catch {}
+  }
+  return targets;
+}
+
+/** 该端口是否已有人在监听（TCP 连得上 = 占用；连不上/被拒 = 空闲）。 */
+export function portInUse(port, { host = "127.0.0.1", timeoutMs = 800, connectFn = connect } = {}) {
+  return new Promise((resolve) => {
+    let done = false;
+    const sock = connectFn({ host, port });
+    const finish = (v) => {
+      if (done) return;
+      done = true;
+      try {
+        sock.destroy();
+      } catch {}
+      resolve(v);
+    };
+    sock.setTimeout(timeoutMs, () => finish(false));
+    sock.once("connect", () => finish(true));
+    sock.once("error", () => finish(false));
+  });
+}
+
+/**
+ * 等端口真正空出来（SIGTERM 之后套接字要几百毫秒才释放，这期间连得上 ≠ 别人的进程占着）。
+ * 返回 true = 空了；false = 等了 rounds 轮还是被占。
+ */
+export async function waitPortFree(port, { inUse = portInUse, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), rounds = 12, stepMs = 250 } = {}) {
+  for (let i = 0; i < rounds; i++) {
+    if (!(await inUse(port))) return true;
+    await sleep(stepMs);
+  }
+  return !(await inUse(port));
+}

package/src/warp-pool/revive.js

@@ -1,14 +1,14 @@
 // warp-pool · 复活与取证（真机事故后新增，2026-10-16）。
 //
-// 两件事，都来自组长 VPS 上暴露的缺陷：
+// 三件事，都来自组长 VPS 上暴露的缺陷：
 //
-// 1. `revive`: 隧道进程意外退出后**必须自愈**。原先 `onExit` 只把端口从表里删掉、打一行日志就完事，
-//    而唯一的补拉路径 `onExhausted` 要求「全池不通」——3 条活着时探活一直成功，那条死隧道
-//    就**再也不会被拉起**，池静默从 4 降到 3，直到 daemon 重启。（真机：:10800 死了就一直死。）
-//    注意：复活走**磁盘上已有的 conf**（不重新注册）——进程挂了不代表设备失效，重注册只会白烧 CF 配额。
+// 1. 隧道退出后必须自愈：原先只有「全池不通」才补拉，一条死隧道会让池静默从 4 降到 3，直到 daemon 重启。
+// 2. 入池后必须实测各节点真实出口：WARP 的 IPv4 出口是共享 NAT，「N 设备」很可能折叠成一个出口。
+// 3. 复活必须**真的活下来**（2026-10-16 组长 VPS 事故）：`tunnels.has(port)` 只证明「spawn 被调用了」，
+//    wireproxy 起一条死一条（端口被上一代孤儿进程占着 ⇒ bind 失败 ⇒ 退出码 1），旧逻辑次次判「已复活」
+//    ⇒ 下一次退出立刻再复活 ⇒ 无限重启刷屏，该端口永远起不来。
 //
-// 2. `labelExits`: 入池后实测各节点**真实出口地址**并标注撞车。WARP 的 IPv4 出口是共享 NAT，
-//    「N 设备」很可能折叠成一个出口；没有这条读数就只能靠人手工 curl 才发现。
+// 复活只走**磁盘上已有的 conf**：进程挂了 ≠ 设备失效，重注册只会白烧 CF 配额。
 import { probeTunnel } from "./wireproxy.js";
 
 /** 出口取证目标：Cloudflare 自己的 trace 端点，回 `ip=` 一行（不烧上游 token）。 */
@@ -20,12 +20,20 @@ export function parseExitIp(text) {
   return m ? m[1] : "";
 }
 
+/** 子进程末行输出当退出原因（wireproxy 的真实报错都在 stderr）；没有输出返回 ""。 */
+export function tailReason(tail, max = 300) {
+  const lines = String(tail || "").split("\n").map((s) => s.trim()).filter(Boolean);
+  return lines.length ? lines[lines.length - 1].slice(0, max) : "";
+}
+
 /**
  * 按端口独立的退避复活器。
- * @param {{ revive: (port:number)=>Promise<boolean>, minGapMs?: number, maxGapMs?: number,
- *           now?: ()=>number, log?: (s:string)=>void }} opts
+ * @param {{ revive: (port:number)=>Promise<boolean>, isAlive?: (port:number)=>boolean, minGapMs?: number,
+ *           maxGapMs?: number, settleMs?: number, now?: ()=>number, sleep?: Function,
+ *           schedule?: Function, cancel?: Function, log?: (s:string)=>void }} opts
+ * 复活是否算数由 `isAlive` 在 `settleMs` 后复查；失败按指数退避并**自己用定时器安排下一次重试**。
  */
-export function createReviver({ revive, minGapMs = 30_000, maxGapMs = 10 * 60_000, now = Date.now, log = () => {} } = {}) {
+export function createReviver({ revive, isAlive, minGapMs = 30_000, maxGapMs = 10 * 60_000, settleMs = 1_200, now = Date.now, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), schedule = (fn, ms) => setTimeout(fn, ms), cancel = (h) => clearTimeout(h), log = () => {} } = {}) {
   /** @type {Map<number, {attempts:number, nextAt:number, busy:boolean}>} */
   const state = new Map();
 
@@ -38,37 +46,71 @@ export function createReviver({ revive, minGapMs = 30_000, maxGapMs = 10 * 60_00
     return s;
   }
 
+  /** @type {Map<number, object>} 每端口最多一个待触发的重试定时器 */
+  const timers = new Map();
+
+  /** 安排「到点自动重试」；没有它，日志里那句「N s 后自动再试」就是空话。 */
+  function armRetry(port, ms) {
+    if (timers.has(port)) return;
+    const h = schedule(() => {
+      timers.delete(port);
+      void attempt(port);
+    }, Math.max(0, ms));
+    if (h && typeof h.unref === "function") h.unref();
+    timers.set(port, h);
+  }
+
+  /**
+   * 复活一次：首次立即复活，失败按 30s→10min 指数退避并自己安排下一次重试。
+   * 复活算不算数由 `isAlive` 在 `settleMs` 后复查——不许拿「spawn 被调用了」冒充「活下来了」。
+   */
+  async function attempt(port) {
+    const s = entry(port);
+    if (s.busy) return false;
+    const wait = Math.max(0, s.nextAt - now());
+    if (wait > 0) {
+      log(`[warp-pool] :${port} 距上次复活不足退避间隔，${Math.ceil(wait / 1000)}s 后再试（防抖动刷屏，不是故障）`);
+      armRetry(port, wait);
+      return false;
+    }
+    s.busy = true;
+    s.attempts += 1;
+    const gap = Math.min(minGapMs * 2 ** (s.attempts - 1), maxGapMs);
+    let ok = false;
+    try {
+      ok = await revive(port);
+    } catch (e) {
+      log(`[warp-pool] :${port} 复活抛出异常：${String(e?.message || e)}`);
+    }
+    if (ok && isAlive) {
+      if (settleMs > 0) await sleep(settleMs);
+      ok = isAlive(port);
+      if (!ok) log(`[warp-pool] :${port} 复活后进程立刻又退出 —— 不认这次复活（原因见上面那条「意外退出」）`);
+    }
+    s.busy = false;
+    if (ok) {
+      const n = s.attempts;
+      s.attempts = 0;
+      s.nextAt = now() + minGapMs; // 稳定期：期间再退出先等一轮，防「起一条死一条」把日志刷爆
+      log(`[warp-pool] :${port} 已复活（第 ${n} 次尝试成功）；${Math.round(minGapMs / 1000)}s 内若又退出会先等一轮再重启`);
+      return true;
+    }
+    s.nextAt = now() + gap;
+    const hint = s.attempts >= 3 ? ` 排查：ss -ltnp | grep :${port}；或前台跑隧道二进制 -c node-${port}.conf 看真实报错` : "";
+    log(`[warp-pool] :${port} 复活未成功（第 ${s.attempts} 次），${Math.round(gap / 1000)}s 后自动再试。${hint}`);
+    armRetry(port, gap);
+    return false;
+  }
+
   return {
-    /** 进程退出时调用。首次立即复活，之后按 30s→10min 指数退避。 */
-    async onExit(port) {
-      const s = entry(port);
-      const wait = Math.max(0, s.nextAt - now());
-      if (wait > 0) {
-        log(`[warp-pool] :${port} 复活退避中（还剩 ${Math.round(wait / 1000)}s）`);
-        return false;
-      }
-      if (s.busy) return false;
-      s.busy = true;
-      s.attempts += 1;
-      const gap = Math.min(minGapMs * 2 ** (s.attempts - 1), maxGapMs);
-      s.nextAt = now() + gap;
-      let ok = false;
-      try {
-        ok = await revive(port);
-      } catch (e) {
-        log(`[warp-pool] :${port} 复活失败：${String(e?.message || e)}`);
-      }
-      s.busy = false;
-      if (ok) {
-        state.delete(port);
-        log(`[warp-pool] :${port} 已复活`);
-      } else {
-        log(`[warp-pool] :${port} 复活未成功（第 ${s.attempts} 次，下次最早 ${Math.round(gap / 1000)}s 后）`);
-      }
-      return ok;
-    },
-    /** 探活成功时调用：清掉退避账，恢复正常节奏。 */
+    onExit: (port) => attempt(port),
+    /** 探活成功时调用：清掉退避账与待触发定时器，恢复正常节奏。 */
     noteHealthy(port) {
+      const h = timers.get(port);
+      if (h) {
+        try { cancel(h); } catch {}
+        timers.delete(port);
+      }
       state.delete(port);
     },
     stats() {
@@ -79,6 +121,15 @@ export function createReviver({ revive, minGapMs = 30_000, maxGapMs = 10 * 60_00
         cooldownMsLeft: Math.max(0, s.nextAt - now()),
       }));
     },
+
+    /** 池关闭时调用：别再有定时器去打复活。 */
+    stop() {
+      for (const h of timers.values()) {
+        try { cancel(h); } catch {}
+      }
+      timers.clear();
+      state.clear();
+    },
   };
 }
 
@@ -108,10 +159,10 @@ export async function labelExits({ ports = [], fetchImpl, timeoutMs = 12_000, lo
 
   const groups = [...byIp.entries()].map(([ip, nodes]) => ({ ip, nodes }));
   if (groups.length === 1) {
-    log(`[warp-pool] ⚠ 出口不分散：${groups[0].nodes.length} 个节点共用同一个出口 ${groups[0].ip}（免费版 WARP 的 IPv4 是共享 NAT）`);
+    log(`[warp-pool] ⚠ 出口不分散：${groups[0].nodes.length} 条隧道同时在线只有 1 个出口地址（${groups[0].ip}）：免费版 WARP 的 IPv4 是共享 NAT，多开隧道换不到多份名额；多份名额靠撞 429 时的身份轮换`);
   } else if (groups.length > 1) {
-    log(`[warp-pool] 出口分散：${groups.length} 个不同地址 / ${groups.reduce((a, g) => a + g.nodes.length, 0)} 个节点`);
+    log(`[warp-pool] 出口分散：${groups.length} 个出口地址 / ${groups.reduce((a, g) => a + g.nodes.length, 0)} 条隧道同时在线（同时在线就有 ${groups.length} 份上游名额）`);
   }
-  if (failed) log(`[warp-pool] ${failed} 个节点出口取证失败（不影响其进池）`);
+  if (failed) log(`[warp-pool] ${failed} 个节点出口取证失败（不影响进池，只影响轮换时「出口到底变没变」的比对）`);
   return groups;
 }

package/src/warp-pool/rotate.js

@@ -78,7 +78,7 @@ export function createRotatingDispatcher({
     if (!e) return;
     e.fails += 1;
     e.cooldownUntil = now() + cooldownMs;
-    log(`[warp-pool] 节点 :${e.port} 连续失败 ${e.fails} 次，冷却 ${Math.round(cooldownMs / 1000)}s`);
+    if (e.fails === 1 || e.fails % 10 === 0) log(`[warp-pool] 节点 :${e.port} 连续失败 ${e.fails} 次，冷却 ${Math.round(cooldownMs / 1000)}s（中间次数静默：健康探活每分钟一轮，一个不通的节点曾把日志刷成 12 行/分钟）`);
   }
 
   function markOk(index) {