tt-help-cli-ycl 1.4.164 → 1.4.166

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.164",
+  "version": "1.4.166",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/add-claim-fallback-index.mjs

@@ -0,0 +1,25 @@
+// 一次性运维脚本：为 task_queue 建 claim 兜底分支加速索引（幂等）
+import { createRequire } from "module";
+const require = createRequire("D:/tiktok/tiktok-cli/package.json");
+const Database = require("better-sqlite3");
+
+const db = new Database("D:/tiktok/data/result.db");
+db.pragma("busy_timeout = 30000");
+const t0 = Date.now();
+db.exec(
+  "CREATE INDEX IF NOT EXISTS idx_tq_claim_fallback ON task_queue(status, follower_count DESC, created_at ASC, unique_id ASC)",
+);
+console.log(`index created in ${Date.now() - t0}ms`);
+
+// 验证兜底分支走新索引
+const SQL = `SELECT * FROM task_queue WHERE status='pending' AND pinned=0 AND tt_seller=1 AND verified=0 AND UPPER(COALESCE(guessed_location,'')) NOT IN ('PL','NL','BE','DE','FR','IT','IE','ES','CZ','GR','HU','PT','AT','TH','US') AND (status_code IS NULL OR status_code=0 OR status_code=209002) ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1`;
+const plan = db
+  .prepare(`EXPLAIN QUERY PLAN ${SQL}`)
+  .all()
+  .map((r) => r.detail)
+  .join(" | ");
+console.log("plan:", plan);
+const t1 = Date.now();
+db.prepare(SQL).get();
+console.log(`fallback branch query: ${Date.now() - t1}ms`);
+db.close();

package/scripts/add-claim-index.mjs

@@ -19,10 +19,8 @@ const plan = db
   .join(" | ");
 console.log("plan:", plan);
 const t1 = Date.now();
-db
-  .prepare(
-    `SELECT * FROM task_queue WHERE status='pending' AND pinned=0 AND tt_seller=1 AND verified=0 AND UPPER(COALESCE(guessed_location,'')) IN ('PL') AND (status_code IS NULL OR status_code=0 OR status_code=209002) ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1`,
-  )
-  .get();
+db.prepare(
+  `SELECT * FROM task_queue WHERE status='pending' AND pinned=0 AND tt_seller=1 AND verified=0 AND UPPER(COALESCE(guessed_location,'')) IN ('PL') AND (status_code IS NULL OR status_code=0 OR status_code=209002) ORDER BY follower_count DESC, created_at ASC, unique_id ASC LIMIT 1`,
+).get();
 console.log(`branch query: ${Date.now() - t1}ms`);
 db.close();

package/scripts/test-clash-hysteresis.mjs

