tt-help-cli-ycl 1.4.184 → 1.4.185

package/scripts/test-login-pool-acquire-order.mjs

@@ -1,21 +1,28 @@
 /**
- * 登录池批量改造 smoke — 取号排序 + reason 聚合 + 清空日志（2026-10-30 清单 B1/B2/B3/C1/C2 服务端）
+ * 登录池取号排序 + 换因计数 + 连败计数 + 清空日志 单测
+ * （2026-11-04 对齐 7be35e8 账号中心简化 + 1cda80f 连败计数改算法）
  *
  * 覆盖:
  *   B2 取号排序五条: 非同类优先生效 / 全同类仍发号 / 全冷却退全池 / 从未用过最前 / lastAppName 空值中性
  *   B1/B3 lastAppName 落账号本体（release 后保留）+ acquired history detail 带 appName
- *   C2 reason 聚合: 显式上报计数、未知 code 原样存、不带 reason 不计（无「未上报」桶）
- *   C1 清空日志: history 清成一条留痕 + useCount/switchStats 清零 + 不动 lastUsedAt/lastAppName
+ *   prev prevAppName 前一任程序记录
+ *   C2 换号原因: lastSwitchReason/switchStreak（同因连击 +1 / 换因重置 1 / 未知 code 原样存 / 不带 reason 不动）
+ *   E   连败计数 errStreak: 挂在被换掉的旧号（banned/captcha/network +1；scheduled 清零；中性/无因不动）
+ *   C1 清空日志: history 清成一条留痕 + useCount/switchStats/换因计数/errStreak 清零 + 不动 lastUsedAt/lastAppName
  *
- * 跑法: HOME=$(mktemp -d) node scripts/test-login-pool-acquire-order.mjs
+ * 跑法: node scripts/test-login-pool-acquire-order.mjs
+ *   （自建临时 HOME 并在 import 前覆盖环境变量——绝不读写真实 ~/.tt-help-watchdog-logins.json）
  */
 import assert from "assert";
