tt-help-cli-ycl 1.4.165 → 1.4.167

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.165",
+  "version": "1.4.167",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {
@@ -48,4 +48,4 @@
   "devDependencies": {
     "better-sqlite3": "^12.10.0"
   }
-}
+}

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/deploy-node.sh

@@ -0,0 +1,83 @@
+#!/bin/bash
+# 将本地 tiktok-cli 打包部署到 Windows 采集节点（试运行，不经 npm registry）
+# 用法:
+#   ./scripts/deploy-node.sh tiktok-210                  # 打包+传输+远程安装+校验
+#   ./scripts/deploy-node.sh tiktok-210 --bump           # 先把 package.json 版本号 +1 再打包
+#   ./scripts/deploy-node.sh tiktok-210 --bump --restart # 安装后重启走 CDP 的命令进程
+#                                                        #（watchdog 检测到退出会用新代码自动拉起）
+# 流程: (可选)升版本号 → npm pack → scp → 远程 npm install -g → 校验 → (可选)重启命令
+# 前提: ~/.ssh/config 已配置节点别名（如 tiktok-210，经跳板机），BatchMode 免密可用
+# 说明:
+#   - 无需停进程再安装：采集客户端不加载 better-sqlite3（只有 videostats/watch 服务端用），无文件锁
+#   - watchdog 自升级：npm 覆盖安装后守护进程经 upgrader.js 自动重启，受管命令随后重建
+#   - 节点上保留 tgz 安装包，回滚时 npm install -g 旧版 tgz 即可
+set -euo pipefail
+
+ALIAS="${1:?用法: deploy-node.sh <ssh别名> [--bump] [--restart]}"
+shift || true
+DO_BUMP=0
+DO_RESTART=0
+for a in "$@"; do
+  case "$a" in
+    --bump) DO_BUMP=1 ;;
+    --restart) DO_RESTART=1 ;;
+    *) echo "未知参数: $a"; exit 1 ;;
+  esac
+done
+
+cd "$(dirname "$0")/.."
+
+if [ "$DO_BUMP" = 1 ]; then
+  node -e "
+    const fs = require('fs');
+    const p = JSON.parse(fs.readFileSync('package.json', 'utf8'));
+    const m = p.version.split('.');
+    m[2] = Number(m[2]) + 1;
+    p.version = m.join('.');
+    fs.writeFileSync('package.json', JSON.stringify(p, null, 2) + '\n');
+    console.log('版本号 ->', p.version);
+  "
+fi
+
+NAME=$(node -p "require('./package.json').name")
+VER=$(node -p "require('./package.json').version")
+TGZ="${NAME}-${VER}.tgz"
+
+echo "==> npm pack"
+rm -f "$TGZ"
+TGZ=$(npm pack 2>/dev/null | tail -1)
+echo "包: $TGZ ($(du -h "$TGZ" | cut -f1))"
+
+echo "==> scp → $ALIAS"
+scp -o ConnectTimeout=25 -o BatchMode=yes "$TGZ" "$ALIAS:$TGZ" 2>&1 |
+  grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' >/dev/null
+echo "已传输到 %USERPROFILE%\\$TGZ"
+
+echo "==> 远程 npm install -g"
+ssh -o ConnectTimeout=25 -o BatchMode=yes "$ALIAS" \
+  "npm install -g %USERPROFILE%\\$TGZ 2>&1" |
+  grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' |
+  tail -3
+
+echo "==> 校验远程版本"
+REMOTE_VER=$(
+  ssh -o ConnectTimeout=25 -o BatchMode=yes "$ALIAS" "tt-help --version 2>nul" 2>/dev/null |
+    grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' |
+    tail -1 | tr -d '\r'
+)
+if [ "$REMOTE_VER" = "$VER" ]; then
+  echo "✓ 远程版本 $REMOTE_VER"
+else
+  echo "✗ 版本不一致: 期望 $VER, 实际 '${REMOTE_VER:-空}'"
+  exit 1
+fi
+
+if [ "$DO_RESTART" = 1 ]; then
+  echo "==> 重启走 CDP 的命令进程（排除 watchdog/webserver，浏览器进程保留、新客户端直接重连）"
+  ssh -o ConnectTimeout=25 -o BatchMode=yes "$ALIAS" 'powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" | Where-Object { $_.CommandLine -match \"cli\.js\" -and $_.CommandLine -notmatch \"watchdog|webserver\" } | ForEach-Object { taskkill /F /PID $_.ProcessId }"' 2>&1 |
+    grep -vE 'post-quantum|openssh.com/pq|store now|upgraded|CLIXML|^Warning|Permanently added' |
+    head -10 || true
+  echo "（watchdog 检测到异常退出后会在 5-30s 内用新代码自动拉起，Edge 进程保留、客户端直连不重启浏览器）"
+fi
+
+echo "==> 完成"

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

@@ -1,11 +1,13 @@
 /**
- * 客户端异常监控单测（2026-08-28，2026-09-28 增补验证码路径）
+ * 客户端异常监控单测（2026-08-28，2026-09-28 增补验证码路径，
+ * 2026-09-29 改为 clientId 本机关联 —— 克隆机 hostname 撞名修复）
  *
  * 验证：
  *   - detectClientError 检测函数：
  *     A. reportCount > 8 且最近一次上报在 2 分钟内
  *     B. captchaCount ≥ 3（webserver 验证码上报，10 分钟过期窗口内累计）
- *   - 按 hostname 过滤本机条目；hostname 为空的旧条目不参与关联
+ *   - 按 clientId 过滤本机条目（每台唯一）；hostname 撞名的兄弟机条目、
+ *     无 clientId 的旧条目均不参与关联
  *   - 命中 → onAlert 收到本机全部条目与命中列表；未命中 → 不回调
  *   - removeErrors 逐条 DELETE 并计数
  *
@@ -13,18 +15,21 @@
  */
 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,
