mslxdff 0.1.207 → 0.1.209

package/docs/cli_help_mini.md

@@ -104,6 +104,7 @@
 | 组同步 | `-group sync` | 刷新全组成员 |
 | 组离开单 | `-group leave <name>` | 离开单组 |
 | 组列表 | `-group list` | 列组+成员+健康/序号 |
+| 组员链路测试 | `-group test <target\|seq> [--group <名>] [--model <id>] [--say <词>] [--json]` | 验「本机 → 组长 → 某组员（含 relay）→ 上游」整条路，**按阶段指出断在哪一跳**；target 可填 url / `relay://id` / `-group list` 序号 |
 | 组踢人 | `-group remove <seq>` | 仅 leader 按序号踢人 |
 | 全部离开 | `-leavegroup` / `--leavegroup` | 离开所有成员组 |
 | 解散组 | `-delgroup <name>` / `--delgroup` | 仅 leader 解散 |
@@ -111,6 +112,7 @@
 | 组员开关 | `-use-group [on\|off]` / `--use-group [on\|off]` | opencode 失败时是否走组员（默认 on，off 则所有供应商仅本机；key 供应商默认恒直连，`MSLXDFF_USE_GROUP_KEYS=1` 可开回；cline/workbuddy 恒禁） |
 | 白嫖雷达 | `-free` / `--free` / `-free-check` / `--free-check` | V2EX 单源白嫖雷达（`latest.json + hot.json` 按白嫖|限免|免费额度过滤） |
 | 白嫖 watch | `-free-watch` / `--free-watch` | V2EX 白嫖雷达 watch（每 5 分钟轮询） |
+| IPv6 出口对照 | `-v6-pool [test] [--count N] [--model <id>]` | **Linux VPS** 专用：直连（IPv4）打一条 free 层请求取基线，再从 v6 段随机采 N 个源地址各打同一条（只换源地址）→ **基线 429 + v6 有 200 ⇒ 换 IP 能换到新额度**；v6 也 429 ⇒ 换 IP 抬不动。自造 `/128` 用完即撤；非 Linux 如实跳过 |
 | 自启开 | `-enable-autostart` / `--enable-autostart` | 开机自启（Windows 任务计划 / Linux systemd） |
 | 自启关 | `-disable-autostart` / `--disable-autostart` | 关闭开机自启 |
 | 自启状态 | `-autostart status` / `--autostart status` | 查看自启状态 |

package/package.json

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

package/src/cli/commands/group.js

@@ -110,6 +110,23 @@ export async function handleGroupCommand(args) {
     }
     console.log(`\njoined groups (${joinedList.length}):`);
     for (const g of joinedList) console.log(`  ${g.name}  ${g.leaderUrl || "(this node is the leader)"}`);
+  } else if (action === "test") {
+    // -group test <target> [--group <名>] [--model <id>] [--say <词>] [--json]
+    // target 可以是 url / relay://id / 或 -group list 里的序号（数字）。
+    const { resolveTargetArg, renderGroupTest } = await import("../group-test-cli.js");
+    const target = await resolveTargetArg(a, rest);
+    if (!target) {
+      console.error("usage: mslxdff -group test <target|seq> [--group <name>] [--model <id>] [--say <text>]");
+      process.exit(1);
+    }
+    const model = argValue(args, "--model", "-m") || undefined;
+    const say = argValue(args, "--say", "-s") || undefined;
+    const groupArg = argValue(args, "--group", "-g") || undefined;
+    const asJson = args.includes("--json");
+    const { runGroupLinkTest } = await import("../group-test.js");
+    const r = await runGroupLinkTest({ group: groupArg || "", target, ...(model ? { model } : {}), ...(say ? { prompt: say } : {}) });
+    renderGroupTest(r, { json: asJson });
+    process.exit(r.status === "ok" ? 0 : 1);
   } else if (action === "remove" && a) {
     const seq = Number(a);
     if (!Number.isInteger(seq) || seq < 1) {
@@ -138,7 +155,7 @@ export async function handleGroupCommand(args) {
       process.exit(1);
     }
   } else {
-    console.error("usage: mslxdff -group sync | -group leave <name> | -group list | -group remove <seq> | -creategroup <name>");
+    console.error("usage: mslxdff -group sync | -group leave <name> | -group list | -group test <target|seq> | -group remove <seq> | -creategroup <name>");
   }
   process.exit(0);
 }

