tt-help-cli-ycl 1.4.169 → 1.4.172

package/scripts/test-country-fix.mjs

@@ -1,341 +0,0 @@
-#!/usr/bin/env node
-/**
- * 回归测试：节点国家配置收敛修复（2026-08-12）
- *
- * 背景：daemon 启动硬编码 --country US，且服务端幂等基准是"是否下发过"，
- * 导致 daemon 重启（崩溃自愈/升级/机器重启）回退 US 后服务端不补发 → 一直用美国节点。
- *
- * 运行方式（务必用隔离 TMPDIR，避免污染真实 clash-*.json / 服务端配置）：
- *   TMPDIR=$(mktemp -d) node scripts/test-country-fix.mjs
- *
- * 覆盖：
- *   A. 服务端幂等基准 = 客户端实际生效国家（核心修复）
- *      - daemon 重启回退 US 后，服务端补发 JP
- *      - daemon 已生效 JP 时，幂等不重复下发
- *      - daemon 未上报时，下发
- *      - 多国配置且已生效时，幂等不重复下发
- *   B. daemon 逗号分隔多国 --country 参数解析
- *   C. checker normalizeCountries / filterNodesByCountry 回归
- *      + 内置策略/机场信息节点过滤（isUsableProxyNode，2026-09-03 剩余流量 GB 修复）
- *   D. 客户端 daemon 启动兜底：读 clash-health.json 上次生效国家 → join(",")
- */
-
-import { mkdtempSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-
-let passed = 0;
-let failed = 0;
-function ok(cond, name, extra = "") {
-  if (cond) {
-    passed++;
-    console.log(`  ✅ ${name}`);
-  } else {
-    failed++;
-    console.log(`  ❌ ${name}  ${extra}`);
-  }
-}
-
-// ── 隔离 HOME：避免读写真实服务端配置 ~/.tt-help-watchdog.json ──
-const fakeHome = mkdtempSync(join(tmpdir(), "tt-wd-home-"));
-process.env.HOME = fakeHome;
-process.env.USERPROFILE = fakeHome;
-
-function fakeRes() {
-  return {
-    status: 0,
-    body: null,
-    writeHead(code) {
-      this.status = code;
-    },
-    end(b) {
-      this.body = b;
-    },
-  };
-}
-async function wdCall(mod, path, method, params, body) {
-  const res = fakeRes();
-  await mod.tryHandleWatchdogRoute(path, method, params, body, res);
-  return { status: res.status, data: res.body ? JSON.parse(res.body) : null };
-}
-
-console.log("\n═══ A. 服务端幂等基准 = 客户端实际生效国家 ═══");
-const wd = await import("../src/watch/watchdog-server.js");
-
-// A1 配置 T1 → JP
-let r = await wdCall(
-  wd,
-  "/api/watchdog/set-country-filter",
-  "POST",
-  {},
-  {
-    userId: "T1",
-    countries: ["JP"],
-  },
-);
-ok(
-  r.status === 200 && JSON.stringify(r.data.countries) === '["JP"]',
-  "A1 配置 T1 → JP",
-  JSON.stringify(r.data),
-);
-
-// A2 心跳：daemon 回退 US（重启后）→ 服务端应补发 JP（核心修复点，旧逻辑因 lastSent 幂等不会下发）
-r = await wdCall(
-  wd,
-  "/api/watchdog/heartbeat",
-  "POST",
-  { clientId: "c1" },
-  {
-    config: { userId: "T1" },
-    clashHealth: { meta: { countryFilter: ["US"] } },
-  },
-);
-let cmds = (r.data && r.data.clashCommands) || [];
-ok(
-  cmds.some(
-    (c) =>
-      c.action === "setCountryFilter" &&
-      JSON.stringify(c.countries) === '["JP"]',
-  ),
-  "A2 daemon 生效 US(重启回退) → 补发 setCountryFilter JP",
-  JSON.stringify(cmds),
-);
-
-// A3 心跳：daemon 已生效 JP → 幂等不重复下发
-r = await wdCall(
-  wd,
-  "/api/watchdog/heartbeat",
-  "POST",
-  { clientId: "c1" },
-  {
-    config: { userId: "T1" },
-    clashHealth: { meta: { countryFilter: ["JP"] } },
-  },
-);
-cmds = (r.data && r.data.clashCommands) || [];
-ok(
-  !cmds.some((c) => c.action === "setCountryFilter"),
-  "A3 daemon 生效 JP → 幂等不下发",
-  JSON.stringify(cmds),
-);
-
-// A4 心跳：daemon 未上报 clashHealth → 下发
-r = await wdCall(
-  wd,
-  "/api/watchdog/heartbeat",
-  "POST",
-  { clientId: "c1" },
-  {
-    config: { userId: "T1" },
-    clashHealth: null,
-  },
-);
-cmds = (r.data && r.data.clashCommands) || [];
-ok(
-  cmds.some(
-    (c) =>
-      c.action === "setCountryFilter" &&
-      JSON.stringify(c.countries) === '["JP"]',
-  ),
-  "A4 daemon 未上报 → 下发 setCountryFilter JP",
-  JSON.stringify(cmds),
-);
-
-// A5 多国配置 US+JP 且 daemon 已生效 US+JP → 幂等不下发
-// 注：配置动作本身会立即入队一次下发（配置后本该生效一次），首轮心跳取走后再验证幂等
-await wdCall(
-  wd,
-  "/api/watchdog/set-country-filter",
-  "POST",
-  {},
-  {
-    userId: "T2",
-    countries: ["US", "JP"],
-  },
-);
-r = await wdCall(
-  wd,
-  "/api/watchdog/heartbeat",
-  "POST",
-  { clientId: "c2" },
-  {
-    config: { userId: "T2" },
-    clashHealth: { meta: { countryFilter: ["US", "JP"] } },
-  },
-);
-cmds = (r.data && r.data.clashCommands) || [];
-ok(
-  cmds.some(
-    (c) =>
-      c.action === "setCountryFilter" &&
-      JSON.stringify(c.countries) === '["US","JP"]',
-  ),
-  "A5a 配置后首次心跳取走命令",
-  JSON.stringify(cmds),
-);
-r = await wdCall(
-  wd,
-  "/api/watchdog/heartbeat",
-  "POST",
-  { clientId: "c2" },
-  {
-    config: { userId: "T2" },
-    clashHealth: { meta: { countryFilter: ["US", "JP"] } },
-  },
-);
-cmds = (r.data && r.data.clashCommands) || [];
-ok(
-  !cmds.some((c) => c.action === "setCountryFilter"),
-  "A5 多国且已生效 → 幂等不下发",
-  JSON.stringify(cmds),
-);
-
-console.log("\n═══ B. daemon 逗号分隔多国 --country 解析 ═══");
-const { ClashDaemon } = await import("../src/clash/daemon.js");
-const checker = await import("../src/clash/checker.js");
-
-const cases = [
-  ["US,JP", ["US", "JP"], "US,JP 逗号分隔 → 多国并集"],
-  ["JP", ["JP"], "JP 单国"],
-  ["us, jp", ["US", "JP"], "小写+空格归一"],
-  [undefined, null, "未传 country → 不过滤"],
-];
-for (const [input, expect, name] of cases) {
-  checker.CONFIG.nodeCountryFilter = null;
-  new ClashDaemon({ country: input });
-  const got = checker.CONFIG.nodeCountryFilter;
-  ok(JSON.stringify(got) === JSON.stringify(expect), name, JSON.stringify(got));
-}
-checker.CONFIG.nodeCountryFilter = null;
-
-console.log("\n═══ C. checker 国家过滤回归 ═══");
-ok(
-  JSON.stringify(checker.normalizeCountries(["us", " JP", "US"])) ===
-    '["US","JP"]',
-  "C1 数组去重大写",
-);
-ok(
-  JSON.stringify(checker.normalizeCountries("jp")) === '["JP"]',
-  "C2 字符串大写",
-);
-ok(checker.normalizeCountries(null).length === 0, "C3 null → 空");
-ok(checker.normalizeCountries("").length === 0, "C4 空串 → 空");
-// 注意：checker.normalizeCountries 不拆分逗号（拆分在 daemon constructor），单字符串"US,JP"保持为一个元素
-ok(
-  JSON.stringify(checker.normalizeCountries("US,JP")) === '["US,JP"]',
-  "C5 单字符串逗号不拆分（保持向后兼容）",
-);
-const nodes = ["🇺🇸美国A", "🇯🇵日本A", "🇩🇪德国A", "无旗帜节点"];
-let fr = checker.filterNodesByCountry(nodes, ["US", "JP"]);
-ok(
-  fr.filtered.length === 2 && fr.excluded === 2,
-  "C6 多国并集过滤（US+JP 命中 2）",
-  JSON.stringify(fr),
-);
-fr = checker.filterNodesByCountry(nodes, ["ZZ"]);
-ok(
-  fr.filtered.length === 4 && fr.excluded === 0,
-  "C7 未知国家向后兼容返回全部",
-);
-fr = checker.filterNodesByCountry(nodes, null);
-ok(fr.filtered.length === 4 && fr.excluded === 0, "C8 null 不过滤");
-
-// ── C9-C14 信息节点/内置策略过滤（2026-09-03：剩余流量 GB 混入候选集修复） ──
-fr = checker.filterNodesByCountry(["剩余流量：5319.72 GB"], ["US", "GB", "JP"]);
-ok(
-  fr.filtered.length === 0,
-  "C9 GB 模式不再命中流量单位（剩余流量：xxx GB）",
-  JSON.stringify(fr),
-);
-fr = checker.filterNodesByCountry(
-  ["🇬🇧英国HY1-1000M专线", "🇬🇧英国trojan1", "UK Premium"],
-  ["GB"],
-);
-ok(
-  fr.filtered.length === 3,
-  "C10 英国节点仍正常命中（英国/UK）",
-  JSON.stringify(fr),
-);
-const junkNodes = [
-  "DIRECT",
-  "REJECT",
-  "REJECT-DROP",
-  "GLOBAL",
-  "剩余流量：5319.72 GB",
-  "剩余流量：1862.27 MB",
-  "官网：example.com",
-  "套餐到期：2099-12-31",
-  "1.5TB",
-];
-ok(
-  junkNodes.every((n) => !checker.isUsableProxyNode(n)),
-  "C11 内置策略+信息节点全部被 isUsableProxyNode 拒绝",
-  JSON.stringify(junkNodes.filter((n) => checker.isUsableProxyNode(n))),
-);
-const goodNodes = [
-  "🇺🇸美国HY1轻量",
-  "🇬🇧英国HY1-1000M专线",
-  "🇯🇵日本Trojan1",
-  "🇹🇼台湾trojan直连AI",
-];
-ok(
-  goodNodes.every((n) => checker.isUsableProxyNode(n)),
-  "C12 正常业务节点全部通过 isUsableProxyNode",
-  JSON.stringify(goodNodes.filter((n) => !checker.isUsableProxyNode(n))),
-);
-// 读口兜底：已持久化的脏候选文件在读取时被过滤
-writeFileSync(
-  join(tmpdir(), "clash-healthy-nodes.json"),
-  JSON.stringify({
-    updated: new Date().toISOString(),
-    nodes: ["🇺🇸美国A", "剩余流量：5319.72 GB", "DIRECT", "🇯🇵日本A"],
-    delays: {},
-  }),
-);
-const hl = checker.loadHealthyList();
-ok(
-  hl.nodes.length === 2 &&
-    !hl.nodes.some((n) => checker.isUsableProxyNode(n) === false),
-  "C13 loadHealthyList 读口剔除已持久化的脏候选",
-  JSON.stringify(hl.nodes),
-);
-
-console.log("\n═══ D. 客户端 daemon 启动兜底（读上次生效国家）═══");
-const { getClashHealth } = await import("../src/watchdog/reporter.js");
-const healthPath = join(tmpdir(), "clash-health.json");
-
-writeFileSync(
-  healthPath,
-  JSON.stringify({
-    meta: { countryFilter: ["JP"] },
-    lastCheck: new Date().toISOString(),
-  }),
-);
-let prev = getClashHealth()?.meta?.countryFilter;
-ok(
-  Array.isArray(prev) && JSON.stringify(prev) === '["JP"]',
-  "D1 读到上次生效国家 JP",
-  JSON.stringify(prev),
-);
-let countryArg = Array.isArray(prev) && prev.length ? prev.join(",") : "US";
-ok(countryArg === "JP", "D2 单国 join → 'JP'", countryArg);
-
-writeFileSync(
-  healthPath,
-  JSON.stringify({
-    meta: { countryFilter: ["US", "JP"] },
-    lastCheck: new Date().toISOString(),
-  }),
-);
-prev = getClashHealth()?.meta?.countryFilter;
-countryArg = Array.isArray(prev) && prev.length ? prev.join(",") : "US";
-ok(countryArg === "US,JP", "D3 多国 join → 'US,JP'", countryArg);
-
-// 无上次生效记录（clashHealth 缺失）→ 兜底 US
-const nonePrev = null?.meta?.countryFilter;
-const noneArg =
-  Array.isArray(nonePrev) && nonePrev.length ? nonePrev.join(",") : "US";
-ok(noneArg === "US", "D4 无记录 → 兜底 US");
-
-console.log(`\n结果: ${passed} 通过, ${failed} 失败`);
-process.exit(failed ? 1 : 0);

package/scripts/test-daemon-failover.mjs

@@ -1,301 +0,0 @@
-/**
- * daemon _handleFailover 单测（2026-08-25，时间锚点方案，无需 Clash 运行）
- *
- * 验证：
- *   - 探针不健康 → 立即切换（无视冷却）
- *   - 探针健康（含壳页）→ 距上次切换 < 冷却期仅检查不切换
- *   - 探针健康 → 距上次切换 >= 冷却期 → 按业务级封禁轮换一次
- *   - 强切（force=true）→ 探针健康且冷却期内仍强制轮换
- *   - 切换后（含手动/巡检/failover）更新 _lastSwitchAt 锚点，冷却期内不再切
- *   - 候选集为空 → 触发 delay 初测且不切换
- *
- * 运行: node --test scripts/test-daemon-failover.mjs
- *      （若当前 Node 版本 module mock 仍需 flag: --experimental-test-module-mocks）
- */
-import { test, mock, before } from "node:test";
-import assert from "node:assert/strict";
-
-// ── 可配置假依赖状态 ──
-const state = {
-  health: {
-    healthy: true,
-    httpCode: 200,
-    timeTotal: 1.2,
-    sizeDownload: 100000,
-    numRedirects: 0,
-    title: "TikTok - Make Your Day",
-    error: null,
-  },
-  nodes: ["🇭🇰 香港01", "🇲🇾 马来02"],
-  currentNode: "🇭🇰 香港01",
-  switches: [],
-  closes: 0, // closeAllConnections（全断）调用次数
-  idleCloses: 0, // closeIdleConnections（优雅断连）调用次数
-  failIdleClose: false, // 模拟优雅断连失败
-  // 订阅切换感知（巡检开头候选集存在性校验）相关
-  proxyMap: { "🇭🇰 香港01": {}, "🇲🇾 马来02": {} }, // 当前 /proxies 中的代理名
-  pruneResult: { kept: 2, removed: 0, allGone: false },
-  pruneCalls: 0,
-  probeCalls: 0,
-  failProxies: false,
-};
-
-function resetState() {
-  state.health = {
-    healthy: true,
-    httpCode: 200,
-    timeTotal: 1.2,
-    sizeDownload: 100000,
-    numRedirects: 0,
-    title: "TikTok - Make Your Day",
-    error: null,
-  };
-  state.nodes = ["🇭🇰 香港01", "🇲🇾 马来02"];
-  state.currentNode = "🇭🇰 香港01";
-  state.switches = [];
-  state.closes = 0;
-  state.idleCloses = 0;
-  state.failIdleClose = false;
-  state.proxyMap = { "🇭🇰 香港01": {}, "🇲🇾 马来02": {} };
-  state.pruneResult = { kept: 2, removed: 0, allGone: false };
-  state.pruneCalls = 0;
-  state.probeCalls = 0;
-  state.failProxies = false;
-}
-
-// ── 注册模块 mock（必须在 import daemon.js 之前） ──
-before(async () => {
-  mock.module("../src/clash/checker.js", {
-    namedExports: {
-      normalizeCountries: (v) => (Array.isArray(v) ? [...v] : v ? [v] : []),
-      CONFIG: {
-        groupName: "GLOBAL",
-        testUrl: "https://www.tiktok.com/explore",
-        proxyUrl: "http://127.0.0.1:7897",
-        nodeCountryFilter: null,
-      },
-      checkNodeHealth: () => ({ ...state.health }),
-      loadHealthyList: () => ({ nodes: [...state.nodes] }),
-      switchToNode: async (n) => {
-        state.switches.push(n);
-        state.currentNode = n;
-        // 模拟真实世界：故障属于原节点，切换后的新节点健康（候选内容验证通过）
-        state.health = { ...state.health, healthy: true, error: null };
-        return true;
-      },
-      applyDiscovered: () => {},
-      checkClashAlive: () => true,
-      pruneHealthyListByCurrentProxies: () => {
-        state.pruneCalls += 1;
-        return { ...state.pruneResult };
-      },
-      runDelayProbe: async () => {
-        state.probeCalls += 1;
-        return {
-          nodes: [...state.nodes],
-          total: state.nodes.length,
-        };
-      },
-      saveHealthyList: () => {},
-    },
-  });
-  mock.module("../src/clash/api.js", {
-    namedExports: {
-      configure: () => {},
-      getProxies: async () => {
-        if (state.failProxies) throw new Error("mock /proxies 不可达");
-        return { proxies: { ...state.proxyMap } };
-      },
-      getCurrentNode: async () => state.currentNode,
-      closeAllConnections: async () => {
-        state.closes += 1;
-      },
-      closeIdleConnections: async () => {
-        if (state.failIdleClose) throw new Error("mock 优雅断连失败");
-        state.idleCloses += 1;
-        return { closed: 3, active: 2 };
-      },
-    },
-  });
-  mock.module("../src/clash/ipc.js", {
-    namedExports: {
-      writeHealth: () => {},
-      listCommandChannels: () => [],
-      readCommand: () => null,
-      clearCommand: () => {},
-    },
-  });
-  mock.module("../src/clash/discover.js", {
-    namedExports: {
-      discoverAll: async () => [],
-      invalidateDiscoverCache: () => {},
-    },
-  });
-  ({ ClashDaemon } = await import("../src/clash/daemon.js"));
-});
-
-let ClashDaemon = null;
-
-function makeCtx(opts = {}) {
-  const d = new ClashDaemon({
-    failoverCooldownMs: 600000,
-    failoverEscapeAfter: 3,
-    ...opts,
-  });
-  const c = { proxyPort: 7897 };
-  return { d, c };
-}
-
-test("F1 探针健康：冷却期外首次 failover 即轮换，并更新锚点", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now() - 600_001; // 距上次切换 > 10min 冷却
-  await d._handleFailover({ reason: "F1" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "冷却期外应轮换切换");
-  assert.equal(state.idleCloses, 1, "切换后应优雅断连（空闲回收）");
-  assert.ok(
-    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
-    "切换后应更新锚点",
-  );
-});
-
-test("F2 探针不健康：立即切换（无视冷却）", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now(); // 刚切过，但探针不健康时不看锚点
-  state.health = { ...state.health, healthy: false, error: "timeout" };
-  await d._handleFailover({ reason: "F2" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "不健康应立即切换");
-});
-
-test("F3 壳页视为链路正常：冷却期内仅检查不切换", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now(); // 冷却期内
-  // 壳页签名：200 + 无跳转 + 无 error + 无 title
-  state.health = {
-    healthy: false,
-    httpCode: 200,
-    timeTotal: 1.0,
-    sizeDownload: 43000,
-    numRedirects: 0,
-    title: "",
-    error: null,
-  };
-  await d._handleFailover({ reason: "F3" }, c);
-  assert.equal(state.switches.length, 0, "冷却期内壳页不应触发切换");
-});
-
-test("F4 冷却期约束：切换后冷却期内不连续切换，过期后再切", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  // 首次 failover（无锚点）→ 按冷却期外处理 → 轮换
-  await d._handleFailover({ reason: "F4-1" }, c);
-  assert.equal(state.switches.length, 1, "首次应轮换切换");
-  // 锚点刚更新，冷却期内再次 failover（探针健康）→ 不切
-  await d._handleFailover({ reason: "F4-2" }, c);
-  assert.equal(state.switches.length, 1, "冷却期内不应再切换");
-  // 冷却期过后 → 再次轮换
-  c._lastSwitchAt = Date.now() - 600_001;
-  await d._handleFailover({ reason: "F4-3" }, c);
-  assert.equal(state.switches.length, 2, "冷却期过后应再切换");
-});
-
-test("F5 手动切换同样更新锚点：切换后冷却期内 failover 不再切", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  // 手动切换（用户主动切，立即执行）
-  await d._handleSwitchNode({ node: "🇲🇾 马来02", proxyPort: 7897 }, c);
-  assert.equal(state.switches.length, 1, "手动切换应立即执行");
-  assert.ok(
-    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
-    "手动切换应更新锚点",
-  );
-  // 手动切换后冷却期内，探针健康的 failover 不再切
-  await d._handleFailover({ reason: "F5-2" }, c);
-  assert.equal(
-    state.switches.length,
-    1,
-    "手动切换后冷却期内 failover 不应再切",
-  );
-});
-
-// F6 已移除：failoverEscapeAfter 计数方案已弃用（2026-08-25 改为时间锚点），
-// 不再存在"连报 N 次"阈值；字段保留仅为兼容外部传参，不影响行为。
-
-test("F7 候选集为空：触发 delay 初测且不切换", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.health = { ...state.health, healthy: false, error: "timeout" };
-  state.nodes = [];
-  await d._handleFailover({ reason: "F7" }, c);
-  assert.equal(state.switches.length, 0, "无候选不应切换");
-  assert.ok(c._lastProbeAt, "应触发过 delay 初测");
-});
-
-test("F8 优雅断连失败：回退全断，切换仍生效", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now() - 600_001; // 冷却期外
-  state.failIdleClose = true; // 优雅断连抛错
-  await d._handleFailover({ reason: "F8" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "切换仍应执行");
-  assert.equal(state.idleCloses, 0, "优雅断连失败未计数");
-  assert.equal(state.closes, 1, "失败后应回退全断");
-});
-
-test("F9 disconnectMode=full：直接全断", async () => {
-  resetState();
-  const { d, c } = makeCtx({ disconnectMode: "full" });
-  c._lastSwitchAt = Date.now() - 600_001;
-  await d._handleFailover({ reason: "F9" }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "切换应执行");
-  assert.equal(state.idleCloses, 0, "full 模式不走优雅断连");
-  assert.equal(state.closes, 1, "full 模式直接全断");
-});
-
-test("F10 强切（force）：冷却期内探针健康仍强制轮换", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  c._lastSwitchAt = Date.now(); // 刚切过，处于 10min 冷却期内
-  await d._handleFailover({ reason: "F10", force: true }, c);
-  assert.deepEqual(state.switches, ["🇲🇾 马来02"], "force 应无视冷却直接轮换");
-  assert.ok(
-    c._lastSwitchAt && c._lastSwitchAt > Date.now() - 5000,
-    "强切后应更新锚点（给新节点观察期）",
-  );
-});
-
-// ── 订阅切换感知：巡检开头候选集存在性校验（2026-08-29） ──
-
-test("S1 候选集全部失效：当前节点健康也立即触发 delay 初测", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.health = { ...state.health, healthy: true }; // 当前节点健康
-  state.pruneResult = { kept: 0, removed: 2, allGone: true };
-  await d._healthCheckController(c);
-  assert.equal(state.pruneCalls, 1, "巡检应执行候选集校验");
-  // 初测经串行锁排队执行，等队列清空后断言
-  await d._withLock(() => {});
-  assert.equal(state.probeCalls, 1, "全失效应立即触发 delay 初测");
-});
-
-test("S2 候选集部分失效：剔除后不触发初测，巡检正常", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.pruneResult = { kept: 1, removed: 1, allGone: false };
-  await d._healthCheckController(c);
-  await d._withLock(() => {});
-  assert.equal(state.pruneCalls, 1, "应执行候选集校验");
-  assert.equal(state.probeCalls, 0, "部分失效不应触发初测");
-});
-
-test("S3 /proxies 拉取失败：静默跳过校验，不阻断巡检", async () => {
-  resetState();
-  const { d, c } = makeCtx();
-  state.failProxies = true;
-  await d._healthCheckController(c);
-  await d._withLock(() => {});
-  assert.equal(state.pruneCalls, 0, "API 失败不应执行校验");
-  assert.equal(state.probeCalls, 0, "API 失败不应触发初测");
-});