tt-help-cli-ycl 1.4.142 → 1.4.145

package/src/cli/tag.js

@@ -1,24 +1,18 @@
 import { writeFileSync } from "fs";
 import { randomUUID } from "crypto";
-import http from "http";
 import readline from "readline";
 import os from "os";
 import {
   getBrowserMemory,
   formatMemoryWithBrowser,
 } from "../lib/browser-memory.js";
-import {
-  reportConsecutiveTaskErrors,
-  reportClientErrorAndFailover,
-} from "../lib/client-error-report.js";
+import { reportClientErrorAndFailover } from "../lib/client-error-report.js";
 import { fetchTagData, enrichVideosWithLocation } from "../lib/tag-fetcher.js";
 import { killEdgeProcesses, ensureBrowserReady } from "../lib/browser/cdp.js";
 import { getOrCreatePage, isBrowserClosedError } from "../lib/browser/page.js";
 import { TikTokScraper } from "../lib/tiktok-scraper.mjs";
-import {
-  DEFAULT_TARGET_LOCATIONS,
-  isLocationInList,
-} from "../lib/target-locations.js";
+import { isLocationInList } from "../lib/target-locations.js";
+import { getTargetLocations } from "../lib/app-config.js";
 import { delay as randomDelay } from "../lib/delay.js";
 import { discoverTags } from "../lib/tag-discover.js";
 import {
@@ -33,26 +27,10 @@ import {
   closeCaptcha,
 } from "../scraper/modules/captcha-handler.js";
 
-const ALL_COUNTRIES = DEFAULT_TARGET_LOCATIONS;
 const DEFAULT_SERVER = cfgServer || "http://127.0.0.1:3000";
-const DEFAULT_SCORE_COUNTRIES = [
-  "ES",
-  "FR",
-  "DE",
-  "PT",
-  "IT",
-  "NL",
-  "BE",
-  "AT",
-  "IE",
-  "PL",
-  "CZ",
-  "GR",
-  "HU",
-];
 
 function resolveTargetCountries(countries) {
-  return countries || DEFAULT_SCORE_COUNTRIES;
+  return countries || getTargetLocations();
 }
 
 /**
@@ -73,38 +51,6 @@ function isBrowserDisconnected(browser, e) {
   return false;
 }
 
-/**
- * 探测端口是否已被监听（CDP /json 端点）。
- * 与 cdp.js 的 checkCDPPort 等价，但 tag.js 独立实现，不依赖未导出的内部函数。
- * 用于端口池挑选时跳过被占用端口、以及关闭旧浏览器后确认端口已释放。
- */
-function checkPortListening(port) {
-  return new Promise((resolve) => {
-    const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
-      res.on("data", () => {});
-      res.on("end", () => resolve(res.statusCode === 200));
-    });
-    req.on("error", () => resolve(false));
-    req.setTimeout(2000, () => {
-      resolve(false);
-      req.destroy();
-    });
-  });
-}
-
-/**
- * 等待端口不再被监听（浏览器进程真正退出、端口释放）。
- * @returns {Promise<boolean>} 端口已释放返回 true
- */
-async function waitForPortReleased(port, timeoutMs = 10000) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!(await checkPortListening(port))) return true;
-    await new Promise((r) => setTimeout(r, 500));
-  }
-  return !(await checkPortListening(port));
-}
-
 // 构建带客户端追踪 header 的 fetch 封装
 function buildClientHeaders(clientId, meta, extra = {}) {
   return {
@@ -465,7 +411,7 @@ export async function handleDiscover(parsed) {
     countries.length === 1 &&
     countries[0].toUpperCase() === "ALL"
   ) {
-    countries = ALL_COUNTRIES;
+    countries = getTargetLocations();
   }
 
   if (!countries || countries.length === 0) {
@@ -826,9 +772,8 @@ export async function handleScoreAll(parsed) {
   } = tagScoreAll || {};
 
   const baseUrl = serverUrl || DEFAULT_SERVER;
-  const defaultScoreAllPort =
-    parseInt(process.env.TAG_SCOREALL_PORT_POOL_START || "7222", 10) || 7222;
-  let cdpPort = port || defaultScoreAllPort;
+  // 固定端口：一次会话一个浏览器，全程不换端口、不重启浏览器（错误只打印，不自愈）
+  const cdpPort = port || 7222;
   const effectiveProxy = cliProxy || configuredProxy;
   const targetCountries = resolveTargetCountries(countries);
 
@@ -881,62 +826,7 @@ export async function handleScoreAll(parsed) {
 
   await setupPageRequestBlocking(page);
 
-  // 运行期用过的所有 CDP 端口（含换端口历史），退出时统一清理，防止旧浏览器窗口残留
-  const usedPorts = new Set([cdpPort]);
-
-  // 端口池起始以 CLI --port / 环境变量 / 默认 7222 为准
-  const portPoolStart = cdpPort;
-  const portPoolSize = Math.max(
-    2,
-    parseInt(process.env.TAG_SCOREALL_PORT_POOL_SIZE || "10", 10) || 10,
-  );
-
-  async function pickNextPort(currentPort) {
-    const candidates = [];
-    for (let i = 0; i < portPoolSize; i++) {
-      const p = portPoolStart + i;
-      if (p !== currentPort) candidates.push(p);
-    }
-    // 跳过已被监听的端口（其他 score-all/attach 等程序的浏览器），
-    // 避免 attach 到别人的实例、后续 close/kill 时互相干扰导致浏览器多开
-    const freePorts = [];
-    for (const p of candidates) {
-      if (!(await checkPortListening(p))) freePorts.push(p);
-    }
-    const pool = freePorts.length > 0 ? freePorts : candidates;
-    if (pool.length === 0) return currentPort;
-    return pool[Math.floor(Math.random() * pool.length)];
-  }
-
-  // ── 内存回收配置 ──
-  const RECYCLE_CONFIG = {
-    nodeRssMb: Math.max(
-      256,
-      parseInt(process.env.TAG_SCOREALL_RECYCLE_RSS_MB || "2000", 10) || 2000,
-    ),
-    nodeHeapMb: Math.max(
-      128,
-      parseInt(process.env.TAG_SCOREALL_RECYCLE_HEAP_MB || "2000", 10) || 2000,
-    ),
-    edgeMb: Math.max(
-      500,
-      parseInt(process.env.TAG_SCOREALL_RECYCLE_EDGE_MB || "2000", 10) || 2000,
-    ),
-    cooldownMs: Math.max(
-      0,
-      parseInt(process.env.TAG_SCOREALL_RECYCLE_COOLDOWN_MS || "180000", 10) ||
-        180000,
-    ),
-    periodicEvery: Math.max(
-      0,
-      parseInt(process.env.TAG_SCOREALL_PERIODIC_RECYCLE_EVERY || "0", 10) || 0,
-    ),
-    switchPortOnRecycle:
-      String(process.env.TAG_SCOREALL_SWITCH_PORT_ON_RECYCLE || "0") !== "0",
-  };
-  let lastRecycleAt = 0;
-
-  // ── 轻量回收：只清空当前 tab ──
+  // ── 轻量回收：只清空当前 tab（不重启浏览器） ──
   async function recyclePage() {
     if (!page || page.isClosed()) {
       page = await getOrCreatePage(browser);
@@ -955,117 +845,29 @@ export async function handleScoreAll(parsed) {
     }
   }
 
-  // ── 深度回收：关闭浏览器 + 可选切换端口 ──
-  async function recycleCdpSession(reason, { switchPort = true } = {}) {
-    const oldPort = cdpPort;
-    const shouldSwitch = switchPort && RECYCLE_CONFIG.switchPortOnRecycle;
-    if (shouldSwitch) {
-      cdpPort = await pickNextPort(cdpPort);
-      cdpOpts.port = cdpPort;
-      clientMeta.port = cdpPort;
-      usedPorts.add(cdpPort);
-    }
-    const portHint =
-      oldPort === cdpPort ? `port=${cdpPort}` : `port ${oldPort}→${cdpPort}`;
-    log(`  ♻️ 重建 CDP 会话 (${reason}; ${portHint})...`);
-    if (page) {
-      await page.close().catch(() => {});
-      page = null;
-    }
-    // CDP 模式下 browser.close() 只断开连接不杀进程，必须显式 kill 旧端口实例；
-    // kill 后确认端口已释放，再启动新实例，防止旧浏览器窗口残留（多开）
-    if (oldPort !== cdpPort) {
-      await killEdgeProcesses(null, oldPort).catch(() => {});
-      if (!(await waitForPortReleased(oldPort))) {
-        log(`  ⚠️ 旧端口 ${oldPort} 未释放，再次尝试关闭...`);
-        await killEdgeProcesses(null, oldPort).catch(() => {});
-        if (!(await waitForPortReleased(oldPort, 5000))) {
-          log(
-            `  ⚠️ 旧端口 ${oldPort} 仍未释放，继续使用新端口（旧浏览器窗口可能残留，退出时会统一清理）`,
-          );
-        }
-      }
-    }
-    await browser.close().catch(() => {});
-    browser = await ensureBrowserReady(cdpOpts);
-    page = await getOrCreatePage(browser);
-    await setupPageRequestBlocking(page);
-    lastRecycleAt = Date.now();
-  }
-
-  // ── 内存检查 + 自动回收 ──
-  // 策略：Node.js 内存超阈值 → 不换端口（只重建连接）
-  //        Edge 内存超阈值 → 换端口（杀旧浏览器 + 启新实例，彻底释放）
-  //        定期轮次         → 不换端口
-  async function maybeRecycleForMemory() {
-    const mem = process.memoryUsage();
-    const rssMB = mem.rss / 1024 / 1024;
-    const heapMB = mem.heapUsed / 1024 / 1024;
-    const edgeMB = getBrowserMemory(cdpPort);
-
-    const nodeOver =
-      rssMB >= RECYCLE_CONFIG.nodeRssMb || heapMB >= RECYCLE_CONFIG.nodeHeapMb;
-    const edgeOver = edgeMB !== null && edgeMB >= RECYCLE_CONFIG.edgeMb;
-
-    if (nodeOver || edgeOver) {
-      // 冷却期内跳过
-      if (
-        RECYCLE_CONFIG.cooldownMs > 0 &&
-        Date.now() - lastRecycleAt < RECYCLE_CONFIG.cooldownMs
-      )
-        return;
-
-      const parts = [];
-      if (rssMB >= RECYCLE_CONFIG.nodeRssMb)
-        parts.push(`rss=${rssMB.toFixed(0)}≥${RECYCLE_CONFIG.nodeRssMb}`);
-      if (heapMB >= RECYCLE_CONFIG.nodeHeapMb)
-        parts.push(`heap=${heapMB.toFixed(0)}≥${RECYCLE_CONFIG.nodeHeapMb}`);
-      if (edgeOver)
-        parts.push(`edge:${cdpPort}=${edgeMB}≥${RECYCLE_CONFIG.edgeMb}`);
-
-      await recycleCdpSession(`mem ${parts.join("+")}`, {
-        switchPort: edgeOver,
-      });
-      return;
-    }
-
-    // 定期轮次回收（默认关闭）
-    if (
-      RECYCLE_CONFIG.periodicEvery > 0 &&
-      totalScored > 0 &&
-      totalScored % RECYCLE_CONFIG.periodicEvery === 0
-    ) {
-      await recycleCdpSession(`periodic #${totalScored}`, {
-        switchPort: false,
-      });
-    }
-  }
-
   let totalScored = 0;
   let emptyRounds = 0; // 连续无任务的轮数
-  let consecutiveCaptcha = 0;
-  const MAX_CONSECUTIVE_CAPTCHA = 3;
-  let consecutiveTaskErrors = 0; // 连续任务处理错误计数（达阈值后上报服务端）
-  const CONSECUTIVE_TASK_ERRORS_MAX = Math.max(
-    1,
-    parseInt(
-      process.env.TAG_SCOREALL_CONSECUTIVE_TASK_ERRORS_MAX || "20",
-      10,
-    ) || 20,
-  ); // 连续任务错误阈值，达到后上报 /api/error-report
-
-  // ── 403 判封 + 重试机制 ──
-  let currentTag = null; // 当前正在处理的 tag（403 重试时复用，不消耗下一个）
-  let retrySameTag = false; // 是否重试同一个 tag
-  let tag403Attempts = 0; // 当前 tag 已发生 403 的次数
-  let bannedCount = 0; // 连续判定“被封”的次数（成功 tag 清零）
-  // 403 渐退重试间隔（秒）：30/40/50s 各重试一次，仍 403 才判定“被封”一次。
-  // 与 api-interceptor 被封重试（30/40/50s 共 3 次）保持一致
-  const BAN_RETRY_WAITS = [
-    (parseInt(process.env.TAG_SCOREALL_403_RETRY_1 || "30", 10) || 30) * 1000,
-    (parseInt(process.env.TAG_SCOREALL_403_RETRY_2 || "40", 10) || 40) * 1000,
-    (parseInt(process.env.TAG_SCOREALL_403_RETRY_3 || "50", 10) || 50) * 1000,
-  ];
+
+  // ── 错误计数（纯观察，不做任何自愈） ──
+  // 阈值语义：连续超过 N 次触发动作（即第 N+1 次）
+  //   403      连续 >2 次 → 上报服务端 + 强制 fallback（daemon 换节点），清零后继续跑
+  //   网络错误 连续 >10 次 → 打印退出（服务端不可达时 fallback 请求也发不出去）
+  //   验证码   连续 >3 次（人工一直未解决）→ 打印退出
+  //   其他错误 连续 >10 次 → 打印退出
+  // 清零规则：成功处理一个 tag → 全部清零；fallback 触发 → 403 计数清零；
+  //           人工点掉验证码 → 验证码计数清零
+  const errorCounts = { http403: 0, network: 0, captcha: 0, other: 0 };
+  const ERROR_LIMITS = { http403: 2, network: 10, captcha: 3, other: 10 };
+  const resetAllErrorCounts = () => {
+    errorCounts.http403 = 0;
+    errorCounts.network = 0;
+    errorCounts.captcha = 0;
+    errorCounts.other = 0;
+  };
+  const bumpErrorCount = (type) => {
+    errorCounts[type]++;
+    return errorCounts[type] > ERROR_LIMITS[type];
+  };
 
   // 生成客户端 ID，用于服务端追踪
   const clientId = randomUUID();
@@ -1098,14 +900,10 @@ export async function handleScoreAll(parsed) {
     if (enrichScraper) await enrichScraper.close().catch(() => {});
     log("正在关闭 CDP 浏览器...");
     try {
-      // 逐个关闭运行期用过的所有端口（含换端口历史），防止旧浏览器窗口残留
-      const ports = [...new Set([...usedPorts, cdpPort])];
-      for (const p of ports) {
-        await Promise.race([
-          killEdgeProcesses(null, p),
-          new Promise((r) => setTimeout(r, 5000)),
-        ]).catch(() => {});
-      }
+      await Promise.race([
+        killEdgeProcesses(null, cdpPort),
+        new Promise((r) => setTimeout(r, 5000)),
+      ]).catch(() => {});
       log("浏览器已关闭");
     } catch (e) {
       log(`关闭浏览器失败: ${e.message}`);
@@ -1134,43 +932,38 @@ export async function handleScoreAll(parsed) {
         return;
       }
       try {
-        let tag;
-        if (retrySameTag) {
-          // 403 重试：复用当前 tag，不消耗队列里的下一个
-          tag = currentTag;
-        } else {
-          // 从服务端取下一个 new 标签（同时查剩余数量）
-          const tagsRes = await fetch(
-            `${baseUrl}/api/tags?status=new&limit=1&userId=${encodeURIComponent(userId)}`,
-            {
-              headers: buildClientHeaders(clientId, clientMeta),
-            },
-          );
-          const tagsData = await tagsRes.json();
+        // 从服务端取下一个 new 标签（同时查剩余数量）
+        const tagsRes = await fetch(
+          `${baseUrl}/api/tags?status=new&limit=1&userId=${encodeURIComponent(userId)}`,
+          {
+            headers: buildClientHeaders(clientId, clientMeta),
+          },
+        );
+        const tagsData = await tagsRes.json();
 
-          if (!tagsData.tags || tagsData.tags.length === 0) {
-            emptyRounds++;
+        if (!tagsData.tags || tagsData.tags.length === 0) {
+          emptyRounds++;
 
-            // 服务端定时发现会自动补充标签，客户端只需等待
-            if (emptyRounds >= 5) {
-              log(
-                `⏳ 连续 ${emptyRounds} 轮无标签，等待服务端发现补充（30 秒后重试）...`,
-              );
-              await new Promise((r) => setTimeout(r, 30000));
-              emptyRounds = 0;
-              continue;
-            }
-            log(`⏳ 暂无待打分标签（连续 ${emptyRounds} 轮），10 秒后重试...`);
-            await new Promise((r) => setTimeout(r, 10000));
+          // 服务端定时发现会自动补充标签，客户端只需等待
+          if (emptyRounds >= 5) {
+            log(
+              `⏳ 连续 ${emptyRounds} 轮无标签，等待服务端发现补充（30 秒后重试）...`,
+            );
+            await new Promise((r) => setTimeout(r, 30000));
+            emptyRounds = 0;
             continue;
           }
-
-          // 有任务了，重置计数器
-          emptyRounds = 0;
-          tag = tagsData.tags[0].tag.replace(/^#+/, "").trim().toLowerCase();
-          currentTag = tag;
-          tag403Attempts = 0;
+          log(`⏳ 暂无待打分标签（连续 ${emptyRounds} 轮），10 秒后重试...`);
+          await new Promise((r) => setTimeout(r, 10000));
+          continue;
         }
+
+        // 有任务了，重置计数器
+        emptyRounds = 0;
+        const tag = tagsData.tags[0].tag
+          .replace(/^#+/, "")
+          .trim()
+          .toLowerCase();
         const startTime = Date.now();
 
         log(`[${totalScored + 1}] 正在打分 #${tag} ...`);
@@ -1188,8 +981,7 @@ export async function handleScoreAll(parsed) {
         };
 
         // 锁定 tag（meta 中不放入 tag，避免非 ASCII 字符导致 header ByteString 报错）
-        // 403 重试时 tag 已被本客户端锁定，跳过 claim，直接复用
-        if (!retrySameTag) {
+        {
           const claimRes = await fetch(
             `${baseUrl}/api/tags/claim?userId=${encodeURIComponent(userId)}`,
             {
@@ -1251,7 +1043,6 @@ export async function handleScoreAll(parsed) {
             totalScored++;
             await randomDelay(0, 5000);
             await recyclePage();
-            await maybeRecycleForMemory();
             continue;
           }
           // 非 tag_not_found 的 0 视频 → 抛异常让其走 error 重试路径，避免误标 dead
@@ -1313,18 +1104,14 @@ export async function handleScoreAll(parsed) {
             );
             videos = enriched.videos;
 
-            // CDN 限流检测：有拦截则冷却 + 重启 scraper
+            // CDN 限流：打印并计入其他错误计数（不自愈、不重启 scraper）
             const cdnBlocked = enriched.cdnBlockedCount || 0;
             if (cdnBlocked > 0) {
               const cdnRatio = cdnBlocked / (videos.length || 1);
-              const coolSec = cdnRatio > 0.3 ? 120 : 60;
+              bumpErrorCount("other");
               log(
-                `  ⚠️ CDN 限流: ${cdnBlocked}/${videos.length} (${(cdnRatio * 100).toFixed(0)}%)，冷却 ${coolSec} 秒后重启 scraper`,
+                `  ⚠️ CDN 限流: ${cdnBlocked}/${videos.length} (${(cdnRatio * 100).toFixed(0)}%)，计入其他错误计数 (${errorCounts.other}/${ERROR_LIMITS.other})`,
               );
-              await new Promise((r) => setTimeout(r, coolSec * 1000));
-              log(`  正在重启 TikTokScraper...`);
-              await enrichScraper.restart();
-              log(`  ✅ TikTokScraper 已重启`);
             }
           }
 
@@ -1352,7 +1139,6 @@ export async function handleScoreAll(parsed) {
             `  ⏭️ 重试 ${COUNTRY_MAX_RETRIES} 次后国家识别率仍 ${(rate * 100).toFixed(0)}% < ${(COUNTRY_RATE_MIN * 100).toFixed(0)}%，跳过该标签，处理下一个`,
           );
           await recyclePage();
-          await maybeRecycleForMemory();
           await randomDelay(3000, 7000);
           continue;
         }
@@ -1397,10 +1183,7 @@ export async function handleScoreAll(parsed) {
           `  ${icon} ${result.status} score=${result.score} authors=${result.authorCount} matched=${result.matchedAuthors} (${elapsed}s)${mc ? "  " + mc : ""}${memStr}`,
         );
         log("");
-        consecutiveTaskErrors = 0; // 成功完成，重置连续任务错误计数
-        retrySameTag = false; // 成功，不再重试
-        tag403Attempts = 0;
-        bannedCount = 0; // 成功 tag，重置连续判封计数
+        resetAllErrorCounts(); // 成功一个 tag → 所有错误计数清零
         // 每 10 个标签输出一次内存汇总
         if (totalScored % 10 === 0) {
           log(
@@ -1408,7 +1191,6 @@ export async function handleScoreAll(parsed) {
           );
         }
         await recyclePage();
-        await maybeRecycleForMemory();
         await randomDelay(3000, 7000);
       } catch (e) {
         // 浏览器窗口被手动关闭（CDP 断开）→ 自动退出，避免无限重试循环
@@ -1427,7 +1209,17 @@ export async function handleScoreAll(parsed) {
               e.message.includes("fetch failed") ||
               e.message.includes("network")));
         if (isNetworkError) {
-          log(`  ⚠️ 服务端连接失败 (${e.message})，15 秒后重试...`);
+          const over = bumpErrorCount("network");
+          log(
+            `  ⚠️ 服务端连接失败 (${e.message})，15 秒后重试（连续网络错误 ${errorCounts.network} 次）...`,
+          );
+          if (over) {
+            log(
+              `  ❌ 连续网络错误超过 ${ERROR_LIMITS.network} 次 → 打印并退出（服务端不可达，fallback 发不出去）`,
+            );
+            await cleanup();
+            return;
+          }
           await new Promise((r) => setTimeout(r, 15000));
           continue;
         }
@@ -1441,35 +1233,16 @@ export async function handleScoreAll(parsed) {
           e.message &&
           (e.message.includes("验证码") || e.message.includes("captcha"));
 
-        // ── 403：渐退等待 30/40/50s 各重试一次，仍 403 判定“被封” ──
-        // 首次被封重启浏览器（同端口换新会话），后续仍 403 只清 tab
+        // ── 403：当前 tag 不上报（留在服务端 scoring 状态超时回收），
+        //        只计数；连续 >2 次上报服务端 + 强制 fallback（daemon 换节点），
+        //        计数清零后继续跑 ──
         if (is403) {
-          const retryIndex = tag403Attempts;
-          tag403Attempts++;
-          if (retryIndex < BAN_RETRY_WAITS.length) {
-            const waitMs = BAN_RETRY_WAITS[retryIndex];
-            retrySameTag = true;
-            if (retryIndex === 0) {
-              log(
-                `  🚫 HTTP 403，判定被封，重启浏览器后 ${waitMs / 1000}s 第 ${tag403Attempts}/${BAN_RETRY_WAITS.length} 次重试 #${currentTag} ...`,
-              );
-              await recycleCdpSession(`首次被封`, { switchPort: false });
-            } else {
-              log(
-                `  🚫 HTTP 403，判定被封，${waitMs / 1000}s 后第 ${tag403Attempts}/${BAN_RETRY_WAITS.length} 次重试 #${currentTag} ...`,
-              );
-              await recyclePage();
-            }
-            await new Promise((r) => setTimeout(r, waitMs));
-            continue;
-          }
-          // 重试耗尽：判定“被封”
-          bannedCount++;
-          log(
-            `  🚫 30/40/50s 重试 ${BAN_RETRY_WAITS.length} 次仍 403，判定账号被封（连续判封 ${bannedCount} 次）`,
-          );
-          if (bannedCount >= 2) {
-            log(`  ⚠️ 连续两次判封 → 汇报服务端 + 触发 daemon fallback`);
+          const over = bumpErrorCount("http403");
+          log(`  🚫 HTTP 403（连续第 ${errorCounts.http403} 次）`);
+          if (over) {
+            log(
+              `  ⚠️ 连续 403 超过 ${ERROR_LIMITS.http403} 次 → 上报服务端 + 触发 daemon fallback`,
+            );
             await reportClientErrorAndFailover({
               post: (url, body) =>
                 fetch(url, {
@@ -1482,16 +1255,13 @@ export async function handleScoreAll(parsed) {
               baseUrl,
               userId,
               errorType: "consecutive_blocked",
-              message: `连续两次判定账号被封 (port=${cdpPort})`,
+              message: `连续 ${ERROR_LIMITS.http403 + 1} 次 403 (port=${cdpPort})`,
               stage: "tag-scoring",
               log,
             });
-            bannedCount = 0;
+            errorCounts.http403 = 0; // fallback 触发后清零
           }
-          retrySameTag = false;
-          tag403Attempts = 0;
           await recyclePage();
-          await maybeRecycleForMemory();
           await randomDelay(3000, 7000);
           continue;
         }
@@ -1500,9 +1270,9 @@ export async function handleScoreAll(parsed) {
         log(`  ❌ 失败: ${e.message}`);
 
         if (isCaptcha) {
-          consecutiveCaptcha++;
+          bumpErrorCount("captcha");
           log(
-            `  🔐 验证码 (${consecutiveCaptcha}/${MAX_CONSECUTIVE_CAPTCHA})，等待用户手动解决...`,
+            `  🔐 验证码（连续第 ${errorCounts.captcha} 次），等待用户手动解决...`,
           );
 
           // 上报验证码错误
@@ -1525,24 +1295,31 @@ export async function handleScoreAll(parsed) {
           } catch {}
 
           // 等待用户手动解决验证码（最多 3 分钟）
+          let captchaResolved = false;
           try {
             const captchaResult = await waitAndGetCaptcha(page, {
               waitMs: 180000,
               pollInterval: 5000,
               log: () => {},
             });
+            captchaResolved = !!captchaResult.resolved;
             if (captchaResult.detected && !captchaResult.resolved) {
               await closeCaptcha(page).catch(() => {});
             }
           } catch {}
 
-          if (consecutiveCaptcha >= MAX_CONSECUTIVE_CAPTCHA) {
-            log(`  ♻️ 连续${MAX_CONSECUTIVE_CAPTCHA}次验证码 → 重启浏览器`);
-            await recycleCdpSession("连续验证码", { switchPort: true });
-            consecutiveCaptcha = 0;
+          if (captchaResolved) {
+            // 人工点掉验证码 → 验证码计数清零
+            log(`  ✅ 验证码已被人工处理，验证码计数清零`);
+            errorCounts.captcha = 0;
+          } else if (errorCounts.captcha > ERROR_LIMITS.captcha) {
+            log(
+              `  ❌ 连续验证码超过 ${ERROR_LIMITS.captcha} 次且未解决 → 打印并退出`,
+            );
+            await cleanup();
+            return;
           }
-        } else {
-          consecutiveCaptcha = 0;
+          continue;
         }
 
         try {
@@ -1561,34 +1338,14 @@ export async function handleScoreAll(parsed) {
           );
         } catch {}
 
-        // 连续任务错误达到阈值，上报服务端 + 触发 daemon fallback 换节点
-        consecutiveTaskErrors++;
-        if (consecutiveTaskErrors >= CONSECUTIVE_TASK_ERRORS_MAX) {
-          log(
-            `  ⚠️ 连续任务错误 ${consecutiveTaskErrors}/${CONSECUTIVE_TASK_ERRORS_MAX} → 汇报服务端 + 触发 fallback`,
-          );
-          await reportConsecutiveTaskErrors({
-            post: (url, body) =>
-              fetch(url, {
-                method: "POST",
-                headers: buildClientHeaders(clientId, clientMeta, {
-                  "Content-Type": "application/json",
-                }),
-                body: JSON.stringify(body),
-              }),
-            baseUrl,
-            userId,
-            message: `连续 ${consecutiveTaskErrors} 个标签处理失败 (port=${cdpPort})`,
-            stage: "tag-scoring",
-            log,
-          });
-          consecutiveTaskErrors = 0;
-        }
         totalScored++;
-        retrySameTag = false;
-        tag403Attempts = 0;
+        const over = bumpErrorCount("other");
+        if (over) {
+          log(`  ❌ 连续其他错误超过 ${ERROR_LIMITS.other} 次 → 打印并退出`);
+          await cleanup();
+          return;
+        }
         await recyclePage();
-        await maybeRecycleForMemory();
       }
     }
   } finally {
@@ -1649,7 +1406,7 @@ export async function handleTag(parsed) {
         .split(",")
         .map((s) => s.trim().toUpperCase())
         .filter(Boolean)
-    : DEFAULT_TARGET_LOCATIONS;
+    : getTargetLocations();
 
   const autoEnrich = enrich || !!discover;
 
@@ -2129,7 +1886,7 @@ export async function handleTagRefresh(parsed) {
         }
 
         // 过滤目标国家的视频和作者
-        const targetLocations = DEFAULT_TARGET_LOCATIONS;
+        const targetLocations = getTargetLocations();
         const filteredVideos = videos.filter((v) =>
           isLocationInList(v.locationCreated, targetLocations),
         );