@@ -0,0 +1,131 @@
+/**
+ * 候选集迟滞（mergeHealthyWithHysteresis）单测（离线，不碰真实健康文件）
+ *
+ * 背景：delay 初测为单点采样，瞬时抖动会把健康节点误踢出池（2026-09-28 生产实锤：
+ * 英国节点被白名单守卫切回）。迟滞规则：连续 2 轮初测失败才除名；失败第 1 轮保留
+ * 在池内作"降级观察"，写盘顺序沉底（幸存者在前后降级在后，轮换优先实测存活节点）。
+ *
+ * 覆盖：
+ *   - 首轮（无上一轮池）→ 仅幸存者，无降级
+ *   - 本轮失败第 1 轮 → 保留 + 计数 1，排幸存者之后
+ *   - 连续第 2 轮失败（prevDegraded=1）→ 除名
+ *   - 降级后恢复 → 计数自动清零
+ *   - maxRounds=1 → 关闭迟滞（失败即除名）
+ *   - 容错：prev 非法值 / 空 prevDegraded
+ *   - 文件往返：saveHealthyList(degraded) → loadHealthyList 读回
+ *   - pruneHealthyListByCurrentProxies 剔除节点时携带留存节点的 degraded
+ *
+ * 运行: node scripts/test-clash-hysteresis.mjs
+ */
+import assert from "node:assert/strict";
+import { unlinkSync, existsSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import {
+  mergeHealthyWithHysteresis,
+  saveHealthyList,
+  loadHealthyList,
+  pruneHealthyListByCurrentProxies,
+  applyDiscovered,
+} from "../src/clash/checker.js";
+
+let passed = 0;
+const failures = [];
+async function check(name, fn) {
+  try {
+    await fn();
+    passed++;
+    console.log(`PASS ${name}`);
+  } catch (e) {
+    failures.push({ name, e });
+    console.log(`FAIL ${name}: ${e.message}`);
+  }
+}
+
+// ── 纯函数：mergeHealthyWithHysteresis ──
+
+await check("首轮（无上一轮池）→ 仅幸存者，无降级", () => {
+  const r = mergeHealthyWithHysteresis(["A", "B"], [], {}, 2);
+  assert.deepEqual(r.nodes, ["A", "B"]);
+  assert.deepEqual(r.degraded, {});
+});
+
+await check("本轮失败第 1 轮 → 保留 + 计数 1，排幸存者之后", () => {
+  // 上一轮池 [A,B,C]，本轮只有 A 可达：B/C 首次失败，保留观察
+  const r = mergeHealthyWithHysteresis(["A"], ["A", "B", "C"], {}, 2);
+  assert.deepEqual(r.nodes, ["A", "B", "C"]); // 幸存者在前、降级在后（B/C 保持原相对序）
+  assert.deepEqual(r.degraded, { B: 1, C: 1 });
+});
+
+await check("连续第 2 轮失败（prevDegraded=1）→ 除名", () => {
+  // B 上一轮已失败 1 次，本轮再失败 → 达到 maxRounds=2，除名；C 首次失败保留
+  const r = mergeHealthyWithHysteresis(["A"], ["A", "B", "C"], { B: 1 }, 2);
+  assert.deepEqual(r.nodes, ["A", "C"]);
+  assert.deepEqual(r.degraded, { C: 1 });
+  assert.ok(!("B" in r.degraded));
+});
+
+await check("降级后恢复 → 计数自动清零", () => {
+  // C 上轮降级（计数 1），本轮恢复 → 回到幸存者区，degraded 中无 C；
+  // B 本轮首次失败，照常保留观察
+  const r = mergeHealthyWithHysteresis(
+    ["A", "C"],
+    ["A", "B", "C"],
+    { C: 1 },
+    2,
+  );
+  assert.deepEqual(r.nodes, ["A", "C", "B"]);
+  assert.deepEqual(r.degraded, { B: 1 });
+});
+
+await check("maxRounds=1 → 关闭迟滞（失败即除名）", () => {
+  const r = mergeHealthyWithHysteresis(["A"], ["A", "B"], {}, 1);
+  assert.deepEqual(r.nodes, ["A"]);
+  assert.deepEqual(r.degraded, {});
+});
+
+await check("容错：prev 非法 / prevDegraded 非法", () => {
+  const r = mergeHealthyWithHysteresis(["A"], null, "bad", 2);
+  assert.deepEqual(r.nodes, ["A"]);
+  assert.deepEqual(r.degraded, {});
+});
+
+// ── 文件往返（隔离端口通道，不碰真实 clash-healthy-nodes.json） ──
+
+const TEST_PORT = 64000 + Math.floor(Math.random() * 1000);
+const TEST_FILE = join(tmpdir(), `clash-healthy-nodes-${TEST_PORT}.json`);
+applyDiscovered({ proxyPort: TEST_PORT });
+
+try {
+  await check("saveHealthyList(degraded) → loadHealthyList 读回", () => {
+    saveHealthyList(
+      ["🇺🇸美国HY1", "🇬🇧英国HY1"],
+      { "🇺🇸美国HY1": 800 },
+      { "🇬🇧英国HY1": 1 },
+    );
+    const d = loadHealthyList();
+    assert.deepEqual(d.nodes, ["🇺🇸美国HY1", "🇬🇧英国HY1"]);
+    assert.equal(d.delays["🇺🇸美国HY1"], 800);
+    assert.equal(d.degraded["🇬🇧英国HY1"], 1);
+  });
+
+  await check("pruneHealthyListByCurrentProxies 携带留存节点的 degraded", () => {
+    // 内核中只剩美国节点：英国被剔除，美国的降级计数（若有）应保留
+    saveHealthyList(
+      ["🇺🇸美国HY1", "🇺🇸美国HY2", "🇬🇧英国HY1"],
+      { "🇺🇸美国HY1": 800 },
+      { "🇺🇸美国HY2": 1, "🇬🇧英国HY1": 1 },
+    );
+    const r = pruneHealthyListByCurrentProxies(["🇺🇸美国HY1", "🇺🇸美国HY2"]);
+    assert.equal(r.removed, 1);
+    const d = loadHealthyList();
+    assert.deepEqual(d.nodes, ["🇺🇸美国HY1", "🇺🇸美国HY2"]);
+    assert.equal(d.degraded["🇺🇸美国HY2"], 1);
+    assert.ok(!("🇬🇧英国HY1" in d.degraded));
+  });
+} finally {
+  if (existsSync(TEST_FILE)) unlinkSync(TEST_FILE);
+}
+
+console.log(`\n结果: ${passed} 通过, ${failures.length} 失败`);
+if (failures.length) process.exit(1);

package/scripts/test-client-error-monitor.mjs

@@ -1,28 +1,35 @@
 /**
- * 客户端异常监控单测（2026-08-28）
+ * 客户端异常监控单测（2026-08-28，2026-09-28 增补验证码路径，
+ * 2026-09-29 改为 clientId 本机关联 —— 克隆机 hostname 撞名修复）
  *
  * 验证：
- *   - detectClientError 检测函数：reportCount > 8 且最近一次上报在 2 分钟内
- *   - 按 hostname 过滤本机条目；hostname 为空的旧条目不参与关联
- *   - 命中 → onAlert 收到本机全部条目（含未命中条目）；未命中 → 不回调
+ *   - detectClientError 检测函数：
+ *     A. reportCount > 8 且最近一次上报在 2 分钟内
+ *     B. captchaCount ≥ 3（webserver 验证码上报，10 分钟过期窗口内累计）
+ *   - 按 clientId 过滤本机条目（每台唯一）；hostname 撞名的兄弟机条目、
+ *     无 clientId 的旧条目均不参与关联
+ *   - 命中 → onAlert 收到本机全部条目与命中列表；未命中 → 不回调
  *   - removeErrors 逐条 DELETE 并计数
  *
  * 运行: node --test scripts/test-client-error-monitor.mjs
  */
 import { test, mock } from "node:test";
 import assert from "node:assert/strict";
-import os from "os";
 import {
   detectClientError,
   ClientErrorMonitor,
 } from "../src/watchdog/client-error-monitor.js";
 
-const HOST = os.hostname();
+// 模拟克隆机群：hostname 全部相同（事故现场），clientId 每台唯一
+const CLONED_HOST = "WIN-AADJ1HTCCAQ";
+const CLIENT_ID = `F-9@${CLONED_HOST}`;
+const BROTHER_CLIENT_ID = `F-10@${CLONED_HOST}`;
 
 function makeErr(overrides = {}) {
   return {
     userId: "u1",
-    hostname: HOST,
+    hostname: CLONED_HOST,
+    clientId: CLIENT_ID,
     errorType: "consecutive_blocked",
     reportCount: 10,
     timestamp: Date.now() - 30_000,
@@ -30,6 +37,22 @@ function makeErr(overrides = {}) {
   };
 }
 
+function makeMonitor(opts = {}) {
+  let received = null;
+  let alerted = false;
+  const m = new ClientErrorMonitor({
+    serverUrl: "http://127.0.0.1:3000",
+    hostname: CLONED_HOST, // 仅展示用；关联只认 clientId
+    clientId: CLIENT_ID,
+    onAlert: async (mine, hit) => {
+      alerted = true;
+      received = { mine, hit };
+    },
+    ...opts,
+  });
+  return { m, isAlerted: () => alerted, getReceived: () => received };
+}
+
 // ── 检测函数 ──
 
 test("D1 detectClientError：累计>8 且 2 分钟内 → 命中", () => {
@@ -60,25 +83,83 @@ test("D4 detectClientError：缺 reportCount → 不命中", () => {
   assert.equal(detectClientError({ timestamp: Date.now() }, Date.now()), false);
 });
 
-// ── 监控器 ──
+// ── 验证码路径（captchaCount ≥ 3） ──
+
+test("C1 detectClientError：captchaCount=3 → 命中", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 0, captchaCount: 3 }), Date.now()),
+    true,
+  );
+});
+
+test("C2 detectClientError：captchaCount=2 不命中（阈值是 ≥3）", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 0, captchaCount: 2 }), Date.now()),
+    false,
+  );
+});
+
+test("C3 detectClientError：captchaCount=3 但最近上报超 2 分钟 → 不命中", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({
+        reportCount: 0,
+        captchaCount: 3,
+        timestamp: Date.now() - 2 * 60_000 - 1,
+      }),
+      Date.now(),
+    ),
+    false,
+  );
+});
 
