tt-help-cli-ycl 1.4.140 → 1.4.144

package/package.json

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

package/scripts/sync-raw-jobs.mjs

@@ -15,13 +15,16 @@ import Database from "better-sqlite3";
 import { initDb, getDb } from "../src/watch/db-schema.js";
 import { loadLlmConfig, reloadLlmConfig } from "../src/watch/llm-config.js";
 import { scoreJobsBatch } from "../src/watch/llm-scoring.js";
-import { DEFAULT_TARGET_LOCATIONS } from "../src/lib/target-locations.js";
+import { getTargetLocations, reloadConfig } from "../src/lib/app-config.js";
 
 // ═══════════════════════════════════════════════════════════════════
 // 常量
 // ═══════════════════════════════════════════════════════════════════
 
-const LOCATIONS = DEFAULT_TARGET_LOCATIONS;
+// 目标国家：每轮 tick 前 reloadConfig() 重读配置文件，捕捉服务端(设置页)修改
+function currentLocations() {
+  return getTargetLocations();
+}
 
 const FILTER = "video_count>6 AND follower_count>0 AND following_count>0";
 
@@ -161,7 +164,7 @@ const vals = (row, cols) => cols.map((c) => row[c] ?? null);
 const ph = (n) => Array(n).fill("?").join(", ");
 
 /** 构建 WHERE 子句（含国家过滤）。strict=true 时仅匹配明确国家，不含 NULL/空 */
