mslxdff 0.1.244 → 0.1.246

package/package.json

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

package/src/chat-pipeline/terminal-verdict.js

@@ -21,10 +21,10 @@ const FREE_TIER_PATTERNS = [
   /FreeTierError/i,
   // ⚠ `FreeUsageLimitError` 曾列在此（BUG-8 于 2026-10-16 加入）**现已移除**（2026-10-17 纠正）：
   // 它是**限额/限流**判决，不是身份闸门。三条独立实证都证明「换出口/换组员就恢复」⇒ 属可接力：
-  //   ① 本仓自测记录（warp-pool/verdict.js:9-10）：同一身份连发 3 次 429 FreeUsageLimitError，
+  //   ① 本仓自测记录（原 warp-pool/verdict.js:9-10，该模块已随 ADR-0073 移除）：同一身份连发 3 次 429 FreeUsageLimitError，
   //      **身份一换、同一个请求立刻 200**（限额按出口 IP 计）；
-  //   ② warp-pool 的决策表（verdict.js:62）对 429 FreeUsage 明写「强制换出口、跳过冷却」；
-  //   ③ v6 池（v6pool-claim-rotate.test.js:140）同样据它换源地址。
+  //   ② 原 warp-pool 的决策表（verdict.js:62）对 429 FreeUsage 明写「强制换出口、跳过冷却」（该模块已随 ADR-0073 移除）；
+  //   ③ 原 v6 池（v6pool-claim-rotate.test.js:140）同样据它换源地址（已随 ADR-0073 移除）。
   // 更根本：ADR-0058 §2 本就把「401/402/**429**/5xx」明列为**可恢复、接力照常**；本文件头 :9-11 也是
   // 同一口径。BUG-8 把 429 的具名文案判成终局，偏离了本模块自己写下的边界 —— 现网代价是
   // 组员额度还在、仍被 `peersSkipped:true` 一刀跳过（2026-10-18 events.log 满屏实证）。
@@ -62,7 +62,7 @@ const TRANSIENT_MARKERS = [
   // 限额/限流具名判决 ⇒ **可恢复**（换出口换组员就恢复，见 FREE_TIER_PATTERNS 上方三条实证）。
   // 显式列出而非指望 message 里的 "rate limit" 字样：上游改文案时这层不能跟着失明
   // （`FreeUsageLimitError` 的类名比它的 message 稳定得多）。
-  // GoUsageLimitError 与它同族（warp-pool/verdict.js:25 把两者并列），同样按出口计、同样可换。
+  // GoUsageLimitError 与它同族（原 warp-pool/verdict.js:25 把两者并列），同族同判。
   /FreeUsageLimitError|GoUsageLimitError/i,
   /security_reject/i,
   /安全校验拒绝/,

package/src/cli/commands/daemon.js

@@ -56,7 +56,7 @@ export async function handleRestart(args, VERSION) {
     console.log("daemon not running — starting...");
   }
   // 结构性盲区收口：不在 daemon.pid 里的 daemon 永远杀不到（真机：Oct16 起的旧 daemon 活了一整天，
-  // 与新版互杀 warp-pool 端口；两边日志格式交错才暴露）。起新的之前先清干净。
+  // 与新版互抢本机端口；两边日志格式交错才暴露）。起新的之前先清干净。
   const ghosts = await reapGhostDaemons({ log: (m) => console.log(m) });
   if (ghosts.length) console.log(`已清掉 ${ghosts.length} 个不在册的 daemon（pid ${ghosts.map((g) => g.pid).join(", ")}）`);
   const port = effectivePort(args);

package/src/cli/index.js

@@ -41,11 +41,6 @@ export async function run(args = process.argv.slice(2)) {
   if (await handleAutostart(args)) return;
   if (await handleFree(args)) return;
 
-  const { handleV6Pool } = await import("./commands/v6-pool.js");
-  if (await handleV6Pool(args)) return;
-
-  const { handleMultiIpPool } = await import("./commands/multi-ip-pool.js");
-  if (await handleMultiIpPool(args)) return;
 
   const { handleProviders, handleProvider } = await import("./commands/provider.js");
   if (await handleProviders(args)) return;

package/src/daemon.js

@@ -180,7 +180,7 @@ export async function waitPidGone(pid, { timeoutMs = 5000, killWaitMs = 2000, st
 
 /**
  * 清「不在 daemon.pid 里的」幽灵 daemon —— `-restart` 的结构性盲区
- *（真机事故：旧 daemon 活了一整天，与新版互杀 warp-pool 端口，两边日志格式交错才暴露）。
+ *（真机事故：旧 daemon 活了一整天，与新版互抢本机端口，两边日志格式交错才暴露）。
  * 先 SIGTERM 全清 → 等 5s → 仍活着的 SIGKILL。返回**确实清掉**的清单（供调用方诚实汇报）。
  */
 export async function reapGhostDaemons({ self = process.pid, list = () => findDaemons({ self }), kill = process.kill, log = () => {}, isAlive = isPidAlive, settleMs = 5000, killWaitMs = 2000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)) } = {}) {
@@ -201,7 +201,7 @@ export async function reapGhostDaemons({ self = process.pid, list = () => findDa
  * 接管：内存里若还有**别的** mslxdff daemon，先把比我们旧的那批请出去。
  * 为什么必须有（用户点名要求 + 真机 2026-10-17 事故）：`-restart` 只认 `daemon.pid`，
  * 不在册的 daemon（SIGTERM 后没真退出、pid 文件又被删掉的那个）会活一整天，与新版互抢
- * warp-pool 的 4 个端口——日志里只能看到「起一条死一条」，看不出是两个 daemon 在互杀。
+ * 本机那 4 个长驻端口（当年是 warp-pool 的 wireproxy，该模块已随 ADR-0073 移除）——日志里只能看到「起一条死一条」，看不出是两个 daemon 在互杀。
  * 判据：比自己早启动 ≥ `minAgeMs` 的一律清（SIGTERM → 等 → SIGKILL）；与本次启动几乎同时的不动
  * （谁该活由 8989 的 bind 决定，`server-lifecycle` 的 EADDRINUSE 自愈会收口），避免两边互杀。
  * 全程不抛（接管失败绝不能挡住启动）。
@@ -227,7 +227,7 @@ export async function takeoverOlderDaemons({
   const older = sibs.filter(isOlder);
   const skipped = sibs.filter((d) => !isOlder(d));
 
-  for (const d of older) log(`[daemon] 内存里还有别的 mslxdff daemon：pid ${d.pid}（父 ${d.ppid}，已运行 ${fmtAlive(d.aliveSec)}，比本进程旧）—— 先请它退出，否则两个 daemon 会抢同一批端口（warp-pool 起一条死一条的真因）`);
+  for (const d of older) log(`[daemon] 内存里还有别的 mslxdff daemon：pid ${d.pid}（父 ${d.ppid}，已运行 ${fmtAlive(d.aliveSec)}，比本进程旧）—— 先请它退出，否则两个 daemon 会抢同一批端口（当年是 warp-pool 起一条死一条的真因，该模块已随 ADR-0073 移除）`);
   for (const d of older) { try { kill(d.pid, "SIGTERM"); } catch {} }
   const t0 = Date.now();
   while (Date.now() - t0 < settleMs && older.some((d) => isAlive(d.pid))) await sleep(100);

package/src/runtime/bootstrap.js

@@ -18,7 +18,7 @@ export async function startDaemonMain(VERSION) {
   const { installLifecycleLog } = await import("./lifecycle-log.js");
   installLifecycleLog({ version: VERSION, logs });
   // 接管：内存里若还有旧的 mslxdff daemon，先请它退出。它不在 daemon.pid 里（-restart 结构性碰不到它），
-  // 两个 daemon 会互抢 warp-pool 的端口（真机 2026-10-17：旧 daemon 活了一整天，日志只显示「起一条死一条」）。
+  // 两个 daemon 会互抢本机长驻端口（真机 2026-10-17：旧 daemon 活了一整天，日志只显示「起一条死一条」）。
   // 必须早于 setupProviders —— 那一步才建池抢端口。debug 前台有自己的收口逻辑，不在这里抢。
   if (process.env.MSLXDFF_DAEMON === "1" && process.env.MSLXDFF_DEBUG !== "1") {
     try {

package/src/runtime/proc-info.js

@@ -1,11 +1,11 @@
 // 进程取证层（Linux /proc 只读）——2026-10-17 组长 VPS「幽灵 daemon 互杀」事故后新增。
 //
-// 事故：两个 daemon 同时活着（一个从昨天起活了一整天），都管同一份 warp-pool 目录，
+// 事故：两个 daemon 同时活着（一个从昨天起活了一整天），都管同一批长驻目录（原 warp-pool，已随 ADR-0073 移除），
 // 把对方的 wireproxy 当「上一代残留」杀掉 ⇒ 无限互杀、池永远不稳。三处都缺「读 /proc 说事实」的能力：
 //   ① 日志不知道「同机还有几个 daemon」（只能靠人肉 ps 才发现）；
 //   ② 清理不知道「这个 wireproxy 的父进程还活着（= 另一个 daemon 的活隧道）」；
 //   ③ 「SIGKILL 都清不掉」其实是**僵尸**（state=Z，kill 对它无效，但 kill(pid,0) 仍返回成功）。
-// 放 runtime 而不是 warp-pool：daemon 与 warp-pool 都要用，放 warp-pool 会让 daemon 反向依赖它。
+// 放 runtime 而不是某个子系统目录：daemon 与子系统都要用，放子系统里会让 daemon 反向依赖它。
 // 非 Linux 一律返回空 —— 读不到 /proc 就别猜（不在别的平台做危险推断）。
 import { readFileSync, readdirSync } from "node:fs";
 

package/src/runtime/providers-setup.js

@@ -13,7 +13,6 @@ import { createOpenCodeProvider } from "../providers/opencode.js";
 import { loadProviderKeys, loadProviderAuths, loadProviderConfigs, saveProviderConfig } from "../state.js";
 import { refreshIntervalMs, modelCooldownMs, slowCooldownMs, peerCooldownMs, peerLimitCooldownMs, peerHeatMs, banWindowMs, banThreshold } from "../cli/policy.js";
 import { errMsg } from "../cli/util.js";
-import { createPreferredDispatcher } from "../v6pool/index.js";
 
 
 import { shouldEnableCustomProvider, loadAuthDocs, seedNoCredentialProviders } from "./provider-gate.js";
@@ -51,7 +50,6 @@ export async function setupProviders() {
   const baseUrl = process.env.UPSTREAM_BASE_URL || "https://opencode.ai";
   let providers = [];
 
-  const outboundDispatcher = createPreferredDispatcher({ baseUrl });
   if (providerPlugin) {
     if (!upstream) {
       try {
@@ -63,9 +61,9 @@ export async function setupProviders() {
         appendEvent({ ts: Date.now(), type: "plugin-upstream-error", plugin: providerPlugin.name, error: errMsg(err) });
       }
     }
-    if (!upstream) upstream = createUpstreamClient({ hooks: upstreamHooks, dispatcher: outboundDispatcher });
+    if (!upstream) upstream = createUpstreamClient({ hooks: upstreamHooks });
   } else {
-    const opencodeClient = createUpstreamEngine({ hooks: upstreamHooks, dispatcher: outboundDispatcher });
+    const opencodeClient = createUpstreamEngine({ hooks: upstreamHooks });
     const opencodeModels = createModelsService({
       baseUrl,
       headers: opencodeClient.headers,

package/src/server.js

@@ -50,10 +50,10 @@ export function startServer({ router, signals = true, host, onBeforeClose }, por
       if (stopping) return;
       stopping = true;
       try { console.log(`[lifecycle] ${sig} received — shutting down (pid ${process.pid}, uptime ${Math.round(process.uptime())}s)`); } catch {}
-      // 关停必须**真的退出**：warp-pool 的 wireproxy 子进程 stdio 是 pipe，活着的子进程会把事件循环钉住；
+      // 关停必须**真的退出**：长驻子进程（当年是 warp-pool 的 wireproxy，已随 ADR-0073 移除）的 stdio 是 pipe，活着的子进程会把事件循环钉住；
       // 只 close() server（放开 8989）会留下「不监听端口却还活着」的幽灵 daemon
-      //（真机 2026-10-17：Oct16 起的幽灵与新版互杀 warp-pool 端口一整天，且它不在 daemon.pid 里，-restart 永远碰不到）。
-      // process.exit 会跑 exit 钩子（warp-pool 杀隧道、lifecycle 写遗书），故清理不会被跳过。
+      //（真机 2026-10-17：Oct16 起的幽灵与新版互抢本机端口一整天，且它不在 daemon.pid 里，-restart 永远碰不到）。
+      // process.exit 会跑 exit 钩子（lifecycle 写遗书等已注册钩子），故清理不会被跳过。
       const hard = setTimeout(() => { try { console.log(`[lifecycle] ${sig} 优雅关停 8s 未完成 — 强制退出`); } catch {} process.exit(0); }, 8000);
       hard.unref?.();
       close().then(() => process.exit(0), (e) => { try { console.log(`[lifecycle] 关停抛错：${String(e?.message || e)}`); } catch {} process.exit(1); });

package/src/upstream-engine/index.js

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

package/src/upstream.js

@@ -33,11 +33,6 @@ function envInt(name, fallback) {
   const v = Number(process.env[name]);
   return Number.isInteger(v) && v > 0 ? v : fallback;
 }
-/** 允许 0 的数值 env（G1a 的逃生阀要认 0=关；envInt 的 `v>0` 会把 0 吞回默认值，那就是个假开关）。 */
-function envIntOrZero(name, fallback) {
-  const v = Number(process.env[name]);
-  return Number.isInteger(v) && v >= 0 ? v : fallback;
-}
 function isPreheatDisabled() {
   const raw = process.env.MSLXDFF_PREHEAT;
   if (raw === undefined || raw === null || raw === "") return false;
@@ -188,62 +183,7 @@ export function createUpstreamClient({
       try { console.error(`[free-lane] resp model=${body?.model} status=${res.status} ct=${res.headers?.get?.("content-type") || ""}`); } catch {}
     }
 
-    // 请求内换出口（v6 池）：撞 429 时在同一请求里换源地址重发。
-    //
-    // ⚠ 顺序契约（用户 2026-10-19 明确）：**先借人，再换出口**。
-    //   429 ⇒ ① 先走组员/组长接力（用**对方的 IPv4 出口**）；② 全都没得用/都失败，
-    //   才轮到 WARP / IPv6 换出口拿"新的自然额度"。WARP/IPv6 是另一层兜底，不该抢在借人之前。
-    //   故本功能**默认关闭**，需要时才显式开：MSLXDFF_V6_INREQUEST_ROTATE=1（原 ADR-0061 行为）。
-    //   关闭时 429 原样交回上层 → chat-pipeline 去试组员/组长，符合用户要的顺序。
-    // 边界（探测实证过的硬约束）：① 仅头部即 429 才换（不碰半开的 200 流）；② 429 错误体已被
-    // transport 非流分支读尽，无连接泄漏；③ 每轮换的是 session 粘的那个槽（swap 原地换 addr/e.agent，
-    // 粘性映射不失效）；④ 次数上限防 429 风暴空烧认领地址；⑤ 无 rotateFor 的 dispatcher（直连/WARP）
-    // 条件短路——WARP 换出口=重注册设备 6s~600s，在请求内做只会白等，**设计上排除**。
-    const inRequestRotateOn = (() => {
-      const raw = process.env.MSLXDFF_V6_INREQUEST_ROTATE;
-      if (raw === undefined || raw === null || raw === "") return false; // 缺省关：先借人
-      const s = String(raw).trim().toLowerCase();
-      return !(s === "0" || s === "false" || s === "off" || s === "no");
-    })();
-    if (inRequestRotateOn && freeLane && res.status === 429 && typeof transport.dispatcher?.rotateFor === "function") {
-      const maxRot = envIntOrZero("MSLXDFF_V6_INREQUEST_RETRIES", 3); // 0 = 关掉请求内换出口
-      let rotated = 0;
-      while (res.status === 429 && rotated < maxRot) {
-        let next = null;
-        try {
-          // 用**线上传的那个** session 头定位粘性槽（无 messages 时 buildHeaders 兜底成进程级
-          // FALLBACK_SESSION；传 null 会让 selector 轮转到别的槽，换掉一个没准真没耗尽的健康出口）
-          next = await transport.dispatcher.rotateFor(firstHeaders["x-opencode-session"] || "");
-        } catch { break; }
-        if (!next?.agent) break; // 换不到新出口（空池/全在换址/认领失败）⇒ 正常收场，不黑洞
-        rotated += 1;
-        if (laneDebug) {
-          try { console.error(`[free-lane] v6 in-request rotate #${rotated} ${next.from} -> ${next.addr} model=${body?.model}`); } catch {}
-        }
-        try {
-          res = await transport.request({
-            url,
-            method: "POST",
-            headers: buildHeaders(reqBody, { sessionId }),
-            body: reqBody,
-            stream: reqBody.stream !== false,
-            timeoutMs: connectTimeoutMs,
-            retry,
-            dispatcher: next.agent, // per-call 出口：绕开 extDispatcher 的旧槽选择
-          });
-        } catch (e) {
-          e._t = e._t || { attempts: [], waitMs: 0, totalMs: Math.round(performance.now() - t0) };
-          throw e;
-        }
-      }
-      if (rotated) {
-        res._t = { ...(res._t || {}), egressRotations: rotated, egressRecovered: res.status < 400 };
-        try {
-          appendFile(freeAnonLogFile(), `${fmtShanghaiYMDHMS(new Date())} model=${body?.model} v6-in-request-rotations=${rotated} finalStatus=${res.status}\n`).catch(() => {});
-        } catch {}
-      }
-    }
-
+    // 出口池（v6 换址 / WARP / 多出口）已移除（2026-10-25）：free 429 原样交回上层去借人（组员/组长，用对方 IPv4 出口）。
     // 匿名兜底：仅非 anonFirst 时，public 429 + free 模型才走 hermes 空头重试
     if (!anonFirst && res.status === 429 && isFreeModel(body?.model) && shouldTryAnonFree()) {
       const anonRetries = envInt("MSLXDFF_FREE_ANON_RETRIES", 3);

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

@@ -1,173 +0,0 @@
-// 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

@@ -1,136 +0,0 @@
-// 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);
-}