@@ -32,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 分钟内 → 命中", () => {
@@ -66,20 +87,14 @@ test("D4 detectClientError：缺 reportCount → 不命中", () => {
 
 test("C1 detectClientError：captchaCount=3 → 命中", () => {
   assert.equal(
-    detectClientError(
-      makeErr({ reportCount: 0, captchaCount: 3 }),
-      Date.now(),
-    ),
+    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(),
-    ),
+    detectClientError(makeErr({ reportCount: 0, captchaCount: 2 }), Date.now()),
     false,
   );
 });
@@ -100,10 +115,7 @@ test("C3 detectClientError：captchaCount=3 但最近上报超 2 分钟 → 不
 
 test("C4 detectClientError：reportCount 未达标 + captchaCount 达标 → 命中", () => {
   assert.equal(
-    detectClientError(
-      makeErr({ reportCount: 1, captchaCount: 5 }),
-      Date.now(),
-    ),
+    detectClientError(makeErr({ reportCount: 1, captchaCount: 5 }), Date.now()),
     true,
   );
 });
@@ -119,41 +131,35 @@ test("C5 监控器：验证码条目命中 → onAlert 收到命中列表", asyn
     ok: true,
     json: async () => ({ clients: [captchaHit, businessMiss] }),
   }));
-  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, "仅验证码条目命中");
   assert.equal(hit[0].userId, "webserver-host");
-  assert.equal(received.hit.length, 1);
-  assert.equal(received.mine.length, 2, "回调同时携带本机未命中条目");
+  assert.equal(getReceived().hit.length, 1);
+  assert.equal(getReceived().mine.length, 2, "回调同时携带本机未命中条目");
   mock.restoreAll();
 });
 
-// ── 监控器 ──
+// ── 监控器：本机关联（clientId） ──
 
-test("M1 按 hostname 过滤：他机条目不触发本机回调", async () => {
+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();
 });
