mslxdff 0.1.242 → 0.1.244

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.242",
+  "version": "0.1.244",
   "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, log: (m) => t.say(m) });
+  t.say(`取到：${got.source} → ${got.rows.length} 个节点`);
+  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, 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("     （之后取表零网络请求；表会旧，免费节点掉得快，建议隔几天重抓一次）");
+    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

@@ -0,0 +1,136 @@
+// mslxdff -multi-ip-pool 的 test 流程：全程 transcript（屏幕 + 文件），每步编号带耗时。
+//
+// 为什么要写成流水账（用户 2026-10-25 明确要求）：真机两轮排障都卡在「只看到最终判语、看不到环节」——
+// openvpn 的 argv、它的 stderr 原文、节点端口通不通、tun 地址有没有拿到、路由装没装上，
+// 每一项都必须是**一行一条**摆在屏幕上，并且整份落盘，贴一个文件就能定位。
+// 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 { checkOpenvpn, isRoot, isSupportedPlatform } from "../../multi-ip-pool/tunnel.js";
+import { createTranscript, envSnapshotLines, residualHints, slotPlanLines } from "../../multi-ip-pool/diagnose.js";
+import { loadGroupsJoined } from "../../state.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: "非额度信号" };
+
+/** 探活结果 → 一行判语（基线与逐槽结果共用同一份口径）。 */
+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}`;
+};
+
+/**
+ * `-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));
+  console.log("  多出口池取证 —— 全程 transcript（每一步都印，失败即停在原地）");
+  console.log("=".repeat(70));
+
+  t.step("① 环境快照");
+  const role = resolveRole({ mode: cfg.mode, joined: loadGroupsJoined() });
+  const root = isRoot();
+  const supported = isSupportedPlatform();
+  const openvpn = await checkOpenvpn(cfg.openvpnBin);
+  for (const l of envSnapshotLines({ cfg, platform: process.platform, root, openvpn, files: dirNotes(cfg.dir) })) t.say(l);
+  t.say(`角色门 role=${role.role} ⇒ ${role.active ? "通过" : "不建池"}（${role.why}）`);
+  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（逐门给人话结论）｜只想测网络可达性用 ${FLAG} probe（不要 root）`);
+    console.log(`   完整 transcript：${t.file}`);
+    process.exit(1);
+  }
+
+  t.step("② 节点表");
+  let rows = [];
+  try {
+    rows = await ensureRows(cfg, t);
+  } catch (e) {
+    t.say(String(e?.message || e));
+    console.log(`\n❌ 取不到节点表（原因见上一行）`);
+    console.log("   下一步：在能连的机器上 `mslxdff -multi-ip-pool fetch` 抓一份表带过来，");
+    console.log("          再 export MSLXDFF_MULTI_IP_NODES_FILE=<路径> 重跑 test");
+    console.log(`   完整 transcript：${t.file}`);
+    process.exit(1);
+  }
+
+  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);
+  }
+  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);
+  }
+  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) => {
+    if (ev.phase === "nodes") t.say(`（selftest 用的表：${ev.source}，${ev.total} 个节点）`);
+    else if (ev.phase === "baseline-start") t.say("基线：直连（系统默认出口）打一条免费层请求…");
+    else if (ev.phase === "baseline-done") t.say(`基线：${line(ev)}${ev.body ? ` ${String(ev.body).slice(0, 90).replace(/\s+/g, " ")}` : ""}`);
+    else if (ev.phase === "exit-start") t.say(`槽 ${ev.i}/${ev.n}：${ev.row.hostName}（${ev.row.countryShort || "?"}）开始`);
+    else if (ev.phase === "exit-done") t.say(`槽 ${ev.i}/${ev.n} 结果：${line(ev)}${ev.exitIp ? `｜出口 IP ${ev.exitIp}` : ""}`);
+  };
+  let r;
+  try {
+    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);
+  }
+  if (r.status === "skip") {
+    t.say(`跳过：${r.reason}`);
+    console.log(`\n❌ 测不了：${r.reason}`);
+    console.log(`   下一步：${r.hint}`);
+    console.log(`   完整 transcript：${t.file}`);
+    process.exit(1);
+  }
+
+  t.step("⑤ 判语");
+  console.log("-".repeat(70));
+  console.log(`  基线（直连）：${line(r.baseline)}`);
+  console.log(`  VPN 出口：有额度 ${r.okCount}｜受限 ${r.limitedCount}｜不可达 ${r.netCount}（共 ${r.requested}）`);
+  const v = VERDICT_ZH[r.verdict] || { text: "未判定", next: "" };
+  const mark = r.verdict === "multi-ip-works" ? "✅" : r.verdict === "mixed" ? "△" : "⛔";
+  console.log(`  ${mark} ${v.text}：${r.okCount}/${r.requested} 条隧道拿到 200`);
+  if (v.next) console.log(`   ${v.next}`);
+  for (const e of r.exits || []) console.log(`   · ${e.hostName}（${e.country || "?"}）${e.exitIp ? `出口 ${e.exitIp}｜` : ""}${line(e)}`);
+
+  t.step("⑥ 善后与存档");
+  t.say(`隧道由本命令自造自拆；若中途 Ctrl+C，按下面几条查残留：`);
+  for (const h of residualHints()) t.say(`  ${h}`);
+  console.log("");
+  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);
+}

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

@@ -1,125 +1,29 @@
-// mslxdff -multi-ip-pool [test|status|help]
-//   多出口池（VPNGate 免费 OpenVPN 节点当出口）：**组长/单机**专属，只服务 opencode 免费层。
+// mslxdff -multi-ip-pool [test|probe|status|fetch|help]
+//   多出口池（VPNGate 免费 OpenVPN 节点当出口）：**组长**专属，只服务 opencode 免费层。
 //
-// 为什么需要这条命令（用户要的"取证"）：换出口到底有没有换来新额度，只有实测能回答。
-// 本命令做 A/B：直连打一条免费层请求取基线 → 逐条 VPN 隧道打**同一条**请求 → 对照判语。
-import { join } from "node:path";
-import { runMultiIpCompare, VERDICT_ZH, MITEST_DEFAULT, MITEST_MAX } from "../../multi-ip-pool/selftest.js";
-import { fetchNodesToFile } from "../../multi-ip-pool/nodes-fetch.js";
+// 本文件只做「分发 + status + 用法」；test / fetch 两条取证流程在 ./multi-ip-pool-test.js
+// （2026-10-25 起拆分：那边是全程 transcript 流水账，混在一起两边都顶过体积线）。
 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 { argValue } from "../policy.js";
+import { runFetch, runProbe } from "./multi-ip-pool-fetch.js";
+import { runTest } from "./multi-ip-pool-test.js";
 
 const FLAG = "-multi-ip-pool";
 
-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 kindZh = { "free-quota": "429 额度耗尽", "free-tier": "403 免费层资格", "ip-limit": "429 限流", "black-quota": "账号日配额", network: "网络不可达", none: "非额度信号" };
-const line = (r) => {
-  if (r.error) return `✗ 不可达（${String(r.error).replace(/\s+/g, " ").slice(0, 220)}）`;
-  if (r.ok) return `✅ HTTP ${r.status} 有额度`;
-  return `⛔ HTTP ${r.status} ${kindZh[r.kind] || r.kind}`;
-};
-
 export async function handleMultiIpPool(args = []) {
   const at = args.findIndex((x) => x === FLAG || x.startsWith(`${FLAG}=`));
   if (at < 0) return false;
   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);
 }
 
-async function runTest(args) {
-  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 model = flagValue(args, "--model", "-m") || "";
-  console.log("=".repeat(66));
-  console.log("  多出口池取证 —— 「直连 429 时，换成 VPN 出口还有额度吗」");
-  console.log("=".repeat(66));
-  console.log("");
-  console.log(`  探测模型 ${model || "(默认免费模型)"}｜采样 ${count} 条隧道｜只换出口，其余请求完全相同`);
-  console.log("");
-
-  const onProgress = (ev) => {
-    if (ev.phase === "nodes") console.log(`  ▸ 节点表：${ev.source}（${ev.total} 个节点）`);
-    else if (ev.phase === "baseline-start") console.log("  ▸ 基线：直连（系统默认出口）打一条免费层请求…");
-    else if (ev.phase === "baseline-done") {
-      console.log(`    基线结果：${line(ev)}${ev.body ? `（${String(ev.body).slice(0, 80).replace(/\s+/g, " ")}）` : ""}`);
-      console.log("");
-    } else if (ev.phase === "exit-start") console.log(`  [${String(ev.i).padStart(2)}/${ev.n}] ${ev.row.hostName}（${ev.row.countryShort || "?"}）…`);
-    else if (ev.phase === "exit-done") console.log(`      ${line(ev)}${ev.exitIp ? `｜出口 IP ${ev.exitIp}` : ""}`);
-  };
-
-  let r;
-  try {
-    r = await runMultiIpCompare({ count, ...(model ? { model } : {}), onProgress });
-  } catch (e) {
-    console.log("");
-    console.log(`❌ 测试执行出错：${e?.message ?? e}`);
-    console.log(`   重试：mslxdff ${FLAG}`);
-    process.exit(1);
-    return true;
-  }
-  if (r.status === "skip") {
-    console.log(`❌ 测不了：${r.reason}`);
-    console.log(`   下一步：${r.hint}`);
-    process.exit(1);
-    return true;
-  }
-
-  console.log("");
-  console.log("-".repeat(66));
-  console.log(`  基线（直连）：${line(r.baseline)}`);
-  console.log(`  VPN 出口：有额度 ${r.okCount}｜受限 ${r.limitedCount}｜不可达 ${r.netCount}（共 ${r.requested}）`);
-  console.log("");
-  const v = VERDICT_ZH[r.verdict] || { text: "未判定", next: "" };
-  const mark = r.verdict === "multi-ip-works" ? "✅" : r.verdict === "mixed" ? "△" : "⛔";
-  console.log(`  ${mark} ${v.text}：${r.okCount}/${r.requested} 条隧道拿到 200`);
-  if (v.next) console.log(`   ${v.next}`);
-  console.log("");
-  console.log(`   重试：mslxdff ${FLAG} --count ${r.requested}${model ? ` --model ${model}` : ""}`);
-  process.exit(r.verdict === "multi-ip-works" || r.verdict === "mixed" ? 0 : 1);
-}
-
-/**
- * `-multi-ip-pool fetch [路径]`：在**能连节点源**的机器上抓一份 VPNGate 表落成文件，scp 到受限网络的组长机，
- * 那边设 `MSLXDFF_MULTI_IP_NODES_FILE=<路径>` 即可完全跳过取表网络请求（2026-10-25 真机：华为云 ECS 上 vpngate.net 不可达）。
- */
-async function runFetch(args) {
-  const cfg = resolveMultiIpConfig(process.env);
-  const out = flagValue(args, "--out", "-o") || join(cfg.dir, "vpngate.csv");
-  console.log(`  节点源（按序试）：${cfg.sources.join("\n              ")}`);
-  console.log("");
-  try {
-    const got = await fetchNodesToFile({ sources: cfg.sources, out, timeoutMs: cfg.probeTimeoutMs });
-    const usable = got.rows.filter((r) => r.config).length;
-    console.log(`  ✅ ${got.rows.length} 个节点（${usable} 个配置可解码）已写入：${out}`);
-    console.log(`     来源：${got.source}`);
-    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) {
-    console.log(`  ❌ 一个源都没取到：${String(e?.message || e)}`);
-    console.log("     下一步：换网络重试，或 MSLXDFF_MULTI_IP_SOURCES=<你自己能连的镜像/本地路径> 再跑一次");
-    process.exit(1);
-  }
-  return true;
-}
-
-async function printStatus(args) {
+/** status：只回答「开没开、为什么」。**不建池不拨号**，所以只能报告配置与门，报不了 daemon 内存里的池。 */
+async function printStatus(args = []) {
   const cfg = resolveMultiIpConfig(process.env);
   const role = resolveRole({ mode: cfg.mode, joined: loadGroupsJoined() });
   const platform = process.platform;
@@ -141,17 +45,22 @@ 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("  在多出口池上做 A/B：直连打一条 free 层请求取基线，再逐条 VPN 隧道打同一条，");
+  console.log("  test 在多出口池上做 A/B：直连打一条 free 层请求取基线，再逐条 VPN 隧道打同一条，");
   console.log("  对照判语：");
   console.log("    基线 429 + VPN 出口有 200 ⇒ 池有用（换 IP 换到新额度）");
   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("");
@@ -171,4 +80,4 @@ function printUsage() {
   console.log("    MSLXDFF_MULTI_IP_PROBE_MODEL=<id>     打 hi 探额度用的免费模型（空＝同款缺省）");
   process.exit(0);
   return true;
-}
+}

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

@@ -0,0 +1,159 @@
+// multi-ip-pool · 诊断层：openvpn 输出归因 / 节点 TCP 预检 / 取证全程 transcript（argv 原文由 report.js:fmtArgv 出）。
+//
+// 为什么单独一份：2026-10-25 真机两轮都栽在「看得见结果、看不见环节」——openvpn 用法错误的末行恒是
+// `Use --help`，真凶在它上面；而 selftest 的内部步骤日志在 CLI 里被接到了空函数上。
+// 本文件把「哪一步出问题」变成一等信息：每一步都有编号、耗时、原文，并整份落盘可粘贴。
+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;
+
+/**
+ * openvpn 输出里挑「最能说明问题」的一行：用法错误的**末行恒是** `Use --help for more information.`，
+ * 真凶（`Options error: …`）在它上面。只报末行等于把病因盖住。
+ */
+export function openvpnErrorLine(text, max = 240) {
+  const lines = String(text || "").split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  if (!lines.length) return "";
+  const pick = lines.find((l) => ERRORISH.test(l));
+  return (pick || lines[lines.length - 1]).slice(0, max);
+}
+
+/**
+ * 一行内的**多行摘要**：真凶行 + 其余最多 3 行（用 ` ‖ ` 分隔）。
+ * 单行是为了日志文件仍可 grep；多行是为了人眼一次看完，不必再翻 openvpn 自己的输出。
+ */
+export function openvpnErrorBrief(text, max = 620) {
+  const lines = String(text || "").split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  if (!lines.length) return "";
+  const first = lines.find((l) => ERRORISH.test(l)) || "";
+  const rest = lines.filter((l) => l !== first && !/^Use --help/i.test(l)).slice(-3);
+  return [first || lines[lines.length - 1], ...rest].join(" ‖ ").slice(0, max);
+}
+
+/**
+ * 节点 TCP 预检：拨号前先确认「这台机能不能连到 host:port」。
+ * 判语口径：VPNGate 实测 91/97 是 `proto tcp`，TCP 连不上基本就是节点/防火墙问题；
+ * `proto udp` 的节点这条只作参考（UDP 无握手，连不上不代表隧道必挂），**必须如实分开说**。
+ */
+export function probeTcp({ host, port, timeoutMs = 6_000, connectFn } = {}) {
+  const t0 = Date.now();
+  return new Promise((resolve) => {
+    const done = (ok, extra) => resolve({ ok, ms: Date.now() - t0, host, port, ...extra });
+    if (!host || !port) return done(false, { error: "缺 host/port" });
+    if (connectFn) {
+      return connectFn(host, port, timeoutMs)
+        .then((r) => done(Boolean(r?.ok), { ...(r?.error ? { error: r.error } : {}) }))
+        .catch((e) => done(false, { error: String(e?.message || e) }));
+    }
+    const s = net.connect({ host, port });
+    const timer = setTimeout(() => { s.destroy(); done(false, { error: `连接超时（${timeoutMs}ms）` }); }, timeoutMs);
+    s.once("connect", () => { clearTimeout(timer); s.destroy(); done(true, {}); });
+    s.once("error", (e) => { clearTimeout(timer); done(false, { error: String(e?.code || e?.message || e) }); });
+  });
+}
+
+/**
+ * 批量 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）。
+ * 落盘是为了「一次跑完贴一个文件给我」，不必复现；写文件失败绝不影响测试本体。
+ */
+export function createTranscript({ dir, out = (s) => console.log(s), now = () => Date.now(), fs = { mkdirSync, appendFileSync }, fileName = "" } = {}) {
+  const t0 = now();
+  let step = 0;
+  const file = dir ? join(dir, fileName || `test-${new Date(t0).toISOString().replace(/[:.]/g, "-")}.log`) : "";
+  const emit = (raw) => {
+    const line = `[${String(step).padStart(2, "0")} +${((now() - t0) / 1000).toFixed(1)}s] ${raw}`;
+    out(line);
+    if (file) {
+      try { fs.appendFileSync(file, line + "\n"); } catch { /* 落盘失败只影响存档，不影响取证 */ }
+    }
+  };
+  try {
+    if (file) { fs.mkdirSync(dirname(file), { recursive: true }); fs.appendFileSync(file, `# multi-ip-pool 取证 transcript（本文件可整份粘贴）\n`); }
+  } catch { /* 同上 */ }
+  return {
+    file,
+    /** 一条步骤行（自动编号）。 */
+    step: (text) => { step += 1; emit(text); return step; },
+    /** 归属当前步骤的明细行（不占编号）。 */
+    say: (text) => emit(`      ${String(text).replace(/^\s+/, "")}`),
+    /** 小节标题。 */
+    section: (text) => { step += 1; emit(`—— ${text} ——`); return step; },
+  };
+}
+
+/** 环境快照：一眼看清「机器/权限/二进制/配置/磁盘上有什么」，省掉一轮来回。 */
+export function envSnapshotLines({ cfg, platform, root, openvpn, files = [], argvNode = "" } = {}) {
+  return [
+    `node ${argvNode || process.version}｜平台 ${platform}｜root ${root ? "是" : "否"}`,
+    `openvpn ${openvpn?.ok ? `可用：${openvpn.version}` : `不可用：${openvpn?.why || "?"}`}`,
+    `配置：隧道 ${cfg?.count} 条｜备胎 ${cfg?.standby} 条/每 ${Math.round((cfg?.standbyEveryMs || 0) / 60_000)} 分钟｜Score 下限 ${cfg?.minScore}｜国家 ${cfg?.countries?.length ? cfg.countries.join("/") : "不限"}｜策略 ${cfg?.strategy}`,
+    `目录 ${cfg?.dir}：${files.length ? files.join(" ") : "（空，本轮第一次跑）"}`,
+    `节点源（按序）：${(cfg?.sources || []).join(" → ")}`,
+  ];
+}
+
+/** 每槽的「设备名/路由表/优先级」对照表：内核侧出问题时按这张表查。 */
+export function slotPlanLines({ cfg, nodes = [] } = {}) {
+  return nodes.map((n, i) => `  槽 ${i}：${n.hostName}（${n.countryShort || "?"}）→ ${n.host}:${n.port}｜proto ${n.proto || "?"}｜设备 ${devNameFor(cfg.devPrefix, i)}｜表 ${tableFor(cfg.baseTable, i)}`);
+}
+
+/** 跑完（尤其是中途失败）后给全善后命令：设备与路由残留必须能一眼查清。 */
+export function residualHints() {
+  return [
+    "ip -brief addr show type tun",
+    "ip link show | grep -E 'mltun|tun'",
+    "ip rule show | grep -E 'from (10\\.|192\\.|172\\.)' | head",
+    "ip route show table all | grep -E 'mltun' | head",
+  ];
+}

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 = [];
@@ -90,7 +90,9 @@ export function createDialer({ cfg, baseUrl = "https://opencode.ai", 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.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,14 +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 });
-  return { ...row, conf: written.path, host: remote.host, port: remote.port };
+  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/report.js

