mslxdff 0.1.243 → 0.1.245

package/package.json

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

package/src/cli/commands/multi-ip-pool-fetch.js

@@ -0,0 +1,173 @@
+// mslxdff -multi-ip-pool 的 `fetch`（抓表落盘）与 `probe`（只测节点可达性），加上 `test` 也要用的
+// 「表准备 + ③ 取样预检」——这三件事都不打隧道，故与 test 的六步流水分开放。
+//
+// 为什么独立成一份（2026-10-25 真机第三轮）：`test` 已顶到 11.3KB；而「这台机到底能连上表里几个节点」
+// 是判断多出口池值不值得继续的**先行问题**——它不要 root、不要 openvpn、不碰内核，
+// 任何平台都能几十秒给出答案，不该被塞进「要 Linux + root + 隧道」的取证流程里。
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { resolveMultiIpConfig } from "../../multi-ip-pool/config.js";
+import { countCandidates, loadNodeCache, probeTargetOf, sampleCandidates } from "../../multi-ip-pool/nodes.js";
+import { fetchNodes, fetchNodesToFile } from "../../multi-ip-pool/nodes-fetch.js";
+import { createTranscript, probeBatch, probeSummaryLines } from "../../multi-ip-pool/diagnose.js";
+import { argValue } from "../policy.js";
+
+const FLAG = "-multi-ip-pool";
+
+/** 取样条数：够看出「哪一片不通」，又不至于把流程拖成几分钟（限并发 6、单条最多 6s ⇒ 最坏约 15s）。 */
+export const PROBE_DEFAULT = 12;
+
+/** `--flag value` 与 `--flag=value` 两种写法都认；认不到返回 null（`-` 开头的不当值）。 */
+export function flagValue(args, ...names) {
+  for (const name of names) {
+    const v = argValue(args, name);
+    if (v !== null && v !== undefined && !String(v).startsWith("-")) return v;
+    const eq = args.find((a) => a.startsWith(`${name}=`));
+    if (eq) return eq.slice(eq.indexOf("=") + 1);
+  }
+  return null;
+}
+
+/** 目录里已经有什么（auth.txt/nodes.json/node-*.conf）——很多失败就是这里少一个文件。 */
+export function dirNotes(dir) {
+  try {
+    const names = readdirSync(dir);
+    const size = (f) => { try { return `${statSync(join(dir, f)).size}B`; } catch { return "?"; } };
+    const files = names.slice(0, 12).map((n) => `${n}(${size(n)})`);
+    files.push(names.length > 12 ? `…共 ${names.length} 个` : "");
+    files.push(`auth.txt ${names.includes("auth.txt") ? "在" : "**缺失**（拨号必挂，看第 4 步）"}`);
+    return files.filter(Boolean);
+  } catch (e) {
+    return [`目录读不到：${String(e?.code || e?.message || e)}`];
+  }
+}
+
+/** 取表（缓存优先，取不到就逐源试并把每个源的死因摆出来）。 */
+export async function ensureRows(cfg, t) {
+  const cache = loadNodeCache({ dir: cfg.dir, ttlMs: cfg.nodesTtlMs });
+  if (cache?.rows?.length) {
+    t.say(`命中本地缓存：${cache.rows.length} 个节点（表源 ${cache.source}，缓存龄 ${Math.round((Date.now() - Number(cache.fetchedAt || 0)) / 1000)}s）`);
+    return cache.rows;
+  }
+  t.say("缓存没有或已过期 ⇒ 逐源取表（每源失败原因都会列出来）");
+  const got = await fetchNodes({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, maxAgeMs: cfg.maxTableAgeMs, log: (m) => t.say(m) });
+  t.say(`取到：${got.source} → ${got.rows.length} 个节点${got.stale ? "（⚠ 这张表已过期：节点多半早下线，别拿它当唯一来源）" : ""}`);
+  return got.rows;
+}
+
+/** 一条预检结果的判语（UDP 节点必须如实标注「无握手，仅供参考」）。 */
+function nodeLine(r, minScore = 0) {
+  const n = r.node || {};
+  const proto = String(n.proto || "").toLowerCase();
+  const how = r.ok ? `✓ TCP 通（${r.ms}ms）` : `✗ TCP 不通（${String(r.error || "?").replace(/\s+/g, " ").slice(0, 60)}，${r.ms}ms）`;
+  const low = Number(n.score || 0) < minScore ? "（Score 低于下限，仅作可达性参考）" : "";
+  return `  ${r.ok ? "✓" : "✗"} ${n.hostName}（${n.countryShort || "?"}）${n.host}:${n.port}｜${n.proto || "?"}｜Score ${n.score}${low} → ${how}`
+    + (proto === "udp" ? "　※ UDP 无握手，此探测仅供参考" : "");
+}
+
+/**
+ * ③ 取样与 TCP 预检（test 与 probe 共用一份，保证「探的」与「拨的」永远是同一批）：
+ * 按簇轮转取样 → 限并发探一遍 → 逐条打印 + 小结 + 簇分布。
+ * @returns {Promise<{ sample: object[], nodes: object[], results: object[], live: object[] }>}
+ */
+export async function surveyCandidates({ cfg, rows = [], t, limit = PROBE_DEFAULT, timeoutMs = 5_000, concurrency = 6 } = {}) {
+  const strict = sampleCandidates({ rows, countries: cfg.countries, minScore: cfg.minScore, limit });
+  // 达下限的候选不够取样条数时补低分节点——**只作可达性参考**（Score 低不等于连不上，先别急着排除它）
+  const skip = new Set(strict.map((r) => r.hostName));
+  const sample = strict.length < limit
+    ? [...strict, ...sampleCandidates({ rows, countries: cfg.countries, minScore: 0, limit: limit - strict.length, skip })]
+    : strict;
+  const matched = countCandidates({ rows, countries: cfg.countries, minScore: cfg.minScore });
+  t.say(`候选池：表 ${rows.length} 个 → 国家/Score 达标 ${matched} 个 → 取样 ${sample.length} 个（按簇轮转：同一机房不占满取样，免得一片不通就判整表不通）`);
+  const nodes = sample
+    .map((row) => { const target = probeTargetOf(row); return target ? { ...row, host: target.host, port: target.port, proto: target.proto } : null; })
+    .filter(Boolean);
+  if (!nodes.length) return { sample, nodes, results: [], live: [] };
+  const low = nodes.filter((n) => Number(n.score || 0) < cfg.minScore).length;
+  t.say(`预检：限并发 ${Math.min(concurrency, nodes.length)}、单条 ${timeoutMs}ms${low ? `（其中 ${low} 条 Score 低于下限，仅作参考）` : ""}`);
+  const results = await probeBatch({ nodes, timeoutMs, concurrency });
+  for (const r of results) t.say(nodeLine(r, cfg.minScore));
+  for (const l of probeSummaryLines({ results, minScore: cfg.minScore })) t.say(l);
+  return { sample, nodes, results, live: results.filter((r) => r.ok).map((r) => r.node) };
+}
+
+/**
+ * `-multi-ip-pool probe [--probe N]`：只回答「这台机能连上表里几个节点」。
+ * 不建隧道、不要 root、不碰 openvpn/内核、不看角色门 ⇒ 任何平台都能跑：这是「池值不值得继续」的先行问题。
+ */
+export async function runProbe(args = []) {
+  const cfg = resolveMultiIpConfig(process.env);
+  const limit = (() => { const v = flagValue(args, "--probe", "-p"); return v === null ? PROBE_DEFAULT : Math.max(1, Math.min(64, Number(v) || PROBE_DEFAULT)); })();
+  const t = createTranscript({ dir: cfg.dir, fileName: `probe-${new Date().toISOString().replace(/[:.]/g, "-")}.log` });
+  console.log("=".repeat(70));
+  console.log("  多出口池 · 节点可达性（只测能不能连上：不拨号、不要 root、不动内核、不看角色门）");
+  console.log("=".repeat(70));
+
+  t.step("① 环境快照");
+  t.say(`node ${process.version}｜平台 ${process.platform}`);
+  t.say(`配置：取样 ${limit} 条｜Score 下限 ${cfg.minScore}｜国家 ${cfg.countries.length ? cfg.countries.join("/") : "不限"}｜目录 ${cfg.dir}`);
+  t.say(`节点源（按序）：${cfg.sources.join(" → ")}`);
+
+  t.step("② 节点表");
+  let rows = [];
+  try {
+    rows = await ensureRows(cfg, t);
+  } catch (e) {
+    t.say(String(e?.message || e));
+    console.log("\n❌ 取不到节点表（原因见上一行）");
+    console.log(`   完整 transcript：${t.file}`);
+    process.exit(1);
+  }
+
+  t.step("③ 取样与 TCP 预检");
+  const survey = await surveyCandidates({ cfg, rows, t, limit, timeoutMs: Math.min(6_000, cfg.probeTimeoutMs), concurrency: 6 });
+  if (!survey.sample.length) {
+    t.say(`Score≥${cfg.minScore} 且国家匹配的候选为 0（表里共 ${rows.length} 个节点）`);
+    console.log(`\n❌ 没有可用候选（放宽 MSLXDFF_MULTI_IP_MIN_SCORE 或去掉 MSLXDFF_MULTI_IP_COUNTRY 再跑）`);
+    console.log(`   完整 transcript：${t.file}`);
+    process.exit(1);
+  }
+  const tcpResults = survey.results.filter((r) => String(r.node?.proto || "").toLowerCase() !== "udp");
+  const tcpLive = tcpResults.filter((r) => r.ok);
+
+  t.step("④ 结论");
+  if (tcpLive.length) {
+    t.say(`✅ 取样里 ${tcpLive.length}/${tcpResults.length} 条 TCP 节点可连 ⇒ 这台机能用多出口池（能不能换来新额度另说：跑 test）`);
+  } else {
+    t.say(`⛔ 取样里 ${tcpResults.length} 条 TCP 节点一条都连不上 ⇒ 这台机到这些免费节点整体不通（网络层，不是本模块配错）`);
+    t.say("下一步：① 换网络/换出口（云厂商安全组、运营商对境外 VPN 端口的限制都在这一层）；② 加大取样 --probe 40 或去掉国家白名单再确认一次");
+  }
+  console.log("");
+  console.log(tcpLive.length ? `  ✅ 取样 ${tcpResults.length} 条 TCP 节点里有 ${tcpLive.length} 条可连` : `  ⛔ 一条 TCP 节点都连不上（探了 ${tcpResults.length} 条）`);
+  console.log(`  完整 transcript（贴这一个文件就够）：${t.file}`);
+  console.log(`  下一步：mslxdff ${FLAG} test（真机取证：换出口到底有没有换来新额度）`);
+  process.exit(tcpLive.length ? 0 : 1);
+}
+
+/**
+ * `-multi-ip-pool fetch [路径]`：在**能连节点源**的机器上抓一份表落成文件，scp 到受限网络的组长机，
+ * 那边设 `MSLXDFF_MULTI_IP_NODES_FILE=<路径>` 即可完全跳过取表网络请求（2026-10-25 真机：华为云 ECS 到 vpngate.net 不通）。
+ */
+export async function runFetch(args = []) {
+  const cfg = resolveMultiIpConfig(process.env);
+  const out = flagValue(args, "--out", "-o") || join(cfg.dir, "vpngate.csv");
+  const t = createTranscript({ dir: cfg.dir, fileName: "fetch.log" });
+  t.step("逐源取表（失败原因逐条列出）");
+  t.say(`源列表：${cfg.sources.join(" → ")}`);
+  try {
+    const got = await fetchNodesToFile({ sources: cfg.sources, out, timeoutMs: cfg.probeTimeoutMs, maxAgeMs: cfg.maxTableAgeMs, log: (m) => t.say(m) });
+    const usable = got.rows.filter((r) => r.config).length;
+    t.say(`✅ ${got.rows.length} 个节点（${usable} 个配置可解码）→ ${out}${got.stale ? "　⚠ 这份表已过期，只能应急" : ""}`);
+    console.log("");
+    console.log("  带到受限网络的机器上：");
+    console.log(`     scp ${out} root@<组长机>:/root/.config/mslxdff/multi-ip-pool/vpngate.csv`);
+    console.log("     export MSLXDFF_MULTI_IP_NODES_FILE=/root/.config/mslxdff/multi-ip-pool/vpngate.csv");
+    console.log("     （之后取表零网络请求；表会旧，免费节点掉得快，建议隔几天重抓一次）");
+    console.log(`     先在那台机上跑 mslxdff ${FLAG} probe：能连上几个节点，比真拨一遍快得多`);
+    process.exit(0);
+  } catch (e) {
+    t.say(`❌ ${String(e?.message || e)}`);
+    console.log("     下一步：换网络重试，或 MSLXDFF_MULTI_IP_SOURCES=<你自己能连的镜像/本地路径> 再跑一次");
+    process.exit(1);
+  }
+}

