tt-help-cli-ycl 1.4.183 → 1.4.184

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,59 @@ 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)) {
+    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 };
+}

package/src/watch/data-store.js

@@ -2391,6 +2391,23 @@ export function createStore(filePath, options = {}) {
     return { saved: true };
   }
 
+  /**
+   * 自动恢复候选：updated_at 早于 maxAgeMs 的 error 行（B 方案：无次数上限全自动回流）。
+   * 仅扫 jobs——commitJob 会把 error 行从 task_queue 搬到 jobs（与页面「批量重新处理」同口径），
+   * 回流本身交给 resetJob（三表迁移 + 空池缓存失效 + 统计置脏全复用）。
+   * @returns {string[]} unique_id 列表（无 DB 的 JSON 模式返回空）
+   */
+  function listStaleErrorJobs(maxAgeMs, limit = 500) {
+    if (!getDb()) return [];
+    const cutoff = Date.now() - maxAgeMs;
+    return getDb()
+      .prepare(
+        `SELECT unique_id FROM jobs WHERE status = 'error' AND updated_at < ? ORDER BY updated_at LIMIT ?`,
+      )
+      .all(cutoff, limit)
+      .map((r) => r.unique_id);
+  }
+
   function togglePin(uniqueId) {
     if (getDb()) {
       const user = getJob(uniqueId);
@@ -2686,6 +2703,8 @@ export function createStore(filePath, options = {}) {
     errorStack,
     hostname,
     clientId,
+    poolUsername,
+    proxyNode,
   ) {
     const existing = clientErrors.get(userId);
     if (existing) {
@@ -2708,6 +2727,9 @@ export function createStore(filePath, options = {}) {
         existing.reportCount = (existing.reportCount || 1) + 1;
       }
       if (username) existing.username = username;
+      // 在手池号/代理节点（方案甲新增）：非空才覆盖，同 username 语义
+      if (poolUsername) existing.poolUsername = poolUsername;
+      if (proxyNode) existing.proxyNode = proxyNode;
     } else {
       clientErrors.set(userId, {
         userId,
@@ -2718,6 +2740,8 @@ export function createStore(filePath, options = {}) {
         errorStack: errorStack || "",
         username,
         stage: stage || "",
+        poolUsername: poolUsername || "",
+        proxyNode: proxyNode || "",
         timestamp: Date.now(),
         reportCount: 1,
         captchaCount: errorType === "captcha" ? 1 : 0,
@@ -3816,6 +3840,7 @@ export function createStore(filePath, options = {}) {
     commitJob,
     commitNewExplore,
     resetJob,
+    listStaleErrorJobs,
     togglePin,
     getNextRedoJob,
     commitRedoJob,

package/src/watch/login-pool.js

@@ -34,11 +34,17 @@ const POOL_FILE = join(homeDir, ".tt-help-watchdog-logins.json");
 
 // ── 常量 ──
 const SAVE_DEBOUNCE_MS = 3 * 1000;
-const LEASE_TTL_MS = 12 * 60 * 60 * 1000; // 租约时长：持有节点心跳自动续，掉线超时回收
+const ZOMBIE_LEASE_MS = 2 * 60 * 60 * 1000; // 租约持有硬顶：从取号起算超 2h 视为僵尸回收（2026-11-03 砍掉心跳续期，无续期语义）
+const ERROR_REASONS = new Set(["banned", "captcha", "network"]); // 换号原因中的错误类；scheduled=健康证明清零；inject_fail/recover_fail/无原因=中性忽略
 const CMD_TTL_MS = 10 * 60 * 1000; // 下发命令 10 分钟未被取走作废（节点离线），租约自动回收
 const HISTORY_MAX = 20; // 每账号保留最近 20 条分配历史
 const POOL_MAX = 256; // 池容量上限
 const VALID_STATUS = ["pool", "leased", "suspect", "retired"];
+// faceBans（2026-11-02）：按数据面标注可用性——登录态有效但 explore/search 某一面拿不到数据
+// 的「面残缺号」。与 status 正交（leased 号也可标注，元数据不动租约，下次派发生效）；
+// 缺失/null = 未验证 = 默认可用，不做数据迁移，读取懒判空。
+const VALID_FACES = ["explore", "search"];
+const VALID_FACE_SOURCES = ["manual", "probe"]; // 标注来源：人工（页面/API）/探针（verify-env 账号闸）
 
 // ── 内存状态 ──
 let _accounts = []; // 账号注册表（含明文 cookies，仅服务端内存/文件持有）
@@ -68,6 +74,17 @@ function pushHistory(acc, event, detail = "") {
   if (acc.history.length > HISTORY_MAX) acc.history.length = HISTORY_MAX;
 }
 
+/** 请求面判定：appName === 'search' → search 面；其余（含未知/缺省）一律 explore 面 */
+export function faceOfAppName(appName) {
+  return appName === "search" ? "search" : "explore";
+}
+
+/** 该账号该面是否被禁用：仅显式 ban=true 才算；缺失/null/字段残缺 = 未验证 = 可用 */
+export function isFaceBanned(acc, face) {
+  const e = acc && acc.faceBans && acc.faceBans[face];
+  return !!(e && e.ban === true);
+}
+
 /** 从 cookies 数组提取账号名（无显式 username 时的兜底） */
 export function deriveUsername(cookies) {
   for (const c of Array.isArray(cookies) ? cookies : []) {
@@ -204,10 +221,6 @@ function publicView(acc) {
         userId: acc.lease.userId,
         port: acc.lease.port,
         assignedAt: acc.lease.assignedAt,
-        expireAt: acc.lease.expireAt,
-        lastHealthAt: acc.lease.lastHealthAt || null,
-        lastBusinessOkAt: acc.lease.lastBusinessOkAt || null,
-        emptyStreak: acc.lease.emptyStreak || 0,
         lastAppliedAt: acc.lease.lastAppliedAt || null,
         lastAppliedOk: acc.lease.lastAppliedOk != null ? acc.lease.lastAppliedOk : null,
         persisted: acc.lease.persisted != null ? acc.lease.persisted : null,
@@ -230,11 +243,17 @@ function publicView(acc) {
     // 最近使用镜像（脱离 lease 独立存在，释放/回收后仍可见）
     lastHealthAt: acc.lastHealthAt || null,
     lastHealth: acc.lastHealth || null,
-    lastBusinessOkAt: acc.lastBusinessOkAt || null,
     lastUsedAt: acc.lastUsedAt || null,
     lastAppName: acc.lastAppName || null,
     prevAppName: acc.prevAppName || null,
-    switchStats: acc.switchStats || {},
+    lastSwitchReason: acc.lastSwitchReason || null,
+    switchStreak: acc.switchStreak || 0,
+    errStreak: acc.errStreak || 0,
+    // 面标注（2026-11-02 faceBans）：{ban,source,at,by?} | null，null=未验证=默认可用
+    faceBans: {
+      explore: (acc.faceBans && acc.faceBans.explore) || null,
+      search: (acc.faceBans && acc.faceBans.search) || null,
+    },
     lease,
     history: acc.history || [],
     createdAt: acc.createdAt,
@@ -300,14 +319,20 @@ function dropStaleCommands() {
 // ── 租约维护 ──
 
 /** 回收过期租约（节点掉线 > TTL）。返回回收数量。 */
-export function reapExpiredLeases() {
+/**
+ * 僵尸租约回收（2026-11-03 替代原 reapExpiredLeases/12h TTL）：无续期语义，
+ * 从 assignedAt（取号时刻）硬顶 ZOMBIE_LEASE_MS=2h，超时即回收。由各 API 入口
+ * 与心跳尾部调用（每次调用顺带执行一遍，成本低）。
+ * 返回回收数量。
+ */
+export function reapZombieLeases() {
   ensureLoaded();
   dropStaleCommands();
   const t = now();
   let reaped = 0;
   for (const acc of _accounts) {
-    if (acc.status === "leased" && acc.lease && t - (acc.lease.lastHealthAt || acc.lease.assignedAt) > LEASE_TTL_MS) {
-      pushHistory(acc, "leaseExpired", `${acc.lease.userId} 掉线超时，自动回收`);
+    if (acc.status === "leased" && acc.lease && t - acc.lease.assignedAt > ZOMBIE_LEASE_MS) {
+      pushHistory(acc, "zombieReaped", `${acc.lease.userId}:${acc.lease.port} 持有超2h，僵尸回收`);
       acc.status = "pool";
       acc.lastUsedAt = t;
       acc.lease = null;
@@ -323,16 +348,17 @@ export function reapExpiredLeases() {
 // ── 心跳集成（watch 主进程心跳热路径调用） ──
 
 /**
- * 心跳处理：续租 + 采集健康数据 + 返回待下发命令。
+ * 心跳处理：写回命令执行回报 + 返回待下发命令。
+ * 2026-11-03 砍掉续租与全部盖章/镜像（lastHealthAt/lastUsedAt/lastBusinessOkAt/emptyStreak
+ * 不再被心跳触碰），僵尸租约由 reapZombieLeases 按 assignedAt 硬顶回收。
  * @param userId 节点 userId（body.config.userId）
- * @param body 心跳 body（可含 loginPool: { ports: { "9222": { username, lastBusinessOkAt, emptyStreak } } }）
+ * @param body 心跳 body
  * @returns loginPoolCommands（无则 undefined）
  */
 export function heartbeatLoginPool(userId, body) {
   ensureLoaded();
   const t = now();
   const poolBody = body && body.loginPool;
-  const report = poolBody && poolBody.ports;
 
   // 0) 节点执行回报（applyLogin/clearLogin 结果）：写回租约与历史
   if (Array.isArray(poolBody && poolBody.applied)) {
@@ -358,37 +384,8 @@ export function heartbeatLoginPool(userId, body) {
     scheduleSave();
   }
 
-  // 1) 续租该节点持有的所有租约 + 采集健康数据
-  //    续租匹配（2026-10-30 修复）：心跳 userId 是纯节点名（如 F-11），业务实例租约 userId
-  //    带实例后缀（F-11-8222-2 = {节点}-{端口}-{实例}）→ 精确相等 + "-" 边界前缀匹配都续。
-  //    边界防节点名互为前缀："F-1" 不得续 "F-11-*"（startsWith("F-1-") 为 false）。
-  //    ⚠️ 铁律：acquireAccount 里「自动释放同使用者旧租约」必须保持精确相等
-  //    （一实例一号不变量），与本处续租匹配是两套语义，不许跟着改成前缀。
-  for (const acc of _accounts) {
-    if (
-      acc.status === "leased" &&
-      acc.lease &&
-      (acc.lease.userId === userId || acc.lease.userId.startsWith(userId + "-"))
-    ) {
-      acc.lease.lastHealthAt = t;
-      acc.lastHealthAt = t; // 镜像到账号本体，释放后仍可查
-      acc.lastUsedAt = t;
-      _dirty = true; // 续租也是变更：配合下方低频持久化落盘
-      if (report && report[acc.lease.port]) {
-        const h = report[acc.lease.port];
-        if (typeof h.lastBusinessOkAt === "number") {
-          acc.lease.lastBusinessOkAt = h.lastBusinessOkAt;
-          acc.lastBusinessOkAt = h.lastBusinessOkAt; // 镜像：最近一次业务出活
-        }
-        if (typeof h.emptyStreak === "number") acc.lease.emptyStreak = h.emptyStreak;
-        if (h.username && !acc.username) acc.username = h.username;
-      }
-    }
-  }
-
-  // 1.5) 心跳续租的低频持久化：只在我们真的持有账号状态时才写，且每 5 分钟最多一次
-  //      （冷启动空状态下绝不落盘，防盖掉对方刚写的数据；TTL 12h，5min 漂移可忽略）
-  if (_loaded && _accounts.length > 0 && t - _lastFileWriteAt > 300000) scheduleSave();
+  // （2026-11-03 砍掉原「1) 续租该节点持有的所有租约 + 采集健康数据」与
+  //  「1.5) 低频持久化」：心跳不再刷新/弄脏任何池状态，落盘只在操作性变更时发生。）
 
   // 2) 取走待下发命令（一次性；跨进程：命令由 watch 进程经池文件投递）
   const list = _queue.filter((c) => c.userId === userId);
@@ -415,8 +412,8 @@ export function heartbeatLoginPool(userId, body) {
     scheduleSave();
   }
 
-  // 3) 低频回收（每次心跳顺带检查，成本低）
-  reapExpiredLeases();
+  // 3) 僵尸租约回收（每次心跳顺带检查，成本低）
+  reapZombieLeases();
 
   return commands && commands.length > 0 ? { commands } : undefined;
 }
@@ -431,7 +428,7 @@ function fullView(acc) {
 /** 池视图（脱敏） */
 export function getLoginPoolView() {
   ensureLoaded();
-  reapExpiredLeases();
+  reapZombieLeases();
   return {
     accounts: _accounts.map(publicView),
     total: _accounts.length,
@@ -506,6 +503,9 @@ export function clearAccountHistory({ id, by } = {}) {
   acc.history = [];
   acc.useCount = 0;
   acc.switchStats = {};
+  acc.lastSwitchReason = null;
+  acc.switchStreak = 0;
+  acc.errStreak = 0;
   acc.updatedAt = now();
   pushHistory(acc, "clearLogs", `清除日志与计数（来源 ${String(by || "page").slice(0, 80)}）`);
   scheduleSave();
@@ -521,6 +521,9 @@ export function clearAllAccountHistory({ by } = {}) {
     acc.history = [];
     acc.useCount = 0;
     acc.switchStats = {};
+    acc.lastSwitchReason = null;
+    acc.switchStreak = 0;
+    acc.errStreak = 0;
     acc.updatedAt = t;
     pushHistory(acc, "clearLogs", `清除日志与计数（来源 ${String(by || "page").slice(0, 80)} · 批量）`);
   }
@@ -529,6 +532,41 @@ export function clearAllAccountHistory({ by } = {}) {
   return { cleared };
 }
 
+/**
+ * 面标注（2026-11-02 faceBans）：按面记录可用性，派号时按面过滤（见 acquireAccount）。
+ * { id|username, face, ban, source='manual', by } — 定位二选一；ban=true 标挂 / false 恢复；
+ * 与 status 正交：leased 号也可标注（不动租约，下次派发生效）。
+ * 写 faceBans[face] → pushHistory 落痕 → saveNow() 立即落盘（操作性变更不走防抖）。
+ */
+export function setAccountFace({ id, username, face, ban, source = "manual", by } = {}) {
+  ensureLoaded();
+  if (!VALID_FACES.includes(face)) {
+    throw new Error(`非法 face: ${face}（仅限 ${VALID_FACES.join("/")}）`);
+  }
+  if (!VALID_FACE_SOURCES.includes(source)) {
+    throw new Error(`非法 source: ${source}（仅限 ${VALID_FACE_SOURCES.join("/")}）`);
+  }
+  if (typeof ban !== "boolean") {
+    throw new Error("ban 必填且为 boolean（true=标挂禁用 / false=恢复）");
+  }
+  const acc = _accounts.find((a) =>
+    id ? a.id === id : username ? a.username === username : false,
+  );
+  if (!acc) throw new Error(`账号不存在: ${id || username}`);
+  const t = now();
+  acc.faceBans = acc.faceBans || {};
+  acc.faceBans[face] = { ban, source, at: t, ...(by ? { by: String(by).slice(0, 80) } : {}) };
+  acc.updatedAt = t;
+  pushHistory(
+    acc,
+    ban ? "faceBan" : "faceRestore",
+    `${face}=${ban ? "禁用" : "恢复"} (${source}${by ? " · " + String(by).slice(0, 60) : ""})`,
+  );
+  _dirty = true; // 先置脏再落盘（与 enqueueCommand 同式）：saveNow 的 !_dirty 早退会吞掉连续标注
+  saveNow();
+  return publicView(acc);
+}
+
 /** 删除（retired 才可删；其余先 retired） */
 export function deleteAccount(id) {
   ensureLoaded();
@@ -584,10 +622,6 @@ export function assignAccount({ id, userId, port, force } = {}) {
     userId,
     port,
     assignedAt: t,
-    expireAt: t + LEASE_TTL_MS,
-    lastHealthAt: t,
-    lastBusinessOkAt: null,
-    emptyStreak: null,
   };
   acc.updatedAt = t;
   pushHistory(acc, "assigned", `${userId}:${port}${force ? " (force)" : ""}`);
@@ -639,7 +673,7 @@ export function releaseAccount({ id, clearOnNode } = {}) {
  */
 export function takeAccount({ userId, port, username, force } = {}) {
   ensureLoaded();
-  reapExpiredLeases();
+  reapZombieLeases();
   if (!userId || !port) throw new Error("userId 和 port 必填");
   let acc;
   if (username) {
@@ -667,11 +701,12 @@ export function takeAccount({ userId, port, username, force } = {}) {
  *   - port 可选：仅作展示元数据（浏览器口），不参与任何键/约束
  *   - appName: 记录在租约与账号本体（lastAppName，释放后保留），参与取号排序 K2 非同类优先
  *   - reason: 可选换号原因受控 code（banned/recover_fail/scheduled/inject_fail/captcha/network），
- *     仅显式上报才计入 switchStats 聚合（无「未上报」桶）；未知 code 原样存不拒绝（旧客户端兼容）
+ *     仅显式上报才计入「最近换号原因 + 连续次数」（lastSwitchReason/switchStreak，2026-11-03
+ *     替代原 switchStats 终身累加）；未知 code 原样存不拒绝（旧客户端兼容）
  */
 export function acquireAccount({ userId, port, appName, reason } = {}) {
   ensureLoaded();
-  reapExpiredLeases();
+  reapZombieLeases();
   if (!userId) throw new Error("userId 必填");
   let portNum = null;
   if (port !== undefined && port !== null && port !== "") {
@@ -694,6 +729,8 @@ export function acquireAccount({ userId, port, appName, reason } = {}) {
   //        请求无 appName 时该键中性化全等，不参与）
   //     K3 lastUsedAt 升序（从未用过组内退化为 createdAt 升序，兼容旧排序）
   const MIN_IDLE_MS = 30 * 60 * 1000;
+  // （2026-11-03 砍掉 faceBans 按面过滤：explore/search 双面派号未验证出价值，机制退役；
+  //  faceBans 数据与 /api/login-pool/face 端点保留休眠，探针标注不受影响）
   const pool = _accounts.filter((a) => a.status === "pool");
   const sortFn = (a, b) => {
     // K1: 从未用过最前
@@ -715,7 +752,9 @@ export function acquireAccount({ userId, port, appName, reason } = {}) {
   const acc = eligible[0] || pool.slice().sort(sortFn)[0];
   if (!acc) {
     const leased = _accounts.filter((a) => a.status === "leased").length;
-    throw new Error(`池中暂无空闲账号（共 ${_accounts.length} 个，其中 ${leased} 个在租约中）`);
+    throw new Error(
+      `池中暂无可用账号（共 ${_accounts.length} 个，租约中 ${leased} 个）`,
+    );
   }
 
   acc.status = "leased";
@@ -728,19 +767,19 @@ export function acquireAccount({ userId, port, appName, reason } = {}) {
     acc.lastAppName = appNameKey;
   }
   if (reasonKey) {
-    // C2: 换号原因聚合（仅显式上报才计数，无「未上报」桶）
-    acc.switchStats = acc.switchStats || {};
-    acc.switchStats[reasonKey] = (acc.switchStats[reasonKey] || 0) + 1;
+    // 换号原因：只留「最近原因 + 连续次数」（2026-11-03 替代 switchStats 终身累加：
+    // 同原因连击 +1，换原因重置为 1。例：例行换号×2 → 被封×2，页面只显示 被封×2）
+    if (acc.lastSwitchReason === reasonKey) acc.switchStreak = (acc.switchStreak || 0) + 1;
+    else {
+      acc.lastSwitchReason = reasonKey;
+      acc.switchStreak = 1;
+    }
   }
   acc.lease = {
     userId,
     port: portNum,
     appName: appNameKey,
     assignedAt: t,
-    expireAt: t + LEASE_TTL_MS,
-    lastHealthAt: t,
-    lastBusinessOkAt: null,
-    emptyStreak: null,
   };
   acc.updatedAt = t;
   pushHistory(
@@ -760,7 +799,13 @@ export function acquireAccount({ userId, port, appName, reason } = {}) {
       other.lease &&
       other.lease.userId === userId
     ) {
-      pushHistory(other, "released", `自动释放（${userId} 取新号）`);
+      // 连败计数 errStreak（2026-11-03 替代心跳通道 cmdFailStreak）：记在被换掉的旧号头上——
+      // 原因码描述的是旧号的遭遇。错误（banned/captcha/network）+1；scheduled=干满周期
+      // 健康证明清零；inject_fail/recover_fail/无原因中性不动（inject_fail 候选号在取新号前
+      // 已单独 release，此处本就无旧租约，物理上天然忽略）
+      if (ERROR_REASONS.has(reasonKey)) other.errStreak = (other.errStreak || 0) + 1;
+      else if (reasonKey === "scheduled") other.errStreak = 0;
+      pushHistory(other, "released", `自动释放（${userId} 取新号${reasonKey ? " · " + reasonKey : ""}）`);
       other.status = "pool";
       other.lastUsedAt = t;
       other.lease = null;
@@ -790,7 +835,7 @@ export function acquireAccount({ userId, port, appName, reason } = {}) {
  */
 export function importAccount({ userId, port, username, cookies, note, proxyHint } = {}) {
   ensureLoaded();
-  reapExpiredLeases();
+  reapZombieLeases();
   if (!userId) throw new Error("userId 必填");
   if (!username) throw new Error("username 必填（须为 passport 验证过的登录号）");
   const norm = normalizeCookies(cookies);
@@ -846,28 +891,26 @@ const importMeta = (userId, portNum, at) => ({ userId, port: portNum, at });
  */
 export function reloginAccount({ username, cookies, userId, note } = {}) {
   ensureLoaded();
-  reapExpiredLeases();
+  reapZombieLeases();
   if (!username) throw new Error("username 必填（重登录目标）");
   if (!userId) throw new Error("userId 必填（操作来源）");
   const norm = normalizeCookies(cookies);
   if (!norm) throw new Error("cookies 必须是非空数组，且每项含 name/value");
   const acc = _accounts.find((a) => a.username === username);
   if (!acc) throw new Error(`账号 ${username} 不在池中（重登录仅针对已有账号，新号走 import/add）`);
-  if (acc.status === "leased") {
-    const w = acc.lease;
-    throw new Error(
-      `账号 ${username} 使用中（${w?.userId || "?"}${w?.port ? ":" + w.port : ""}），先释放再重登录`,
-    );
-  }
+  // 2026-11-03 改（X 方案）：使用中也可重登录——只替换池内 cookies，状态与租约原样保留，
+  // 不再置 pool（避免租约挂着状态却变 pool 被别的节点取走）；风险自担：本机重登录窗口
+  // 与在租节点同 sessionid 并用，可能触发风控踢会话，节点会自愈重取
   const revived = acc.status === "retired";
   const wasSuspect = acc.status === "suspect";
+  const inUse = !!acc.lease;
   acc.cookies = norm;
-  acc.status = "pool";
+  if (!inUse) acc.status = "pool";
   acc.updatedAt = now();
   pushHistory(
     acc,
     "relogin",
-    `${revived ? "重登录复活（已停用→池）" : wasSuspect ? "重登录（疑似→池）" : "重登录刷新"} · ${userId}${note ? ` · ${String(note).slice(0, 80)}` : ""}`,
+    `${inUse ? "重登录刷新（使用中，仅换 cookies）" : revived ? "重登录复活（已停用→池）" : wasSuspect ? "重登录（疑似→池）" : "重登录刷新"} · ${userId}${note ? ` · ${String(note).slice(0, 80)}` : ""}`,
   );
   scheduleSave();
   return { account: publicView(acc), revived, wasSuspect };
@@ -879,7 +922,7 @@ export function reloginAccount({ username, cookies, userId, note } = {}) {
  */
 export function healthTargets({ ids } = {}) {
   ensureLoaded();
-  reapExpiredLeases();
+  reapZombieLeases();
   const idSet = Array.isArray(ids) && ids.length ? new Set(ids) : null;
   return _accounts
     .filter((a) => a.status !== "retired")
@@ -926,16 +969,10 @@ export function recordHealth({ id, ok, detail } = {}) {
  */
 export function prepareRelogin({ username } = {}) {
   ensureLoaded();
-  reapExpiredLeases();
+  reapZombieLeases();
   if (!username) throw new Error("username 必填");
   const acc = _accounts.find((a) => a.username === username);
   if (!acc) throw new Error(`账号 ${username} 不在池中`);
-  if (acc.status === "leased") {
-    const w = acc.lease;
-    throw new Error(
-      `账号 ${username} 使用中（${w?.userId || "?"}${w?.port ? ":" + w.port : ""}），先释放再重登录`,
-    );
-  }
   return { account: fullView(acc) };
 }
 

package/src/watch/public/app.js

@@ -122,6 +122,10 @@ async function fetchClientErrors() {
         const msgDetail = c.errorMessage
           ? `<br><span style="color:#666;font-size:11px">${escapeHtml(c.errorMessage)}</span>`
           : "";
+        // 旧字段 username 语义混杂（池号/占位/目标用户），改造后挪进详情区小字保留可见性
+        const legacyUsernameDetail = c.username
+          ? `<br><span style="color:#666;font-size:10px">上报账号: @${escapeHtml(c.username)}</span>`
+          : "";
         const stackDetail = c.errorStack
           ? `<br><span style="color:#555;font-size:10px;max-width:250px;display:block;word-break:break-all">${escapeHtml(c.errorStack)}</span>`
           : "";
@@ -134,8 +138,9 @@ async function fetchClientErrors() {
         <td style="color:#f87171;font-weight:600">${c.reportCount || 1}</td>
         <td style="color:#f59e0b;font-weight:600">${captchaText}${captchaDetail}</td>
         <td style="color:#a78bfa;font-size:12px">${stageText}</td>
-        <td style="color:#ccc;font-size:12px;max-width:300px;word-break:break-all">${msgDetail}${stackDetail}</td>
-        <td style="color:#60a5fa">@${escapeHtml(c.username || "-")}</td>
+        <td style="color:#ccc;font-size:12px;max-width:300px;word-break:break-all">${msgDetail}${legacyUsernameDetail}${stackDetail}</td>
+        <td style="color:#34d399;font-size:12px">@${escapeHtml(c.poolUsername || "-")}</td>
+        <td style="color:#94a3b8;font-size:11px;font-family:monospace;max-width:120px;word-break:break-all">${escapeHtml(c.proxyNode || "-")}</td>
         <td style="color:#888;font-size:12px">${new Date(c.timestamp).toLocaleTimeString()}</td>
         <td><button class="btn-delete" onclick="deleteClientError('${escapeHtml(c.userId)}')" style="background:#991b1b;color:#fff;border:none;padding:3px 10px;border-radius:4px;cursor:pointer;font-size:12px">删除</button></td>
       </tr>`;

package/src/watch/public/index.html

@@ -103,7 +103,8 @@
             <th>验证码次数</th>
             <th>阶段</th>
             <th>错误详情</th>
-            <th>当时处理的 TikTok 用户</th>
+            <th>在手账号</th>
+            <th>代理节点</th>
             <th>时间</th>
             <th>操作</th>
           </tr>