package/src/cli/commands/v6-pool.js

@@ -0,0 +1,123 @@
+// mslxdff -v6-pool [test|help] —— IPv6 出口额度对照测试（在 VPS 上验证 v6 池值不值得用）。
+//
+// 目的（用户 2026-10-18 明确）：**当这台 VPS 的 IPv4 出口撞 429 时，对比测一下 IPv6 出口还有没有额度**。
+// 所以本命令做 A/B：
+//   ① 直连（IPv4/系统默认出口）打一条免费层请求，记下额度状态作基线；
+//   ② 从 v6 段里随机采 N 个源地址，各打**同一条**请求（同 UA/模型/stream/tools，只换源地址）；
+//   ③ 对照两者：v6 有 200 ⇒ 池有用（换 IP 换到新额度）；v6 全 429 ⇒ 换 IP 抬不动。
+//
+// 纯可逆：自造的 /128 用完即撤（bind 模式不碰网卡）。非 Linux 如实跳过。
+import { runV6PoolCompare, V6TEST_DEFAULT, DEFAULT_PROBE_MODEL } from "../../v6pool/selftest.js";
+import { argValue } from "../policy.js";
+
+const FLAG = "-v6-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).slice(0, 50)}）`;
+  if (r.ok) return `✅ HTTP ${r.status} 有额度`;
+  return `⛔ HTTP ${r.status} ${kindZh[r.kind] || r.kind}`;
+};
+
+export async function handleV6Pool(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();
+
+  const count = (() => { const v = flagValue(args, "--count", "-n"); return v === null ? V6TEST_DEFAULT : Math.max(1, Math.min(64, Number(v) || V6TEST_DEFAULT)); })();
+  const model = flagValue(args, "--model", "-m") || DEFAULT_PROBE_MODEL;
+
+  console.log("=".repeat(66));
+  console.log("  IPv6 出口额度对照 —— 「IPv4 撞 429 时，IPv6 还有额度吗」");
+  console.log("=".repeat(66));
+  console.log("");
+  console.log(`  探测模型 ${model}｜采样 ${count} 个 v6 源地址｜只换源地址，其余请求完全相同`);
+  console.log("");
+
+  const onProgress = (ev) => {
+    if (ev.phase === "baseline-start") console.log(`  ▸ 基线：直连（IPv4 / 系统默认出口）打一条免费层请求…`);
+    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 === "v6-start") process.stdout.write(`  [${String(ev.i).padStart(2)}/${ev.n}] ${ev.addr}  … `);
+    else if (ev.phase === "v6-done") process.stdout.write(`${line(ev)}\n`);
+  };
+
+  let r;
+  try {
+    r = await runV6PoolCompare({ count, 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(`❌ 无法测 v6 出口：${r.reason}`);
+    console.log(`   下一步：${r.hint}`);
+    process.exit(1);
+    return true;
+  }
+
+  console.log("");
+  console.log("-".repeat(66));
+  console.log(`  基线（IPv4/直连）：${line(r.baseline)}`);
+  console.log(`  v6 采样：有额度 ${r.v6OkCount}｜429 ${r.v6LimitedCount}｜不可达 ${r.v6NetCount}（共 ${r.requested}）`);
+  console.log("");
+  const verdicts = {
+    "v6-works": {
+      mark: "✅",
+      text: `IPv6 **能换到新额度**：${r.v6OkCount}/${r.requested} 个 v6 出口拿到 200`,
+      next: `   结论：v6 池对这台机器**有用** —— IPv4 耗尽时换 v6 出口能续。daemon 建池时会自动启用。`,
+    },
+    "v6-also-limited": {
+      mark: "⛔",
+      text: `IPv6 **也全 429**：换 IP 没换到新额度`,
+      next: `   结论：v6 池对这台机器**无意义**（要么上游不按出口 IP 计额，要么该段没真路由出去）。建议 MSLXDFF_V6_POOL=0。`,
+    },
+    "v6-unreachable": {
+      mark: "❌",
+      text: `IPv6 源地址**全都够不着上游**（段没路由到本机）`,
+      next: `   结论：本机这段 v6 不能用作出口。查机房是否把该段 routed 过来，或用 MSLXDFF_V6_PREFIX 指更准的段。`,
+    },
+    mixed: {
+      mark: "△",
+      text: `部分可用：${r.v6OkCount}/${r.requested} 个 v6 出口有额度`,
+      next: `   结论：v6 池**部分可用**（可能有些 /128 被沿途丢弃）。够用即可开着。`,
+    },
+  }[r.verdict] || { mark: "?", text: "未判定", next: "" };
+  console.log(`  ${verdicts.mark} ${verdicts.text}`);
+  if (verdicts.next) console.log(verdicts.next);
+  console.log("");
+  console.log(`   重试：mslxdff ${FLAG} --count ${r.requested}${model !== DEFAULT_PROBE_MODEL ? ` --model ${model}` : ""}`);
+  process.exit(r.verdict === "v6-works" || r.verdict === "mixed" ? 0 : 1);
+}
+
+function printUsage() {
+  console.log(`用法: mslxdff ${FLAG} [test] [--count N] [--model <id>]`);
+  console.log("");
+  console.log("  在 Linux VPS 上做 A/B：直连（IPv4）打一条 free 层请求取基线，");
+  console.log("  再从 v6 段随机采 N 个源地址各打同一条，对照 IPv6 出口还有没有额度。");
+  console.log("    基线 429 + v6 有 200 ⇒ 池有用（换 IP 换到新额度）");
+  console.log("    基线 429 + v6 也 429 ⇒ 换 IP 抬不动（上游不按出口 IP 计额 / 段没路由过来）");
+  console.log("");
+  console.log("相关 env（与 daemon 建池同源）：");
+  console.log("    MSLXDFF_V6_PREFIX=<段>/<位数>   显式指定池前缀（缺省取本机全局地址前缀）");
+  console.log("    MSLXDFF_V6_IFACE=<网卡>        指定网卡");
+  console.log("    MSLXDFF_V6_CLAIM=auto|bind|add 认领方式（bind 需 ip_nonlocal_bind=1；add 需 root）");
+  process.exit(0);
+  return true;
+}

package/src/cli/group-test-cli.js

@@ -0,0 +1,66 @@
+// `-group test` 的 CLI 适配层：把 -group list 的序号解析成 target，并把链路测试结果渲染成四态人话。
+import { loadPeers, loadGroupsJoined, loadToken } from "../state.js";
+import { refreshGroupMembers } from "../groups.js";
+import { compatFetch, timeoutSignal } from "../compat.js";
+import { resolveLeader } from "./group-test.js";
+
+/**
+ * 把用户给的 target 归一：数字 = -group list 里的序号；否则原样（url / relay://id）。
+ * 与 -group list 的编号口径一致（跳过 leader、broadband/static 都算）。
+ */
+export async function resolveTargetArg(a, rest = []) {
+  const raw = String(a ?? "").trim();
+  if (!raw) return "";
+  if (!/^\d+$/.test(raw)) return raw; // url 或 relay://id
+  const seq = Number(raw);
+  const joined = loadGroupsJoined();
+  const g = joined.find((x) => x?.leaderUrl) || joined[0];
+  if (!g) return "";
+  let members;
+  if (g.leaderUrl) {
+    try {
+      const { token } = await loadToken();
+      members = await refreshGroupMembers(g.name, {
+        leaderUrl: g.leaderUrl, memberName: g.memberName, url: g.myUrl, token,
+        fetchImpl: (url, opts) => compatFetch(url, { ...opts, signal: timeoutSignal(4000) }),
+      });
+    } catch { return ""; }
+  } else {
+    return ""; // 本机是组长时，序号口径见 -group list（此处不展开）
+  }
+  const entries = Object.entries(members || {}).filter(([id]) => id !== "leader");
+  const hit = entries[seq - 1];
+  return hit ? (hit[1]?.url || hit[0]) : "";
+}
+
+/** 结果 → 人话。`json` 时直接吐结构化结果（脚本用）。 */
+export function renderGroupTest(r, { json = false } = {}) {
+  if (json) { console.log(JSON.stringify(r, null, 2)); return; }
+  console.log("=".repeat(62));
+  console.log(`  组员链路测试：本机 → 组长 → ${r.target}`);
+  console.log("=".repeat(62));
+  console.log(`  组长 ${r.leaderUrl || "?"}｜组 ${r.group || "?"}${r.ms !== undefined ? `｜耗时 ${r.ms}ms` : ""}`);
+  console.log("");
+  if (r.status === "ok") {
+    console.log(`  ✅ 通了！经组长转发到该组员，上游返回：`);
+    console.log(`     "${String(r.content || "").slice(0, 200) || "(空正文)"}"`);
+    process.exitCode = 0;
+    return;
+  }
+  const stageZh = {
+    usage: "参数错误",
+    "resolve-leader": "定位组长失败",
+    "resolve-group": "确定组名失败",
+    "forward-fetch": "连不上组长",
+    auth: "鉴权被拒",
+    "target-missing": "目标不在组内",
+    "max-hops": "转发跳数超限",
+    "relay-timeout": "组长入了队但成员没回",
+    "forward-failed": "组长转发失败",
+    upstream: "成员打上游失败",
+  }[r.stage] || r.stage;
+  console.log(`  ❌ 没通 — 断在：**${stageZh}**${r.httpStatus ? `（HTTP ${r.httpStatus}）` : ""}`);
+  if (r.error) console.log(`     原因：${String(r.error).slice(0, 300)}`);
+  if (r.hint) console.log(`     下一步：${r.hint}`);
+  process.exitCode = 1;
+}

package/src/cli/group-test.js

@@ -0,0 +1,118 @@
+// 组员链路测试：验证「本机 → 组长 → 某组员（含 relay 宽带成员）→ 上游 → 回数据」整条路。
+//
+// 为什么需要它：这条链路跨 3 台机器 + 1 道鉴权，坏了只会看到一句 `502 fetch failed`，
+// 完全无法定位是哪一跳断的。本模块**按阶段**记录，把断点直接指出来：
+//   ① 定位本机组/组长 → ② 取组长 token（调组长 forward 要**组长的** token，见下）→
+//   ③ POST 组长 /v1/groups/relay/forward → ④ 判读回包（200 拿内容 / 401 鉴权 / 404 成员不存在 / 502·504 转发失败）
+//
+// ⚠ 鉴权事实（2026-10-19 实测）：`authorized()` 比的是**接收方自己的 token**，
+//   而 `/v1/groups/relay/forward` 在路由层 requiresAuth=true ⇒ 要**组长 token**。
+//   普通组员只有自己的 token ⇒ 调不动组长 forward（这就是"组员经组长"从没通的原因）。
+//   本命令调用时用组长 token；若拿不到组长 token（如你只是组员且未持有），会明确报出这一步。
+import { loadPeers, loadGroupsJoined, loadToken } from "../state.js";
+import { compatFetch, timeoutSignal } from "../compat.js";
+
+/** 默认探测模型与提示词。 */
+export const DEFAULT_TEST_MODEL = "deepseek-v4.1-flash-free";
+export const DEFAULT_TEST_PROMPT = "hi";
+
+/**
+ * 找一个可用的组长 token：优先 state.peers 里名为 leader 的记录，其次 groupsJoined 里非本机 url 的 peer。
+ * @returns {{ leaderUrl: string, leaderToken: string, group: string, source: string } | null}
+ */
+export function resolveLeader({ peers = [], joined = [] } = {}) {
+  const byName = (peers || []).find((p) => String(p?.name || "") === "leader" && p?.url);
+  if (byName) {
+    const g = joined.find((x) => x?.leaderUrl === byName.url);
+    return { leaderUrl: byName.url, leaderToken: String(byName.token || ""), group: g?.name || "", source: "peers[leader]" };
+  }
+  // 兜底：用 groupsJoined 的 leaderUrl 去 peers 里找同 url 的记录取 token
+  const g = (joined || []).find((x) => x?.leaderUrl);
+  if (g) {
+    const p = (peers || []).find((x) => x?.url === g.leaderUrl);
+    return { leaderUrl: g.leaderUrl, leaderToken: String(p?.token || ""), group: g.name, source: "groupsJoined.leaderUrl" };
+  }
+  return null;
+}
+
+/**
+ * 跑一次链路测试。返回结构化结果（不打印，由 CLI 渲染）。
+ *
+ * @param {{ group?: string, target: string, model?: string, prompt?: string, timeoutMs?: number,
+ *           deps?: { peers?, joined?, myToken?, fetchImpl? } }} opts
+ * @returns {Promise<{ status: "ok"|"error", stage: string, httpStatus?: number, content?: string,
+ *                      reply?: any, leaderUrl?: string, group?: string, target: string, ms?: number,
+ *                      error?: string, hint?: string }>}
+ */
+export async function runGroupLinkTest({
+  group = "",
+  target = "",
+  model = DEFAULT_TEST_MODEL,
+  prompt = DEFAULT_TEST_PROMPT,
+  timeoutMs = 45_000,
+  deps = {},
+} = {}) {
+  if (!target) return { status: "error", stage: "usage", target, error: "必须给目标组员（url、relay://id 或 -group list 里的序号对应项）" };
+
+  const peers = deps.peers ?? loadPeers();
+  const joined = deps.joined ?? loadGroupsJoined();
+  const myToken = deps.myToken ?? (await loadToken()).token;
+  const fetchImpl = deps.fetchImpl ?? compatFetch;
+
+  const lead = resolveLeader({ peers, joined });
+  if (!lead) return { status: "error", stage: "resolve-leader", target, error: "本机没有可用的组长记录（未加入任何组？）", hint: "先 mslxdff -addtogroup <组长host> <组名>" };
+  const groupName = group || lead.group;
+  if (!groupName) return { status: "error", stage: "resolve-group", target, error: "无法确定组名（state 里 peers/groupsJoined 缺 group）", hint: "用 -group 显式指定组名" };
+
+  const reqId = `gt-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+  const body = { group: groupName, target, reqId, body: { model, messages: [{ role: "user", content: prompt }], stream: false } };
+
+  const t0 = Date.now();
+  let res;
+  try {
+    res = await fetchImpl(`${lead.leaderUrl}/v1/groups/relay/forward`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Authorization: `Bearer ${lead.leaderToken}` },
+      body: JSON.stringify(body),
+      signal: timeoutSignal(timeoutMs),
+    });
+  } catch (e) {
+    const msg = String(e?.message || e);
+    return { status: "error", stage: "forward-fetch", target, leaderUrl: lead.leaderUrl, group: groupName, ms: Date.now() - t0,
+      error: `连组长都打不通：${msg}`, hint: "组长地址/网络不通；先 mslxdff -group list 看组长健康" };
+  }
+  const ms = Date.now() - t0;
+  const txt = await res.text().catch(() => "");
+
+  // 按阶段归类失败 —— 这是本命令存在的意义：一眼看出断在哪一跳
+  if (res.status === 401) {
+    return { status: "error", stage: "auth", httpStatus: 401, target, leaderUrl: lead.leaderUrl, group: groupName, ms,
+      error: "组长拒了鉴权（401）：调 /v1/groups/relay/forward 需要**组长的** token，本机没有",
+      hint: "这是已知缺陷：组员中继链路的鉴权断了。修复 = 组长侧 forward 应接受成员 token（见 -group test 的 PR）" };
+  }
+  if (res.status === 404) {
+    return { status: "error", stage: "target-missing", httpStatus: 404, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 200), hint: "该目标不在组内（名称/url 对不上）；用 -group list 核对" };
+  }
+  if (res.status === 429) {
+    return { status: "error", stage: "max-hops", httpStatus: 429, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 200), hint: "转发跳数超限（有环）" };
+  }
+  if (res.status === 504) {
+    return { status: "error", stage: "relay-timeout", httpStatus: 504, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 200), hint: "组长入了队但目标成员没在 30s 内回结果（成员不在线/不通）" };
+  }
+  if (res.status !== 200) {
+    const isFetchFail = /fetch failed/i.test(txt);
+    const isRelay = String(target).startsWith("relay://");
+    return { status: "error", stage: "forward-failed", httpStatus: res.status, target, leaderUrl: lead.leaderUrl, group: groupName, ms, error: txt.slice(0, 300),
+      hint: isFetchFail && isRelay
+        ? "对 relay 成员，502 fetch failed 通常是**该成员自己的上游**打不通（组长只负责转发，不碰上游）。判据：同组其他 relay 成员若正常，即证是这一台的网络/上游问题，不是组长。也可能是该成员离线。"
+        : isFetchFail ? "组长直连该静态成员失败（它离线或端口不通）" : "" };
+  }
+
+  let reply = null;
+  try { reply = JSON.parse(txt); } catch { reply = null; }
+  const content = reply?.choices?.[0]?.message?.content ?? reply?.content ?? "";
+  if (reply && (reply.error || reply.object === "error")) {
+    return { status: "error", stage: "upstream", httpStatus: 200, target, leaderUrl: lead.leaderUrl, group: groupName, ms, reply, error: String(reply.error?.message || reply.error || "").slice(0, 300), hint: "组长转到了成员，但成员打上游失败（该成员自己的上游/额度问题）" };
+  }
+  return { status: "ok", stage: "done", httpStatus: 200, target, leaderUrl: lead.leaderUrl, group: groupName, ms, content: String(content || ""), reply };
+}

package/src/cli/index.js

@@ -41,6 +41,9 @@ 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 { handleProviders, handleProvider } = await import("./commands/provider.js");
   if (await handleProviders(args)) return;
   if (await handleProvider(args)) return;

package/src/v6pool/selftest.js

@@ -0,0 +1,154 @@
+// v6pool · 出口对照测试：回答「这台 VPS 的 IPv4 出口撞 429 时，换成 IPv6 出口还有没有额度」。
+//
+// 这才是 v6 池的**唯一价值判据**：opencode 免费层按**出口 IP** 计额。若本机 IPv4 已耗尽
+// （打上游回 429 FreeUsageLimitError），而某个 IPv6 出口还能 200 ⇒ 池有用（换 IP 换到新额度）；
+// 若 IPv6 出口也 429 ⇒ 要么上游按别的东西计额（账号/session），要么该段没真路由出去。
+//
+// 对照纪律：**除"源地址"外一切相同** —— 同 URL、同 UA、同模型、同 `stream:true`+五核心工具
+// （否则会 403 FreeTierError 而非 429，测出来的不是额度）；差异只允许来自"哪个源地址出网"。
+// 判定复用 `warp-pool/verdict.js` 的 classifyWarpSignal（与生产换址判决同源，不自造一套）。
+//
+// IO 全部注入（agentFactory/fetch/detect/claimer），零真机依赖，可单测。
+import { getUndici, timeoutSignal } from "../compat.js";
+import { classifyWarpSignal } from "../warp-pool/verdict.js";
+import { opencodeUa } from "../opencode-identity.js";
+import { CORE_AGENT_TOOL_NAMES } from "../free-lane.js";
+import { detectPool } from "./detect.js";
+import { resolveV6Config } from "./config.js";
+import { createClaimer } from "./claim.js";
+import { randomAddress, parsePrefix, hostBitsOf } from "./prefix.js";
+
+/** 采样上限：抽查，不扫全段。 */
+export const V6TEST_MAX = 64;
+export const V6TEST_DEFAULT = 6;
+
+/** 默认探测模型：免费池里最有代表性、额度最容易耗的一个。 */
+export const DEFAULT_PROBE_MODEL = "deepseek-v4.1-flash-free";
+
+/** 免费层请求体形状（stream:true + 五核心工具名），缺了会 403 而非 429 ⇒ 测不出额度。 */
+export function freeLaneBody(model, prompt = "hi") {
+  return {
+    model,
+    stream: true,
+    max_tokens: 16,
+    messages: [{ role: "user", content: prompt }],
+    tools: CORE_AGENT_TOOL_NAMES.map((name) => ({
+      type: "function",
+      function: { name, description: `The ${name} tool.`, parameters: { type: "object", properties: {} } },
+    })),
+  };
+}
+
+/** 读响应正文（有上界，失败给空串——不读就无法判决 403/429 的具名类名）。 */
+async function readBody(res, max = 2048) {
+  try {
+    const t = await res.text();
+    return t.slice(0, max);
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * 从某个源地址打一次免费层 chat，返回判决。
+ * `addr=""` 表示**直连**（走本机默认路由 = IPv4 出口，或双栈默认）。
+ * @returns {Promise<{addr, ok, status, kind, rotate, ms, body, error}>}
+ */
+export async function probeUpstreamFrom({ addr = "", model, baseUrl = "https://opencode.ai", agentFactory, fetchImpl, timeoutMs = 20_000, prompt } = {}) {
+  const t0 = Date.now();
+  let agent = null;
+  try {
+    agent = addr ? agentFactory(addr) : null; // 直连：不注入 dispatcher，走系统默认出口
+    const f = fetchImpl || getUndici().fetch;
+    const res = await f(`${baseUrl}/zen/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": opencodeUa(), Accept: "text/event-stream" },
+      body: JSON.stringify(freeLaneBody(model, prompt)),
+      ...(agent ? { dispatcher: agent } : {}),
+      signal: timeoutSignal(timeoutMs),
+    });
+    const body = await readBody(res);
+    const v = classifyWarpSignal({ status: res.status, text: body });
+    return { addr, ok: res.status >= 200 && res.status < 300, status: res.status, kind: v.kind, rotate: v.rotate, ms: Date.now() - t0, body };
+  } catch (e) {
+    return { addr, ok: false, status: 0, kind: "network", rotate: true, ms: Date.now() - t0, body: "", error: String(e?.message || e) };
+  } finally {
+    if (agent) { try { await agent.close?.(); } catch { /* 一次性 Agent */ } }
+  }
+}
+
+/**
+ * 跑一次出口对照测试。返回结构化结果，由 CLI 渲染（本模块不打印）。
+ *
+ * @param {{ env?: object, count?: number, model?: string, baseUrl?: string,
+ *           onProgress?: (ev: object) => void,
+ *           deps?: { detect?, claimer?, agentFactory?, fetchImpl?, probe?, randomAddress? } }} opts
+ */
+export async function runV6PoolCompare({
+  env = process.env,
+  count = V6TEST_DEFAULT,
+  model = DEFAULT_PROBE_MODEL,
+  baseUrl = "https://opencode.ai",
+  onProgress,
+  deps = {},
+} = {}) {
+  const cfg = resolveV6Config(env);
+  const tick = (ev) => { try { onProgress?.(ev); } catch { /* 渲染出错不打断测试 */ } };
+
+  const detect = deps.detect || detectPool;
+  const d = detect({ cfg, env });
+  if (!d.ok) return { status: "skip", reason: d.reason, hint: d.hint };
+  const prefix = parsePrefix(`${d.prefix}`);
+  if (!prefix) return { status: "skip", reason: `前缀解析失败：${d.prefix}`, hint: "用 MSLXDFF_V6_PREFIX=<段>/<位数> 显式指定" };
+
+  const { Agent } = getUndici();
+  const agentFactory = deps.agentFactory || ((addr) => new Agent({ connect: { localAddress: addr }, connections: 1, keepAliveTimeout: 5_000 }));
+  const probe = deps.probe || probeUpstreamFrom;
+  const pick = deps.randomAddress || ((p) => randomAddress(p));
+
+  // ① 基准：直连（IPv4 / 系统默认出口），记下它的额度状态作为对照基线
+  tick({ phase: "baseline-start", prefix: d.prefix, model });
+  const baseline = await probe({ addr: "", model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl });
+  tick({ phase: "baseline-done", ...baseline });
+
+  // ② IPv6 池采样：每个随机源地址打同一条请求
+  const n = Math.max(1, Math.min(V6TEST_MAX, Number(count) || V6TEST_DEFAULT));
+  const claimer = deps.claimer ? deps.claimer(d, cfg) : createClaimer({ iface: d.iface, mode: d.mode, dir: cfg.dir });
+  const mineSet = new Set(d.mine || []);
+  const v6 = [];
+  try {
+    for (let i = 0; i < n; i++) {
+      let addr = pick(prefix);
+      for (let k = 0; k < 16 && mineSet.has(addr); k++) addr = pick(prefix);
+      await claimer.ensure(addr);
+      tick({ phase: "v6-start", i: i + 1, n, addr });
+      const r = await probe({ addr, model, baseUrl, agentFactory, fetchImpl: deps.fetchImpl });
+      v6.push(r);
+      tick({ phase: "v6-done", i: i + 1, n, ...r });
+    }
+  } finally {
+    try { await claimer.releaseAll(); } catch { /* 释放失败交给下次 sweepStale */ }
+  }
+
+  // ③ 判语：对照基线
+  const baseLimited = baseline.status === 429 || baseline.kind === "free-quota" || baseline.kind === "free-tier" || baseline.kind === "ip-limit";
+  const v6Ok = v6.filter((r) => r.ok);
+  const v6Limited = v6.filter((r) => r.status === 429);
+  const v6Net = v6.filter((r) => !r.status);
+
+  let verdict;
+  const allOk = v6Ok.length === v6.length && v6.length > 0;
+  if (allOk) verdict = "v6-works";                                  // 全部 v6 出口都有额度
+  else if (v6Limited.length === v6.length) verdict = "v6-also-limited"; // 全部 429 ⇒ 没换到新额度
+  else if (v6Net.length === v6.length) verdict = "v6-unreachable";  // 全部够不着 ⇒ 段没路由过来
+  else verdict = "mixed";                                           // 有的成有的不成
+
+  return {
+    status: "ok",
+    prefix: d.prefix, iface: d.iface, mode: d.mode, hostBits: hostBitsOf(prefix.bits), model, baseUrl,
+    baseline, baseLimited,
+    v6, requested: n,
+    v6OkCount: v6Ok.length, v6LimitedCount: v6Limited.length, v6NetCount: v6Net.length,
+    verdict,
+  };
+}