+import { mkdtempSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
 
-const HOME = process.env.HOME;
-if (!HOME || HOME === "/") {
-  console.error("请用隔离 HOME 运行: HOME=$(mktemp -d) node scripts/test-login-pool-acquire-order.mjs");
-  process.exit(1);
-}
+// ── 测试基建：临时 HOME 隔离 ──
+// login-pool.js 的 POOL_FILE 在模块加载期由 os.homedir() 计算（POSIX 下 homedir() 实时读
+// process.env.HOME），故必须在动态 import 之前覆盖 HOME/USERPROFILE；生产代码零改动即可隔离。
+process.env.HOME = mkdtempSync(join(tmpdir(), "loginpool-order-test-"));
+process.env.USERPROFILE = process.env.HOME; // Windows 语义兜底
 
 const {
   getLoginPoolView,
@@ -117,7 +124,7 @@ console.log("\n[B2-4] 全冷却退全池兜底");
   acquireAccount({ userId: "O4b", appName: "explore" });
   releaseAccount({ id: findAcc("ordE1").id });
   releaseAccount({ id: findAcc("ordF1").id });
-  // 全部压进 30min 冷却窗内
+  // 全部压进 30min 休息窗内
   backdate("ordE1", 5 * 60 * 1000);
   backdate("ordF1", 8 * 60 * 1000);
   const got = acquireAccount({ userId: "O4c", appName: "explore" });
@@ -129,13 +136,16 @@ console.log("\n[B2-4] 全冷却退全池兜底");
 // ── B2-5: lastAppName 空值中性 ──
 console.log("\n[B2-5] lastAppName 空值按非同类 / 请求无 appName 时键中性化");
 {
-  // 先加 ordExploreApp（创建序在前 → 首个 acquire 取到它并盖上 explore）
+  // 两个号都先 acquire+release（都盖 lastUsedAt → K1 打平），再清空其一的 lastAppName，
+  // 隔离出纯粹的「lastAppName 空 = 按非同类」K2 分支
   add("ordExploreApp");
   add("ordEmptyApp");
-  acquireAccount({ userId: "O5", appName: "explore" });
+  acquireAccount({ userId: "O5", appName: "explore" }); // ordExploreApp（创建序在前）
+  acquireAccount({ userId: "O5a", appName: "search" }); // ordEmptyApp（唯一剩余 pool）
   releaseAccount({ id: findAcc("ordExploreApp").id });
+  releaseAccount({ id: findAcc("ordEmptyApp").id });
   for (const a of _accountsInternal()) {
-    if (a.username === "ordEmptyApp") a.lastAppName = null; // 模拟改造前的存量账号（无 lastAppName）
+    if (a.username === "ordEmptyApp") a.lastAppName = null; // 模拟存量账号（无 lastAppName）
   }
   backdate("ordEmptyApp", 32 * 60 * 1000); // eligible、lastAppName 空
   backdate("ordExploreApp", 31 * 60 * 1000); // eligible、同类 explore
@@ -180,7 +190,6 @@ console.log("\n[prev] 前一任程序记录（页面「上次使用」列数据
   const got = acquireAccount({ userId: "P2", appName: "search" });
   check("第二次取号后 lastAppName=当前程序", got.lastAppName === "search", `got ${got.lastAppName}`);
   check("prevAppName=前一任（explore→search 切换可追溯）", got.prevAppName === "explore", `got ${got.prevAppName}`);
-  const first = getLoginPoolView().accounts.find((x) => x.username === "ordBatchA");
   // 从未换过程序的账号 prevAppName 应为 null（首次取号无前一任）
   add("ordPrevFirst");
   const g2 = acquireAccount({ userId: "P3", appName: "explore" });
@@ -188,45 +197,99 @@ console.log("\n[prev] 前一任程序记录（页面「上次使用」列数据
   retireAll();
 }
 
-// ── C2: reason 聚合 ──
-console.log("\n[C2] switchStats 聚合：显式计数 / 未知 code 原样存 / 不带不计");
+// ── C2: 换号原因（lastSwitchReason/switchStreak，2026-11-03 替代 switchStats 终身累加） ──
+console.log("\n[C2] 换因计数：最近原因+连续次数（同因连击+1 / 换因重置1 / 未知code原样存 / 不带不动）");
 {
   add("ordReason1");
   let got = acquireAccount({ userId: "O7", appName: "explore", reason: "banned" });
-  check("显式上报 banned 计数 1", got.switchStats && got.switchStats.banned === 1, JSON.stringify(got.switchStats));
+  check("显式上报 banned → lastSwitchReason=banned ×1",
+    got.lastSwitchReason === "banned" && got.switchStreak === 1,
+    JSON.stringify({ r: got.lastSwitchReason, s: got.switchStreak }));
   const hist = got.history.find((h) => h.event === "acquired");
   check("acquired history detail 带原因", hist && hist.detail.includes("原因 banned"), JSON.stringify(hist && hist.detail));
 
   releaseAccount({ id: got.id });
   backdate("ordReason1", 31 * 60 * 1000);
   got = acquireAccount({ userId: "O7b", appName: "explore", reason: "banned" });
-  check("同账号再上报 banned 累计为 2", got.switchStats.banned === 2, JSON.stringify(got.switchStats));
+  check("同因连击 +1（banned ×2）", got.lastSwitchReason === "banned" && got.switchStreak === 2,
+    JSON.stringify({ r: got.lastSwitchReason, s: got.switchStreak }));
 
   releaseAccount({ id: got.id });
   backdate("ordReason1", 31 * 60 * 1000);
   got = acquireAccount({ userId: "O7c", appName: "explore", reason: "weird_reason" });
-  check("未知 code 原样存不拒绝", got.switchStats.weird_reason === 1, JSON.stringify(got.switchStats));
+  check("换因重置为 1，未知 code 原样存不拒绝",
+    got.lastSwitchReason === "weird_reason" && got.switchStreak === 1,
+    JSON.stringify({ r: got.lastSwitchReason, s: got.switchStreak }));
+
+  releaseAccount({ id: got.id });
+  backdate("ordReason1", 31 * 60 * 1000);
+  got = acquireAccount({ userId: "O7d", appName: "explore" }); // 不带 reason
+  check("不带 reason 不计（保留上次值，无「未上报」桶）",
+    got.lastSwitchReason === "weird_reason" && got.switchStreak === 1,
+    JSON.stringify({ r: got.lastSwitchReason, s: got.switchStreak }));
+  retireAll();
+}
 
-  add("ordNoReason");
-  got = acquireAccount({ userId: "O7d", appName: "explore" });
-  const noBucket = !got.switchStats || Object.keys(got.switchStats).length === 0;
-  check("不带 reason 不计数（无「未上报」桶）", noBucket, JSON.stringify(got.switchStats));
+// ── E: 连败计数 errStreak（1cda80f：挂在被换掉的旧号上，按换号原因码分类） ──
+console.log("\n[E] errStreak 连败计数：错误类+1 / scheduled 清零 / 中性与无因不动");
+{
+  add("ordErrP");
+  let g = acquireAccount({ userId: "E1", appName: "explore" });
+  check("前置：E1 持 ordErrP", g.username === "ordErrP", `取到 ${g.username}`);
+  add("ordErrA");
+  g = acquireAccount({ userId: "E1", appName: "explore", reason: "banned" }); // 唯一 pool=ordErrA
+  check("换号取到新号 ordErrA", g.username === "ordErrA", `取到 ${g.username}`);
+  check("banned 换号：旧号 ordErrP errStreak=+1", findAcc("ordErrP").errStreak === 1, `got ${findAcc("ordErrP").errStreak}`);
+  check("新号不背旧账（ordErrA errStreak=0）", (findAcc("ordErrA").errStreak || 0) === 0);
+  check("旧号释放历史附原因码", (findAcc("ordErrP").history || []).some((h) => h.event === "released" && h.detail.includes("banned")));
+
+  // 同号连败：ordErrP 回到 E1 手上再被换掉一次 → 1→2（连续非累计基数=每次释放事件各计）
+  backdate("ordErrP", 31 * 60 * 1000);
+  g = acquireAccount({ userId: "E1", appName: "explore" }); // 唯一 eligible pool=ordErrP；ordErrA 无因中性释放
+  check("E1 换回 ordErrP", g.username === "ordErrP", `取到 ${g.username}`);
+  check("无 reason 释放 ordErrA：errStreak 中性不动", (findAcc("ordErrA").errStreak || 0) === 0);
+  add("ordErrB");
+  g = acquireAccount({ userId: "E1", appName: "explore", reason: "banned" }); // 旧号=ordErrP
+  check("ordErrP 连败 +1 → 2（同因连击累加）", findAcc("ordErrP").errStreak === 2, `got ${findAcc("ordErrP").errStreak}`);
+
+  // scheduled=干满周期健康证明 → 清零
+  backdate("ordErrP", 31 * 60 * 1000);
+  g = acquireAccount({ userId: "E1", appName: "explore" }); // 再持 P；ordErrB 无因中性释放
+  add("ordErrC");
+  g = acquireAccount({ userId: "E1", appName: "explore", reason: "scheduled" }); // 旧号=ordErrP
+  check("scheduled 换号：ordErrP errStreak 清零", findAcc("ordErrP").errStreak === 0, `got ${findAcc("ordErrP").errStreak}`);
+
+  // 中性原因（inject_fail）不动
+  backdate("ordErrP", 31 * 60 * 1000);
+  g = acquireAccount({ userId: "E1", appName: "explore" }); // 再持 P；ordErrC 无因中性释放
+  add("ordErrD");
+  g = acquireAccount({ userId: "E1", appName: "explore", reason: "inject_fail" }); // 旧号=ordErrP
+  check("inject_fail 中性：errStreak 保持 0", findAcc("ordErrP").errStreak === 0, `got ${findAcc("ordErrP").errStreak}`);
   retireAll();
 }
 
 // ── C1: 清空日志 ──
-console.log("\n[C1] 清空日志：留痕一条 + useCount/switchStats 清零 + 不动休息窗/最近程序");
+console.log("\n[C1] 清空日志：留痕一条 + useCount/switchStats/换因计数/errStreak 清零 + 不动休息窗/最近程序");
 {
   add("ordClear");
   let got = acquireAccount({ userId: "O8", appName: "explore", reason: "banned" });
   assert(got.useCount === 1);
-  const lastUsedBefore = got.lastUsedAt;
+  // 注入连败基数与遗留 switchStats，验证清空归零
+  for (const a of _accountsInternal()) {
+    if (a.username === "ordClear") { a.errStreak = 3; a.switchStats = { legacy: 9 }; }
+  }
   releaseAccount({ id: got.id });
+  // 基线在 release 之后读取（release 会重盖 lastUsedAt，拿 acquire 时刻的值比较会跨毫秒必挂——
+  // 本断言语义是「清日志不改 lastUsedAt」，比较对象应是 pre-clear vs post-clear）
+  const lastUsedBefore = findAcc("ordClear").lastUsedAt;
   const cleared = clearAccountHistory({ id: got.id, by: "page" });
   check("history 清成一条留痕", cleared.history.length === 1, `len=${cleared.history.length}`);
   check("留痕含来源 page", cleared.history[0].detail.includes("page"), JSON.stringify(cleared.history[0]));
   check("useCount 归零", cleared.useCount === 0);
-  check("switchStats 清空", !cleared.switchStats || Object.keys(cleared.switchStats).length === 0);
+  check("switchStats 清空（遗留字段一并清）", !cleared.switchStats || Object.keys(cleared.switchStats).length === 0);
+  check("lastSwitchReason 清空 + switchStreak 归零", cleared.lastSwitchReason === null && cleared.switchStreak === 0,
+    JSON.stringify({ r: cleared.lastSwitchReason, s: cleared.switchStreak }));
+  check("errStreak 归零", (cleared.errStreak || 0) === 0, `got ${cleared.errStreak}`);
   check("不动 lastUsedAt（休息窗保留）", cleared.lastUsedAt === lastUsedBefore,
     `before=${lastUsedBefore} after=${cleared.lastUsedAt}`);
   check("不动 lastAppName", cleared.lastAppName === "explore");
@@ -248,6 +311,7 @@ console.log("\n[批量清空] clearAllAccountHistory 一键全清");
   const snap = {};
   for (const a of _accountsInternal()) {
     if (a.username === "ordBatchA") snap.A = { lastUsedAt: a.lastUsedAt, lastAppName: a.lastAppName };
+    if (a.username === "ordBatchB") a.errStreak = 2; // 注入连败基数，验证批量清零
   }
   const r = clearAllAccountHistory({ by: "page" });
   check("返回清空数量（含历史遗留账号）", r.cleared >= 2, `cleared=${r.cleared}`);
@@ -256,6 +320,8 @@ console.log("\n[批量清空] clearAllAccountHistory 一键全清");
     check(`${u}: history 清成一条批量留痕`, a.history.length === 1 && a.history[0].detail.includes("批量"),
       JSON.stringify(a.history));
     check(`${u}: useCount/switchStats 清零`, a.useCount === 0 && Object.keys(a.switchStats || {}).length === 0);
+    check(`${u}: 换因计数/errStreak 清零`, a.lastSwitchReason === null && a.switchStreak === 0 && (a.errStreak || 0) === 0,
+      JSON.stringify({ r: a.lastSwitchReason, s: a.switchStreak, e: a.errStreak }));
   }
   const a = findAcc("ordBatchA");
   check("批量清空不动 lastUsedAt/lastAppName", a.lastUsedAt === snap.A.lastUsedAt && a.lastAppName === snap.A.lastAppName);

package/scripts/test-login-pool-ui.mjs

@@ -157,7 +157,8 @@ check("状态徽章=使用中", row1.includes("使用中"));
 check("使用者=机器:口", row1.includes("F-11:9222"));
 const poolSrc = await page.content();
 check("独立页无 cookie 明文", !poolSrc.includes("SECRET-SID-XYZ"));
-check("独立页检测按钮已点亮（重登录已改名）", await page.$$eval("#content button:not([disabled])", (bs) => bs.some((b) => b.textContent.trim() === "检测")));
+// d77a82c 批量改造：行内按钮改回「重登录」（与新增「检测」列解撞名）；「检测」列已由上方新列断言覆盖
+check("独立页重登录按钮已点亮（与检测列解撞名，d77a82c）", await page.$$eval("#content button:not([disabled])", (bs) => bs.some((b) => b.textContent.trim() === "重登录")));
 check("独立页含新增账号/批量检测按钮", await page.$$eval(".bar button", (bs) => {
   const t = bs.map((b) => b.textContent).join();
   return t.includes("新增账号") && t.includes("批量检测");

package/scripts/test-login-pool.mjs

@@ -1,25 +1,32 @@
 /**
  * 共享登录池单元测试 — 模块级直驱（不起 HTTP）
  *
- * 覆盖:
- *   1. 入池（cookies 归一化/username 兜底/去重/池满）+ 视图脱敏（明文永不出）
+ * 覆盖（2026-11-04 对齐 7be35e8 账号中心简化 + 1cda80f 连败计数改算法）:
+ *   1. 入池（cookies 归一化/username 兜底/去重）+ 视图脱敏（明文永不出）
  *   2. 指派独占约束（同账号双租拒绝 / 目标端口占用拒绝 / force 替换 / suspect 需 force）
  *   3. 心跳下发（applyLogin/clearLogin 一次性取走，cookies 仅在心跳响应出现）
- *   4. 续租 + 健康采集（lastBusinessOkAt/emptyStreak）
- *   5. 掉线回收（leaseExpired）+ 命令超时作废（deliveryExpired 回收）
+ *   4. 心跳零状态变更（续租/健康采集已物理删除）+ 节点执行回报写回（applied/applyFailed/cleared）
+ *   5. 僵尸回收（lease.assignedAt 硬顶 2h → zombieReaped，reapZombieLeases）+ 命令超时作废（deliveryExpired）
  *   6. release（含 clearOnNode）+ update 状态迁移 + delete 保护
+ *   7. 取号排序（K1/K2/K3 + 30min 休息窗）· 自动释放（一实例一号）· retired 排除
+ *   8. 登录态导入 import（登记语义 + lastImportFrom）
+ *   9. 重登录 relogin（X 方案：使用中仅换 cookies；suspect 回池 / retired 复活）
+ *   10. 巡检 healthTargets/recordHealth/checkPoolAccounts + prepareRelogin（X 方案守卫同步放宽）
  *
- * 跑法: HOME=$(mktemp -d) node scripts/test-login-pool.mjs
+ * 跑法: node scripts/test-login-pool.mjs
+ *   （自建临时 HOME 并在 import 前覆盖环境变量——绝不读写真实 ~/.tt-help-watchdog-logins.json）
  */
 import assert from "assert";
-import { readFileSync, existsSync } from "fs";
+import { mkdtempSync, readFileSync, writeFileSync, existsSync } from "fs";
+import { tmpdir } from "os";
 import { join } from "path";
 
+// ── 测试基建：临时 HOME 隔离 ──
+// login-pool.js 的 POOL_FILE 在模块加载期由 os.homedir() 计算（POSIX 下 homedir() 实时读
+// process.env.HOME），故必须在动态 import 之前覆盖 HOME/USERPROFILE；生产代码零改动即可隔离。
+process.env.HOME = mkdtempSync(join(tmpdir(), "loginpool-test-"));
+process.env.USERPROFILE = process.env.HOME; // Windows 语义兜底
 const HOME = process.env.HOME;
-if (!HOME || HOME === "/") {
-  console.error("请用隔离 HOME 运行: HOME=$(mktemp -d) node scripts/test-login-pool.mjs");
-  process.exit(1);
-}
 
 const {
   getLoginPoolView,
@@ -31,7 +38,7 @@ const {
   acquireAccount,
   importAccount,
   heartbeatLoginPool,
-  reapExpiredLeases,
+  reapZombieLeases,
   reloginAccount,
   prepareRelogin,
   healthTargets,
@@ -197,19 +204,27 @@ console.log("\n[3] 心跳下发");
   check("GET 视图持续无明文", !JSON.stringify(getLoginPoolView()).includes("sid-b"));
 }
 
-// ── 4. 续租 + 健康采集 + 节点执行回报 ──
-console.log("\n[4] 续租 + 健康采集 + 节点执行回报");
+// ── 4. 心跳零状态变更 + 节点执行回报（7be35e8：续租/健康采集已删，心跳唯一写路径=applied 写回） ──
+console.log("\n[4] 心跳零状态变更 + 节点执行回报");
 {
-  const okAt = Date.now() - 60000;
-  heartbeatLoginPool("F-2", {
-    loginPool: { ports: { 9224: { username: "userC", lastBusinessOkAt: okAt, emptyStreak: 2 } } },
+  const cBefore = getLoginPoolView().accounts.find((x) => x.username === "userC"); // 在租（F-2:9224）
+  const snapBefore = JSON.stringify(getLoginPoolView());
+
+  // 无命令、无回报的心跳（携带旧版健康采集 payload）→ 返回 undefined 且池状态一个字节都不动
+  const hb = heartbeatLoginPool("F-ZERO", {
+    loginPool: { ports: { 9224: { username: "userC", lastBusinessOkAt: Date.now() - 60000, emptyStreak: 2 } } },
   });
+  check("无命令无回报的心跳返回 undefined", hb === undefined, JSON.stringify(hb));
+  const snapAfter = JSON.stringify(getLoginPoolView());
+  check("心跳零状态变更（整池快照逐字节一致）", snapBefore === snapAfter);
+
   let b = getLoginPoolView().accounts.find((x) => x.username === "userC");
-  check("业务出活时间入库", b.lease.lastBusinessOkAt === okAt);
-  check("空响应连击入库", b.lease.emptyStreak === 2);
-  check("续租刷新 lastHealthAt", b.lease.lastHealthAt > 0);
+  check("健康采集已删：lastBusinessOkAt/emptyStreak 不再入库",
+    b.lease.lastBusinessOkAt === undefined && b.lease.emptyStreak === undefined);
+  check("心跳不刷新 lastUsedAt/lastHealthAt（盖章/镜像已删）",
+    b.lastUsedAt === cBefore.lastUsedAt && b.lastHealthAt === (cBefore.lastHealthAt || null));
 
-  // 节点 applyLogin 成功回报（含持久化）
+  // 节点 applyLogin 成功回报（含持久化）→ 写回租约（心跳唯一写路径）
   heartbeatLoginPool("F-2", {
     loginPool: {
       applied: [{ action: "applyLogin", accountId: b.id, port: 9224, username: "userC", ok: true, persisted: true, at: Date.now() }],
@@ -228,31 +243,55 @@ console.log("\n[4] 续租 + 健康采集 + 节点执行回报");
   b = getLoginPoolView().accounts.find((x) => x.username === "userC");
   check("失败回报覆盖状态（最新为准）", b.lease.lastAppliedOk === false);
   check("历史记录 applyFailed", b.history.some((h) => h.event === "applyFailed"));
+
+  // clearLogin 执行回报
+  heartbeatLoginPool("F-2", {
+    loginPool: {
+      applied: [{ action: "clearLogin", accountId: b.id, port: 9224, at: Date.now() }],
+    },
+  });
+  b = getLoginPoolView().accounts.find((x) => x.username === "userC");
+  check("clearLogin 回报记 cleared", b.history.some((h) => h.event === "cleared"));
 }
 
-// ── 5. 掉线回收 + 命令超时作废 ──
-console.log("\n[5] 掉线回收 + 命令超时作废");
+// ── 5. 僵尸回收（assignedAt 硬顶 2h，reapZombieLeases）+ 命令超时作废 ──
+console.log("\n[5] 僵尸回收（2h 硬顶）+ 命令超时作废");
 {
-  // 直接改内存时间不可行（模块内部 now），改用字段注入验证 reap 逻辑：
-  // 给 A 重新指派，然后人为把 lease.lastHealthAt 拨回 13 小时前
+  // 5.1 边界内（≤2h）不回收
   const aLeased = assignAccount({ id: accA.id, userId: "F-3", port: 9225 });
   check("A 再指派成功", aLeased.status === "leased");
-  // 取走 F-3 的命令，避免干扰
-  heartbeatLoginPool("F-3", {});
-
-  // 内部状态篡改：用 update 不行（不暴露 lease 写），通过文件回写模拟时间流逝
-  const file = join(HOME, ".tt-help-watchdog-logins.json");
-  // 强制落盘：scheduleSave 是 3s debounce；reapExpiredLeases 内部 ensureLoaded 读文件，
-  // 这里直接改文件 + 清模块缓存不可行（ESM 无缓存清理）→ 用 lastHealthAt 拨回方式：
-  // 模块导出 _accountsInternal 供测试直改内存
-  const internal = (await import("../src/watch/login-pool.js"))._accountsInternal();
-  const aInternal = internal.find((x) => x.username === "userA");
-  aInternal.lease.lastHealthAt = Date.now() - 13 * 60 * 60 * 1000; // 13h 前
-  const reaped = reapExpiredLeases();
-  check("超时租约被回收", reaped === 1, `reaped=${reaped}`);
+  heartbeatLoginPool("F-3", {}); // 取走 F-3 命令，避免干扰
+
+  // 内部状态直改（_accountsInternal 供测试直改内存）：assignedAt 拨回 1h59m
+  const aInternal = _accountsInternal().find((x) => x.username === "userA");
+  aInternal.lease.assignedAt = Date.now() - (2 * 60 * 60 * 1000 - 60 * 1000);
+  check("持有 1h59m 未超顶不回收", reapZombieLeases() === 0);
+  check("边界内租约保持", getLoginPoolView().accounts.find((x) => x.username === "userA").status === "leased");
+
+  // 5.2 超顶（>2h）→ zombieReaped 回收回池
+  aInternal.lease.assignedAt = Date.now() - (2 * 60 * 60 * 1000 + 60 * 1000);
+  const reaped = reapZombieLeases();
+  check("超 2h 租约被回收", reaped === 1, `reaped=${reaped}`);
   const aView = getLoginPoolView().accounts.find((x) => x.username === "userA");
   check("回收后回池", aView.status === "pool" && !aView.lease);
-  check("历史记录 leaseExpired", aView.history.some((h) => h.event === "leaseExpired"));
+  check("历史留痕 zombieReaped", aView.history.some((h) => h.event === "zombieReaped"));
+  check("回收盖 lastUsedAt（休息窗从回收起算）", aView.lastUsedAt > 0 && Math.abs(aView.lastUsedAt - Date.now()) < 60000);
+
+  // 5.3 命令 10min 未被取走 → deliveryExpired + 租约回收（区别于僵尸路径）
+  assignAccount({ id: aView.id, userId: "F-5", port: 9227 }); // 排队命令，故意不心跳取走
+  await new Promise((r) => setTimeout(r, 3200)); // 等防抖落盘，保证磁盘=内存（外部改文件前的安全窗）
+  const file = join(HOME, ".tt-help-watchdog-logins.json");
+  const disk = JSON.parse(readFileSync(file, "utf-8"));
+  const cmd = disk.queue.find((c) => c.userId === "F-5");
+  check("待发命令已随池文件持久化", !!cmd);
+  cmd.queuedAt = Date.now() - 11 * 60 * 1000; // 拨回 11 分钟前（mtime 变化 → 模块自动重载）
+  writeFileSync(file, JSON.stringify(disk, null, 2), "utf-8");
+  const zombieCount = reapZombieLeases(); // 内部先 dropStaleCommands
+  check("超时命令走 deliveryExpired 路径（僵尸计数 0）", zombieCount === 0, `zombie=${zombieCount}`);
+  const aAfter = getLoginPoolView().accounts.find((x) => x.username === "userA");
+  check("超时命令作废并回收租约回池", aAfter.status === "pool" && !aAfter.lease, `status=${aAfter.status}`);
+  check("历史留痕 deliveryExpired", aAfter.history.some((h) => h.event === "deliveryExpired"));
+  check("作废后 F-5 心跳收不到命令", heartbeatLoginPool("F-5", {}) === undefined);
 }
 
 // ── 6. release / update / delete ──
@@ -294,7 +333,7 @@ console.log("\n[6] release / update / delete");
   }
 }
 
-// ── 7. 取号排序（双键+冷却）· 自动释放（一实例一号）· retired 排除 ──
+// ── 7. 取号排序（K1/K2/K3 + 30min 休息窗）· 自动释放（一实例一号）· retired 排除 ──
 console.log("\n[7] 取号·导入·自动释放");
 {
   // 清池重建：全量 release→retired→delete，再导入 4 个新号（uc 全 0，createdAt 递增）
@@ -311,25 +350,25 @@ console.log("\n[7] 取号·导入·自动释放");
   mk("userE"); mk("userF"); mk("userG"); mk("userH");
   check("重建后池=4", getLoginPoolView().total === 4);
 
-  // 7.1 双键排序：uc 全 0 → createdAt 升序 → userE
+  // 7.1 K1 从未用过最前（组内 K3 退化为 createdAt 升序）→ userE
   const t1 = acquireAccount({ userId: "n1" });
   check("永不用过的优先（userE）", t1.username === "userE", `got ${t1.username}`);
   check("取号次数 +1", t1.useCount === 1);
 
-  // 7.2 第二低（userF）[自动释放：n2 无旧租约，无操作]
+  // 7.2 其次 userF [自动释放：n2 无旧租约，无操作]
   const t2 = acquireAccount({ userId: "n2" });
   check("其次取 userF", t2.username === "userF", `got ${t2.username}`);
 
-  // 7.3 错峰冷却：还回 userE（lastUsedAt=now → 10min 冷却）→ 不立即复用
+  // 7.3 休息窗（30min）：还回 userE（lastUsedAt=now → 窗内不可领取）→ 不立即复用
   releaseAccount({ id: t1.id });
   const t3 = acquireAccount({ userId: "n3" });
   check("刚还的号不立即复用（取 userG）", t3.username === "userG", `got ${t3.username}`);
 
-  // 7.4 最后一个非冷却空闲号（userH）
+  // 7.4 最后一个非休息窗空闲号（userH）
   const t4 = acquireAccount({ userId: "n4" });
   check("取 userH", t4.username === "userH", `got ${t4.username}`);
 
-  // 7.5 ③ 自动释放：池内放入新号 → n1 再取 → 拿新号 + n1 名下旧租约（userE）自动归还
+  // 7.5 自动释放：池内放入新号 → n1 再取 → 拿新号 + n1 名下旧租约（userE）自动归还
   importAccount({ userId: "x", username: "userZ", cookies: [{ name: "sessionid", value: "sid-z" }] });
   const t5 = acquireAccount({ userId: "n1" });
   check("n1 取到新放入的 userZ", t5.username === "userZ", `got ${t5.username}`);
@@ -343,7 +382,7 @@ console.log("\n[7] 取号·导入·自动释放");
 
   // 7.7 retired 不参与取号：停用 userZ → 取号拿到别的
   const zId = getLoginPoolView().accounts.find((x) => x.username === "userZ").id;
-  releaseAccount({ id: zId }).account; // 若在租则释放
+  releaseAccount({ id: zId });
   updateAccount({ id: zId, status: "retired" });
   const t6 = acquireAccount({ userId: "n5" });
   check("retired 不被取用", t6.username !== "userZ", `got ${t6.username}`);
@@ -383,7 +422,7 @@ console.log("\n[8] 登录态导入 import");
   check("缺 cookies 确实抛错", threw);
 }
 
-console.log("\n[9] 重登录 relogin（覆盖刷新 + 守卫）");
+console.log("\n[9] 重登录 relogin（X 方案：使用中仅换 cookies + 守卫 + 复活）");
 {
   for (const a of getLoginPoolView().accounts) {
     try { releaseAccount({ id: a.id }); } catch {}
@@ -405,7 +444,7 @@ console.log("\n[9] 重登录 relogin（覆盖刷新 + 守卫）");
   const after = JSON.parse(JSON.stringify(_accountsInternal().find((a) => a.username === "userD")));
   check("覆盖刷新（新 cookies 落池）", JSON.stringify(after.cookies).includes("sid-d-new") && JSON.stringify(after.cookies).includes("poc_marker"));
   check("历史含 relogin 事件", (after.history || []).some((h) => h.event === "relogin"));
-  check("正常刷新不改状态不复活", r.revived === false && r.wasSuspect === false && r.account.status === "pool");
+  check("空闲刷新不改状态不复活", r.revived === false && r.wasSuspect === false && r.account.status === "pool");
 
   let threw = false;
   try { reloginAccount({ username: "ghost", cookies: D2, userId: "cli" }); } catch (e) { threw = /不在池中/.test(e.message); }
@@ -417,10 +456,14 @@ console.log("\n[9] 重登录 relogin（覆盖刷新 + 守卫）");
   try { reloginAccount({ username: "userD", userId: "cli" }); } catch (e) { threw = /cookies/.test(e.message); }
   check("缺 cookies 拒绝", threw);
 
+  // X 方案（2026-11-03）：使用中也可重登录——仅替换池内 cookies，状态与租约原样保留
   acquireAccount({ userId: "T1", port: 9400 });
-  threw = false;
-  try { reloginAccount({ username: "userD", cookies: D2, userId: "cli" }); } catch (e) { threw = /使用中/.test(e.message); }
-  check("使用中拒绝重登录", threw);
+  r = reloginAccount({ username: "userD", cookies: D2, userId: "cli", note: "使用中刷新" });
+  check("使用中可重登录（X 方案）", !!r && r.account.status === "leased", JSON.stringify(r && r.account && r.account.status));
+  check("使用中重登录不动租约", r.account.lease && r.account.lease.userId === "T1" && r.account.lease.port === 9400);
+  const afterUse = JSON.parse(JSON.stringify(_accountsInternal().find((a) => a.username === "userD")));
+  check("使用中重登录 cookies 已覆盖", JSON.stringify(afterUse.cookies).includes("poc_marker"));
+  check("使用中重登录历史注明仅换 cookies", (afterUse.history || []).some((h) => h.event === "relogin" && h.detail.includes("使用中")));
   releaseAccount({ id: getLoginPoolView().accounts.find((a) => a.username === "userD").id });
 
   updateAccount({ id: getLoginPoolView().accounts.find((a) => a.username === "userD").id, status: "suspect" });
@@ -470,7 +513,7 @@ console.log("\n[10] 巡检 healthTargets/recordHealth/checkPoolAccounts（注入
   const aliveAcc = getLoginPoolView().accounts.find((a) => a.username === "u-alive");
   check("活号不写 history（防刷屏）", !(aliveAcc.history || []).some((h) => h.event === "health"));
 
-  acquireAccount({ userId: "T2", port: 9401 }); // 租走最久未用的（u-alive 或 u-dead 中 LRU 者）
+  acquireAccount({ userId: "T2", port: 9401 }); // 租走空闲号（u-alive；u-dead 是 suspect 不会被取）
   const leased = getLoginPoolView().accounts.find((a) => a.status === "leased");
   const rec = recordHealth({ id: leased.id, ok: "dead", detail: "单测" });
   check("leased 死号仅记录不迁移状态", rec.status === "leased" && leased.username === rec.username);
@@ -478,10 +521,10 @@ console.log("\n[10] 巡检 healthTargets/recordHealth/checkPoolAccounts（注入
   const notLeased = getLoginPoolView().accounts.find((a) => a.status !== "leased").username;
   const prep = prepareRelogin({ username: notLeased });
   check("prepare 返回明文 cookies", Array.isArray(prep.account.cookies) && prep.account.cookies.length > 0);
+  // X 方案：prepareRelogin 守卫与 reloginAccount 同步放宽——使用中也放行（仅在池即可）
+  const prepLeased = prepareRelogin({ username: leased.username });
+  check("prepare 使用中也返回 cookies（X 方案守卫放宽）", Array.isArray(prepLeased.account.cookies) && prepLeased.account.cookies.length > 0);
   let threw = false;
-  try { prepareRelogin({ username: leased.username }); } catch (e) { threw = /使用中/.test(e.message); }
-  check("prepare 使用中拒绝", threw);
-  threw = false;
   try { prepareRelogin({ username: "ghost" }); } catch (e) { threw = /不在池中/.test(e.message); }
   check("prepare 不在池拒绝", threw);
 }