-test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
+test("C4 detectClientError：reportCount 未达标 + captchaCount 达标 → 命中", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 1, captchaCount: 5 }), Date.now()),
+    true,
+  );
+});
+
+test("C5 监控器：验证码条目命中 → onAlert 收到命中列表", async () => {
+  const captchaHit = makeErr({
+    userId: "webserver-host",
+    reportCount: 0,
+    captchaCount: 3,
+  });
+  const businessMiss = makeErr({ userId: "u-task", reportCount: 2 });
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({ clients: [captchaHit, businessMiss] }),
+  }));
+  const { m, getReceived } = makeMonitor();
+  const hit = await m._poll();
+  assert.equal(hit.length, 1, "仅验证码条目命中");
+  assert.equal(hit[0].userId, "webserver-host");
+  assert.equal(getReceived().hit.length, 1);
+  assert.equal(getReceived().mine.length, 2, "回调同时携带本机未命中条目");
+  mock.restoreAll();
+});
+
+// ── 监控器：本机关联（clientId） ──
+
+test("M1 按 clientId 过滤：撞名兄弟机条目不触发本机回调", async () => {
+  // 克隆机事故回归：F-10 与 F-9 hostname 完全相同，仅 clientId 不同
   mock.method(globalThis, "fetch", async () => ({
     ok: true,
     json: async () => ({
-      clients: [makeErr({ hostname: "OTHER-MACHINE" })],
+      clients: [
+        makeErr({
+          userId: "F-10-8222-1",
+          clientId: BROTHER_CLIENT_ID,
+          captchaCount: 3,
+          reportCount: 0,
+        }),
+      ],
     }),
   }));
-  let alerted = false;
-  const m = new ClientErrorMonitor({
-    serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
-    onAlert: async () => {
-      alerted = true;
-    },
-  });
+  const { m, isAlerted } = makeMonitor();
   const hit = await m._poll();
-  assert.equal(alerted, false, "他机异常不应回调");
+  assert.equal(isAlerted(), false, "兄弟机异常不应触发本机回调/强切");
   assert.equal(hit, null, "无本机条目应返回 null");
   mock.restoreAll();
 });