-function buildWhere(locations = LOCATIONS, strict = false) {
+function buildWhere(locations = currentLocations(), strict = false) {
   const locs = [
     ...new Set(
       locations.map((l) => String(l).trim().toUpperCase()).filter(Boolean),
@@ -268,14 +271,14 @@ function countPendingByCountry() {
   const map = {};
   for (const r of rows) map[r.loc] = r.c;
   // 确保所有目标国家都有值
-  for (const loc of LOCATIONS) {
+  for (const loc of currentLocations()) {
     if (!(loc in map)) map[loc] = 0;
   }
   return map;
 }
 
 function findNeedyCountries(byCountry, threshold) {
-  return LOCATIONS.filter((loc) => (byCountry[loc] || 0) < threshold);
+  return currentLocations().filter((loc) => (byCountry[loc] || 0) < threshold);
 }
 
 // ═══════════════════════════════════════════════════════════════════
@@ -335,7 +338,7 @@ async function refillLLM(archiveDb, needyLocations) {
 
     // 2. LLM 打分
     const ts = Date.now();
-    const scores = await scoreJobsBatch(samples, LOCATIONS);
+    const scores = await scoreJobsBatch(samples, currentLocations());
     log("  ", `${loc} 打分${scores.length}条 ${Date.now() - ts}ms`);
 
     if (
@@ -406,6 +409,7 @@ async function tick(archiveDb, opts) {
   const t0 = Date.now();
 
   archiveNewUsers(archiveDb);
+  reloadConfig(); // 每轮重读目标国家配置，支持服务端(设置页)修改
   if (opts.llm) reloadLlmConfig(); // 每轮重载，支持热切换模型
 
   const byCountry = countPendingByCountry();
@@ -414,7 +418,9 @@ async function tick(archiveDb, opts) {
   if (!needy.length) {
     log(
       "--",
-      `轮${tickN} 全部充足 | ${LOCATIONS.map((l) => `${l}:${byCountry[l]}`).join(" ")}`,
+      `轮${tickN} 全部充足 | ${currentLocations()
+        .map((l) => `${l}:${byCountry[l]}`)
+        .join(" ")}`,
     );
     return;
   }

package/scripts/test-api-interceptor-429.mjs

@@ -0,0 +1,122 @@
+// 临时验证：fetchUserVideosAPI 对 HTTP 429 / ratelimit triggered 判定为"被封"
+// 运行：RM_BLOCKED_WAIT_MS=1 node scripts/test-api-interceptor-429.mjs
+import { fetchUserVideosAPI } from "../src/lib/api-interceptor.js";
+
+// 构造一个可被 waitForResponse 返回的 429 响应
+function make429Response() {
+  return {
+    url: () => "https://www.tiktok.com/api/post/item_list/?...",
+    status: () => 429,
+    headers: () => ({ "content-length": "19" }),
+    json: async () => {
+      throw new Error("Unexpected token 'r'...");
+    },
+    body: async () => Buffer.from("ratelimit triggered"),
+  };
+}
+
+// 构造一个正常响应（itemList 非空）
+function make200Response(username) {
+  const itemList = [
+    { id: "111", stats: { playCount: 1 }, isECVideo: 0, isAd: 0 },
+  ];
+  return {
+    url: () => "https://www.tiktok.com/api/post/item_list/?...",
+    status: () => 200,
+    headers: () => ({}),
+    json: async () => ({ itemList, cursor: 0, hasMore: false }),
+    body: async () => Buffer.from(JSON.stringify({ itemList })),
+    username,
+  };
+}
+
+// 构造 mock page：封禁场景时 waitForResponse 返回 429 响应
+function makePage(username, respFactory) {
+  const page = {
+    _handlers: {},
+    on(event, fn) {
+      (page._handlers[event] ||= []).push(fn);
+      return page;
+    },
+    off(event) {
+      delete page._handlers[event];
+      return page;
+    },
+    url: () => `https://www.tiktok.com/@${username}`,
+    goto: async () => {},
+    // checkCdpHealth 用 () => document.readyState（fn.length===0）→ 返回 "complete"；
+    // detectPageError 用 (patterns)=>...（fn.length===1）→ 返回 null（页面无错误文案）
+    evaluate: async (fn) => (fn.length === 1 ? null : "complete"),
+    reload: async () => {},
+    waitForFunction: async () => null,
+    waitForResponse: async (pred, opts) => {
+      const resp = respFactory();
+      if (!pred(resp)) throw new Error("response 不匹配 item_list");
+      return resp;
+    },
+  };
+  return page;
+}
+
+let pass = 0;
+let fail = 0;
+
+async function expectReject(name, fn, expectedMsg) {
+  try {
+    await fn();
+    fail++;
+    console.error(`✗ ${name}: 未抛错（期望 "${expectedMsg}"）`);
+  } catch (e) {
+    if (e.message === expectedMsg || e.message.includes(expectedMsg)) {
+      pass++;
+      console.log(`✓ ${name}: 抛错 "${e.message}"`);
+    } else {
+      fail++;
+      console.error(
+        `✗ ${name}: 抛错 "${e.message}"（期望含 "${expectedMsg}"）`,
+      );
+    }
+  }
+}
+
+async function expectResolve(name, fn) {
+  try {
+    const r = await fn();
+    if (r instanceof Map && r.size === 1) {
+      pass++;
+      console.log(`✓ ${name}: 正常返回 ${r.size} 个视频`);
+    } else {
+      fail++;
+      console.error(`✗ ${name}: 返回异常 ${JSON.stringify(r)}`);
+    }
+  } catch (e) {
+    fail++;
+    console.error(`✗ ${name}: 抛错 ${e.message}`);
+  }
+}
+
+// 用例1：429 + ratelimit triggered → 判定为"被封"
+await expectReject(
+  "HTTP 429 ratelimit triggered 判为被封",
+  () =>
+    fetchUserVideosAPI(
+      makePage("fumolbbf08o", make429Response),
+      "fumolbbf08o",
+      5,
+      () => {},
+    ),
+  "被封: fumolbbf08o",
+);
+
+// 用例2：正常 200 itemList → 不误判，正常返回视频
+await expectResolve("HTTP 200 正常 itemList 不被误伤", () =>
+  fetchUserVideosAPI(
+    makePage("fumolbbf08o", make200Response),
+    "fumolbbf08o",
+    5,
+    () => {},
+  ),
+);
+
+console.log(`\n结果: ${pass} 通过, ${fail} 失败`);
+process.exit(fail > 0 ? 1 : 0);

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

@@ -0,0 +1,176 @@
+/**
+ * 客户端异常监控单测（2026-08-28）
+ *
+ * 验证：
+ *   - detectClientError 检测函数：reportCount > 8 且最近一次上报在 2 分钟内
+ *   - 按 hostname 过滤本机条目；hostname 为空的旧条目不参与关联
+ *   - 命中 → 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();
+
+function makeErr(overrides = {}) {
+  return {
+    userId: "u1",
+    hostname: HOST,
+    errorType: "consecutive_blocked",
+    reportCount: 10,
+    timestamp: Date.now() - 30_000,
+    ...overrides,
+  };
+}
+
+// ── 检测函数 ──
+
+test("D1 detectClientError：累计>8 且 2 分钟内 → 命中", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 9 }), Date.now()),
+    true,
+  );
+});
+
+test("D2 detectClientError：reportCount=8 不命中（阈值是 >8）", () => {
+  assert.equal(
+    detectClientError(makeErr({ reportCount: 8 }), Date.now()),
+    false,
+  );
+});
+
+test("D3 detectClientError：最近上报超过 2 分钟 → 不命中", () => {
+  assert.equal(
+    detectClientError(
+      makeErr({ timestamp: Date.now() - 2 * 60_000 - 1 }),
+      Date.now(),
+    ),
+    false,
+  );
+});
+
+test("D4 detectClientError：缺 reportCount → 不命中", () => {
+  assert.equal(detectClientError({ timestamp: Date.now() }, Date.now()), false);
+});
+
+// ── 监控器 ──
+
+test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({
+      clients: [makeErr({ hostname: "OTHER-MACHINE" })],
+    }),
+  }));
+  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, "他机异常不应回调");
+  assert.equal(hit, null, "无本机条目应返回 null");
+  mock.restoreAll();
+});
+
+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" });
+  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 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.deepEqual(
+    received.mine.map((e) => e.userId).sort(),
+    ["u-hit", "u-miss"],
+    "回调含命中与未命中的本机条目",
+  );
+  mock.restoreAll();
+});
+
+test("M3 hostname 为空的旧条目不参与本机关联", async () => {
+  mock.method(globalThis, "fetch", async () => ({
+    ok: true,
+    json: async () => ({ clients: [makeErr({ hostname: "" })] }),
+  }));
+  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(hit, null);
+  mock.restoreAll();
+});
+
+test("M4 removeErrors：逐条 DELETE 并计数", async () => {
+  const deleted = [];
+  mock.method(globalThis, "fetch", async (url, opts) => {
+    if (opts && opts.method === "DELETE") {
+      deleted.push(String(url));
+      return { ok: true };
+    }
+    return { ok: true, json: async () => ({ clients: [] }) };
+  });
+  const m = new ClientErrorMonitor({ serverUrl: "http://127.0.0.1:3000" });
+  const removed = await m.removeErrors([
+    { userId: "a" },
+    { userId: "b" },
+    { userId: "" },
+    null,
+  ]);
+  assert.equal(removed, 2, "有效 userId 各删一条");
+  assert.equal(deleted.length, 2, "共 2 次 DELETE");
+  assert.ok(
+    deleted.every((u) =>
+      ["a", "b"].some((id) => u.endsWith(`/api/client-error/${id}`)),
+    ),
+    "DELETE 路径正确",
+  );
+  mock.restoreAll();
+});
+
+test("M5 拉取失败静默：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 hit = await m._poll();
+  assert.equal(alerted, false);
+  assert.equal(hit, null);
+  mock.restoreAll();
+});

package/scripts/test-daemon-failover.mjs

@@ -5,6 +5,7 @@
  *   - 探针不健康 → 立即切换（无视冷却）
  *   - 探针健康（含壳页）→ 距上次切换 < 冷却期仅检查不切换
  *   - 探针健康 → 距上次切换 >= 冷却期 → 按业务级封禁轮换一次
+ *   - 强切（force=true）→ 探针健康且冷却期内仍强制轮换
  *   - 切换后（含手动/巡检/failover）更新 _lastSwitchAt 锚点，冷却期内不再切
  *   - 候选集为空 → 触发 delay 初测且不切换
  *
@@ -229,3 +230,15 @@ test("F9 disconnectMode=full：直接全断", async () => {
   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,
+    "强切后应更新锚点（给新节点观察期）",
+  );
+});

package/scripts/test-proxy-switch-restart.mjs

@@ -0,0 +1,198 @@
+/**
+ * 代理切换 → watchdog 强制重启命令 链路测试（2026-08-28，先打通路版本）
+ *
+ * 验证：
+ *   T1  daemon _markSwitchTime 递增 restartSeq（首次为 1，连续递增）
+ *   T2  daemon _writeHealth 把 restartSeq 带进 health 文件
+ *   T3  daemon 未切换时 restartSeq 保持 0
+ *   T4  ProcessManager.restartAll 先停后起（真实子进程，pid 变化、数量恢复）
+ *   T5  restartAll 跳过 stopped / 无 child 的命令
+ *   T6  无运行命令时 restartAll 返回 {restarted:0}
+ *   T7  Agent._checkProxySwitch 首次读取仅建基线不触发
+ *   T8  health.restartSeq 变大 → 触发强制重启（真实子进程 pid 变化）
+ *   T9  health.restartSeq 变小（daemon 重启归零）→ 不触发
+ *   T10 通道重启：主文件 seq 不变时不触发
+ *
+ * 运行: node --test scripts/test-proxy-switch-restart.mjs
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const HEALTH_FILE = join(tmpdir(), "clash-health.json");
+
+/** 清理并写 health 文件（模拟 daemon 写入） */
+function writeHealthFile(extra) {
+  writeFileSync(
+    HEALTH_FILE,
+    JSON.stringify(
+      {
+        node: "🇺🇸 美国01",
+        healthy: true,
+        lastCheck: new Date().toISOString(),
+        ...extra,
+      },
+      null,
+      2,
+    ),
+  );
+}
+
+/** 生成一个常驻假命令（测试业务进程） */
+function fakeCmd(id) {
+  return {
+    id,
+    name: id,
+    command: process.execPath,
+    args: ["-e", "setInterval(()=>{},1000)"],
+    enabled: true,
+  };
+}
+
+function cleanup() {
+  try {
+    rmSync(HEALTH_FILE, { force: true });
+  } catch {}
+}
+
+test("T1-T3: daemon 切换信号（_markSwitchTime 递增 + _writeHealth 带出）", async () => {
+  const { ClashDaemon } = await import("../src/clash/daemon.js");
+  const ipc = await import("../src/clash/ipc.js");
+  cleanup();
+  try {
+    const d = new ClashDaemon({ dryRun: true });
+    const c = { proxyPort: 0 };
+
+    // T3: 未切换 → restartSeq = 0
+    d._writeHealth(c, { node: "A", healthy: true });
+    let h = ipc.readHealth(0);
+    assert.equal(h.restartSeq, 0, "未切换时 restartSeq 应为 0");
+
+    // T1: 首次切换 → 1
+    d._markSwitchTime(c);
+    assert.equal(c._restartSeq, 1, "首次切换 restartSeq 应为 1");
+    d._markSwitchTime(c);
+    assert.equal(c._restartSeq, 2, "连续切换 restartSeq 递增");
+
+    // T2: _writeHealth 带出 restartSeq
+    d._writeHealth(c, { node: "B", healthy: true, lastSwitch: "A → B" });
+    h = ipc.readHealth(0);
+    assert.equal(h.restartSeq, 2, "health 文件应携带 restartSeq=2");
+    assert.equal(h.lastSwitch, "A → B");
+  } finally {
+    cleanup();
+  }
+});
+
+test("T4-T6: ProcessManager.restartAll 先停后起", async () => {
+  const { ProcessManager } = await import("../src/watchdog/process-manager.js");
+  const pm = new ProcessManager();
+  try {
+    // T6: 空集
+    const empty = await pm.restartAll("测试");
+    assert.deepEqual(empty, { restarted: 0 }, "无运行命令应返回 0");
+
+    pm.startCommand(fakeCmd("proc-a"));
+    await new Promise((r) => setTimeout(r, 500));
+    assert.equal(pm.runningCount, 1);
+    const oldPid = pm.processes.get("proc-a").child.pid;
+
+    // T4: 先停后起，pid 变化、数量恢复
+    const r = await pm.restartAll("代理切换(测试)");
+    assert.equal(r.restarted, 1, "应重启 1 个命令");
+    assert.equal(pm.runningCount, 1, "重启后数量恢复");
+    const newPid = pm.processes.get("proc-a").child.pid;
+    assert.notEqual(newPid, oldPid, "重启后应是新进程（pid 不同）");
+
+    // T5: stopped 的命令不参与重启
+    pm.startCommand(fakeCmd("proc-b"));
+    await new Promise((r) => setTimeout(r, 500));
+    pm.stopCommand("proc-b");
+    const r2 = await pm.restartAll("二次重启");
+    assert.equal(r2.restarted, 1, "只重启 running 的 1 个，stopped 的不算");
+    assert.equal(pm.runningCount, 1);
+    assert.ok(!pm.processes.has("proc-b"), "proc-b 保持停止状态");
+  } finally {
+    pm.stopAll();
+  }
+});
+
+test("T7-T13: Agent._checkProxySwitch 感知切换（默认禁用，开启后才重启）", async () => {
+  const { WatchdogAgent } = await import("../src/watchdog/agent.js");
+  cleanup();
+  const agent = new WatchdogAgent({
+    serverUrl: "http://127.0.0.1:9",
+    clientId: "test-switch",
+    intervalMs: 60000,
+    spawnDaemon: false,
+  });
+  try {
+    // 准备一个运行中的假业务命令
+    agent.processManager.startCommand(fakeCmd("proc-c"));
+    await new Promise((r) => setTimeout(r, 500));
+    const pid0 = agent.processManager.processes.get("proc-c").child.pid;
+
+    // T7: 首次读取建基线，不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "首次读取仅建基线，不应重启",
+    );
+
+    // T10: seq 不变不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "初始化" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "seq 不变不应重启",
+    );
+
+    // T11: 默认禁用时 seq 变大 → 不触发（但基线已跟随更新）
+    writeHealthFile({ restartSeq: 1, lastSwitch: "禁用期间切换: A → B" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "默认禁用时检测到切换也不应重启",
+    );
+
+    // T12: 开启开关后，seq 仍为 1（无新切换）→ 不补触发历史切换
+    agent._applySwitchRestartConfig({ enabled: true });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid0,
+      "开启开关后不应补触发开启前的历史切换",
+    );
+
+    // T8: 开启后 seq 1→2 → 触发强制重启
+    writeHealthFile({ restartSeq: 2, lastSwitch: "开启后切换: B → C" });
+    await agent._checkProxySwitch();
+    const pid1 = agent.processManager.processes.get("proc-c").child.pid;
+    assert.notEqual(pid1, pid0, "开启后检测到切换应强制重启（pid 变化）");
+    assert.equal(agent.processManager.runningCount, 1, "重启后数量恢复");
+
+    // T9: seq 变小（daemon 重启归零）→ 不触发
+    writeHealthFile({ restartSeq: 0, lastSwitch: "daemon 重启" });
+    await agent._checkProxySwitch();
+    assert.equal(
+      agent.processManager.processes.get("proc-c").child.pid,
+      pid1,
+      "seq 变小（daemon 重启归零）不应触发",
+    );
+
+    // T13: 归零后再次真实切换（0 → 1）应重新触发
+    writeHealthFile({ restartSeq: 1, lastSwitch: "再次切换: C → D" });
+    await agent._checkProxySwitch();
+    const pid2 = agent.processManager.processes.get("proc-c").child.pid;
+    assert.notEqual(pid2, pid1, "归零后再次切换应重新触发");
+  } finally {
+    await agent.stop();
+    cleanup();
+  }
+});

package/src/clash/daemon.js

@@ -104,7 +104,11 @@ export class ClashDaemon {
 
   /** 记录最近一次实际切换节点的时间（failover/巡检/手动切换共用锚点，冷却期判断依据） */
   _markSwitchTime(c) {
-    if (c) c._lastSwitchAt = Date.now();
+    if (!c) return;
+    c._lastSwitchAt = Date.now();
+    // 切换通知序号：每次实际切换 +1，watchdog 感知变化后强制重启全部命令
+    // （先打通路：发现切了就重启；冷却/开关等控制后续再加）
+    c._restartSeq = (c._restartSeq || 0) + 1;
   }
 
   /**
@@ -191,7 +195,12 @@ export class ClashDaemon {
 
   /** 写通道健康状态（每端口一份；主控制端额外写默认文件兼容 watchdog） */
   _writeHealth(c, state) {
-    const payload = { ...state, meta: this._buildMeta(c) };
+    const payload = {
+      ...state,
+      // 切换通知序号（每次实际切换 +1，watchdog 比较变化感知切换）
+      restartSeq: (c && c._restartSeq) || 0,
+      meta: this._buildMeta(c),
+    };
     ipc.writeHealth(payload, c.proxyPort || 0);
     if (c === this._primary && c.proxyPort) ipc.writeHealth(payload, 0);
   }
@@ -667,21 +676,28 @@ export class ClashDaemon {
     try {
       const reason = (cmd && cmd.reason) || "看门狗主动故障切换";
       const now = Date.now();
+      // 强切（force=true，看门狗客户端异常监控触发）：无视冷却期直接轮换；
+      // 切换成功后仍更新 _lastSwitchAt 锚点，给新节点干净观察期
+      const force = !!(cmd && cmd.force);
 
       // 第 1 级：先检查当前节点（壳页 = 链路正常，按健康对待，与巡检口径一致）
       const h = checker.checkNodeHealth();
       const probeOk = !!h && (h.healthy || this._isShellPage(h));
       if (probeOk) {
-        // 探针健康：受冷却期约束（锚点 = 最近一次实际切换节点的时间 _lastSwitchAt）
-        const gap = now - (c._lastSwitchAt || 0);
-        if (gap < this.failoverCooldownMs) {
-          this._log(
-            `🔄 [${c.proxyPort}] 探针健康，距上次切换 ${Math.round(gap / 1000)}s（<${this.failoverCooldownMs / 60000}min 冷却），仅检查不切换 [${reason}]`,
-          );
-          return;
+        if (!force) {
+          // 探针健康：受冷却期约束（锚点 = 最近一次实际切换节点的时间 _lastSwitchAt）
+          const gap = now - (c._lastSwitchAt || 0);
+          if (gap < this.failoverCooldownMs) {
+            this._log(
+              `🔄 [${c.proxyPort}] 探针健康，距上次切换 ${Math.round(gap / 1000)}s（<${this.failoverCooldownMs / 60000}min 冷却），仅检查不切换 [${reason}]`,
+            );
+            return;
+          }
         }
         this._log(
-          `🔄 [${c.proxyPort}] 探针健康但业务持续报错，距上次切换已过冷却期，按业务级封禁轮换 [${reason}]`,
+          force
+            ? `🔄 [${c.proxyPort}] 强切指令（无视冷却），按业务级封禁轮换 [${reason}]`
+            : `🔄 [${c.proxyPort}] 探针健康但业务持续报错，距上次切换已过冷却期，按业务级封禁轮换 [${reason}]`,
         );
       } else {
         this._log(