@@ -44,6 +44,11 @@ export function fmtSpawn({ dev, pid, host, port, country, table }) {
   return `${TAG} ${SYM.ok} ${dev} 隧道就绪（pid=${pid}，出口节点 ${host}:${port} ${country}，策略表 ${table}）`;
 }
 
+/** 实际执行的 openvpn 命令行（argv 原文）：真机排障第一问就是「你到底跑了什么」。 */
+export function fmtArgv({ bin, args }) {
+  return `${TAG} ${SYM.step} 执行：${bin} ${(args || []).join(" ")}`;
+}
+
 export function fmtTunAddrFail({ dev, out }) {
   return `${TAG} ${SYM.bad} ${dev} 起来了但读不到 tun 地址（ip -4 addr show dev ${dev} 的输出：${(out || "(空)").slice(0, 200)}）—— 隧道建不起来，这槽换下一个节点`;
 }

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 || (() => {});
@@ -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 真机三条槽全挂在这。

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

@@ -9,7 +9,8 @@
 // 平台纪律：只有 Linux 能干（tun + `ip rule`）；其它平台由调用方**诚实跳过一行**，不做半吊子。
 import { spawn } from "node:child_process";
 import { devNameFor, tableFor } from "./config.js";
-import { fmtExit, fmtRpf, fmtRuleFail, fmtSpawn, fmtTunAddrFail } from "./report.js";
+import { fmtArgv, fmtExit, fmtRpf, fmtRuleFail, fmtSpawn, fmtTunAddrFail } from "./report.js";
+import { openvpnErrorLine, openvpnErrorBrief } from "./diagnose.js";
 
 /** openvpn 就绪标志（配置文件里可能出现别的 "Sequence"，必须整串匹配）。 */
 export const READY_PATTERN = /Initialization Sequence Completed/;