@@ -86,51 +167,62 @@ test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
 test("M2 命中：onAlert 收到本机全部条目（含未命中条目）", async () => {
   const mineHit = makeErr({ userId: "u-hit", reportCount: 10 });
   const mineMiss = makeErr({ userId: "u-miss", reportCount: 2 });
-  const other = makeErr({ userId: "u-other", hostname: "OTHER-MACHINE" });
+  const other = makeErr({
+    userId: "u-other",
+    clientId: BROTHER_CLIENT_ID, // hostname 相同，clientId 不同
+  });
   mock.method(globalThis, "fetch", async () => ({
     ok: true,
     json: async () => ({ clients: [mineHit, mineMiss, other] }),
   }));
-  let received = null;
-  const m = new ClientErrorMonitor({
-    serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
-    onAlert: async (mine, hit) => {
-      received = { mine, hit };
-    },
-  });
+  const { m, getReceived } = makeMonitor();
   const hit = await m._poll();
   assert.equal(hit.length, 1, "命中 1 条");
   assert.equal(hit[0].userId, "u-hit");
-  assert.equal(received.mine.length, 2, "回调收到本机全部 2 条");
+  assert.equal(getReceived().mine.length, 2, "回调收到本机全部 2 条");
   assert.deepEqual(
-    received.mine.map((e) => e.userId).sort(),
+    getReceived()
+      .mine.map((e) => e.userId)
+      .sort(),
     ["u-hit", "u-miss"],
     "回调含命中与未命中的本机条目",
   );
   mock.restoreAll();
 });
 