@@ -161,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({ hostname: "" })] }),
+    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({ 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") {
@@ -232,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/src/cli/attach.js

@@ -160,13 +160,26 @@ export async function handleAttach(options) {
         data = await res.json();
       } catch {}
       if (!res.ok) {
-        // CDN 限流：抛 CDNBlockedError，外层据此冷却（webserver 模式同样生效）
+        // CDN 限流：抛 CDNBlockedError，外层据此冷却（webserver 模式同样生效）。
+        // 服务端冷却期返回 503 + error="CDN cooldown active, cooling IP"（server.mjs），
+        // 并携带 cdnCooldownSec=剩余秒数，一并识别；秒数挂到 err.serverCooldownSec
+        // 供外层精确对齐冷却窗口，避免冷却期整批空转猛冲。
         if (
           data &&
           typeof data.error === "string" &&
-          data.error.includes("CDN限流")
+          (data.error.includes("CDN限流") ||
+            data.error.includes("CDN cooldown"))
         ) {
-          throw new CDNBlockedError(data.error);
+          const cdnErr = new CDNBlockedError(data.error);
+          if (data.cdnCooldownSec > 0)
+            cdnErr.serverCooldownSec = data.cdnCooldownSec;
+          throw cdnErr;
+        }
+        if (data && data.cdnCooldownSec > 0) {
+          // 文案兜底：只要响应带冷却秒数字段就按 CDN 限流处理
+          const cdnErr = new CDNBlockedError("CDN限流 (cooldown)");
+          cdnErr.serverCooldownSec = data.cdnCooldownSec;
+          throw cdnErr;
         }
         // 其余失败（504 超时 / 503 / 502 / 500 等）：抛出带状态码与错误详情的异常，
         // 让外层日志显示真实原因（如 page.goto 超时）而非笼统"未获取到用户信息"。
@@ -221,6 +234,7 @@ export async function handleAttach(options) {
     let browserRestartCount = 0;
     let taskBatchCount = 0;
     let consecutiveCdnBlocks = 0; // 连续 CDN 限流轮数（自适应：前几次切换节点，之后长等待）
+    let consecutiveHighFail = 0; // 连续高失败率轮数（webserver 模式通用阶梯冷却）
 
     while (!shuttingDown) {
       loopCount++;
@@ -299,6 +313,7 @@ export async function handleAttach(options) {
       let successCount = 0;
       let failCount = 0;
       let cdnBlockedCount = 0;
+      let serverCdnCooldownSec = 0; // 服务端告知的剩余冷却秒数（webserver 503 响应携带）
       let needRestart = false;
 
       // 收集抓取成功的任务，记录抓取失败的
@@ -308,8 +323,16 @@ export async function handleAttach(options) {
           const { uniqueId, info, error } = result.value;
           if (error) {
             if (error instanceof CDNBlockedError) {
-              attachLog(`  ⚠ @${uniqueId} CDN限流 (Access Denied)`);
+              attachLog(
+                error.serverCooldownSec
+                  ? `  ⚠ @${uniqueId} CDN限流 (服务端冷却中，剩余 ${error.serverCooldownSec}s)`
+                  : `  ⚠ @${uniqueId} CDN限流 (Access Denied)`,
+              );
               cdnBlockedCount++;
+              serverCdnCooldownSec = Math.max(
+                serverCdnCooldownSec,
+                error.serverCooldownSec || 0,
+              );
               failCount++;
             } else if (isBrowserClosedError(error)) {
               needRestart = true;
@@ -384,9 +407,13 @@ export async function handleAttach(options) {
 
       attachLog(`  本批结果: ${successCount} 成功, ${failCount} 失败\n`);
 
-      // CDN 限流比例超过 30% 时：自适应策略（前几次切节点，连续限流则长等待）
+      // 失败率冷却策略：
+      // - 本地浏览器模式（scraper）：CDN 限流 >30% 触发切节点 + 冷却（主动绕过）
+      // - webserver 模式：统一按总失败率阶梯冷却（出口在远端，分类对客户端无意义，
+      //   唯一手段是等；冷却期服务端 503 会带 cdnCooldownSec，优先精确对齐窗口）
       const cdnRatio = tasks.length > 0 ? cdnBlockedCount / tasks.length : 0;
-      if (cdnRatio > 0.3) {
+      const failRatio = tasks.length > 0 ? failCount / tasks.length : 0;
+      if (cdnRatio > 0.3 && scraper) {
         consecutiveCdnBlocks++;
         // 冷却指数退避：60s→120s→240s→…上限 300s（切换后短等，持续限流则长等窗口过去）
         const coolDownSeconds = Math.min(
@@ -394,12 +421,7 @@ export async function handleAttach(options) {
           MAX_CDN_COOLDOWN_SEC,
         );
         const shouldSwitch = consecutiveCdnBlocks <= MAX_CDN_SWITCH_ATTEMPTS;
-        if (!scraper) {
-          // webserver 模式：限流发生在远端 webserver 出口，本地切节点无效，仅冷却等待
-          attachLog(
-            `  [Attach] CDN限流比例 ${(cdnRatio * 100).toFixed(0)}% (${cdnBlockedCount}/${tasks.length})，webserver 模式不切节点，冷却 ${coolDownSeconds} 秒...`,
-          );
-        } else if (shouldSwitch) {
+        if (shouldSwitch) {
           // 用现有 IPC 接口通知 daemon 从候选集切下一个健康节点（换 IP 绕过 CDN 限流）
           try {
             writeCommand({
@@ -417,16 +439,42 @@ export async function handleAttach(options) {
           );
         }
         await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
-        if (scraper) {
-          await recycleScraper(
-            scraper,
-            `CDN限流比例过高 (${cdnBlockedCount}/${tasks.length})`,
-          );
-          browserRestartCount++;
-        }
+        await recycleScraper(
+          scraper,
+          `CDN限流比例过高 (${cdnBlockedCount}/${tasks.length})`,
+        );
+        browserRestartCount++;
+        taskBatchCount = 0;
+      } else if (
+        webserverUrl &&
+        tasks.length >= 5 &&
+        failRatio > 0.5
+      ) {
+        // webserver 模式统一阶梯：总失败率 >50% 即冷却（含 CDN 限流/goto 超时/
+        // 验证码/网络错误等所有类型）。首次 30s 低代价试探，连续则指数升级
+        // 30→60→120→240→300s 封顶；服务端告知冷却剩余秒数时优先精确对齐；
+        // 失败率回落 ≤30% 清零
+        consecutiveHighFail++;
+        const coolDownSeconds = serverCdnCooldownSec
+          ? Math.min(
+              Math.max(serverCdnCooldownSec + 5, 30),
+              MAX_CDN_COOLDOWN_SEC,
+            )
+          : Math.min(
+              30 * Math.pow(2, consecutiveHighFail - 1),
+              MAX_CDN_COOLDOWN_SEC,
+            );
+        const cdnTag = cdnBlockedCount
+          ? `（其中 CDN限流 ${cdnBlockedCount}）`
+          : "";
+        attachLog(
+          `  [Attach] 失败率 ${(failRatio * 100).toFixed(0)}% (${failCount}/${tasks.length})${cdnTag}，冷却 ${coolDownSeconds} 秒...`,
+        );
+        await new Promise((r) => setTimeout(r, coolDownSeconds * 1000));
         taskBatchCount = 0;
       } else {
         consecutiveCdnBlocks = 0; // 正常批次重置连续限流计数
+        if (failRatio <= 0.3) consecutiveHighFail = 0; // 失败率回落清零阶梯计数
       }
 
       if (scraper) {

package/src/cli/tag.js

@@ -7,6 +7,7 @@ import {
   formatMemoryWithBrowser,
 } from "../lib/browser-memory.js";
 import { reportClientErrorAndFailover } from "../lib/client-error-report.js";
+import { getWatchdogClientId } from "../lib/api-client.js";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
 import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
 import { getOrCreatePage } from "../lib/browser/page.js";
@@ -1324,6 +1325,7 @@ export async function handleScoreAll(parsed) {
                 stage: "tag-scoring",
                 errorStack: "",
                 hostname: os.hostname(),
+                clientId: getWatchdogClientId(), // 看门狗按 clientId 关联本机异常
               }),
             });
           } catch {}

package/src/lib/api-client.js

@@ -1,5 +1,9 @@
 import crypto from "node:crypto";
 import os from "os";
+import { getWatchdogClientId } from "../watchdog/reporter.js";
+
+// 供业务侧（client-error-report / tag / webserver 等）统一从本模块取机器标识
+export { getWatchdogClientId };
 
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
 
@@ -82,11 +86,23 @@ export function createApiClient(opts = {}) {
         //   - header 放净化后的 ASCII 值（仅保证请求能发出）
         //   - 原始 hostname 塞进 body（JSON 为 UTF-8，无 ByteString 限制），
         //     服务端 body.hostname 优先，看门狗仍能按原始主机名关联本机异常
+        // 另：克隆机群 hostname 全部相同（如 F-2~F-10 均为 WIN-AADJ1HTCCAQ），
+        // hostname 已不能唯一标识机器 → 同时携带 watchdog clientId（每台唯一，
+        // watchdog 启动时写入 ~/.tt-help.json 的 watchdogClientId 字段），
+        // 看门狗按 clientId 关联本机异常，hostname 仅作展示。
         if (/\/api\/error-report(\?|$)/.test(String(url))) {
           headers["X-Client-Hostname"] = os
             .hostname()
             .replace(/[^\x20-\x7e]/g, "_");
           body = { ...body, hostname: os.hostname() };
+          const wdClientId = getWatchdogClientId();
+          if (wdClientId) {
+            headers["X-Watchdog-Client-Id"] = wdClientId.replace(
+              /[^\x20-\x7e]/g,
+              "_",
+            );
+            body = { ...body, clientId: wdClientId };
+          }
         }
         const res = await fetch(url, {
           method: "POST",

package/src/lib/browser/cdp.js

@@ -222,22 +222,66 @@ function killEdgeProcesses(targetDir, port) {
   });
 }
 
+/** 查询监听指定端口的进程 PID 列表（netstat，不依赖 WMI）；查询失败返回 [] */
+function getListeningPidsOnPort(port) {
+  try {
+    const out = execSync("netstat -ano", {
+      encoding: "utf-8",
+      timeout: 10000,
+      windowsHide: true,
+    });
+    return parseNetstatListeningPids(out, port);
+  } catch {
+    return [];
+  }
+}
+
+/** tasklist 验证 PID 存活且属于 msedge（不依赖 WMI）：true/false；查询失败返回 null */
+function isEdgePidAliveWin(pid) {
+  try {
+    const out = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, {
+      encoding: "utf-8",
+      timeout: 5000,
+      windowsHide: true,
+    });
+    return out.toLowerCase().includes("msedge");
+  } catch {
+    return null;
+  }
+}
+
 /**
- * 查找"残留" Edge 主进程：命令行包含指定 user-data-dir、但不带
- * --remote-debugging-port（Edge 自动更新/崩溃自恢复、上次强杀残留等，
- * 占着 profile 却没监听 CDP 端口）。
- * 排除带 --type= 的子进程：渲染进程等子进程同样带 user-data-dir 却没有
- * CDP 参数，误杀会打断同 profile 的健康实例。
+ * 读取 profile 目录下 lockfile 里的数字（ProcessSingleton 持有者 PID 候选）。
+ * Chromium 写入格式随版本有差异，返回前 5 个数字串，由调用方逐一验证。
+ */
+function readLockPidCandidates(userDataDir) {
+  try {
+    const content = fs.readFileSync(path.join(userDataDir, "lockfile"), "utf-8");
+    return (content.match(/\d+/g) || []).slice(0, 5);
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 查找"残留" Edge 主进程：占着指定 user-data-dir 的实例（调用前已确认
+ * CDP 端口未监听，故带 --remote-debugging-port 参数的僵死实例同样算残留）。
+ * 排除带 --type= 的子进程：渲染进程等子进程同样带 user-data-dir，
+ * 误杀会打断同 profile 的健康实例。
  *
  * 这类实例必须先杀掉再启动：否则新 msedge 会因 Chromium ProcessSingleton
  * 把命令行转发给旧实例，变成"旧实例开一个 about:blank 新 tab"，CDP 端口
  * 永远起不来 → 等待超时 → watchdog 自动重启 → 每轮再开一个 tab。
  *
  * killEdgeProcesses 在 Windows 上按监听端口找 PID，对这类实例无效，
- * 故单独按命令行匹配精确清理。
+ * 故单独按命令行/lockfile 匹配精确清理，且不依赖 WMI：
+ *  1. PowerShell 枚举 msedge 命令行按 user-data-dir 匹配（需 WMI，
+ *     WMI 损坏的机器上可能返回空）
+ *  2. lockfile 兜底：读 profile 目录 lockfile 中的 PID，用 tasklist 验证
+ *     存活且是 msedge（不依赖 WMI，覆盖 WMI 损坏 + 带 CDP 参数的僵死实例）
  *
  * @param {string} targetDir - user-data-dir 路径
- * @returns {string[]|null} PID 列表；无法枚举进程命令行（PowerShell/WMI 不可用）时返回 null
+ * @returns {string[]|null} PID 列表；命令行枚举失败且 lockfile 无可信结论时返回 null
  */
 function findStaleEdgePids(targetDir) {
   const platform = os.platform();
@@ -245,31 +289,61 @@ function findStaleEdgePids(targetDir) {
     let out;
     if (platform === "win32") {
       // PowerShell 为主（wmic 已从新版 Win11 移除；项目其他模块同样依赖 PowerShell）
-      out = decodeWinOutput(
-        execSync(
-          'powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq \'msedge.exe\' } | ForEach-Object { Write-Output ($_.ProcessId.ToString() + \'|\' + $_.CommandLine) }"',
-          { encoding: "buffer", timeout: 10000, windowsHide: true },
-        ),
-      );
-    } else {
-      out = execSync("ps -eo pid,args", {
-        encoding: "utf-8",
-        timeout: 10000,
-      });
+      let byCmdline = null;
+      try {
+        out = decodeWinOutput(
+          execSync(
+            'powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -eq \'msedge.exe\' } | ForEach-Object { Write-Output ($_.ProcessId.ToString() + \'|\' + $_.CommandLine) }"',
+            { encoding: "buffer", timeout: 10000, windowsHide: true },
+          ),
+        );
+        const dirLower = targetDir.toLowerCase();
+        const pids = [];
+        for (const line of out.split(/\r?\n/)) {
+          const lower = line.toLowerCase();
+          if (!lower.includes(dirLower)) continue; // 只匹配本 profile
+          // 边界保护：避免 _p9222 误匹配 _p92221 这类前缀目录
+          const idx = lower.indexOf(dirLower);
+          const next = lower[idx + dirLower.length];
+          if (next && /[a-z0-9_]/.test(next)) continue;
+          if (lower.includes("--type=")) continue; // 子进程，误杀会打断健康实例
+          // 提取 PID：win 格式 "PID|命令行"
+          const m = line.match(/^\s*(\d+)\|/);
+          if (m && !pids.includes(m[1])) pids.push(m[1]);
+        }
+        byCmdline = pids;
+      } catch (e) {
+        console.error(`[findStaleEdgePids] PowerShell 枚举失败: ${e.message}`);
+        byCmdline = null;
+      }
+      if (byCmdline && byCmdline.length > 0) return byCmdline;
+
+      // lockfile 兑底：WMI 损坏时命令行枚举为空/失败；或残留实例带 CDP
+      // 参数时命令行匹配可能误报为空，lockfile 直接给出持有者 PID
+      for (const cand of readLockPidCandidates(targetDir)) {
+        if (isEdgePidAliveWin(cand) === true) return [cand];
+      }
+
+      // 命令行枚举失败且 lockfile 没找到活持有者 → 无法判断
+      if (byCmdline === null) return null;
+      return [];
     }
+
+    out = execSync("ps -eo pid,args", {
+      encoding: "utf-8",
+      timeout: 10000,
+    });
     const dirLower = targetDir.toLowerCase();
     const pids = [];
     for (const line of out.split(/\r?\n/)) {
       const lower = line.toLowerCase();
       if (!lower.includes(dirLower)) continue; // 只匹配本 profile
-      // 边界保护：避免 _p9222 误匹配 _p92221 这类前缀目录
       const idx = lower.indexOf(dirLower);
       const next = lower[idx + dirLower.length];
       if (next && /[a-z0-9_]/.test(next)) continue;
-      if (lower.includes("remote-debugging-port")) continue; // 健康 CDP 实例，不动
       if (lower.includes("--type=")) continue; // 子进程，误杀会打断健康实例
-      // 提取 PID：win 格式 "PID|命令行"，unix 格式 "  PID 命令行"
-      const m = line.match(/^\s*(\d+)(?:\||\s)/);
+      // 提取 PID：unix 格式 "  PID 命令行"
+      const m = line.match(/^\s*(\d+)\s/);
       if (m && !pids.includes(m[1])) pids.push(m[1]);
     }
     return pids;
@@ -308,6 +382,66 @@ function killEdgeStale(pids) {
   });
 }
 
+/**
+ * CDP 等待超时后的现场诊断：端口被谁占用、msedge 进程总数、profile 锁持有者。
+ * 输出随超时错误一起打印/上报，远程节点无需人工登录即可定位问题。
+ * @param {number} port
+ * @param {string} userDataDir
+ * @returns {string} 形如 "[诊断] ...; ..." 的摘要；收集失败返回 ""
+ */
+function collectTimeoutDiagnostics(port, userDataDir) {
+  const parts = [];
+  try {
+    if (os.platform() === "win32") {
+      const listenPids = getListeningPidsOnPort(port);
+      if (listenPids.length > 0) {
+        const names = listenPids.map((pid) => {
+          try {
+            const out = execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, {
+              encoding: "utf-8",
+              timeout: 5000,
+              windowsHide: true,
+            });
+            return out.split(",")[0]?.replace(/"/g, "").trim() || pid;
+          } catch {
+            return pid;
+          }
+        });
+        parts.push(
+          `端口 ${port} 正被监听但 CDP 未响应 (PID: ${listenPids.join(", ")}, 进程: ${names.join(", ")})`,
+        );
+      } else {
+        parts.push(`端口 ${port} 无任何进程监听`);
+      }
+      try {
+        const out = execSync(
+          'tasklist /FI "IMAGENAME eq msedge.exe" /FO CSV /NH',
+          {
+            encoding: "utf-8",
+            timeout: 5000,
+            windowsHide: true,
+          },
+        );
+        const count = out
+          .split(/\r?\n/)
+          .filter((l) => l.toLowerCase().includes("msedge")).length;
+        parts.push(`msedge 进程总数: ${count}`);
+      } catch {}
+      const lockPids = readLockPidCandidates(userDataDir).filter(
+        (pid) => isEdgePidAliveWin(pid) !== false,
+      );
+      parts.push(
+        lockPids.length
+          ? `profile lockfile 持有者: ${lockPids.join(", ")}`
+          : "profile lockfile 无存活持有者",
+      );
+    }
+  } catch (e) {
+    parts.push(`诊断收集失败: ${e.message}`);
+  }
+  return parts.length ? `[诊断] ${parts.join("; ")}` : "";
+}
+
 function launchEdgeWithCDP(port, userDataDir, proxyServer) {
   return new Promise((resolve, reject) => {
     const platform = os.platform();
@@ -405,14 +539,32 @@ export async function ensureBrowserReady(options = {}) {
         console.error(`CDP 端口 ${port} 未就绪，正在启动 Edge 浏览器...`);
       }
     }
-    // 残留实例清理：占着该 user-data-dir 却没开 CDP 的旧 Edge 必须先杀掉，
-    // 否则 launch 会被 ProcessSingleton 转发成"旧实例开新 tab"，CDP 永远起不来。
+    // （Windows）CDP 端口被非 Edge 进程占用 → 立即报错，避免干等 60 秒超时
+    if (os.platform() === "win32") {
+      const listenPids = getListeningPidsOnPort(port);
+      if (listenPids.length > 0) {
+        const isEdge = listenPids.map((pid) => isEdgePidAliveWin(pid));
+        if (isEdge.every((v) => v === false)) {
+          throw new Error(
+            `CDP 端口 ${port} 被非 Edge 进程占用 (PID: ${listenPids.join(", ")})，` +
+              `无法启动浏览器。请释放该端口或更换 --cdp-port`,
+          );
+        }
+        // Edge 在监听但 HTTP 未响应 → 视为僵死，按残留处理（下方清理）
+      }
+    }
+
+    // 残留实例清理：占着该 user-data-dir 但 CDP 端口未监听的旧 Edge 必须先杀掉
+    //（含带 --remote-debugging-port 参数的僵死实例），否则 launch 会被
+    // ProcessSingleton 转发成"旧实例开新 tab"，CDP 永远起不来。
     const stalePids = findStaleEdgePids(userDataDir);
     if (stalePids === null) {
-      console.error("[浏览器] 无法枚举 Edge 进程命令行，跳过残留实例检测");
+      console.error(
+        "[浏览器] 无法判断是否存在残留 Edge 实例（WMI/lockfile 均不可用），跳过清理",
+      );
     } else if (stalePids.length > 0) {
       console.error(
-        `[浏览器] 检测到占用 ${path.basename(userDataDir)} 但未开 CDP 的残留 Edge 实例 (PID: ${stalePids.join(", ")})，正在清理...`,
+        `[浏览器] 检测到占用 ${path.basename(userDataDir)} 但 CDP 端口未监听的残留 Edge 实例 (PID: ${stalePids.join(", ")})，正在清理...`,
       );
       await killEdgeStale(stalePids);
       await new Promise((r) => setTimeout(r, 3000));
@@ -427,8 +579,11 @@ export async function ensureBrowserReady(options = {}) {
       os.platform() === "win32" ? 60000 : 30000,
     );
     if (!launched) {
+      const diag = collectTimeoutDiagnostics(port, userDataDir);
+      if (diag) console.error(`[浏览器] ${diag}`);
       throw new Error(
-        `等待 CDP 端口 ${port} 超时。请确认 Edge 浏览器已安装，\n` +
+        `等待 CDP 端口 ${port} 超时。${diag ? diag + "\n" : ""}` +
+          `请确认 Edge 浏览器已安装，\n` +
           `或手动启动: Microsoft Edge --remote-debugging-port=${port} [参见 cdp.js extraArgs]`,
       );
     }

package/src/lib/client-error-report.js

@@ -4,6 +4,7 @@
  */
 
 import os from "os";
+import { getWatchdogClientId } from "./api-client.js";
 
 /**
  * 触发 Clash daemon 的故障切换（换出口节点），与 watchdog 的 failover 一致。
@@ -49,7 +50,9 @@ export async function reportClientErrorAndFailover({
       errorMessage: message,
       stage,
       errorStack: "",
-      hostname: os.hostname(), // 机器标识：看门狗按 hostname 关联本机异常
+      hostname: os.hostname(), // 机器标识（展示用；克隆机群 hostname 重复）
+      // 看门狗按 clientId 关联本机异常（每台唯一，克隆机 hostname 重复不可用）
+      clientId: getWatchdogClientId(),
     });
   } catch {}
   await triggerClashFailover(message, log);

package/src/watch/data-store.js

@@ -1260,6 +1260,10 @@ export function createStore(filePath, options = {}) {
     return data;
   }
 
+  // 空级跳过记忆（claimNextJob 用）：key = "level|国家列表"，value = 首次全 miss 时间。
+  // 某来源级（如 seed）全部国家分支 miss 后，TTL 内跳过该级，避免每次领任务空跑
+  const levelEmptyCache = new Map();
+
   async function claimNextJob(
     userId,
     expireMs = 5 * 60 * 1000,
@@ -1391,24 +1395,42 @@ export function createStore(filePath, options = {}) {
       // 非 pinned 优先级：seed → seller → follow → other，每级 × 3 个 location tier × (hasVideo / noVideoReq)
       const priorities = [
         {
+          name: "seed",
           filter: `instr(COALESCE(sources, ''), '"seed"') > 0`,
           loggedInOnly: false,
         },
         {
+          name: "seller",
           filter: `tt_seller = 1 AND verified = 0`,
           loggedInOnly: true,
           sellerAnyCountry: true,
         },
         {
+          name: "follow",
           filter: `(instr(COALESCE(sources, ''), '"following"') > 0 OR instr(COALESCE(sources, ''), '"follower"') > 0 OR instr(COALESCE(sources, ''), '"comment"') > 0)`,
           loggedInOnly: false,
         },
-        { filter: `1 = 1`, loggedInOnly: false },
+        { name: "other", filter: `1 = 1`, loggedInOnly: false },
       ];
 
+      // 空级跳过记忆：某来源级（如 seed）全部国家分支 miss 后，记录时间；
+      // TTL 内该级整体跳过（池子空了没必要每次领任务都空跑 24国×2 条查询，
+      // 2026-09-29 实测 seed 空级每次烧 1.4s CPU 是 watch 饱和主因）。
+      // TTL 过期后恢复探测一次——refill 补进新任务即可自动恢复。
+      const LEVEL_EMPTY_TTL = 60 * 1000;
+      for (const p of priorities) {
+        if (p.loggedInOnly && !loggedIn) continue;
+        const levelKey = `${p.name}|${orderedCountries.join(",")}`;
+        const emptySince = levelEmptyCache.get(levelKey);
+        if (emptySince && now - emptySince < LEVEL_EMPTY_TTL) {
+          p.skip = true; // 标记跳过，下面构建分支时跳过
+        }
+      }
+
       let basePrio = 4;
       for (const p of priorities) {
         if (p.loggedInOnly && !loggedIn) continue;
+        if (p.skip) continue;
         // 逐国顺序分支：配置内国家按优先级顺序；未传子集时末尾补“配置外国家”兑底。
         // 空位置（loc=''）只在首个国家的分支参与：首国的 noVideoReq 分支 miss 即意味着
         // 空位置池已耗尽，后续分支无需再 OR ''（避免反复扫描空位置大池）
@@ -1421,6 +1443,7 @@ export function createStore(filePath, options = {}) {
         // 传了国家子集时对应国家的商家仍优先，领完再兜任意国家（含空位置商家）；
         // 未传国家时同理（配置内各国 → 配置外 → 任意）。其他来源级分支不受影响。
         if (p.sellerAnyCountry) locationBranches.push(null); // null → 任意国家分支
+        p._branchStart = branches.length; // 记录该级分支区间（用于判空）
         let subPrio = 0;
         for (const loc of locationBranches) {
           // 商家任意国家分支：不限 guessed_location（含空位置的商家）
@@ -1453,12 +1476,16 @@ export function createStore(filePath, options = {}) {
           );
           subPrio++;
         }
+        p._branchEnd = branches.length;
         basePrio += 2;
       }
 
-      // 逐级执行：首个命中分支的最优行即领取结果（未命中继续下一优先级分支）
+      // 逐级执行：首个命中分支的最优行即领取结果（未命中继续下一优先级分支）。
+      // 同时记录哪些来源级全部 miss → 写入 levelEmptyCache（下次领取 TTL 内直接跳过该级）
       let selectedRow = null;
-      for (const b of branches) {
+      let bi = 0;
+      for (; bi < branches.length; bi++) {
+        const b = branches[bi];
         selectedRow =
           getDb()
             .prepare(
@@ -1468,6 +1495,18 @@ export function createStore(filePath, options = {}) {
         if (selectedRow) break;
       }
 
+      // 记录空级：分支按优先级顺序执行，命中所处级之前的所有来源级必然全 miss；
+      // 空级写入 levelEmptyCache（TTL 内下次领取直接跳过），命中级清除记忆
+      // bi = 命中分支下标（未命中则停在 branches.length）
+      const hitIdx = bi;
+      for (const p of priorities) {
+        if (p.loggedInOnly && !loggedIn) continue;
+        if (p._branchStart == null) continue; // 被 skip 跳过的级无分支，保留原记忆
+        const levelKey = `${p.name}|${orderedCountries.join(",")}`;
+        if (hitIdx >= p._branchEnd) levelEmptyCache.set(levelKey, now);
+        else levelEmptyCache.delete(levelKey);
+      }
+
       if (selectedRow) {
         getDb()
           .prepare(
@@ -2563,11 +2602,15 @@ export function createStore(filePath, options = {}) {
     stage,
     errorStack,
     hostname,
+    clientId,
   ) {
     const existing = clientErrors.get(userId);
     if (existing) {
       existing.timestamp = Date.now();
       if (hostname) existing.hostname = hostname;
+      // clientId（机器唯一标识，如 F-9@HOST）随上报刷新；克隆机群 hostname 重复，
+      // 看门狗只认 clientId 关联本机条目
+      if (clientId) existing.clientId = clientId;
       if (errorType === "captcha") {
         existing.captchaCount = (existing.captchaCount || 0) + 1;
         if (!existing.captchaStage) existing.captchaStage = stage || "";
@@ -2586,6 +2629,7 @@ export function createStore(filePath, options = {}) {
       clientErrors.set(userId, {
         userId,
         hostname: hostname || "",
+        clientId: clientId || "", // 机器唯一标识；空 = 旧版客户端上报，不参与看门狗触发
         errorType,
         errorMessage: errorMessage || "",
         errorStack: errorStack || "",

package/src/watch/db-schema.js

@@ -173,7 +173,6 @@ export function initDb(filePath) {
     product_review_count: "INTEGER",
     product_sold_count: "INTEGER",
     product_name: "TEXT",
-    product_skus: "TEXT",
     user_create_time: "INTEGER",
     recent_ec_videos: "TEXT",
   });
@@ -210,7 +209,6 @@ export function initDb(filePath) {
     product_review_count: "INTEGER",
     product_sold_count: "INTEGER",
     product_name: "TEXT",
-    product_skus: "TEXT",
     user_create_time: "INTEGER",
     recent_ec_videos: "TEXT",
   });
@@ -248,7 +246,6 @@ export function initDb(filePath) {
     product_review_count: "INTEGER",
     product_sold_count: "INTEGER",
     product_name: "TEXT",
-    product_skus: "TEXT",
     user_create_time: "INTEGER",
     recent_ec_videos: "TEXT",
   });
@@ -451,13 +448,17 @@ export function initDb(filePath) {
 
   // ===== task_queue 索引（claimNextJob 逐级短路查询 + 监控列表） =====
   // idx_tq_claim_fast：claim 分支查询主索引（2026-09-17 实战验证：分支 7s→1ms）。
-  // 普通复合索引，不依赖部分索引的 WHERE 表达式文本匹配（旧 4 个部分索引因
+  // idx_tq_claim_fallback：兜底分支索引（2026-09-28 实战验证：NOT IN 多国分支 4.2s→16ms）。
+  //   配置外国家（OTHER）的池子可达十几万行，NOT IN 多国无法用 loc 前导列 seek，
+  //   此索引跳过 loc、直接按 (status, follower_count) 排序 seek 第一行。
+  // 均为普通复合索引，不依赖部分索引的 WHERE 表达式文本匹配（旧 4 个部分索引因
   // pinned=0 与 COALESCE(pinned,0)=0 文本不一致、首国分支 OR 空串，从未被命中，已废弃清理）。
   const tqIndexes = [
     `CREATE INDEX IF NOT EXISTS idx_tq_status ON task_queue(status)`,
     `CREATE INDEX IF NOT EXISTS idx_tq_claimed_by_status ON task_queue(claimed_by, status, claimed_at)`,
     `CREATE INDEX IF NOT EXISTS idx_tq_status_claimed_at ON task_queue(status, claimed_at)`,
     `CREATE INDEX IF NOT EXISTS idx_tq_claim_fast ON task_queue(status, UPPER(COALESCE(guessed_location,'')), follower_count DESC, created_at ASC, unique_id ASC)`,
+    `CREATE INDEX IF NOT EXISTS idx_tq_claim_fallback ON task_queue(status, follower_count DESC, created_at ASC, unique_id ASC)`,
     // 监控页面用户列表查询加速
     `CREATE INDEX IF NOT EXISTS idx_tq_list_pending ON task_queue(pinned, processed_at, follower_count, unique_id) WHERE status = 'pending'`,
     `CREATE INDEX IF NOT EXISTS idx_tq_list_processing ON task_queue(pinned, processed_at, follower_count, unique_id) WHERE status = 'processing'`,

package/src/watch/server.js

@@ -2047,6 +2047,7 @@ export function startWatchServer(
             body.stage || "",
             body.errorStack || "",
             body.hostname || req.headers["x-client-hostname"] || "",
+            body.clientId || req.headers["x-watchdog-client-id"] || "",
           );
           sendJSON(res, 200, { ok: true });
         } else {

package/src/watchdog/agent.js

@@ -13,6 +13,7 @@ import {
   getLocalIP,
   getClashHealth,
   getClashHealthChannels,
+  setWatchdogClientId,
 } from "./reporter.js";
 import { ProcessManager } from "./process-manager.js";
 import {
@@ -343,6 +344,14 @@ export class WatchdogAgent {
       `[watchdog] 升级: ${isGlobalInstall() ? "已启用" : "跳过（源码模式）"}`,
     );
 
+    // 把 clientId 写入 ~/.tt-help.json：业务进程上报异常时携带，看门狗按
+    // clientId（每台唯一）关联本机条目；克隆机群 hostname 重复不可用
+    if (!setWatchdogClientId(this.clientId)) {
+      console.error(
+        `[watchdog] ⚠️ clientId 写入 ~/.tt-help.json 失败，客户端异常监控将无法关联本机条目`,
+      );
+    }
+
     // 注册信号处理
     this._setupSignalHandlers();
 
@@ -353,7 +362,11 @@ export class WatchdogAgent {
         spawnDaemon: this.spawnDaemon,
         selfPid: process.pid,
       });
-      if (takeover.agents.length || takeover.daemons.length || takeover.orphans.length) {
+      if (
+        takeover.agents.length ||
+        takeover.daemons.length ||
+        takeover.orphans.length
+      ) {
         console.error(
           `[watchdog] 环境初始化: 接管旧 agent ${takeover.agents.length} 个、旧 daemon ${takeover.daemons.length} 个、孤儿命令 ${takeover.orphans.length} 个`,
         );
@@ -736,7 +749,8 @@ export class WatchdogAgent {
     }
     this.clientErrorMonitor = new ClientErrorMonitor({
       serverUrl: server,
-      hostname: osHostname(),
+      hostname: osHostname(), // 仅展示；关联用 clientId
+      clientId: this.clientId, // 唯一机器标识，克隆机 hostname 重复不可用
       intervalMs: 60_000,
       onAlert: async (mine, hit) => {
         const ids = hit.map((e) => e.userId).join(",");
@@ -856,7 +870,10 @@ export class WatchdogAgent {
         applyClientConfig(data.clientConfig);
       }
       // 服务端下发的代理订阅配置（变化才转发给 daemon 热应用；daemon 侧幂等）
-      if (data.proxySettings && Array.isArray(data.proxySettings.subscriptions)) {
+      if (
+        data.proxySettings &&
+        Array.isArray(data.proxySettings.subscriptions)
+      ) {
         const sig = JSON.stringify(data.proxySettings.subscriptions);
         if (sig !== this._proxySubsSig) {
           this._proxySubsSig = sig;

package/src/watchdog/client-error-monitor.js

@@ -3,13 +3,18 @@
  *
  * 职责：
  *   1. 定时拉取 watch 服务端 /api/client-errors
- *   2. 按 hostname 过滤出本机条目（异常条目由业务进程上报时携带 hostname）
+ *   2. 按 clientId 过滤出本机条目（异常条目由业务进程上报时携带 watchdog clientId）
  *   3. 逐条过独立检测函数，命中 → onAlert(本机全部条目, 命中条目)
  *   4. 提供 removeErrors 删除接口（处理完成后的清理）
  *
  * 检测函数（两条命中路径，满足任一即命中）：
  *   A. reportCount > 8（非验证码业务错误累计）且最近一次上报在 2 分钟内
  *   B. captchaCount ≥ 3（webserver 验证码上报，服务端 10 分钟过期窗口内累计）
+ *
+ * ⚠️ 本机关联必须用 clientId（如 F-9@WIN-AADJ1HTCCAQ，每台唯一）：克隆机群
+ * hostname 全部相同，按 hostname 关联会把兄弟机器的条目当自己的 → 误删条目 +
+ * 误强切（2026-09-28 F-9 条目被 F-10/F-6 抢删事故）。旧条目无 clientId 不参与
+ * 触发（宁漏不误：漏切由业务自带 failover + daemon 冷却兑底）。
  */
 
 import os from "os";
@@ -56,14 +61,24 @@ export class ClientErrorMonitor {
   /**
    * @param {object} opts
    * @param {string} opts.serverUrl - watch 服务端地址（~/.tt-help.json 的 server）
-   * @param {string} [opts.hostname] - 本机 hostname（默认 os.hostname()）
+   * @param {string} opts.clientId - 本机 watchdog clientId（唯一机器标识，必传；
+   *   未传则不匹配任何条目，客户端异常监控不生效）
+   * @param {string} [opts.hostname] - 本机 hostname（仅日志展示用，不再参与关联）
    * @param {number} [opts.intervalMs] - 拉取周期，默认 60s
    * @param {(err: object, now: number) => boolean} [opts.detect] - 检测函数，默认 detectClientError
-   * @param {(mine: Array, hit: Array) => Promise|void} [opts.onAlert] - 命中回调
+   * @param {(err: object, now: number) => boolean} [opts.onAlert] - 命中回调
    */
-  constructor({ serverUrl, hostname, intervalMs = 60_000, detect, onAlert }) {
+  constructor({
+    serverUrl,
+    hostname,
+    clientId,
+    intervalMs = 60_000,
+    detect,
+    onAlert,
+  }) {
     this.serverUrl = serverUrl ? String(serverUrl).replace(/\/+$/, "") : "";
-    this.hostname = hostname || os.hostname();
+    this.hostname = hostname || os.hostname(); // 仅展示用
+    this.clientId = clientId || ""; // 本机关联唯一依据
     this.intervalMs = intervalMs;
     this.detect = detect || detectClientError;
     this.onAlert = onAlert || null;
@@ -105,10 +120,11 @@ export class ClientErrorMonitor {
       if (!resp.ok) return null;
       const data = await resp.json();
       const clients = Array.isArray(data.clients) ? data.clients : [];
-      // hostname 为空的旧条目（升级前上报）不参与本机关联
-      const mine = clients.filter(
-        (c) => c.hostname && c.hostname === this.hostname,
-      );
+      // 严格 clientId 匹配：克隆机群 hostname 重复，绝不用 hostname 关联；
+      // 未配置 clientId（异常）或条目无 clientId（旧版客户端上报）均不匹配
+      const mine = this.clientId
+        ? clients.filter((c) => c.clientId && c.clientId === this.clientId)
+        : [];
       if (mine.length === 0) return null;
       const now = Date.now();
       const hit = mine.filter((c) => this.detect(c, now));

package/src/watchdog/reporter.js

@@ -4,7 +4,7 @@
  */
 
 import os from "os";
-import { existsSync, readFileSync, readdirSync } from "fs";
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 
@@ -12,6 +12,47 @@ const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const CONFIG_PATH = join(homeDir, ".tt-help.json");
 const CLASH_HEALTH_FILE = join(tmpdir(), "clash-health.json");
 
+/**
+ * 写入本机 watchdog clientId 到 ~/.tt-help.json（业务进程上报异常时读取携带）
+ *
+ * 背景：克隆机群 hostname 全部相同（如 F-2~F-10 均为 WIN-AADJ1HTCCAQ），
+ * 看门狗按 hostname 关联「本机异常」会把兄弟机器的条目当自己的 → 互删条目、
+ * 误强切。clientId（如 F-9@WIN-AADJ1HTCCAQ）每台唯一，取代 hostname 做关联。
+ * @param {string} id - watchdog clientId（--client-id 参数值）
+ * @returns {boolean} 是否写入成功（失败不阻断启动，仅影响异常关联精度）
+ */
+export function setWatchdogClientId(id) {
+  if (!id) return false;
+  try {
+    let cfg = {};
+    if (existsSync(CONFIG_PATH)) {
+      cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+    if (cfg.watchdogClientId === id) return true; // 已一致，免写
+    cfg.watchdogClientId = id;
+    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 读取本机 watchdog clientId（业务进程上报异常时携带；watchdog 未启动过/未写入时返回 ""）
+ * @returns {string}
+ */
+export function getWatchdogClientId() {
+  try {
+    if (existsSync(CONFIG_PATH)) {
+      const cfg = JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+      return cfg.watchdogClientId || "";
+    }
+  } catch {
+    // 配置不可读
+  }
+  return "";
+}
+
 /**
  * 获取系统信息
  */

package/src/webserver/server.mjs

@@ -3,6 +3,7 @@ import os from "os";
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
 import { getProductInfo } from "../lib/shop-scraper.mjs";
 import { userId as configUserId } from "../lib/constants.js";
+import { getWatchdogClientId } from "../lib/api-client.js";
 import { killListeningOnPort } from "../lib/port.js";
 import {
   getCurrentNode,
@@ -378,9 +379,7 @@ export async function switchClashNode(reason) {
   const current = await getCurrentNode(CLASH_GROUP_NAME).catch(() => "?");
   const nodes = await listGroupNodes(CLASH_GROUP_NAME);
   // 过滤机场信息节点（剩余流量/套餐到期等，非真实出口）
-  const candidates = nodes.filter(
-    (n) => n !== current && isUsableProxyNode(n),
-  );
+  const candidates = nodes.filter((n) => n !== current && isUsableProxyNode(n));
   if (!candidates.length) {
     throw new Error(
       `切节点失败：组 ${CLASH_GROUP_NAME} 无候选节点 (当前 ${current})`,
@@ -808,6 +807,7 @@ async function notifyCaptchaToWatch(url, maxRetries = 3) {
           stage: "product_info",
           errorStack: url,
           hostname: os.hostname(),
+          clientId: getWatchdogClientId(), // 看门狗按 clientId 关联本机异常
         }),
       });
       console.error("[webserver] Captcha alert sent to watch server");