@@ -58,16 +59,6 @@ export function buildOpenvpnArgs({ conf, dev, authFile, logFile = "", verb = 3 }
   ];
 }
 
-/**
- * openvpn 输出里挑「最能说明问题」的一行：用法错误的**末行恒是** `Use --help for more information.`，
- * 真凶（`Options error: …`）在它上面。只报末行等于把病因盖住——2026-10-25 真机就因为这样绕了一圈。
- */
-export function openvpnErrorLine(text, max = 240) {
-  const lines = String(text || "").split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
-  if (!lines.length) return "";
-  const pick = lines.find((l) => /options error|unrecognized|missing or extra|fatal|error:|can ?not|cannot|denied|failed|refused|reset|auth failed/i.test(l));
-  return (pick || lines[lines.length - 1]).slice(0, max);
-}
 
 /** 从 `ip -4 addr show dev <dev>` 输出里取 tun 地址（VPNGate 推的是 10.x 内网地址）。 */
 export function parseTunAddr(text) {
@@ -138,6 +129,8 @@ export async function checkOpenvpn(bin, { runCmdFn = runCmd } = {}) {
  * tail 保留末 20 行：真机排障时"openvpn 为什么退"全在这几行里。
  */
 export function startTunnel({ bin, args, timeoutMs = 25_000, spawnFn = spawn, log = () => {}, onExit = null, dev = "" } = {}) {
+  // 「我到底跑了什么」必须是第一条信息：openvpn 的 argv 报错只有对着命令行原文才看得懂
+  log(fmtArgv({ bin, args }));
   let child;
   try {
     child = spawnFn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
@@ -157,12 +150,13 @@ export function startTunnel({ bin, args, timeoutMs = 25_000, spawnFn = spawn, lo
     }
   };
   const lastTail = () => openvpnErrorLine(tail.join("\n"));
+  const briefTail = () => openvpnErrorBrief(tail.join("\n"));
   const ready = new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
       if (settled) return;
       settled = true;
       try { child.kill("SIGTERM"); } catch { /* 已退 */ }
-      reject(new Error(`等 ${Math.round(timeoutMs / 1000)}s 没等到「Initialization Sequence Completed」（隧道没起来）：${lastTail()}`));
+      reject(new Error(`等 ${Math.round(timeoutMs / 1000)}s 没等到「Initialization Sequence Completed」（隧道没起来）：${briefTail()}`));
     }, timeoutMs);
     const onChunk = (buf) => {
       push(buf);
@@ -178,7 +172,7 @@ export function startTunnel({ bin, args, timeoutMs = 25_000, spawnFn = spawn, lo
       if (!settled) {
         settled = true;
         clearTimeout(timer);
-        reject(new Error(`openvpn 提前退出（code=${code} signal=${signal}）：${lastTail()}`));
+        reject(new Error(`openvpn 提前退出（code=${code} signal=${signal}）：${briefTail()}`));
       }
       // 主动关掉的隧道不算"意外退出"：收摊日志只该出现在真出事时（否则每次换槽都刷一行假警报）
       if (!stopping) log(fmtExit({ dev, code, signal, pid: child.pid, aliveMs, tail: lastTail() }));