package/src/cli/commands/multi-ip-pool-test.js

@@ -1,73 +1,37 @@
-// mslxdff -multi-ip-pool 的 test / fetch 两条流程：全程 transcript（屏幕 + 文件），每步编号带耗时。
+// mslxdff -multi-ip-pool 的 test 流程：全程 transcript（屏幕 + 文件），每步编号带耗时。
 //
 // 为什么要写成流水账（用户 2026-10-25 明确要求）：真机两轮排障都卡在「只看到最终判语、看不到环节」——
 // openvpn 的 argv、它的 stderr 原文、节点端口通不通、tun 地址有没有拿到、路由装没装上，
 // 每一项都必须是**一行一条**摆在屏幕上，并且整份落盘，贴一个文件就能定位。
-import { readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
+// fetch / probe 两条「不打隧道」的流程、以及本文件也要用的「表准备 + ③ 取样预检」在 ./multi-ip-pool-fetch.js。
 import { runMultiIpCompare, VERDICT_ZH, MITEST_DEFAULT, MITEST_MAX } from "../../multi-ip-pool/selftest.js";
 import { resolveMultiIpConfig, resolveRole } from "../../multi-ip-pool/config.js";
-import { candidateNodes, loadNodeCache, materializeNode } from "../../multi-ip-pool/nodes.js";
-import { fetchNodes, fetchNodesToFile } from "../../multi-ip-pool/nodes-fetch.js";
 import { checkOpenvpn, isRoot, isSupportedPlatform } from "../../multi-ip-pool/tunnel.js";
-import { createTranscript, envSnapshotLines, probeTcp, residualHints, slotPlanLines } from "../../multi-ip-pool/diagnose.js";
+import { createTranscript, envSnapshotLines, residualHints, slotPlanLines } from "../../multi-ip-pool/diagnose.js";
 import { loadGroupsJoined } from "../../state.js";
-import { argValue } from "../policy.js";
+import { PROBE_DEFAULT, dirNotes, ensureRows, flagValue, surveyCandidates } from "./multi-ip-pool-fetch.js";
 
 const FLAG = "-multi-ip-pool";
 
 const kindZh = { "free-quota": "429 额度耗尽", "free-tier": "403 免费层资格", "ip-limit": "429 限流", "black-quota": "账号日配额", network: "网络不可达", none: "非额度信号" };
 
-function flagValue(args, ...names) {
-  for (const name of names) {
-    const v = argValue(args, name);
-    if (v !== null && v !== undefined && !String(v).startsWith("-")) return v;
-    const eq = args.find((a) => a.startsWith(`${name}=`));
-    if (eq) return eq.slice(eq.indexOf("=") + 1);
-  }
-  return null;
-}
-
+/** 探活结果 → 一行判语（基线与逐槽结果共用同一份口径）。 */
 const line = (r) => {
   if (r.error) return `✗ 不可达（${String(r.error).replace(/\s+/g, " ").slice(0, 300)}）`;
   if (r.ok) return `✅ HTTP ${r.status} 有额度`;
   return `⛔ HTTP ${r.status} ${kindZh[r.kind] || r.kind}`;
 };
 
-/** 目录里已经有什么（auth.txt/nodes.json/node-*.conf）——很多失败就是这里少一个文件。 */
-function dirNotes(dir) {
-  try {
-    const names = readdirSync(dir);
-    const size = (f) => { try { return `${statSync(join(dir, f)).size}B`; } catch { return "?"; } };
-    const files = names.slice(0, 12).map((n) => `${n}(${size(n)})`);
-    files.push(names.length > 12 ? `…共 ${names.length} 个` : "");
-    files.push(`auth.txt ${names.includes("auth.txt") ? "在" : "**缺失**（拨号必挂，看第 4 步）"}`);
-    return files.filter(Boolean);
-  } catch (e) {
-    return [`目录读不到：${String(e?.code || e?.message || e)}`];
-  }
-}
-
-/** 取表（缓存优先，取不到就逐源试并把每个源的死因摆出来）。 */
-async function ensureRows(cfg, t) {
-  const cache = loadNodeCache({ dir: cfg.dir, ttlMs: cfg.nodesTtlMs });
-  if (cache?.rows?.length) {
-    t.say(`命中本地缓存：${cache.rows.length} 个节点（表源 ${cache.source}，缓存龄 ${Math.round((Date.now() - Number(cache.fetchedAt || 0)) / 1000)}s）`);
-    return cache.rows;
-  }
-  t.say("缓存没有或已过期 ⇒ 逐源取表（每源失败原因都会列出来）");
-  const got = await fetchNodes({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, log: (m) => t.say(m) });
-  t.say(`取到：${got.source} → ${got.rows.length} 个节点`);
-  return got.rows;
-}
-
 /**
- * `-multi-ip-pool test`：五道门 → 取表 → 每槽 TCP 预检 → 基线 → 逐槽起隧道取证 → 判语 → 善后。
+ * `-multi-ip-pool test`：五道门 → 取表 → **按簇取样 + 批量 TCP 预检（只拨探通的）** → 基线 → 逐槽起隧道取证 → 判语 → 善后。
  * 任何一步失败都会停在那一步并说清「下一步做什么」，不会攒到最后给你一个 unreachable。
+ * @param {string[]} args 认 `--count N`（拨几条）、`--probe N`（取样几条）、`--force`（一条都不通也真拨留证据）、`--model <id>`
  */
 export async function runTest(args = []) {
   const cfg = resolveMultiIpConfig(process.env);
   const count = (() => { const v = flagValue(args, "--count", "-n"); return v === null ? MITEST_DEFAULT : Math.max(1, Math.min(MITEST_MAX, Number(v) || MITEST_DEFAULT)); })();
+  const probeN = (() => { const v = flagValue(args, "--probe", "-p"); return v === null ? PROBE_DEFAULT : Math.max(1, Math.min(64, Number(v) || PROBE_DEFAULT)); })();
+  const force = args.includes("--force");
   const model = flagValue(args, "--model", "-m") || "";
   const t = createTranscript({ dir: cfg.dir });
   console.log("=".repeat(70));
@@ -84,7 +48,8 @@ export async function runTest(args = []) {
   if (!cfg.enabled || !role.active || !supported || !root || !openvpn.ok) {
     t.say("五道门有不过的 ⇒ 后面不再动作（否则只会被 openvpn/内核报一堆看不懂的错）");
     console.log(`\n❌ 前置不足：开关=${cfg.enabled} 角色=${role.active} Linux=${supported} root=${root} openvpn=${openvpn.ok}`);
-    console.log(`   下一步：mslxdff ${FLAG} status（逐门给人话结论）｜完整 transcript：${t.file}`);
+    console.log(`   下一步：mslxdff ${FLAG} status（逐门给人话结论）｜只想测网络可达性用 ${FLAG} probe（不要 root）`);
+    console.log(`   完整 transcript：${t.file}`);
     process.exit(1);
   }
 
@@ -99,29 +64,32 @@ export async function runTest(args = []) {
     console.log("          再 export MSLXDFF_MULTI_IP_NODES_FILE=<路径> 重跑 test");
     console.log(`   完整 transcript：${t.file}`);
     process.exit(1);
-    return true;
   }
 
-  t.step(`③ 选槽与 TCP 预检（拨号前先确认端口通不通，省掉 3×20s 的瞎等）`);
-  const picked = candidateNodes({ rows, countries: cfg.countries, minScore: cfg.minScore, scan: count });
-  if (!picked.length) {
+  t.step("③ 取样与 TCP 预检（按簇摊开取样；探不通的一律不拨，省掉几分钟白等）");
+  const survey = await surveyCandidates({ cfg, rows, t, limit: probeN, timeoutMs: Math.min(6_000, cfg.probeTimeoutMs), concurrency: 6 });
+  if (!survey.sample.length) {
     t.say(`Score≥${cfg.minScore} 且国家匹配的候选为 0（表里共 ${rows.length} 个节点）`);
     console.log(`\n❌ 没有可用候选`);
     console.log("   下一步：放宽 MSLXDFF_MULTI_IP_MIN_SCORE 或去掉 MSLXDFF_MULTI_IP_COUNTRY 再跑");
     console.log(`   完整 transcript：${t.file}`);
     process.exit(1);
-    return true;
   }
-  const nodes = picked.map((row) => materializeNode({ dir: cfg.dir, row, name: `pre${picked.indexOf(row)}` })).filter(Boolean);
-  for (const l of slotPlanLines({ cfg, nodes })) t.say(l);
-  let reachable = 0;
-  for (const n of nodes) {
-    const p = await probeTcp({ host: n.host, port: n.port, timeoutMs: Math.min(6_000, cfg.connectTimeoutMs) });
-    const verdict = p.ok ? `✓ TCP 通（${p.ms}ms）` : `✗ TCP 不通（${p.error || "?"}，${p.ms}ms）`;
-    t.say(`  ${n.hostName} ${n.host}:${n.port} proto=${n.proto || "?"} → ${verdict}${String(n.proto).toLowerCase() === "udp" ? "　※ UDP 节点无握手，此探测仅供参考" : ""}`);
-    if (p.ok) reachable++;
+  const tcpResults = survey.results.filter((r) => String(r.node?.proto || "").toLowerCase() !== "udp");
+  if (!survey.live.length && tcpResults.length && !force) {
+    t.say(`⛔ 取样里 ${tcpResults.length} 条 TCP 节点**一条都连不上** ⇒ 这台机到这一片节点整体不通（网络层，不是本模块配错）`);
+    t.say("下一步：① 换网络/换出口——云厂商安全组、运营商对境外 VPN 端口的限制都在这一层");
+    t.say(`        ② 加大取样再看一次：mslxdff ${FLAG} test --probe 40（或去掉国家白名单 MSLXDFF_MULTI_IP_COUNTRY=）`);
+    t.say(`        ③ 只测可达性、不要 root：mslxdff ${FLAG} probe --probe 40`);
+    t.say(`        ④ 一定要看真拨的证据：mslxdff ${FLAG} test --force`);
+    console.log(`\n❌ 取样里 ${tcpResults.length} 条 TCP 节点一条都连不上`);
+    console.log("   这不是本模块的配置错，是这台机到这些免费节点（这一片机房）的网络不通");
+    console.log(`   完整 transcript：${t.file}`);
+    process.exit(1);
   }
-  if (!reachable) t.say("全部候选 TCP 都不通 ⇒ 多半是本机到公网节点被限制（不是本模块的配置问题），下面仍会真拨一次以留证据");
+  const dialRows = (survey.live.length ? survey.live : survey.nodes).slice(0, count);
+  for (const l of slotPlanLines({ cfg, nodes: dialRows })) t.say(l);
+  t.say(`拨号计划：${dialRows.length} 条${survey.live.length ? "（取自上面探通的）" : "（没有探通的 ⇒ 按取样顺序强拨，只为留证据）"}`);
 
   t.step("④ 基线 + 逐槽起隧道取证");
   const onProgress = (ev) => {
@@ -133,13 +101,12 @@ export async function runTest(args = []) {
   };
   let r;
   try {
-    r = await runMultiIpCompare({ count, ...(model ? { model } : {}), onProgress, deps: { log: (m) => t.say(m) } });
+    r = await runMultiIpCompare({ count: dialRows.length || count, slots: dialRows, ...(model ? { model } : {}), onProgress, deps: { log: (m) => t.say(m) } });
   } catch (e) {
     t.say(`测试执行抛错：${String(e?.stack || e?.message || e)}`);
     console.log(`\n❌ 测试执行出错：${e?.message ?? e}`);
     console.log(`   完整 transcript：${t.file}`);
     process.exit(1);
-    return true;
   }
   if (r.status === "skip") {
     t.say(`跳过：${r.reason}`);
@@ -147,7 +114,6 @@ export async function runTest(args = []) {
     console.log(`   下一步：${r.hint}`);
     console.log(`   完整 transcript：${t.file}`);
     process.exit(1);
-    return true;
   }
 
   t.step("⑤ 判语");
@@ -167,33 +133,4 @@ export async function runTest(args = []) {
   console.log(`  完整 transcript（贴这一个文件就够）：${t.file}`);
   console.log(`  重试：mslxdff ${FLAG} test --count ${r.requested}${model ? ` --model ${model}` : ""}`);
   process.exit(r.verdict === "multi-ip-works" || r.verdict === "mixed" ? 0 : 1);
-  return true;
-}
-
-/**
- * `-multi-ip-pool fetch [路径]`：在**能连节点源**的机器上抓一份表落成文件，scp 到受限网络的组长机，
- * 那边设 `MSLXDFF_MULTI_IP_NODES_FILE=<路径>` 即可完全跳过取表网络请求（2026-10-25 真机：华为云 ECS 到 vpngate.net 不通）。
- */
-export async function runFetch(args = []) {
-  const cfg = resolveMultiIpConfig(process.env);
-  const out = flagValue(args, "--out", "-o") || join(cfg.dir, "vpngate.csv");
-  const t = createTranscript({ dir: cfg.dir, fileName: "fetch.log" });
-  t.step("逐源取表（失败原因逐条列出）");
-  t.say(`源列表：${cfg.sources.join(" → ")}`);
-  try {
-    const got = await fetchNodesToFile({ sources: cfg.sources, out, timeoutMs: cfg.probeTimeoutMs, log: (m) => t.say(m) });
-    const usable = got.rows.filter((r) => r.config).length;
-    t.say(`✅ ${got.rows.length} 个节点（${usable} 个配置可解码）→ ${out}`);
-    console.log("");
-    console.log("  带到受限网络的机器上：");
-    console.log(`     scp ${out} root@<组长机>:/root/.config/mslxdff/multi-ip-pool/vpngate.csv`);
-    console.log("     export MSLXDFF_MULTI_IP_NODES_FILE=/root/.config/mslxdff/multi-ip-pool/vpngate.csv");
-    console.log("     （之后取表零网络请求；表会旧，免费节点掉得快，建议隔几天重抓一次）");
-    process.exit(0);
-  } catch (e) {
-    t.say(`❌ ${String(e?.message || e)}`);
-    console.log("     下一步：换网络重试，或 MSLXDFF_MULTI_IP_SOURCES=<你自己能连的镜像/本地路径> 再跑一次");
-    process.exit(1);
-  }
-  return true;
-}
+}

package/src/cli/commands/multi-ip-pool.js

@@ -1,4 +1,4 @@
-// mslxdff -multi-ip-pool [test|status|fetch|help]
+// mslxdff -multi-ip-pool [test|probe|status|fetch|help]
 //   多出口池（VPNGate 免费 OpenVPN 节点当出口）：**组长**专属，只服务 opencode 免费层。
 //
 // 本文件只做「分发 + status + 用法」；test / fetch 两条取证流程在 ./multi-ip-pool-test.js
@@ -6,7 +6,8 @@
 import { resolveMultiIpConfig, resolveRole } from "../../multi-ip-pool/config.js";
 import { checkOpenvpn, isRoot, isSupportedPlatform } from "../../multi-ip-pool/tunnel.js";
 import { loadGroupsJoined } from "../../state.js";
-import { runFetch, runTest } from "./multi-ip-pool-test.js";
+import { runFetch, runProbe } from "./multi-ip-pool-fetch.js";
+import { runTest } from "./multi-ip-pool-test.js";
 
 const FLAG = "-multi-ip-pool";
 
@@ -16,6 +17,7 @@ export async function handleMultiIpPool(args = []) {
   const sub = (args[at].includes("=") ? args[at].split("=")[1] : args[at + 1] || "test").toLowerCase();
   if (["-h", "--help", "help"].includes(sub)) return printUsage();
   if (sub === "status") return await printStatus(args);
+  if (sub === "probe" || sub === "ping") return await runProbe(args);
   if (sub === "fetch" || sub === "grab") return await runFetch(args);
   return await runTest(args);
 }
@@ -43,12 +45,13 @@ async function printStatus(args = []) {
   console.log(`  节点源     ${cfg.nodesFile ? `本地表优先：${cfg.nodesFile}（其后 ${cfg.sources.length - 1} 个网络源）` : cfg.sources.join("，")}`);
   console.log("");
   console.log(`  下一步：mslxdff ${FLAG} test（真机取证：换出口到底有没有换来新额度）`);
+  console.log(`  测网络可达性（不要 root）：mslxdff ${FLAG} probe [--probe N]`);
   process.exit(0);
   return true;
 }
 
 function printUsage() {
-  console.log(`用法: mslxdff ${FLAG} [test|status|fetch|help] [--count N] [--model <id>] [--out <路径>]`);
+  console.log(`用法: mslxdff ${FLAG} [test|probe|status|fetch|help] [--count N] [--probe N] [--force] [--model <id>] [--out <路径>]`);
   console.log("");
   console.log("  test 在多出口池上做 A/B：直连打一条 free 层请求取基线，再逐条 VPN 隧道打同一条，");
   console.log("  对照判语：");
@@ -56,6 +59,9 @@ function printUsage() {
   console.log("    基线 429 + VPN 出口也全 429 ⇒ 换 IP 抬不动（上游不按出口 IP 计额）");
   console.log("  test 每一步都编号打印并整份落盘（结尾给出 transcript 路径），失败即停在原地。");
   console.log("");
+  console.log("  probe 只回答「这台机能连上表里几个节点」（按簇轮转取样 + 限并发 TCP 预检）：不拨号、不要 root、");
+  console.log("  不碰 openvpn/内核、不看角色门，任何平台都能跑 —— 池值不值得继续用的先行问题。");
+  console.log("");
   console.log("  前置：Linux + root + openvpn（tun 设备与策略路由必需）。非 Linux 如实跳过。");
   console.log("");
   console.log("相关 env（与 daemon 建池同源）：");

package/src/multi-ip-pool/config.js

@@ -30,6 +30,7 @@ export const DEFAULTS = {
   cooldownMs: 600_000, // 槽失败冷却
   rotate: true, // 撞额度信号时换槽
   nodesTtlMs: 30 * 60_000, // 节点表缓存有效期（VPNGate 免费节点掉得快）
+  maxTableAgeMs: 24 * 60 * 60_000, // 表龄告警阈值：镜像表超过它就 ⚠（旧表 = 一堆早下线的 IP，白拨几分钟）
   openvpnBin: "openvpn",
   authUser: "vpn", // VPNGate 公共账号（非私人凭据）
   authPass: "vpn",
@@ -38,16 +39,16 @@ export const DEFAULTS = {
 };
 
 /**
- * VPNGate 节点源：**官方永远在前**，第三方镜像只作兜墙的最后一条。
- * 镜像 `aimili-vpngate` 仓库内 `mirror/vpngate.csv` 由它的 GitHub Actions **每 15 分钟**从官方表刷新
- * （cron `7,22,37,52 * * * *`），实测 2026-10-25 与官方**同 15 列同 schema**、99 节点全部可解码 ⇒ 解析器零改动。
- * 注意：它自己配的那条 GitHub Pages 镜像 `baoweise-bot.github.io/...` 已 404 死（实测），故不采用。
- * 表内容只是**公开节点的连接配置 + VPNGate 公共账号（vpn/vpn）**，不含任何私人凭据；仍不信任镜像就用
- * `MSLXDFF_MULTI_IP_SOURCES` 只留官方，或 `MSLXDFF_MULTI_IP_NODES_FILE` 自带一份本地表。
+ * VPNGate 节点源：**官方永远在前**，第三方镜像只作兜墙。
+ * 纠错（2026-10-26 实测）：`aimili-vpngate` 的 Actions 只把新鲜快照发到 **GitHub Pages**（`openmili.github.io/aimili-vpngate/`），
+ * **不往仓库里写表**；仓库内 `mirror/vpngate.csv` 是手工提交的死快照（2026-08-26 后未变）——此前当「每 15 分钟刷新」用 =
+ * 拿两个月前的死 IP 白拨，真机症状与被墙一模一样。
+ * 表只是公开节点配置 + VPNGate 公共账号（vpn/vpn）；不信任镜像就 `_SOURCES` 只留官方或 `_NODES_FILE` 自带。
  */
 export const NODE_SOURCES = [
   "https://www.vpngate.net/api/iphone/",
   "http://www.vpngate.net/api/iphone/",
+  "https://openmili.github.io/aimili-vpngate/vpngate.csv",
   "https://raw.githubusercontent.com/OpenMili/aimili-vpngate/main/mirror/vpngate.csv",
 ];
 
@@ -124,6 +125,7 @@ export function resolveMultiIpConfig(env = process.env, { logDirFn = logDir } =
     cooldownMs: envInt(env, "MSLXDFF_MULTI_IP_COOLDOWN_MS", DEFAULTS.cooldownMs),
     rotate: envBool(env, "MSLXDFF_MULTI_IP_ROTATE", DEFAULTS.rotate),
     nodesTtlMs: envInt(env, "MSLXDFF_MULTI_IP_NODES_TTL_MS", DEFAULTS.nodesTtlMs),
+    maxTableAgeMs: envInt(env, "MSLXDFF_MULTI_IP_MAX_TABLE_AGE_MS", DEFAULTS.maxTableAgeMs),
     openvpnBin: envStr(env, "MSLXDFF_MULTI_IP_OPENVPN", DEFAULTS.openvpnBin),
     authUser: envStr(env, "MSLXDFF_MULTI_IP_AUTH_USER", DEFAULTS.authUser),
     authPass: envStr(env, "MSLXDFF_MULTI_IP_AUTH_PASS", DEFAULTS.authPass),

package/src/multi-ip-pool/diagnose.js

@@ -7,6 +7,7 @@ import { mkdirSync, appendFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import net from "node:net";
 import { devNameFor, tableFor } from "./config.js";
+import { clusterOf } from "./nodes.js";
 
 /** 值得单独成行的报错关键词（openvpn 的用法/握手/认证/网络失败都在这里）。 */
 const ERRORISH = /options error|unrecognized|missing or extra|fatal|error:|can ?not|cannot|denied|failed|refused|reset|auth failed|tls|write udp|bind|permission/i;
@@ -56,6 +57,52 @@ export function probeTcp({ host, port, timeoutMs = 6_000, connectFn } = {}) {
   });
 }
 
+/**
+ * 批量 TCP 预检：**限并发**探一组节点，按输入顺序返回结果（`{ node, ok, ms, error }`）。
+ * 为什么必须成批：真机实证「同一机房整片连不上」远多于「个别节点不通」——只探 3 条会给出
+ * 一句误导的「全部不通」，探一批才看得出**是哪一片不通、还有哪片是通的**。
+ */
+export async function probeBatch({ nodes = [], timeoutMs = 6_000, concurrency = 6, probe = probeTcp } = {}) {
+  const out = new Array(nodes.length);
+  let next = 0;
+  const worker = async () => {
+    for (;;) {
+      const i = next++;
+      if (i >= nodes.length) return;
+      const node = nodes[i];
+      out[i] = { node, ...(await probe({ host: node?.host, port: node?.port, timeoutMs })) };
+    }
+  };
+  const width = Math.max(1, Math.min(Math.max(1, concurrency), nodes.length || 1));
+  await Promise.all(Array.from({ length: width }, worker));
+  return out;
+}
+
+/**
+ * 取样小结：一句「探了几条、通几条」+ **簇分布**（哪个机房整片不通，一眼看出）。
+ * 判死口径必须分开写：`proto udp` 的节点无握手，TCP 探不通**不能**当成「这条隧道必挂」。
+ */
+export function probeSummaryLines({ results = [], minScore = 0, clustersShown = 6 } = {}) {
+  const udp = results.filter((r) => String(r.node?.proto || "").toLowerCase() === "udp");
+  const tcp = results.filter((r) => !udp.includes(r));
+  const tcpLive = tcp.filter((r) => r.ok);
+  const strict = results.filter((r) => Number(r.node?.score || 0) >= minScore).length;
+  const groups = new Map();
+  for (const r of tcp) {
+    const key = clusterOf(r.node);
+    const cur = groups.get(key) || { total: 0, ok: 0 };
+    cur.total += 1;
+    cur.ok += r.ok ? 1 : 0;
+    groups.set(key, cur);
+  }
+  const tail = udp.length ? `（另有 ${udp.length} 条 UDP 节点：无握手，不计入判死）` : "";
+  const lines = [`取样 ${results.length} 个（Score 达下限 ${strict} 个）→ TCP 通 ${tcpLive.length}｜不通 ${tcp.length - tcpLive.length}${tail}`];
+  const shown = [...groups.entries()].slice(0, clustersShown).map(([key, v]) => `${key} ${v.ok}/${v.total} 通`);
+  if (shown.length) lines.push(`簇分布（机房/IP 段）：${shown.join("｜")}${groups.size > clustersShown ? `｜…共 ${groups.size} 簇` : ""}`);
+  if (!tcpLive.length && udp.some((r) => r.ok)) lines.push("探通的都是 UDP 节点 ⇒ TCP 探不出结论，下面仍按取样顺序真拨");
+  return lines;
+}
+
 /**
  * 取证全程 transcript：每行带 `[步骤号]` 与相对耗时，同时进屏幕与文件（0600）。
  * 落盘是为了「一次跑完贴一个文件给我」，不必复现；写文件失败绝不影响测试本体。

package/src/multi-ip-pool/dial.js

@@ -8,7 +8,7 @@
 // 拆成独立模块的原因：装配（index）、拨号（本文件）、备选池（standby）三件事各自都要单测，混一起必超 10KB 门。
 import { getUndici } from "../compat.js";
 import { DEFAULT_PROBE_MODEL, probeUpstreamFrom } from "../v6pool/selftest.js";
-import { candidateNodes, loadNodeCache, materializeNode } from "./nodes.js";
+import { loadNodeCache, materializeNode, sampleCandidates } from "./nodes.js";
 import { fetchNodes, probeExitIp } from "./nodes-fetch.js";
 import { bringUpTunnel, tearDownTunnel } from "./tunnel.js";
 import { AGENT_OPTIONS } from "./dispatch.js";
@@ -74,7 +74,7 @@ export function createDialer({ cfg, baseUrl = "https://opencode.ai", log = () =>
     return { ok: Boolean(r.ok), status: Number(r.status) || 0, kind: r.kind || "", ms: Number(r.ms) || 0, ip, error: r.error || "" };
   }
 
-  /** 取节点表 → 候选队列（按 Score 降序，剔除已用过的）；`force` = 绕过缓存重取（每小时刷新备选池用）。 */
+  /** 取节点表 → 候选队列（Score 降序 + **按簇轮转**，剔除已用过的）；`force` = 绕过缓存重取（每小时刷新备选池用）。 */
   async function ensureCandidates({ force = false } = {}) {
     if (!force && pending.length) return pending.length;
     let rows = [];
@@ -86,11 +86,13 @@ export function createDialer({ cfg, baseUrl = "https://opencode.ai", log = () =>
       }
     }
     if (!rows.length) {
-      const got = await (deps.fetchNodes || fetchNodes)({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, log });
+      const got = await (deps.fetchNodes || fetchNodes)({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, maxAgeMs: cfg.maxTableAgeMs, log });
       rows = got.rows;
       source = got.source;
     }
-    pending = candidateNodes({ rows, countries: cfg.countries, minScore: cfg.minScore, skip: used, scan: cfg.scan * (cfg.count + cfg.standby + 1) });
+    // 按簇轮转（见 nodes.js sampleCandidates）：免费表前列常被同一个机房霸榜，纯 Score 序会让「那一片连不上」
+    // 变成「池永远起不来」（真机 2026-10-25：三个候选同属 219.100.37.x）。轮转不丢节点，只是把各机房摊开。
+    pending = sampleCandidates({ rows, countries: cfg.countries, minScore: cfg.minScore, skip: used, limit: cfg.scan * (cfg.count + cfg.standby + 1) });
     log(fmtNodes({ source, total: rows.length, countries: cfg.countries, minScore: cfg.minScore }));
     return pending.length;
   }

package/src/multi-ip-pool/nodes-fetch.js

@@ -48,11 +48,11 @@ export function sourceToLocalPath(url) {
 }
 
 /**
- * 逐源尝试取表；任一源返回可解析的 CSV 即成功（并顺手写缓存）。
+ * 逐源尝试取表；任一源返回可解析的 CSV 即成功（顺手写缓存 + 问一句表龄：`maxAgeMs`）。
  * 全失败时**逐源原因都进异常**（受限网络下「为什么取不到」就是用户唯一的线索）。
- * @returns {Promise<{ source: string, rows: object[], text: string }>} text 是原始 CSV，供 `fetchNodesToFile` 落盘
+ * @returns {Promise<{ source: string, rows: object[], text: string, meta: object|null, stale: boolean }>} text 供 `fetchNodesToFile` 落盘
  */
-export async function fetchNodes({ sources = [], dir = "", fetchImpl, timeoutMs = 20_000, now = () => Date.now(), log = () => {} } = {}) {
+export async function fetchNodes({ sources = [], dir = "", fetchImpl, timeoutMs = 20_000, now = () => Date.now(), maxAgeMs = 0, log = () => {} } = {}) {
   const f = fetchImpl || getUndici().fetch || compatFetch;
   const fails = [];
   for (const url of sources) {
@@ -68,9 +68,9 @@ export async function fetchNodes({ sources = [], dir = "", fetchImpl, timeoutMs
       }
       const rows = parseVpnGateCsv(text);
       if (!rows.length) throw new Error("返回体不是可解析的 VPNGate CSV");
-      log(`[multi-ip-pool] 节点表取自 ${url}（${rows.length} 个节点）`);
-      if (dir) saveNodeCache({ dir, source: url, rows, now });
-      return { source: url, rows, text };
+      const meta = await fetchTableMeta({ source: url, fetchImpl: f, timeoutMs: Math.min(5_000, timeoutMs), now });
+      const stale = noteTable({ url, rows, meta, maxAgeMs, dir, now, log });
+      return { source: url, rows, text, meta, stale };
     } catch (e) {
       const why = errorWhy(e);
       fails.push(`${url}：${why}`);
@@ -84,8 +84,8 @@ export async function fetchNodes({ sources = [], dir = "", fetchImpl, timeoutMs
  * 取表并原样落一份 CSV（`-multi-ip-pool fetch` 的实现）：在能连的机器上抓，scp 进受限网络的组长机，
  * 那边 `MSLXDFF_MULTI_IP_NODES_FILE=<路径>` 即可零网络取表。0600：表里是节点凭据，不该给同机用户读。
  */
-export async function fetchNodesToFile({ sources = [], out, fetchImpl, timeoutMs = 20_000, log } = {}) {
-  const got = await fetchNodes({ sources, fetchImpl, timeoutMs, log });
+export async function fetchNodesToFile({ sources = [], out, fetchImpl, timeoutMs = 20_000, maxAgeMs = 0, log } = {}) {
+  const got = await fetchNodes({ sources, fetchImpl, timeoutMs, maxAgeMs, log });
   mkdirSync(dirname(out), { recursive: true });
   writeFileSync(out, got.text, { mode: 0o600 });
   return { ...got, out, file: out };
@@ -108,3 +108,53 @@ export async function probeExitIp({ agent, fetchImpl, timeoutMs = 12_000 } = {})
     return { ok: false, ip: "", ms: Date.now() - t0, error: errorWhy(e) };
   }
 }
+
+/** 镜像表的同源元数据文件名（上游 `build_vpngate_mirror.py` 固定产出，含 `generated_at_iso`）。 */
+const TABLE_META_NAME = "vpngate.meta.json";
+
+/** 表 URL → 同目录元数据 URL：只认 `.../vpngate.csv` 这类镜像表（官方 `api/iphone/`、本地表文件都没有 meta）。 */
+export function metaUrlFor(url) {
+  const m = /^(https?:\/\/\S*\/)vpngate\.csv$/i.exec(String(url || "").trim());
+  return m ? `${m[1]}${TABLE_META_NAME}` : "";
+}
+
+/** 表龄的人话（分钟/小时/天）。 */
+export function humanAge(ms) {
+  const mins = Math.round(Number(ms) / 60_000);
+  if (!Number.isFinite(mins) || mins < 0) return "未知";
+  if (mins < 60) return `${mins} 分钟`;
+  const hours = mins / 60;
+  return hours < 48 ? `${hours.toFixed(1)} 小时` : `${Math.round(hours / 24)} 天`;
+}
+
+/**
+ * 问一句「这份表是什么时候生成的」——镜像源长得一模一样（同样 15 列、同样能解析），
+ * 但可能是**几个月前的手工快照**：真机 2026-10-26 实测，参照实现仓库内那份 2026-08-26 生成、
+ * 而它的活表在 GitHub Pages（2026-10-24 生成）⇒ 拿旧表就是拿一堆早已下线的 IP 白拨几分钟，
+ * 症状与被墙完全一样。拿不到 meta（官方源/本地表/网络失败）就返回 null，绝不猜。
+ * @returns {Promise<{ ageMs: number, generatedAtIso: string } | null>}
+ */
+export async function fetchTableMeta({ source = "", fetchImpl, timeoutMs = 5_000, now = () => Date.now() } = {}) {
+  const url = metaUrlFor(source);
+  if (!url) return null;
+  try {
+    const f = fetchImpl || getUndici().fetch || compatFetch;
+    const res = await f(url, { signal: timeoutSignal(timeoutMs) });
+    if (!res.ok) return null;
+    const meta = JSON.parse(await res.text());
+    const at = Number(meta?.generated_at) * 1000 || Date.parse(String(meta?.generated_at_iso || ""));
+    if (!Number.isFinite(at) || at <= 0) return null;
+    return { ageMs: Math.max(0, now() - at), generatedAtIso: String(meta.generated_at_iso || new Date(at).toISOString()) };
+  } catch {
+    return null;
+  }
+}
+
+/** 取到表后的一次性记账：打「表龄」行、过期就 ⚠、按需写缓存，返回是否过期。 */
+function noteTable({ url = "", rows = [], meta = null, maxAgeMs = 0, dir = "", now = () => Date.now(), log = () => {} } = {}) {
+  const stale = Boolean(meta && maxAgeMs > 0 && meta.ageMs > maxAgeMs);
+  log(`[multi-ip-pool] 节点表取自 ${url}（${rows.length} 个节点${meta ? `，${humanAge(meta.ageMs)}前生成` : ""}）${stale ? " ⚠ 表已过期" : ""}`);
+  if (stale) log(`[multi-ip-pool] ⚠ 这张表已 ${humanAge(meta.ageMs)}没更新 ⇒ 节点多半早已下线（免费节点掉得快），拿它拨号就是白等几分钟：换源 MSLXDFF_MULTI_IP_SOURCES，或自带表 MSLXDFF_MULTI_IP_NODES_FILE`);
+  if (dir) saveNodeCache({ dir, source: url, rows, now });
+  return stale;
+}

package/src/multi-ip-pool/nodes.js

@@ -105,6 +105,60 @@ export function candidateNodes({ rows = [], countries = [], minScore = 0, scan =
     .slice(0, scan);
 }
 
+/**
+ * 节点「簇」：同一批免费节点往往同机房同网段（hostName 同前缀 + 同 /24），**一条连不上时整片都连不上**。
+ * 真机 2026-10-25 实证：按 Score 取 3 个候选全落在 `public-vpn-*` / `219.100.37.x`，
+ * 于是「一个机房的墙」被误读成「全部节点不通」。取样与候选排序都必须按簇摊开。
+ */
+export function clusterOf(row) {
+  const host = String(row?.hostName || "").replace(/[-.\d]+$/, "");
+  const seg = String(row?.ip || "").split(".").slice(0, 3).join(".");
+  return `${host}|${seg}`;
+}
+
+/** 达标候选条数（只数不取：给「取样里有几个是达标的」这类结论用）。 */
+export function countCandidates({ rows = [], countries = [], minScore = 0 } = {}) {
+  return rows.filter((r) => r.config && r.score >= minScore && matchCountry(r, countries)).length;
+}
+
+/**
+ * 取样候选：Score 降序，但**按簇轮转**（先每个机房各出一条，再轮到各家第二条…）。
+ * 为什么不沿用纯 Score 序：免费表前列常被同一个机房霸榜，纯排序取样＝拿一个机房的运气赌整台机器能不能用。
+ * 轮转不丢节点——簇内仍是 Score 降序，只是把同簇的连续几条摊到后面几轮去。
+ * @param {{ rows?: object[], countries?: string[], minScore?: number, limit?: number,
+ *           perCluster?: number, skip?: Set<string> }} opts perCluster=0 表示不设每簇上限
+ */
+export function sampleCandidates({ rows = [], countries = [], minScore = 0, limit = 12, perCluster = 0, skip = new Set() } = {}) {
+  const pool = candidateNodes({ rows, countries, minScore, scan: Math.max(1, rows.length), skip });
+  const groups = new Map();
+  for (const r of pool) {
+    const key = clusterOf(r);
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(r);
+  }
+  const out = [];
+  for (let round = 0; out.length < limit && groups.size; round++) {
+    let added = 0;
+    for (const list of groups.values()) {
+      if (out.length >= limit) break;
+      if (round >= list.length || (perCluster > 0 && round >= perCluster)) continue;
+      out.push(list[round]);
+      added += 1;
+    }
+    if (!added) break; // 各簇都取空了
+  }
+  return out;
+}
+
+/** 只读地把一行解成「探什么/拨什么」（不落文件）：TCP 预检与选槽共用同一份解析。 */
+export function probeTargetOf(row) {
+  const conf = decodeConfig(row?.config);
+  if (!conf) return null;
+  const remote = parseRemote(conf);
+  if (!remote) return null;
+  return { decoded: conf, host: remote.host, port: remote.port, proto: (/^\s*proto\s+(\S+)/m.exec(conf) || [])[1] || "" };
+}
+
 /** 节点表缓存（TTL 内直接用，省一次外网请求；VPNGate 免费节点掉得快，默认 30min）。 */
 export function loadNodeCache({ dir, ttlMs = 0, now = () => Date.now() } = {}) {
   try {
@@ -133,15 +187,15 @@ export function writeNodeConf({ dir, row, name = "" } = {}) {
   return { path: writePrivate(join(dir, `node-${alias}.conf`), row.config), hostName: row.hostName };
 }
 
-/** writeNodeConf 落的是**解码后**的配置；这里显式解码一次，把「解不开」的节点挡在门外（绝不猜）。 */
+/** writeNodeConf 落的是**解码后**的配置；这里复用 `probeTargetOf` 解码：
+ * 解不开或缺 remote 的节点一律返 null（绝不猜），绝不把坏配置交给 openvpn。 */
 export function materializeNode({ dir, row, name = "" } = {}) {
-  const conf = decodeConfig(row.config);
-  if (!conf) return null;
-  const remote = parseRemote(conf);
-  if (!remote) return null;
-  const written = writeNodeConf({ dir, row: { ...row, config: conf }, name });
-  // proto 一并带出：预检与判语要分清「TCP 节点连不上」与「UDP 节点无握手可探」两回事
-  return { ...row, conf: written.path, host: remote.host, port: remote.port, proto: (/^\s*proto\s+(\S+)/m.exec(conf) || [])[1] || "" };
+  const target = probeTargetOf(row);
+  if (!target) return null;
+  // 落盘的是解码后的配置文本；别名照旧按 hostName/ip 生成（与旧行为一致）
+  const written = writeNodeConf({ dir, row: { ...row, config: target.decoded }, name });
+  // host/port/proto 与 TCP 预检同源（都出自 `probeTargetOf`）：预检探的与这里拨的必须是同一份解释
+  return { ...row, conf: written.path, host: target.host, port: target.port, proto: target.proto };
 }
 
 /** VPNGate 公共账号（vpn/vpn）；落在 0600 文件里，绝不入库。 */

package/src/multi-ip-pool/selftest.js

@@ -27,9 +27,9 @@ export const MITEST_DEFAULT = 3;
  *           onProgress?: (ev: object) => void,
  *           deps?: { joined?, platform?, supported?, isRoot?, checkOpenvpn?, loadNodeCache?, fetchNodes?,
  *                    materializeNode?, bringUpTunnel?, tearDownTunnel?, agentFactory?, probeExitIp?,
- *                    probeUpstream?, fetchImpl?, session?, log? } }} opts
+ *                    probeUpstream?, fetchImpl?, session?, log? }, slots?: object[] }} opts
  */
-export async function runMultiIpCompare({ env = process.env, count = MITEST_DEFAULT, model = DEFAULT_PROBE_MODEL, baseUrl = "https://opencode.ai", onProgress, deps = {} } = {}) {
+export async function runMultiIpCompare({ env = process.env, count = MITEST_DEFAULT, model = DEFAULT_PROBE_MODEL, baseUrl = "https://opencode.ai", onProgress, deps = {}, slots = null } = {}) {
   const cfg = resolveMultiIpConfig(env);
   const tick = (ev) => { try { onProgress?.(ev); } catch { /* 渲染出错不打断测试 */ } };
   const log = deps.log || (() => {});
@@ -62,7 +62,7 @@ export async function runMultiIpCompare({ env = process.env, count = MITEST_DEFA
   let source = cache?.source || "(本地缓存)";
   if (!rows.length) {
     try {
-      const got = await (deps.fetchNodes || fetchNodes)({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, log });
+      const got = await (deps.fetchNodes || fetchNodes)({ sources: cfg.sources, dir: cfg.dir, timeoutMs: cfg.probeTimeoutMs, maxAgeMs: cfg.maxTableAgeMs, log });
       rows = got.rows;
       source = got.source;
     } catch (e) {
@@ -76,8 +76,10 @@ export async function runMultiIpCompare({ env = process.env, count = MITEST_DEFA
   tick({ phase: "baseline-start", model });
   const baseline = await probe({ addr: "", model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl, session });
   tick({ phase: "baseline-done", ...baseline });
+  // 候选：调用方给了 `slots` 就用它——CLI 侧已经「按簇取样 + TCP 预检」过，拨的必须就是探通的那些；
+  // 没给才自己按 Score 取（单测与旧路径）。两边各挑一次会让「探的」与「拨的」不是同一批，预检就白做了。
 
-  const picked = candidateNodes({ rows, countries: cfg.countries, minScore: cfg.minScore, scan: Math.max(1, Math.min(MITEST_MAX, Number(count) || MITEST_DEFAULT)) });
+  const picked = (Array.isArray(slots) && slots.length) ? slots.slice(0, MITEST_MAX) : candidateNodes({ rows, countries: cfg.countries, minScore: cfg.minScore, scan: Math.max(1, Math.min(MITEST_MAX, Number(count) || MITEST_DEFAULT)) });
   if (!picked.length) return { status: "skip", reason: "没有满足条件的候选节点（国家/Score 过滤后为空）", hint: "放宽 MSLXDFF_MULTI_IP_MIN_SCORE 或去掉 MSLXDFF_MULTI_IP_COUNTRY" };
   // auth 文件必须先落到磁盘再把路径交给 openvpn。取证路径以前把 `deps.authFile`（undefined）直接传下去
   // ⇒ `--auth-user-pass` 拿到空参数 ⇒ openvpn 判「选项缺参数」，只留一句「Use --help」——2026-10-25 真机三条槽全挂在这。