-test("M3 hostname 为空的旧条目不参与本机关联", async () => {
+test("M3 无 clientId 的旧条目不参与本机关联（宁漏不误）", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({
+      clients: [makeErr({ clientId: "", reportCount: 99 })],
+    }),
+  }));
+  const { m, isAlerted } = makeMonitor();
+  const hit = await m._poll();
+  assert.equal(isAlerted(), false, "旧版上报条目不应触发强切");
+  assert.equal(hit, null);
+  mock.restoreAll();
+});
+
+test("M4 未配置 clientId 的监控器：不匹配任何条目", async () => {
   mock.method(globalThis, "fetch", async () => ({
     ok: true,
-    json: async () => ({ clients: [makeErr({ hostname: "" })] }),
+    json: async () => ({ clients: [makeErr({ reportCount: 99 })] }),
   }));
   let alerted = false;
   const m = new ClientErrorMonitor({
     serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
     onAlert: async () => {
       alerted = true;
     },
   });
   const hit = await m._poll();
-  assert.equal(alerted, false, "空 hostname 旧条目不应回调");
+  assert.equal(alerted, false, "clientId 未配置时监控不生效");
   assert.equal(hit, null);
   mock.restoreAll();
 });
 
-test("M4 removeErrors：逐条 DELETE 并计数", async () => {
+test("M5 removeErrors：逐条 DELETE 并计数", async () => {
   const deleted = [];
   mock.method(globalThis, "fetch", async (url, opts) => {
     if (opts && opts.method === "DELETE") {
@@ -157,20 +249,13 @@ test("M4 removeErrors：逐条 DELETE 并计数", async () => {
   mock.restoreAll();
 });
 
-test("M5 拉取失败静默：fetch 抛错不回调不崩溃", async () => {
+test("M6 拉取失败静默：fetch 抛错不回调不崩溃", async () => {
   mock.method(globalThis, "fetch", async () => {
     throw new Error("ECONNREFUSED");
   });
-  let alerted = false;
-  const m = new ClientErrorMonitor({
-    serverUrl: "http://127.0.0.1:3000",
-    hostname: HOST,
-    onAlert: async () => {
-      alerted = true;
-    },
-  });
+  const { m, isAlerted } = makeMonitor();
   const hit = await m._poll();
-  assert.equal(alerted, false);
+  assert.equal(isAlerted(), false);
   assert.equal(hit, null);
   mock.restoreAll();
 });

package/scripts/test-webserver-error-classify.mjs

@@ -244,6 +244,36 @@ check("switchClashNode：选第一个 delay 通过的候选并切换", async ()
   }
 });
 
+check("switchClashNode：批量测速（/group/{G}/delay）优先且覆盖候选时不逐个探测", async () => {
+  let switchedTo = null;
+  let perNodeDelayCalls = 0;
+  const server = await startMockClash((req, url, body, reply) => {
+    if (req.method === "GET" && url.pathname === "/proxies/GLOBAL") {
+      reply(200, { now: "A", all: ["A", "B", "C"] });
+    } else if (req.method === "GET" && url.pathname === "/group/GLOBAL/delay") {
+      reply(200, { B: 88, C: 999 });
+    } else if (req.method === "GET" && url.pathname.endsWith("/delay")) {
+      perNodeDelayCalls++; // 批量可用时不应走到这里
+      reply(200, { delay: 120, timeout: false });
+    } else if (req.method === "PUT" && url.pathname === "/proxies/GLOBAL") {
+      switchedTo = body.name;
+      reply(204);
+    } else {
+      reply(404, {});
+    }
+  });
+  configure({ port: server.address().port });
+  try {
+    const picked = await switchClashNode("测试批量优先");
+    assert.equal(picked, "B");
+    assert.equal(switchedTo, "B");
+    assert.equal(perNodeDelayCalls, 0);
+  } finally {
+    resetConfig();
+    await new Promise((r) => server.close(r));
+  }
+});
+
 check("switchClashNode：候选均探测不通 → 抛错", async () => {
   const server = await startMockClash((req, url, body, reply) => {
     if (req.method === "GET" && url.pathname === "/proxies/GLOBAL") {

package/src/clash/checker.js

@@ -461,17 +461,23 @@ export function loadHealthyList(country = null) {
       isUsableProxyNode,
     );
     const allDelays = d.delays && typeof d.delays === "object" ? d.delays : {};
+    const degradedRaw =
+      d.degraded && typeof d.degraded === "object" ? d.degraded : {};
     const filter = country || CONFIG.nodeCountryFilter;
     const { filtered, excluded } = filterNodesByCountry(allNodes, filter);
     const delays = {};
+    const degraded = {};
     for (const n of filtered) {
       const v = allDelays[n];
       if (typeof v === "number" && v > 0) delays[n] = v;
+      const g = degradedRaw[n];
+      if (typeof g === "number" && g > 0) degraded[n] = g;
     }
     return {
       updated: d.updated || "",
       nodes: filtered,
       delays,
+      degraded,
       totalNodes: allNodes.length,
       excluded,
       countryFilter: filter || null,
@@ -482,12 +488,17 @@ export function loadHealthyList(country = null) {
   return _emptyList();
 }
 
-export function saveHealthyList(nodes, delays = {}) {
+export function saveHealthyList(nodes, delays = {}, degraded = {}) {
   try {
     writeFileSync(
       _healthyFile,
       JSON.stringify(
-        { updated: new Date().toISOString(), nodes, delays: delays || {} },
+        {
+          updated: new Date().toISOString(),
+          nodes,
+          delays: delays || {},
+          degraded: degraded || {},
+        },
         null,
         2,
       ),
@@ -498,6 +509,42 @@ export function saveHealthyList(nodes, delays = {}) {
   }
 }
 
+/**
+ * 候选集迟滞合并（纯函数，便于单测）
+ *
+ * 背景：delay 初测为单点采样，瞬时抖动会把健康节点误踢出池（2026-09-28 生产实锤：
+ * 英国节点被白名单守卫切回）。规则：连续 maxRounds 轮初测失败才除名；失败第 1 轮
+ * 保留在池内作"降级观察"，且排在幸存者之后（写盘顺序即沉底，轮换优先尝试实测存活节点）。
+ *
+ * @param {string[]} survivors 本轮初测幸存者（delay ≤ 阈值，升序）
+ * @param {string[]} prevNodes 上一轮池内节点（含上轮降级保留）
+ * @param {Record<string,number>} prevDegraded 上一轮降级计数 {node: 连续失败轮数}
+ * @param {number} maxRounds 连续失败轮数上限（达到即除名），默认 2；1 = 关闭迟滞
+ * @returns {{nodes: string[], degraded: Record<string, number>}} 合并后的池
+ *   （幸存者在前、降级保留在后）与新降级计数；本轮恢复的节点计数自动清零
+ */
+export function mergeHealthyWithHysteresis(
+  survivors,
+  prevNodes,
+  prevDegraded = {},
+  maxRounds = 2,
+) {
+  const list = Array.isArray(survivors) ? survivors : [];
+  const survivorSet = new Set(list);
+  const degraded = {};
+  const retained = [];
+  for (const n of Array.isArray(prevNodes) ? prevNodes : []) {
+    if (survivorSet.has(n)) continue; // 本轮存活：不进新 degraded，计数自动清零
+    const fails = (Number(prevDegraded[n]) || 0) + 1;
+    if (fails < maxRounds) {
+      degraded[n] = fails;
+      retained.push(n);
+    }
+    // fails >= maxRounds：连续多轮失败，确认除名
+  }
+  return { nodes: [...list, ...retained], degraded };
+}
+
 /**
  * 剔除候选集中已不在当前内核配置中的节点（订阅切换 / 订阅更新场景）
  *
@@ -516,6 +563,8 @@ export function pruneHealthyListByCurrentProxies(validNames) {
     const d = JSON.parse(readFileSync(_healthyFile, "utf-8"));
     const allNodes = Array.isArray(d.nodes) ? d.nodes : [];
     const allDelays = d.delays && typeof d.delays === "object" ? d.delays : {};
+    const degradedRaw =
+      d.degraded && typeof d.degraded === "object" ? d.degraded : {};
     const valid = new Set(validNames);
     const keptNodes = allNodes.filter((n) => valid.has(n));
     const removed = allNodes.length - keptNodes.length;
@@ -523,11 +572,14 @@ export function pruneHealthyListByCurrentProxies(validNames) {
       return { kept: keptNodes.length, removed: 0, allGone: false };
     }
     const keptDelays = {};
+    const keptDegraded = {};
     for (const n of keptNodes) {
       const v = allDelays[n];
       if (typeof v === "number" && v > 0) keptDelays[n] = v;
+      const g = degradedRaw[n];
+      if (typeof g === "number" && g > 0) keptDegraded[n] = g;
     }
-    saveHealthyList(keptNodes, keptDelays);
+    saveHealthyList(keptNodes, keptDelays, keptDegraded);
     return {
       kept: keptNodes.length,
       removed,
@@ -544,6 +596,7 @@ function _emptyList() {
     updated: "",
     nodes: [],
     delays: {},
+    degraded: {},
     totalNodes: 0,
     excluded: 0,
     countryFilter: null,

package/src/clash/daemon.js

@@ -24,6 +24,10 @@ function fmtCountries(v) {
 // failover 冷却期（默认 10 分钟，与候选集 delay 初测周期对齐；可经 opts.failoverCooldownMs 覆盖）
 // 锚点 = 最近一次实际切换节点的时间（_lastSwitchAt）：冷却期内探针健康不切换
 const FAILOVER_COOLDOWN_MS = 600_000;
+// 候选集迟滞（2026-09-28）：delay 初测为单点采样，瞬时抖动会把健康节点误踢出池
+// （生产实锤：英国节点被白名单守卫切回）。连续 PROBE_HYSTERESIS_ROUNDS 轮初测失败
+// 才除名；失败第 1 轮保留在池内作"降级观察"，写盘时排在幸存者之后（轮换优先实测存活）
+const PROBE_HYSTERESIS_ROUNDS = 2;
 // 已弃用（2026-08-25 改为时间锚点方案）：旧版"窗口内连报 N 次"计数，字段保留仅为兼容外部传参
 const FAILOVER_ESCAPE_AFTER = 3;
 
@@ -972,10 +976,20 @@ export class ClashDaemon {
         if (typeof it.delay === "number" && it.delay > 0)
           delays[it.node] = it.delay;
       }
-      checker.saveHealthyList(r.nodes, delays);
+      // 迟滞合并：本轮失败的上一轮池内节点保留一轮观察（降级沉底），
+      // 连续 PROBE_HYSTERESIS_ROUNDS 轮失败才除名；恢复的节点计数自动清零
+      const prev = checker.loadHealthyList();
+      const merged = checker.mergeHealthyWithHysteresis(
+        r.nodes,
+        prev.nodes,
+        prev.degraded,
+        PROBE_HYSTERESIS_ROUNDS,
+      );
+      checker.saveHealthyList(merged.nodes, delays, merged.degraded);
+      const retainedCount = merged.nodes.length - r.nodes.length;
       // 清理切换历史中已不在候选集的节点，防止 Map 无限增长
       if (c._switchHistory && c._switchHistory.size) {
-        const keep = new Set(r.nodes);
+        const keep = new Set(merged.nodes);
         for (const k of [...c._switchHistory.keys()]) {
           if (!keep.has(k)) c._switchHistory.delete(k);
         }
@@ -985,7 +999,7 @@ export class ClashDaemon {
       c._meta.healthyNodesCount = r.nodes.length;
       if (r.nodes.length) {
         this._log(
-          `=== [${c.proxyPort}] delay 初测完成 (${elapsed}s): ${r.nodes.length} 个可达节点 ===`,
+          `=== [${c.proxyPort}] delay 初测完成 (${elapsed}s): ${r.nodes.length} 个可达${retainedCount ? `（另降级保留 ${retainedCount} 个）` : ""} ===`,
         );
       } else {
         this._log(

package/src/clash/proxy-switch.js

@@ -37,12 +37,16 @@ export function isDaemonAlive(port = 0) {
  * @param {string} reason 切换原因
  * @param {number} [proxyPort] 代理通道端口（0=默认通道）
  * @param {number} [waitMs] 等待毫秒数，默认 30000
+ * @param {object} [opts]
+ * @param {boolean} [opts.force] 强切（无视 daemon failover 冷却期直接轮换）；
+ *   供调用方已自行节流的场景（如 webserver CDN 自愈：100s 冷却+5min 窗口+次数上限）
  * @returns {boolean} 是否发起了切换（有代理端口）
  */
 export async function triggerProxySwitch(
   reason,
   proxyPort = 0,
   waitMs = DEFAULT_SWITCH_WAIT_MS,
+  { force = false } = {},
 ) {
   if (!proxyPort) {
     console.error(`  [代理] 未配置代理，跳过切换（${reason}）`);
@@ -57,7 +61,7 @@ export async function triggerProxySwitch(
     `  [代理] 触发切换（${reason}，通道 ${proxyPort}），等待 ${Math.round(waitMs / 1000)}s 生效...`,
   );
   writeCommand(
-    { action: "failover", reason: `proxy-switch: ${reason}`, proxyPort },
+    { action: "failover", reason: `proxy-switch: ${reason}`, proxyPort, force },
     proxyPort,
   );
   await new Promise((r) => setTimeout(r, waitMs));