tt-help-cli-ycl 1.4.183 → 1.4.185

package/src/cli/search.js

@@ -26,6 +26,7 @@ import {
   getOrCreatePage,
   safeCheckLogin,
   isBrowserClosedError,
+  isRetryableRestoreFailure,
   relaunchBrowser,
 } from "../lib/browser/page.js";
 import { collectSearchAuthors } from "../lib/search-collector.js";
@@ -39,16 +40,23 @@ import {
   closeCaptcha,
 } from "../scraper/modules/captcha-handler.js";
 import { createApiClient } from "../lib/api-client.js";
+import { createErrorReporter } from "../lib/error-report.js";
 import {
   HealthChecker,
-  MEMORY_THRESHOLD,
   ROTATE_INTERVAL_MS,
 } from "../lib/browser/health-checker.js";
 import {
   createLoginPoolClient,
   injectPoolAccount,
   ensurePoolLogin,
+  crashBackoffMs,
+  retryRestoreOnNavFailure,
+  CANDIDATE_INJECT_MAX_RETRIES,
+  CANDIDATE_INJECT_DELAY_MS,
+  decideCandidateInjectAction,
+  isRetryableInjectFailure,
 } from "../lib/login-pool-client.js";
+import { getClientConfig } from "../watchdog/reporter.js";
 import {
   server as cfgServer,
   proxy as configuredProxy,
@@ -62,6 +70,7 @@ const STARTUP_TIKTOK_URL = "https://www.tiktok.com/@ycl5007";
 const PAGE_GOTO_TIMEOUT = 60000;
 const MAX_RETRY_WAIT = 5 * 60 * 1000;
 const MAX_REBUILD_ATTEMPTS = 5; // 账户切换后导航恢复：连续重启浏览器超过该次数仍失败则上报并退出
+const CRASH_BACKOFF_SLICE_MS = 1000; // 崩溃熔断/恢复重试等待的分片粒度（分片醒检 shuttingDown）
 
 async function withRetry(label, fn) {
   let backoff = 1000;
@@ -115,11 +124,14 @@ export async function handleSearch(parsed) {
   // ── 初始化 ──
   const baseUrl = serverUrl || DEFAULT_SERVER;
   const poolMode = !searchNoPool;
+  // 内存阈值可配置覆盖（~/.tt-help.json memoryThreshold，默认 0.95）：F16 类 7G 双浏览器机可调低提前重启
+  const memoryThresholdConfig = getClientConfig().memoryThreshold;
   const healthChecker = poolMode
-    ? new HealthChecker({ basePort, totalAccounts: 1 })
+    ? new HealthChecker({ basePort, totalAccounts: 1, memoryThreshold: memoryThresholdConfig })
     : new HealthChecker({
         basePort,
         totalAccounts: portCount,
+        memoryThreshold: memoryThresholdConfig,
       });
   let currentAccount = healthChecker.getCurrentAccount();
 
@@ -136,6 +148,21 @@ export async function handleSearch(parsed) {
   let poolClient = null;
   let poolAccount = null;
   let poolAccountSince = Date.now();
+  // 崩溃熔断状态（F16 实录）：浏览器级注入失败轮数 + 退避窗口截止时刻（窗口内不取号）
+  let crashStreak = 0;
+  let crashBackoffUntil = 0;
+
+  /** 分片 sleep：每 CRASH_BACKOFF_SLICE_MS 醒检 shuttingDown，被中断返回 false */
+  const sleepSliced = async (totalMs) => {
+    let remaining = totalMs;
+    while (remaining > 0) {
+      if (shuttingDown) return false;
+      const slice = Math.min(CRASH_BACKOFF_SLICE_MS, remaining);
+      await new Promise((r) => setTimeout(r, slice));
+      remaining -= slice;
+    }
+    return !shuttingDown;
+  };
 
   const cleanup = () => {
     if (shuttingDown) return;
@@ -167,6 +194,15 @@ export async function handleSearch(parsed) {
   }
   log(`[Search] 用户编号: ${userId}`);
 
+  // 客户端错误上报封装：自动附带 poolUsername（报错时在手池号）与 proxyNode（当前 clash 节点）
+  const errorReporter = createErrorReporter({
+    apiPost,
+    serverUrl: baseUrl,
+    userId,
+    proxyUrl: resolvedProxy,
+    getState: () => ({ poolUsername: poolAccount?.username || "" }),
+  });
+
   setDelayConfig("normal");
 
   try {
@@ -378,8 +414,7 @@ export async function handleSearch(parsed) {
               log(
                 `[致命] 账户切换后导航持续失败，已重启浏览器 ${rebuildCount - 1} 次仍无法恢复，上报后退出`,
               );
-              await apiPost(`${baseUrl}/api/error-report`, {
-                userId,
+              await errorReporter.report({
                 username: "account-switch",
                 errorType: "account_switch_failed",
                 errorMessage: `账户切换后导航持续失败: ${err.message}`,
@@ -435,8 +470,43 @@ export async function handleSearch(parsed) {
 
     // ── 登录池模式辅助 ──
 
-    async function switchPoolAccount(reason) {
+    async function switchPoolAccount(reason, opts = {}) {
       log(`\n[换号] ${reason}，从账号中心取新账号...`);
+      // 崩溃熔断：退避窗口内不取号（保护账号池），分片 sleep 响应 shuttingDown
+      const backoffWaitMs = Math.max(0, crashBackoffUntil - Date.now());
+      if (backoffWaitMs > 0) {
+        log(
+          `[浏览器] 崩溃熔断中，${Math.ceil(backoffWaitMs / 1000)}s 后再试（不取号，保护账号池）`,
+        );
+        if (!(await sleepSliced(backoffWaitMs))) return false;
+      }
+      // 候选注入失败命中浏览器级崩溃签名时的处置（首判与重试中途重判共用）：
+      // crashStreak++ 按轮退避 + 释放候选 + 上报 + 转同号重启；返回值由调用方直接 return
+      async function abortCandidateLoopOnCrash(crashReason, candidate, fromRecovery) {
+        // 浏览器级崩溃：不怪账号，立即中止候选循环（不消耗 inject_fail 口径），
+        // 已取候选照常 release，转同号重启（与内存超限路径同语义）；按轮熔断退避
+        crashStreak++;
+        const backoffMs = crashBackoffMs(crashStreak);
+        crashBackoffUntil = Date.now() + backoffMs;
+        log(
+          `[换号] @${candidate.username} 注入失败为浏览器级崩溃（${crashReason}），中止候选循环（第 ${crashStreak} 轮，熔断 ${Math.round(backoffMs / 1000)}s），释放候选...`,
+        );
+        await poolClient.release(candidate).catch(() => {});
+        await errorReporter.report({
+          username: poolAccount ? poolAccount.username : "unknown",
+          errorType: "account_switch_failed",
+          errorMessage: `注入失败为浏览器级崩溃，中止候选循环转同号重启（第${crashStreak}轮，熔断${Math.round(backoffMs / 1000)}s）: ${crashReason}`,
+          stage: "account-switch",
+        }).catch(() => {});
+        if (fromRecovery) {
+          // 恢复链中（重启后恢复失败触发的换号）不再递归重启，保留现场等熔断窗口
+          log(`[换号] 恢复链中不再递归重启浏览器，保留现场等待熔断窗口`);
+          return false;
+        }
+        return await restartPoolBrowser(
+          `注入验证遭遇浏览器级崩溃（${crashReason}）`,
+        );
+      }
       for (let attempt = 0; attempt < 5; attempt++) {
         let next = null;
         try {
@@ -447,18 +517,77 @@ export async function handleSearch(parsed) {
           );
           return false;
         }
-        const r = await injectPoolAccount(page, next, {
+        let r = await injectPoolAccount(page, next, {
           verifyUsername: next.username,
         }).catch((e) => ({ ok: false, reason: e.message }));
         if (!r.ok) {
-          log(`[换号] @${next.username} 注入验证失败（${r.reason}），释放候选换下一个...`);
-          await poolClient.release(next).catch(() => {});
-          continue;
+          // 注入失败三路分流（与 explore.js 镜像）：崩溃 → 既有熔断（中止候选循环）；
+          // 确定性号死 → 立即弃号换下一个候选（现状行为）；
+          // 瞬态/环境失败 → 同一候选原号重试（共 3 次尝试，间隔 15s），重试期间租约保持在手
+          let action = decideCandidateInjectAction(r.reason, isBrowserClosedError);
+          if (action === "circuit-break") {
+            return await abortCandidateLoopOnCrash(r.reason, next, opts.fromRecovery);
+          }
+          if (action === "retry") {
+            // 瞬态/环境失败（超时/AbortError/net::ERR_*/Execution context destroyed/无账号数据/导航类）：
+            // 原号重试最多 2 次（共 3 次尝试），间隔 15s，重试期间不 release（租约保持在手）；
+            // 确定性号死（会话过期/身份不符）不进此分支，直接弃号换下一个候选
+            r = await retryRestoreOnNavFailure(
+              () =>
+                injectPoolAccount(page, next, { verifyUsername: next.username }),
+              r.reason,
+              {
+                isRetryable: isRetryableInjectFailure,
+                maxRetries: CANDIDATE_INJECT_MAX_RETRIES,
+                delayMs: CANDIDATE_INJECT_DELAY_MS,
+                sleep: (ms) => sleepSliced(ms),
+                shouldAbort: () => shuttingDown,
+                onRetry: (n, delayMs, why) =>
+                  log(
+                    `[换号] @${next.username} 第${n}次注入失败（瞬态，${why}），${Math.round(delayMs / 1000)}s 后原号重试`,
+                  ),
+              },
+            );
+            if (r.aborted) {
+              // shuttingDown 中断：释放候选退出（租约主动还干净，服务端 TTL 兑底）
+              log(`[换号] @${next.username} 原号重试等待中被关闭信号中断，释放候选`);
+              await poolClient.release(next).catch(() => {});
+              return false;
+            }
+            if (r.ok && r.attempts > 1) {
+              log(
+                `[换号] @${next.username} 原号重试成功（第 ${r.attempts} 次尝试）`,
+              );
+            }
+            if (!r.ok) {
+              // 重试中途失败签名可能升级为浏览器级崩溃（如首败 timeout、再败 Page crashed）：
+              // 对最终原因重判，命中熔断则中止候选循环（不弃号给下一候选——坏浏览器再吃一个号），
+              // 升级为确定性号死则 fall through 到下方弃号分支换候选
+              action = decideCandidateInjectAction(r.reason, isBrowserClosedError);
+              if (action === "circuit-break") {
+                return await abortCandidateLoopOnCrash(r.reason, next, opts.fromRecovery);
+              }
+            }
+          }
+          if (!r.ok) {
+            if (r.attempts > 1) {
+              log(
+                `[换号] @${next.username} 原号重试 ${r.attempts - 1} 次后仍失败（共 ${r.attempts} 次尝试，${r.reason}），释放候选换下一个...`,
+              );
+            } else {
+              log(
+                `[换号] @${next.username} 注入验证失败（${r.reason}），释放候选换下一个...`,
+              );
+            }
+            await poolClient.release(next).catch(() => {});
+            continue;
+          }
         }
         const prev = poolAccount;
         poolAccount = next;
         poolAccountSince = Date.now();
         loggedIn = true;
+        crashStreak = 0; // 注入验证成功即清零熔断轮数
         captchaCount = 0;
         staleRounds = 0;
         consecutiveNetworkErrors = 0;
@@ -472,8 +601,7 @@ export async function handleSearch(parsed) {
         return true;
       }
       log(`[换号] 连续 5 个候选注入验证失败，保留现场等待下轮重试`);
-      await apiPost(`${baseUrl}/api/error-report`, {
-        userId,
+      await errorReporter.report({
         username: poolAccount ? poolAccount.username : "unknown",
         errorType: "account_switch_failed",
         errorMessage: "连续5个候选账号注入验证失败（详情见节点日志）",
@@ -485,17 +613,39 @@ export async function handleSearch(parsed) {
     /** 浏览器重建后恢复在手账号：磁盘态一致则免注入，否则用内存 cookies 补注入 */
     async function restorePoolLogin() {
       if (!poolAccount) return false;
-      const r = await ensurePoolLogin(page, poolAccount).catch((e) => ({
+      let r = await ensurePoolLogin(page, poolAccount).catch((e) => ({
         ok: false,
         reason: e.message,
       }));
+      if (!r.ok) {
+        // 导航类瞬态失败（net::ERR_* / 超时 / 崩溃）重试后再弃号，重试期间不弃号；
+        // 账号级失败（身份不符/会话过期）不重试直接走换号
+        r = await retryRestoreOnNavFailure(
+          () => ensurePoolLogin(page, poolAccount),
+          r.reason,
+          {
+            isRetryable: isRetryableRestoreFailure,
+            sleep: (ms) => sleepSliced(ms),
+            shouldAbort: () => shuttingDown,
+          },
+        );
+        if (r.aborted) return false;
+        if (!r.ok && r.attempts > 1) {
+          log(`[登录池] 登录态恢复重试 ${r.attempts} 次后仍失败`);
+        }
+      }
       if (r.ok) {
         loggedIn = true;
+        crashStreak = 0; // 恢复成功（含注入验证成功）即清零熔断轮数
         log(`[登录池] 登录态已恢复 @${poolAccount.username}`);
         return true;
       }
       log(`[登录池] 登录态恢复失败（${r.reason}），转入换号流程`);
-      return await switchPoolAccount(`浏览器重启后无法恢复 @${poolAccount.username} 的登录态`);
+      // 恢复链中的换号不再嵌套浏览器重启（fromRecovery）：崩溃则熔断退避，不烧池
+      return await switchPoolAccount(
+        `浏览器重启后无法恢复 @${poolAccount.username} 的登录态`,
+        { fromRecovery: true },
+      );
     }
 
     /** 内存超限：同号重启浏览器（不换号——内存是浏览器进程问题，不是账号问题） */
@@ -509,7 +659,10 @@ export async function handleSearch(parsed) {
         page = await setupNewPage(browser);
       } catch (e) {
         log(`[浏览器] 重启失败: ${e.message}，转入换号流程`);
-        return await switchPoolAccount(`浏览器重启失败（${e.message}）`);
+        // 恢复链中的换号不再嵌套浏览器重启（fromRecovery）：崩溃则熔断退避，不烧池
+        return await switchPoolAccount(`浏览器重启失败（${e.message}）`, {
+          fromRecovery: true,
+        });
       }
       return await restorePoolLogin();
     }
@@ -540,7 +693,7 @@ export async function handleSearch(parsed) {
           // 登录池模式：内存超限→同号重启浏览器；48min→换号（原地切号）
           const memRatio = healthChecker.memoryUsage();
           const elapsedMs = Date.now() - poolAccountSince;
-          if (memRatio >= MEMORY_THRESHOLD) {
+          if (memRatio >= healthChecker.memoryThreshold) {
             await restartPoolBrowser(`系统内存 ${(memRatio * 100).toFixed(1)}% 超阈值`);
           } else if (elapsedMs >= ROTATE_INTERVAL_MS) {
             await handleAccountSwitch(
@@ -582,7 +735,7 @@ export async function handleSearch(parsed) {
 
           // 上报
           await withRetry("report captcha", () =>
-            apiPost(`${baseUrl}/api/error-report`, {
+            errorReporter.report({
               userId: clientId,
               username: "unknown",
               errorType: "captcha",
@@ -739,7 +892,7 @@ export async function handleSearch(parsed) {
 
           const errorType = consecutiveNetworkErrors > 1 ? "network" : "other";
           await withRetry("report error", () =>
-            apiPost(`${baseUrl}/api/error-report`, {
+            errorReporter.report({
               userId: clientId,
               username: tag,
               errorType,
@@ -772,7 +925,7 @@ export async function handleSearch(parsed) {
           log(`  [验证码] 搜索后检测到验证码，累计 ${captchaCount} 次`);
 
           await withRetry("report captcha", () =>
-            apiPost(`${baseUrl}/api/error-report`, {
+            errorReporter.report({
               userId: clientId,
               username: tag,
               errorType: "captcha",

package/src/lib/browser/health-checker.js

@@ -5,12 +5,28 @@ import { execSync } from "child_process";
 const DEFAULT_BASE_PORT = 9222;
 const DEFAULT_TOTAL_ACCOUNTS = 10;
 const MEMORY_THRESHOLD = 0.95;
+// 配置覆盖（~/.tt-help.json memoryThreshold）钳制边界：过低误触发频繁重启，过高失去保护意义
+const MEMORY_THRESHOLD_MIN = 0.5;
+const MEMORY_THRESHOLD_MAX = 0.98;
 const ROTATE_INTERVAL_MS = 0.8 * 60 * 60 * 1000;
 
+/**
+ * 内存阈值解析：缺省/非法（null/undefined/空串/非数值）回退默认 0.95，
+ * 合法值钳制 [0.5, 0.98]。纯函数，供 HealthChecker 构造与单测使用。
+ */
+function resolveMemoryThreshold(raw) {
+  if (raw === null || raw === undefined || raw === "") return MEMORY_THRESHOLD;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return MEMORY_THRESHOLD;
+  return Math.min(MEMORY_THRESHOLD_MAX, Math.max(MEMORY_THRESHOLD_MIN, n));
+}
+
 class HealthChecker {
   constructor(options = {}) {
     const basePort = options.basePort ?? DEFAULT_BASE_PORT;
     const totalAccounts = options.totalAccounts ?? DEFAULT_TOTAL_ACCOUNTS;
+    // 内存阈值可配置覆盖（默认 0.95）：F16 类 7G 双浏览器机可调低提前重启（explore/search 构造时传入）
+    this.memoryThreshold = resolveMemoryThreshold(options.memoryThreshold);
 
     this.accounts = [];
     for (let i = 0; i < totalAccounts; i++) {
@@ -83,7 +99,7 @@ class HealthChecker {
     const memUsage = this.memoryUsage();
     const memPercent = (memUsage * 100).toFixed(1);
 
-    if (memUsage >= MEMORY_THRESHOLD) {
+    if (memUsage >= this.memoryThreshold) {
       const currentPort = this.accounts[this.currentIndex].port;
       return {
         shouldSwitch: true,
@@ -104,7 +120,7 @@ class HealthChecker {
     // 计算预计切换时间
     const remainingMs = ROTATE_INTERVAL_MS - elapsed;
     const remainingMins = Math.round(remainingMs / 60000);
-    const memHeadroom = ((MEMORY_THRESHOLD - memUsage) * 100).toFixed(1);
+    const memHeadroom = ((this.memoryThreshold - memUsage) * 100).toFixed(1);
     const currentPort = this.accounts[this.currentIndex].port;
 
     return {
@@ -114,4 +130,4 @@ class HealthChecker {
   }
 }
 
-export { HealthChecker, MEMORY_THRESHOLD, ROTATE_INTERVAL_MS };
+export { HealthChecker, MEMORY_THRESHOLD, MEMORY_THRESHOLD_MIN, MEMORY_THRESHOLD_MAX, resolveMemoryThreshold, ROTATE_INTERVAL_MS };

package/src/lib/browser/page.js

@@ -15,12 +15,20 @@ const DEFAULT_USER_DATA_DIR = path.join(
 const BROWSER_CLOSED_PATTERNS = [
   "Target page, context or browser has been closed",
   "Target closed",
+  "Target crashed",
+  "Page crashed",
   "Browser has been closed",
   "Protocol error",
   "Connection closed",
   "net::ERR_CONNECTION",
 ];
 
+/**
+ * 判定浏览器级故障：浏览器关闭**或渲染进程崩溃**。
+ * 渲染崩溃（Target/Target crashed / Page crashed）发生时 CDP 连接往往仍存活，
+ * 但页面已死，须与连接断开同语义处理：重建浏览器 + 重试。
+ * （F16 实录：崩溃曾被误判为「账号注入失败」驱动换号循环，单日烧 28 个账号）
+ */
 export function isBrowserClosedError(error) {
   if (!error) return false;
   const msg = error.message || error.toString() || "";
@@ -71,6 +79,21 @@ const DOM_CHECK_RETRIES = 3; // DOM 检测最大重试次数
 const SAFE_CHECK_ROUNDS = 2; // 安全登录检测轮数（首次检测 + 额外1轮确认）
 const SAFE_CHECK_INTERVAL = 5000; // 安全登录检测每轮间隔 5 秒
 
+/**
+ * 登录态恢复失败是否属导航类瞬态失败（可重试，重试期间不弃号）：
+ * - net::ERR_*（含 ERR_HTTP_RESPONSE_CODE_FAILURE / ERR_CONNECTION_* 等导航层错误）
+ * - 超时（Timeout ... exceeded / timed out）
+ * - 浏览器级关闭或渲染崩溃（isBrowserClosedError）
+ * 账号级失败（身份不符/会话过期/无账号数据等）不可重试，直接走换号流程。
+ */
+export function isRetryableRestoreFailure(reason) {
+  if (!reason) return false;
+  const msg = String(reason);
+  if (msg.includes("net::ERR_")) return true;
+  if (/timed?\s*out|timeout/i.test(msg)) return true;
+  return isBrowserClosedError(new Error(msg));
+}
+
 /**
  * 判断登录状态：Cookie 为主，DOM 验真为辅。
  * - 无 sessionid Cookie → 未登录

package/src/lib/error-report.js

@@ -0,0 +1,119 @@
+/**
+ * 客户端错误上报封装（方案甲：客户端报错自带字段）
+ *
+ * 背景：/api/error-report 的旧 username 字段语义混乱（在手池号/"account-switch"
+ * 占位/被探索目标/"unknown" 四种混传），且代理节点完全没报。本封装统一附加：
+ *   - poolUsername：报错时在手池号（getState 注入，无在手号空串，不传 "unknown"）
+ *   - proxyNode：当前 clash 节点名（三级 fallback：端口匹配通道 → 主通道 → 空串）
+ * 旧 username 字段原样透传（兼容存量页面显示），语义不动。
+ *
+ * 用法：
+ *   const errorReporter = createErrorReporter({
+ *     apiPost, serverUrl, userId,
+ *     proxyUrl: resolvedProxy,                    // 可选，缺省用 ~/.tt-help.json 的 proxy
+ *     getState: () => ({ poolUsername: poolAccount?.username || "" }),
+ *   });
+ *   await errorReporter.report({ errorType, errorMessage, stage, errorStack, username });
+ *
+ * 单测：scripts/test-error-report.mjs
+ */
+
+import { proxy as configuredProxy } from "./constants.js";
+import {
+  getClashHealth,
+  getClashHealthChannels,
+} from "../watchdog/reporter.js";
+
+/** 从代理地址提取端口（http://127.0.0.1:7897 → 7897；解析不出返回 0） */
+export function parseProxyPort(url) {
+  if (!url) return 0;
+  try {
+    const u = new URL(url);
+    const p = parseInt(u.port, 10);
+    if (p > 0) return p;
+  } catch {
+    /* 非 URL 形态走正则兑底 */
+  }
+  const m = String(url).match(/:(\d+)/);
+  return m ? parseInt(m[1], 10) || 0 : 0;
+}
+
+/**
+ * 解析当前 clash 节点名（三级 fallback）：
+ *   1. 与业务代理端口匹配且非 stale 的通道（clash-health-{port}.json）的 node
+ *   2. 主通道（clash-health.json，daemon 对主控制端双写）非 stale 的 node
+ *   3. 读不到（无 clash daemon / 文件 stale / 无 node 字段）→ ""
+ *
+ * @param {string|null} proxyUrl - 业务代理地址（--proxy 或 ~/.tt-help.json 的 proxy）
+ * @param {{channels?: Array<object>, health?: object|null}} [deps] - 测试注入用
+ * @returns {string}
+ */
+export function resolveProxyNode(proxyUrl, deps = {}) {
+  const channels = deps.channels ?? getClashHealthChannels();
+  const health = deps.health !== undefined ? deps.health : getClashHealth();
+  const port = parseProxyPort(proxyUrl);
+  if (port > 0) {
+    const ch = channels.find((c) => c && c.port === port && !c.stale);
+    if (ch && ch.node) return String(ch.node);
+  }
+  if (health && !health.stale && health.node) return String(health.node);
+  return "";
+}
+
+/**
+ * 创建错误上报器
+ *
+ * @param {object} opts
+ * @param {(url: string, body: object) => Promise<any>} opts.apiPost - API 客户端 POST（createApiClient 产出）
+ * @param {string} opts.serverUrl - watch 服务端地址
+ * @param {string} opts.userId - 客户端用户编号（机器级；单次调用可用 userId 覆盖）
+ * @param {string|null} [opts.proxyUrl] - 业务代理地址（缺省读 ~/.tt-help.json 的 proxy）
+ * @param {() => {poolUsername?: string}} [opts.getState] - 报错时刻状态（CLI 闭包注入在手池号）
+ * @returns {{ report: (info: object) => Promise<any> }}
+ */
+export function createErrorReporter({
+  apiPost,
+  serverUrl,
+  userId,
+  proxyUrl,
+  getState,
+}) {
+  if (!apiPost || !serverUrl) {
+    throw new Error("createErrorReporter 需要 apiPost 与 serverUrl");
+  }
+  // proxyUrl 未显式传（undefined）才回退配置文件；显式传 null 表示确无代理
+  const effectiveProxyUrl = proxyUrl === undefined ? configuredProxy : proxyUrl;
+
+  return {
+    /**
+     * 上报一条客户端异常
+     * @param {object} info
+     * @param {string} [info.userId] - 单次覆盖（如 search 每轮标签搜索的随机 clientId）
+     * @param {string} info.errorType
+     * @param {string} [info.errorMessage]
+     * @param {string} [info.stage]
+     * @param {string} [info.errorStack]
+     * @param {string} [info.username] - 旧字段原样透传（兼容），语义不动
+     */
+    async report({
+      userId: callUserId,
+      errorType,
+      errorMessage,
+      stage,
+      errorStack,
+      username,
+    } = {}) {
+      const state = getState ? getState() || {} : {};
+      return apiPost(`${serverUrl}/api/error-report`, {
+        userId: callUserId || userId,
+        username: username || "",
+        errorType: errorType || "other",
+        errorMessage: errorMessage || "",
+        stage: stage || "",
+        errorStack: errorStack || "",
+        poolUsername: state.poolUsername || "",
+        proxyNode: resolveProxyNode(effectiveProxyUrl),
+      });
+    },
+  };
+}

package/src/lib/login-pool-client.js

@@ -193,3 +193,126 @@ export async function ensurePoolLogin(page, account) {
   }));
   return { ...r, injected: true };
 }
+
+// ── 崩溃熔断与恢复重试（纯函数/纯常量，2026-11-04 F16 实录驱动）──
+// 背景：渲染进程崩溃（Target/Page crashed）曾被误判为「账号注入失败」→ 换号循环烧池
+// （单日 28 号）。浏览器级失败须熔断退避（不取号保护账号池），账号级失败才候选轮换。
+// 本组常量/函数保持零依赖（login-pool-client 同时被 watchdog 侧引用，勿引入 playwright 链）。
+
+/** 崩溃熔断退避基数：第 1 轮 60s */
+export const CRASH_BACKOFF_BASE_MS = 60 * 1000;
+/** 崩溃熔断退避上限：15 分钟 */
+export const CRASH_BACKOFF_MAX_MS = 15 * 60 * 1000;
+
+/**
+ * 崩溃熔断退避时长：第 n 轮 = base × 2^(n-1)，封顶 max；n 非正整数返回 0。
+ * 注入验证成功即清零轮数（清零由调用方闭包状态负责）。
+ */
+export function crashBackoffMs(crashStreak, base = CRASH_BACKOFF_BASE_MS, max = CRASH_BACKOFF_MAX_MS) {
+  if (!Number.isInteger(crashStreak) || crashStreak <= 0) return 0;
+  return Math.min(base * 2 ** (crashStreak - 1), max);
+}
+
+/** 登录态恢复首败后追加重试次数（共 3 次尝试，全败才弃号转 recover_fail） */
+export const RESTORE_RETRY_MAX_RETRIES = 2;
+/** 恢复重试间隔 */
+export const RESTORE_RETRY_DELAY_MS = 10 * 1000;
+
+/**
+ * 登录态恢复重试驱动（纯逻辑，I/O 与谓词均注入，可单测；本文件保持零依赖）：
+ * 首次尝试已失败（firstFailure 为其失败原因），谓词判定为导航类瞬态失败则再试
+ * maxRetries 次、间隔 delayMs；账号级失败不重试直接返回。
+ * 调用方须传入 isRetryable（客户端用 page.js 的 isRetryableRestoreFailure）。
+ * @param {() => Promise<{ok: boolean, reason?: string}>} attemptFn 重试尝试
+ * @param {string} firstFailure 首次失败原因
+ * @param {object} opts {isRetryable, maxRetries, delayMs, sleep, shouldAbort}
+ *        （sleep/shouldAbort 供调用方接入分片中断）
+ * @returns {Promise<{ok: boolean, reason?: string, attempts: number, aborted?: boolean}>}
+ */
+export async function retryRestoreOnNavFailure(attemptFn, firstFailure, opts = {}) {
+  const isRetryable = opts.isRetryable;
+  const maxRetries = opts.maxRetries ?? RESTORE_RETRY_MAX_RETRIES;
+  const delayMs = opts.delayMs ?? RESTORE_RETRY_DELAY_MS;
+  const sleep = opts.sleep || ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const shouldAbort = opts.shouldAbort || (() => false);
+  let reason = firstFailure;
+  let attempts = 1; // 首次尝试已发生
+  while (typeof isRetryable === "function" && attempts <= maxRetries && isRetryable(reason)) {
+    // 每轮重试前回调（可选）：attempts=当前已失败次数，供调用方打「第N次失败→间隔后重试」日志
+    if (typeof opts.onRetry === "function") opts.onRetry(attempts, delayMs, reason);
+    await sleep(delayMs);
+    if (shouldAbort()) return { ok: false, reason, attempts, aborted: true };
+    attempts++;
+    const r = await Promise.resolve()
+      .then(attemptFn)
+      .catch((e) => ({ ok: false, reason: e?.message || String(e) }));
+    if (r.ok) return { ...r, attempts };
+    reason = r.reason;
+  }
+  return { ok: false, reason, attempts };
+}
+
+// ── 候选注入失败原号重试（纯函数/纯常量，2026-11-05 f11 48h 实测驱动）──
+// 背景：注入验证失败 82.8% 为浏览器级崩溃（走既有崩溃熔断），~17% 为瞬态环境失败
+// （page.goto 超时 / AbortError / net::ERR_* / Execution context destroyed / 无账号数据），
+// 0 条会话过期。现状对非崩溃失败一律立即弃号换下一个候选，网络劣化窗口会连续烧掉
+// 5 个候选且全死于同一环境。改造：瞬态失败同一候选原号重试（共 3 次尝试，间隔 15s），
+// 重试期间租约保持在手；确定性号死（会话过期/身份不符）维持立即弃号；
+// 浏览器级崩溃维持熔断路径（决策上崩溃优先，见 decideCandidateInjectAction）。
+// 本组函数保持零依赖（崩溃签名判定由调用方注入 isBrowserClosedError，勿拖 playwright 链）。
+
+/** 候选注入瞬态失败原号重试：追加次数（共 3 次尝试，全败才弃号换下一个候选） */
+export const CANDIDATE_INJECT_MAX_RETRIES = 2;
+/** 候选注入重试间隔 */
+export const CANDIDATE_INJECT_DELAY_MS = 15 * 1000;
+
+/**
+ * 确定性号死：会话过期 / 身份不符（injectPoolAccount 的账号级失败文案）。
+ * 重试无意义（号本身死了，换环境也救不活），立即弃号换下一个候选。
+ */
+export function isDeterministicAccountFailure(reason) {
+  if (!reason) return false;
+  const msg = String(reason);
+  return msg.includes("会话过期") || msg.includes("身份不符");
+}
+
+/**
+ * 候选注入失败是否可原号重试（瞬态/环境失败白名单，f11 实测清单）：
+ * - 可重试：超时 / net::ERR_*（导航层） / AbortError / Execution context destroyed /
+ *   无账号数据 / 导航失败前缀
+ * - 不可重试：确定性号死（会话过期/身份不符）；浏览器级崩溃签名（Page/Target crashed 等
+ *   由调用方决策先行分流走熔断，此处对不含 net::ERR_CONNECTION 前缀的纯崩溃签名兜底排除）；
+ *   未知失败（既非号死也非已知瞬态签名）→ 不重试，维持现状立即弃号（保守兜底）
+ */
+export function isRetryableInjectFailure(reason) {
+  if (!reason) return false;
+  const msg = String(reason);
+  if (isDeterministicAccountFailure(msg)) return false;
+  if (msg.includes("net::ERR_")) return true;
+  if (/timed?\s*out|timeout/i.test(msg)) return true;
+  if (/AbortError/i.test(msg)) return true;
+  if (/Execution context (was )?destroyed/i.test(msg)) return true;
+  if (msg.includes("无账号数据")) return true;
+  if (msg.includes("导航失败")) return true;
+  return false;
+}
+
+/**
+ * 候选注入失败处置决策（纯函数，候选循环内按返回值三路分流）：
+ * 返回 "circuit-break" | "retry" | "discard"
+ * - circuit-break：浏览器级崩溃（isBrowserClosedError 命中，含 Page/Target crashed、
+ *   net::ERR_CONNECTION_* 等）→ 既有崩溃熔断路径（中止候选循环，已取候选照常 release）
+ * - discard：确定性号死（会话过期/身份不符）或未知失败 → 立即弃号换下一个候选（现状行为）
+ * - retry：瞬态/环境失败 → 同一候选原号重试（共 3 次尝试，间隔 15s，租约保持在手）
+ * @param {string} reason 注入失败原因
+ * @param {(error: Error) => boolean} [isBrowserClosedFn] 崩溃签名判定（客户端传
+ *        page.js 的 isBrowserClosedError，SSOT 留 page.js；测试可注入假谓词）
+ */
+export function decideCandidateInjectAction(reason, isBrowserClosedFn) {
+  const msg = String(reason ?? "");
+  if (typeof isBrowserClosedFn === "function" && isBrowserClosedFn(new Error(msg))) {
+    return "circuit-break";
+  }
+  if (isRetryableInjectFailure(msg)) return "retry";
+  return "discard";
+}