tt-help-cli-ycl 1.4.125 → 1.4.128

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tt-help-cli-ycl",
-  "version": "1.4.125",
+  "version": "1.4.128",
   "description": "TikTok user & video data scraper - extract ttSeller, verified, locationCreated from HTML source",
   "type": "module",
   "bin": {

package/scripts/test-daemon-switch-history.mjs

@@ -0,0 +1,141 @@
+/**
+ * daemon 切换历史排序单测（无需 Clash 运行）
+ * 验证 _sortCandidates / _markSwitch 的纯时间轮换（后进后出）行为
+ */
+import { ClashDaemon } from "../src/clash/daemon.js";
+
+let pass = 0;
+let fail = 0;
+function ok(cond, name, detail = "") {
+  if (cond) {
+    pass++;
+    console.log(`  ✓ ${name}`);
+  } else {
+    fail++;
+    console.error(`  ✗ ${name} ${detail}`);
+  }
+}
+
+const d = new ClashDaemon({});
+const nodes = ["A", "B", "C", "D"];
+const T0 = Date.now();
+
+// T1 无历史 → 原序
+{
+  const c = { proxyPort: 1 };
+  ok(
+    JSON.stringify(d._sortCandidates(nodes, c)) === JSON.stringify(nodes),
+    "T1 无历史保持原序",
+  );
+}
+
+// T2 切过沉底，未切过保持原序
+{
+  const c = { proxyPort: 2 };
+  c._switchHistory = new Map([["B", T0 - 10_000]]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,C,D,B", "T2 切过沉底，未切过保持原序", r.join());
+}
+
+// T3 切过按切换时间升序，未切过最前
+{
+  const c = { proxyPort: 3 };
+  c._switchHistory = new Map([
+    ["C", T0 - 2_000],
+    ["A", T0 - 1_000],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "B,D,C,A", "T3 切过按切换时间升序，未切过最前", r.join());
+}
+
+// T4 全部切过 → 完全按切换时间轮换
+{
+  const c = { proxyPort: 4 };
+  c._switchHistory = new Map([
+    ["A", T0 - 4_000],
+    ["B", T0 - 1_000],
+    ["C", T0 - 3_000],
+    ["D", T0 - 2_000],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,C,D,B", "T4 全切过按切换时间轮换", r.join());
+}
+
+// T5 无时间窗口：无论多久前切过都按时间排队（不恢复 delay 原序）
+{
+  const c = { proxyPort: 5 };
+  c._switchHistory = new Map([["C", T0 - 3_600_000]]); // 1 小时前切过
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "A,B,D,C", "T5 无窗口：1 小时前切过仍沉底", r.join());
+}
+
+// T6 排序不改原数组
+{
+  ok(nodes.join() === "A,B,C,D", "T6 原数组未被修改");
+}
+
+// T7 _markSwitch 惰性初始化 + 更新
+{
+  const c = { proxyPort: 6 };
+  d._markSwitch(c, "A");
+  ok(
+    c._switchHistory instanceof Map && c._switchHistory.has("A"),
+    "T7 _markSwitch 惰性初始化并记录",
+  );
+  const t1 = c._switchHistory.get("A");
+  d._markSwitch(c, "A");
+  ok(c._switchHistory.get("A") >= t1, "T8 _markSwitch 重复记录更新时间戳");
+}
+
+// T9 时间戳相同时稳定排序（V8 sort 稳定，保持原相对序）
+{
+  const c = { proxyPort: 7 };
+  c._switchHistory = new Map([
+    ["A", T0 - 100],
+    ["B", T0 - 100],
+  ]);
+  const r = d._sortCandidates(nodes, c);
+  ok(r.join() === "C,D,A,B", "T9 相同时间戳保持原相对序（稳定排序）", r.join());
+}
+
+// T10 壳页判定：200 + 无跳转 + 无 error + 无 title → 壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 200, numRedirects: 0, title: "" }) ===
+    true,
+  "T10 壳页判定：200+无title → true",
+);
+// T11 健康页（有 title）→ 非壳页
+ok(
+  d._isShellPage({
+    error: null,
+    httpCode: 200,
+    numRedirects: 0,
+    title: "TikTok - Make Your Day",
+  }) === false,
+  "T11 健康页有 title → false",
+);
+// T12 连接错误 → 非壳页
+ok(
+  d._isShellPage({
+    error: "timeout",
+    httpCode: 0,
+    numRedirects: 0,
+    title: "",
+  }) === false,
+  "T12 连接错误 → false",
+);
+// T13 跳转 → 非壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 200, numRedirects: 1, title: "" }) ===
+    false,
+  "T13 跳转 → false",
+);
+// T14 非 200 → 非壳页
+ok(
+  d._isShellPage({ error: null, httpCode: 403, numRedirects: 0, title: "" }) ===
+    false,
+  "T14 非 200 → false",
+);
+
+console.log(`\n结果: ${pass} 通过 / ${fail} 失败`);
+process.exit(fail ? 1 : 0);

package/scripts/test-wmi-free-upgrade.mjs

@@ -0,0 +1,98 @@
+/**
+ * 测试：升级链绕开 WMI 的新逻辑（2026-08-21）
+ * 范围（macOS 可测部分）：
+ *  1. parseCsvLine：tasklist /FO CSV 输出解析（引号/逗号边界）
+ *  2. 模拟 tasklist /V 输出的窗口标题匹配过滤逻辑（复算与实现一致的筛选规则）
+ *  3. agent 构造即写存活标记文件（STARTED_FILE），内容含 pid/version
+ */
+import assert from "assert";
+import { readFileSync, rmSync } from "fs";
+import { join, dirname } from "path";
+import { tmpdir } from "os";
+import { fileURLToPath } from "url";
+
+const { parseCsvLine } = await import("../src/watchdog/upgrader.js");
+
+let pass = 0;
+const ok = (msg) => {
+  pass++;
+  console.log(`  ✓ ${msg}`);
+};
+
+// ── 1. parseCsvLine ──
+const L1 = '"conhost.exe","5234","Console","2","8,312 K","Running","x\\user","0:00:01","tt-help-watchdog (F-7@WIN)"';
+const f1 = parseCsvLine(L1);
+assert.strictEqual(f1[0], "conhost.exe", "映像名");
+assert.strictEqual(f1[1], "5234", "PID");
+assert.strictEqual(f1[3], "2", "会话#");
+assert.strictEqual(f1[4], "8,312 K", "带逗号字段 8,312 K");
+assert.strictEqual(f1[8], "tt-help-watchdog (F-7@WIN)", "窗口标题");
+ok("parseCsvLine: 常规行（含带逗号字段）");
+
+// 标题内含转义引号（CSV 标准：双引号 "" 转义）
+const L2 = '"cmd.exe","999","Console","2","1,024 K","Running","x\\user","0:00:00","say ""hi"", tt-help-watchdog"';
+const f2 = parseCsvLine(L2);
+assert.strictEqual(f2[8], 'say "hi", tt-help-watchdog', "标题含转义引号与逗号");
+ok("parseCsvLine: 标题含转义引号+逗号");
+
+// 无引号行（表头）
+const f3 = parseCsvLine("映像名称,PID,会话名,会话#,内存使用,状态,用户名,CPU 时间,窗口标题");
+assert.strictEqual(f3.length, 9, "表头 9 列");
+ok("parseCsvLine: 无引号表头");
+
+// ── 2. 模拟 tasklist /V 输出做标题匹配过滤（复算实现逻辑） ──
+const mockTasklist = [
+  '"映像名称","PID","会话名","会话#","内存使用","状态","用户名","CPU 时间","窗口标题"',
+  '"System Idle Process","0","Services","0","8 K","Unknown","NT AUTHORITY\\SYSTEM","1:23:45:55","N/A"',
+  '"conhost.exe","5234","Console","2","8,312 K","Running","x\\user","0:00:01","tt-help-watchdog (F-7@WIN-AADJ1HTCCAQ)"',
+  '"cmd.exe","4000","Console","2","4,444 K","Running","x\\user","0:00:00","N/A"',
+  '"conhost.exe","7777","Console","2","2,048 K","Running","x\\user","0:00:00","C:\\Windows\\system32\\cmd.exe"',
+  '"node.exe","6400","Console","2","120,000 K","Running","x\\user","0:00:10","N/A"',
+  '"cmd.exe","6401","Console","2","3,000 K","Running","x\\user","0:00:00","tt-help-watchdog (old)"',
+];
+const TAG = "tt-help-watchdog";
+const matched = [];
+for (const line of mockTasklist) {
+  if (!line.toLowerCase().includes(TAG.toLowerCase())) continue;
+  const fields = parseCsvLine(line);
+  if (fields.length < 2) continue;
+  const name = (fields[0] || "").toLowerCase();
+  if (!name.includes("conhost") && !name.includes("cmd")) continue;
+  const pid = parseInt(fields[1], 10);
+  if (pid > 0) matched.push(pid);
+}
+assert.deepStrictEqual(
+  [...new Set(matched)].sort((a, b) => a - b),
+  [5234, 6401],
+  "只匹配到标题含 tag 的 conhost/cmd，普通窗口/其他进程不误匹配",
+);
+ok("标题匹配过滤: 命中旧窗口 conhost+cmd，排除无关进程");
+
+// ── 3. agent 构造即写存活标记文件 ──
+const STARTED_FILE = join(tmpdir(), "tt-help-watchdog-started.json");
+rmSync(STARTED_FILE, { force: true });
+const { WatchdogAgent } = await import("../src/watchdog/agent.js");
+const agent = new WatchdogAgent({
+  serverUrl: "http://127.0.0.1:3001",
+  clientId: "test@unit",
+  intervalMs: 15000,
+});
+assert.ok(agent, "agent 构造成功");
+const st = JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+assert.strictEqual(st.pid, process.pid, "pid=当前进程");
+assert.ok(typeof st.version === "string" && st.version.length > 0, "version 非空");
+assert.ok(st.ts > 0, "ts 存在");
+ok(`存活文件写入: pid=${st.pid}, version=${st.version}`);
+
+// 重复构造覆盖写（模拟新版 watchdog 启动覆盖旧文件）
+const agent2 = new WatchdogAgent({
+  serverUrl: "http://127.0.0.1:3001",
+  clientId: "test2@unit",
+});
+const st2 = JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+assert.strictEqual(st2.pid, process.pid, "覆盖写仍有效");
+ok("存活文件: 重复构造覆盖写正常");
+
+// 清理测试文件
+rmSync(STARTED_FILE, { force: true });
+console.log(`\n全部通过: ${pass} 项`);

package/src/clash/daemon.js

@@ -84,6 +84,45 @@ export class ClashDaemon {
     return run;
   }
 
+  /** 记录一次成功切换（failover/巡检/手动切换共用），供候选排序使用 */
+  _markSwitch(c, nodeName) {
+    if (!c || !nodeName) return;
+    c._switchHistory = c._switchHistory || new Map();
+    c._switchHistory.set(nodeName, Date.now());
+  }
+
+  /**
+   * 壳页判定：TikTok SSR 降级响应（HTTP 200 + 无跳转 + 无 error + 无 title）。
+   * 壳页 = 加载页（data-downgrade 骨架屏），链路正常、浏览器会自行渲染，不算节点故障。
+   */
+  _isShellPage(h) {
+    return (
+      !!h && !h.error && h.httpCode === 200 && h.numRedirects === 0 && !h.title
+    );
+  }
+
+  /**
+   * 候选排序（切换历史感知，纯时间轮换）：
+   * 业务级封禁（TikTok 风控）探针无法感知，用"最近切换时间"作为唯一可靠信号，
+   * 让 failover/巡检在候选池内公平轮换，避免少数节点间反复横跳。
+   * 排序规则：
+   *   - 从未切过的节点排最前（保持 delay 原序，新入池节点优先尝试）
+   *   - 切过的节点按切换时间升序沉底（最早切换的先试，最近切换的最后试 = 后进后出）
+   * 轮完一圈自然回访最早切过的节点（等于重新评估），无需时间窗口过期。
+   */
+  _sortCandidates(nodes, c) {
+    const hist = c && c._switchHistory;
+    if (!hist || !hist.size || !Array.isArray(nodes)) return nodes;
+    return [...nodes].sort((a, b) => {
+      const aLast = hist.get(a) || 0;
+      const bLast = hist.get(b) || 0;
+      if (aLast && bLast) return aLast - bLast; // 都切过：最早切换的先试
+      if (aLast) return 1; // 仅 a 切过：沉底
+      if (bLast) return -1;
+      return 0; // 都未切过：保持 delay 原序（Array.sort 稳定排序）
+    });
+  }
+
   /** 将全局 api/checker 上下文指向指定控制器 */
   _useController(c) {
     api.configure({ port: c.port, secret: c.secret });
@@ -271,7 +310,7 @@ export class ClashDaemon {
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
-      const h = checker.checkNodeHealth();
+      let h = checker.checkNodeHealth();
       this._writeHealth(c, {
         node,
         healthy: h.healthy,
@@ -290,6 +329,45 @@ export class ClashDaemon {
         return;
       }
 
+      // 空壳页（TikTok SSR 降级响应）：链路可用、浏览器会自行渲染，
+      // 切换无收益且会打断业务连接，不触发切换
+      if (this._isShellPage(h)) {
+        c._apiFailCount = 0;
+        this._log(
+          `~ [${c.proxyPort}] 空壳页（降级响应，链路正常），不切换 (${(h.sizeDownload / 1024).toFixed(0)}KB ${h.timeTotal.toFixed(1)}s)`,
+        );
+        return this._writeHealth(c, {
+          node,
+          healthy: true,
+          httpCode: h.httpCode,
+          timeTotal: h.timeTotal,
+          sizeDownload: h.sizeDownload,
+          title: h.title,
+          shellPage: true,
+        });
+      }
+
+      // 真异常先复测一次：过滤瞬时抖动（截断/丢包），连续异常才进入切换
+      const firstReason =
+        h.error || `HTTP ${h.httpCode} ${(h.sizeDownload / 1024).toFixed(0)}KB`;
+      await new Promise((r) => setTimeout(r, 3000));
+      const hr = checker.checkNodeHealth();
+      if (hr.healthy || this._isShellPage(hr)) {
+        this._log(
+          `~ [${c.proxyPort}] 复测恢复（首次异常: ${firstReason}），不切换`,
+        );
+        return this._writeHealth(c, {
+          node,
+          healthy: true,
+          httpCode: hr.httpCode,
+          timeTotal: hr.timeTotal,
+          sizeDownload: hr.sizeDownload,
+          title: hr.title,
+          shellPage: this._isShellPage(hr) ? true : undefined,
+        });
+      }
+      h = hr; // 复测仍异常，以最新数据为准
+
       const reason =
         h.error || `HTTP ${h.httpCode} ${(h.sizeDownload / 1024).toFixed(0)}KB`;
       const { nodes } = checker.loadHealthyList();
@@ -320,17 +398,20 @@ export class ClashDaemon {
         `✗ [${c.proxyPort}] 巡检异常 [${reason}]，开始从候选集切换 (当前 ${node})`,
       );
       // 逐个切换候选 + 内容验证，第一个满足即采用
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      const ordered = this._sortCandidates(nodes, c);
       let target = null;
       let h2 = null;
-      for (const cand of nodes) {
+      for (const cand of ordered) {
         if (cand === node) continue;
         this._log(`↺ [${c.proxyPort}] 尝试候选: ${cand} [原因: ${reason}]`);
         if (!(await checker.switchToNode(cand))) {
           this._log(`  ↺ ${cand} 切换失败，下一个`);
           continue;
         }
+        this._markSwitch(c, cand);
         h2 = checker.checkNodeHealth();
-        if (h2.healthy) {
+        if (h2.healthy || this._isShellPage(h2)) {
           target = cand;
           break;
         }
@@ -340,6 +421,7 @@ export class ClashDaemon {
       if (!target) {
         // 全部候选不可用，恢复原节点
         await checker.switchToNode(node).catch(() => {});
+        this._markSwitch(c, node);
         await api.closeAllConnections().catch(() => {});
         this._log(
           `✗ [${c.proxyPort}] 恢复原节点 ${node}（原因: ${reason} — 候选全部不可用）`,
@@ -428,6 +510,13 @@ export class ClashDaemon {
       });
       const elapsed = ((Date.now() - start) / 1000).toFixed(0);
       checker.saveHealthyList(r.nodes);
+      // 清理切换历史中已不在候选集的节点，防止 Map 无限增长
+      if (c._switchHistory && c._switchHistory.size) {
+        const keep = new Set(r.nodes);
+        for (const k of [...c._switchHistory.keys()]) {
+          if (!keep.has(k)) c._switchHistory.delete(k);
+        }
+      }
       c._meta.lastBenchmark = new Date().toISOString();
       c._meta.healthyNodesTotal = r.total;
       c._meta.healthyNodesCount = r.nodes.length;
@@ -489,6 +578,7 @@ export class ClashDaemon {
           lastSwitch: `manual → ${cmd.node} (失败)`,
         });
       }
+      this._markSwitch(c, cmd.node);
       const h = checker.checkNodeHealth();
       // 切换后断开所有旧连接，浏览器立即重建到新节点（同巡检切换）
       await api.closeAllConnections().catch(() => {});
@@ -551,17 +641,20 @@ export class ClashDaemon {
         return;
       }
       // 逐个切换候选 + 内容验证，第一个满足即采用（跳过当前节点）
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      const ordered = this._sortCandidates(nodes, c);
       let target = null;
       let h2 = null;
-      for (const cand of nodes) {
+      for (const cand of ordered) {
         if (cand === node) continue;
         this._log(`↺ 尝试候选: ${cand}`);
         if (!(await checker.switchToNode(cand))) {
           this._log(`  ↺ ${cand} 切换失败，下一个`);
           continue;
         }
+        this._markSwitch(c, cand);
         h2 = checker.checkNodeHealth();
-        if (h2.healthy) {
+        if (h2.healthy || this._isShellPage(h2)) {
           target = cand;
           break;
         }
@@ -569,6 +662,7 @@ export class ClashDaemon {
       }
       if (!target) {
         await checker.switchToNode(node).catch(() => {});
+        this._markSwitch(c, node);
         await api.closeAllConnections().catch(() => {});
         this._log(
           `✗ failover [${reason}] — 候选全部不可用，恢复原节点 ${node}`,

package/src/cli/open.js

@@ -90,8 +90,8 @@ export async function handleOpen(parsed) {
 
     browser = await ensureBrowserReady(cdpOptions);
 
-    // Ctrl+C 关闭浏览器
-    process.on("SIGINT", async () => {
+    // Ctrl+C 关闭浏览器：优雅断开优先（超时保护），强杀进程兜底，最后强制退出
+    const shutdown = async () => {
       console.error("\n正在关闭浏览器...");
       // 先优雅断开 CDP 连接（带 3s 超时保护）：进程已被强杀时 close() 会挂起等 close 事件
       try {
@@ -109,7 +109,8 @@ export async function handleOpen(parsed) {
       });
       console.error("浏览器已关闭");
       process.exit(0);
-    });
+    };
+    process.on("SIGINT", shutdown);
 
     console.error("");
     console.error("浏览器已启动并连接成功");

package/src/cli/refresh-mini.js

@@ -576,22 +576,49 @@ export async function handleRefreshMini(options) {
 
       if (result.error) {
         const isBlocked = result.error.startsWith("被封:");
-        consecutiveTaskErrors++;
+        // 导航打断（多为切换节点后的网络重建期）不计入连续任务错误，
+        // 避免"切换 → 掐断连接 → 导航打断 → 计错 → 再切换"的循环
+        const isNavBreak = result.error.includes(
+          "Execution context was destroyed",
+        );
+        if (!isNavBreak) consecutiveTaskErrors++;
         errorCount++;
 
-        // 临时性错误：自动重试一次
+        // 临时性错误：自动重试
         if (result.retryable) {
-          console.error(`  [临时错误] 等待 5 秒后重试 @${username}...`);
-          await sleep(5000);
-          result = await processExplore(
-            page,
-            username,
-            processOptions(),
-            console.error,
-          );
-          if (!result.error) {
-            consecutiveTaskErrors = 0;
-            errorCount--;
+          if (isNavBreak) {
+            // 与被封同款渐退等待：30/40/50s，给切换后的网络重建时间
+            const navWaits = [30_000, 40_000, 50_000];
+            for (let retry = 0; retry < navWaits.length; retry++) {
+              console.error(
+                `  [网络重建] 导航打断（切换节点后），等待 ${navWaits[retry] / 1000}s 稳定后第 ${retry + 1}/${navWaits.length} 次重试 @${username}...`,
+              );
+              await sleep(navWaits[retry]);
+              result = await processExplore(
+                page,
+                username,
+                processOptions(),
+                console.error,
+              );
+              if (!result.error) {
+                consecutiveTaskErrors = 0;
+                errorCount--;
+                break;
+              }
+            }
+          } else {
+            console.error(`  [临时错误] 等待 5 秒后重试 @${username}...`);
+            await sleep(5000);
+            result = await processExplore(
+              page,
+              username,
+              processOptions(),
+              console.error,
+            );
+            if (!result.error) {
+              consecutiveTaskErrors = 0;
+              errorCount--;
+            }
           }
         }
 

package/src/lib/api-interceptor.js

@@ -251,17 +251,16 @@ async function attemptItemListFetch(page, username, log, apiRequestUrlRef) {
   };
 }
 
-async function fetchUserVideosAPI(
-  page,
-  username,
-  maxVideos,
-  log,
-  options = {},
-) {
-  log(`  [API拦截] 获取 @${username} 视频 ...`);
-
+/**
+ * CDP 健康检查：带超时保护，区分"页面忙"与"页面死"。
+ * evaluate 排队在页面主线程上，加载中的慢页面（肉眼可见转圈）10s 轮不到执行很正常，
+ * 此时是忙不是死：先观察等待（默认 2 轮 x 20s），慢页面通常在此期间自然加载完自愈。
+ * 观察后仍无响应才刷新页面（实测刷新可解除主线程死锁）；刷新后页面处于最忙的加载期，
+ * 先缓冲等待再以更宽松的窗口重检，避免误杀正在恢复的页面。
+ * 全部失败抛 "CDP 连接异常（刷新后仍失败）"。
+ */
+async function checkCdpHealth(page, options, log) {
   const {
-    blockedRetryWaitsMs = DEFAULT_BLOCKED_RETRY_WAITS,
     cdpProbeTimeoutMs = 10000, // 单次探活超时
     cdpObserveWaitMs = 20000, // 观察等待间隔（页面转圈加载期）
     cdpObserveRounds = 2, // 观察轮数
@@ -269,11 +268,6 @@ async function fetchUserVideosAPI(
     cdpReloadProbeTimeoutMs = 20000, // 刷新后重检窗口
   } = options;
 
-  // CDP 健康检查：带超时保护，区分"页面忙"与"页面死"。
-  // evaluate 排队在页面主线程上，加载中的慢页面（肉眼可见转圈）10s 轮不到执行很正常，
-  // 此时是忙不是死：先观察等待（默认 2 轮 x 20s），慢页面通常在此期间自然加载完自愈。
-  // 观察后仍无响应才刷新页面（实测刷新可解除主线程死锁）；刷新后页面处于最忙的加载期，
-  // 先缓冲等待再以更宽松的窗口重检，避免误杀正在恢复的页面。
   const evalWithTimeout = (label, ms) =>
     Promise.race([
       page.evaluate(() => document.readyState),
@@ -285,49 +279,62 @@ async function fetchUserVideosAPI(
       ),
     ]);
 
-  let healthy = false;
+  // 首探：成功（即使页面仍在加载）即认为健康
   try {
     const state = await evalWithTimeout("CDP 健康检查", cdpProbeTimeoutMs);
-    healthy = true;
     if (state !== "complete") {
       log(`  [API拦截] 健康检查通过，页面加载中 (readyState=${state})`);
     }
+    return;
   } catch (e) {
-    // 观察阶段：慢页面几十秒内通常自愈，期间不做任何操作
     log(
       `  [API拦截] CDP 探活超时: ${e.message}，页面可能仍在加载，观察等待...`,
     );
-    for (let round = 1; round <= cdpObserveRounds && !healthy; round++) {
-      await new Promise((r) => setTimeout(r, cdpObserveWaitMs));
-      try {
-        await evalWithTimeout(
-          `观察重检 ${round}/${cdpObserveRounds}`,
-          cdpProbeTimeoutMs,
-        );
-        healthy = true;
-        log(`  [API拦截] 页面已恢复（观察 ${round} 轮后）`);
-      } catch (e2) {
-        log(
-          `  [API拦截] 观察 ${round}/${cdpObserveRounds} 后仍无响应: ${e2.message}`,
-        );
-      }
-    }
   }
 
-  if (!healthy) {
-    log(`  [API拦截] 观察后仍无响应，刷新页面恢复...`);
-    await page
-      .reload({ waitUntil: "domcontentloaded", timeout: 30000 })
-      .catch(() => {});
-    await new Promise((r) => setTimeout(r, cdpReloadSettleMs));
+  // 观察阶段：慢页面几十秒内通常自愈，期间不做任何操作
+  for (let round = 1; round <= cdpObserveRounds; round++) {
+    await new Promise((r) => setTimeout(r, cdpObserveWaitMs));
     try {
-      await evalWithTimeout("刷新后重检", cdpReloadProbeTimeoutMs);
-      log(`  [API拦截] 页面已恢复（刷新后）`);
+      await evalWithTimeout(
+        `观察重检 ${round}/${cdpObserveRounds}`,
+        cdpProbeTimeoutMs,
+      );
+      log(`  [API拦截] 页面已恢复（观察 ${round} 轮后）`);
+      return;
     } catch (e2) {
-      throw new Error(`CDP 连接异常（刷新后仍失败）: ${e2.message}`);
+      log(
+        `  [API拦截] 观察 ${round}/${cdpObserveRounds} 后仍无响应: ${e2.message}`,
+      );
     }
   }
 
+  // 观察后仍无响应才刷新页面
+  log(`  [API拦截] 观察后仍无响应，刷新页面恢复...`);
+  await page
+    .reload({ waitUntil: "domcontentloaded", timeout: 30000 })
+    .catch(() => {});
+  await new Promise((r) => setTimeout(r, cdpReloadSettleMs));
+  try {
+    await evalWithTimeout("刷新后重检", cdpReloadProbeTimeoutMs);
+    log(`  [API拦截] 页面已恢复（刷新后）`);
+  } catch (e2) {
+    throw new Error(`CDP 连接异常（刷新后仍失败）: ${e2.message}`);
+  }
+}
+
+async function fetchUserVideosAPI(
+  page,
+  username,
+  maxVideos,
+  log,
+  options = {},
+) {
+  log(`  [API拦截] 获取 @${username} 视频 ...`);
+
+  await checkCdpHealth(page, options, log);
+
+  const { blockedRetryWaitsMs = DEFAULT_BLOCKED_RETRY_WAITS } = options;
   let apiRequestUrlRef = { value: null };
   const retryWaits = Array.isArray(blockedRetryWaitsMs)
     ? blockedRetryWaitsMs

package/src/lib/browser/cdp.js

@@ -70,6 +70,19 @@ function checkEdgeArgs() {
   });
 }
 
+/**
+ * 解码 Windows 命令输出：中文系统 taskkill 输出为 GBK，
+ * 先按 UTF-8 解码，出现乱码替换符（U+FFFD）时改用 GBK 重解。
+ */
+function decodeWinOutput(data) {
+  if (!Buffer.isBuffer(data)) return String(data ?? "").trim();
+  let text = new TextDecoder("utf-8").decode(data);
+  if (text.includes("\uFFFD")) {
+    text = new TextDecoder("gbk").decode(data);
+  }
+  return text.trim();
+}
+
 /**
  * 解析 netstat -ano 输出，返回监听指定端口的 PID 列表（去重）。
  * 不依赖 WMI，适配 WMI 损坏/禁用的 Windows 机器。
@@ -89,6 +102,58 @@ export function parseNetstatListeningPids(netstatOutput, port) {
   return pids;
 }
 
+/**
+ * Windows：按监听端口杀掉 Edge 主进程及其进程树（不依赖 WMI，
+ * Get-CimInstance 在 WMI 损坏/禁用的机器上查不到进程）。
+ * 返回后续清理 Singleton 锁文件的命令。
+ */
+function killEdgeOnWindowsByPort(port) {
+  let killCmds = "";
+  try {
+    const netstatOut = execSync("netstat -ano", {
+      encoding: "utf-8",
+      timeout: 5000,
+      windowsHide: true,
+    });
+    const pids = parseNetstatListeningPids(netstatOut, port);
+    if (pids.length > 0) {
+      // 不重定向 stderr：taskkill 的错误信息（拒绝访问/找不到进程）需要可见
+      killCmds = pids.map((pid) => `taskkill /F /T /PID ${pid}`).join(" & ");
+      console.error(
+        `[killEdgeProcesses] 端口 ${port} 监听进程 PID: ${pids.join(", ")}`,
+      );
+    }
+  } catch (e) {
+    console.error(`[killEdgeProcesses] netstat 查询失败: ${e.message}`);
+  }
+
+  if (killCmds) {
+    // 同步执行并打印结果：taskkill 失败（权限/会话不匹配等）必须可见，不能静默吞掉
+    try {
+      const out = execSync(`(${killCmds})`, {
+        encoding: "buffer",
+        timeout: 15000,
+        windowsHide: true,
+      });
+      const lines = decodeWinOutput(out).split(/\r?\n/).filter(Boolean);
+      console.error(
+        `[killEdgeProcesses] taskkill 结果: ${lines.join(" | ") || "(无输出)"}`,
+      );
+    } catch (e) {
+      console.error(`[killEdgeProcesses] taskkill 失败: ${e.message}`);
+      const detail = decodeWinOutput(
+        Buffer.concat([
+          Buffer.isBuffer(e.stdout) ? e.stdout : Buffer.alloc(0),
+          Buffer.isBuffer(e.stderr) ? e.stderr : Buffer.alloc(0),
+        ]),
+      );
+      if (detail) console.error(`[killEdgeProcesses] 详情: ${detail}`);
+    }
+  }
+
+  return `del /f /q "%LOCALAPPDATA%\\Microsoft\\Edge\\Singleton*" 2>nul; exit 0`;
+}
+
 function killEdgeProcesses(targetDir, port) {
   return new Promise((resolve) => {
     const platform = os.platform();
@@ -138,53 +203,11 @@ function killEdgeProcesses(targetDir, port) {
           'killall -9 "Microsoft Edge" 2>/dev/null; rm -f ~/Library/Caches/Microsoft\\ Edge/Singleton*; true';
       }
     } else if (platform === "win32") {
-      if (port) {
-        // 不依赖 WMI：Get-CimInstance 在 WMI 损坏/禁用的机器上查不到进程（KILLED_PIDS 为空）。
-        // 改为 netstat 按监听端口找 PID（CDP 端口由浏览器主进程监听），taskkill /F /T 杀进程树
-        let killCmds = "";
-        try {
-          const netstatOut = execSync("netstat -ano", {
-            encoding: "utf-8",
-            timeout: 5000,
-            windowsHide: true,
-          });
-          const pids = parseNetstatListeningPids(netstatOut, port);
-          if (pids.length > 0) {
-            // 不重定向 stderr：taskkill 的错误信息（拒绝访问/找不到进程）需要可见
-            killCmds = pids
-              .map((pid) => `taskkill /F /T /PID ${pid}`)
-              .join(" & ");
-            console.error(
-              `[killEdgeProcesses] 端口 ${port} 监听进程 PID: ${pids.join(", ")}`,
-            );
-          }
-        } catch (e) {
-          console.error(`[killEdgeProcesses] netstat 查询失败: ${e.message}`);
-        }
-        if (killCmds) {
-          // 同步执行并打印结果：taskkill 失败（权限/会话不匹配等）必须可见，不能静默吞掉
-          const killCmd = `(${killCmds})`;
-          try {
-            const out = execSync(killCmd, {
-              encoding: "utf-8",
-              timeout: 15000,
-              windowsHide: true,
-            });
-            const lines = out.trim().split(/\r?\n/).filter(Boolean);
-            console.error(
-              `[killEdgeProcesses] taskkill 结果: ${lines.join(" | ") || "(无输出)"}`,
-            );
-          } catch (e) {
-            console.error(`[killEdgeProcesses] taskkill 失败: ${e.message}`);
-            const detail = `${e.stdout || ""}${e.stderr || ""}`.trim();
-            if (detail) console.error(`[killEdgeProcesses] 详情: ${detail}`);
-          }
-        }
-        // 找不到监听进程 = 浏览器可能已退出，不做按进程名的兜底（避免误杀其他端口实例）
-        command = `del /f /q "%LOCALAPPDATA%\\Microsoft\\Edge\\Singleton*" 2>nul; exit 0`;
-      } else {
-        command = "taskkill /F /IM msedge.exe 2>nul || exit 0";
-      }
+      // 有端口：按监听端口杀进程树（找不到监听进程 = 浏览器可能已退出，
+      // 不做按进程名的兜底，避免误杀其他端口实例）
+      command = port
+        ? killEdgeOnWindowsByPort(port)
+        : "taskkill /F /IM msedge.exe 2>nul || exit 0";
     } else {
       if (targetDir) {
         const escapedDir = targetDir.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&");

package/src/watchdog/agent.js

@@ -24,7 +24,7 @@ import {
 import { writeFileSync, existsSync, readFileSync } from "fs";
 import { spawn } from "child_process";
 import { join, dirname } from "path";
-import { homedir } from "os";
+import { homedir, tmpdir } from "os";
 import { fileURLToPath } from "url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -32,6 +32,36 @@ const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const TT_HELP_CONFIG = join(homeDir, ".tt-help.json");
 const IS_WIN = process.platform === "win32";
 
+// ── 升级配套（绕开 WMI）──
+// 部分 Windows 机器 WMI（WinMgmt）损坏，升级器用 Get-CimInstance 查进程表会失效，
+// 导致旧 cmd 窗口不关、新版存活误判。故升级链改为：
+//   1. 本进程启动时设置控制台窗口标题 → 升级器按标题匹配（tasklist /V）关旧窗
+//   2. 本进程启动时写存活标记文件 → 升级器读文件确认新版存活（不再枚举进程表）
+const STARTED_FILE = join(tmpdir(), "tt-help-watchdog-started.json");
+const WINDOW_TITLE_TAG = "tt-help-watchdog";
+
+/** 设置控制台窗口标题（仅 Windows 交互窗口生效，ESC ]0 转义；失败静默） */
+function setConsoleTitle(clientId) {
+  if (process.platform !== "win32") return;
+  try {
+    process.stdout.write(`\x1b]0;${WINDOW_TITLE_TAG} (${clientId})\x07`);
+  } catch {}
+}
+
+/** 写存活标记文件（升级器据此确认新版 watchdog 已启动，绕开 WMI） */
+function writeStartedFile() {
+  try {
+    writeFileSync(
+      STARTED_FILE,
+      JSON.stringify({
+        pid: process.pid,
+        version: getVersion(),
+        ts: Date.now(),
+      }),
+    );
+  } catch {}
+}
+
 // ── 业务日志错误统计 → 触发节点切换 ──
 // 识别采集程序日志里已有的错误分类标签（explore 等已打标），连续错误达标则切换出口节点
 const NETWORK_ERROR_PATTERNS = [
@@ -173,6 +203,9 @@ export class WatchdogAgent {
   }) {
     this.serverUrl = serverUrl.replace(/\/+$/, "");
     this.clientId = clientId;
+    // 升级配套：设窗口标题（升级器按标题关旧窗）+ 写存活文件（升级器做存活校验）
+    setConsoleTitle(clientId);
+    writeStartedFile();
     this.intervalMs = intervalMs;
     this.spawnDaemon = !!spawnDaemon;
     this.loginCheckIntervalMs = Math.max(

package/src/watchdog/process-manager.js

@@ -175,36 +175,45 @@ function getProcessStats(pid) {
   }
 }
 
+/**
+ * Windows: 执行 PowerShell -Command 并返回 stdout（trim 后）。
+ * 统一 execSync 选项，避免各处重复配置。
+ */
+function runPowerShell(psCommand, timeoutMs = 3000) {
+  return execSync(`powershell -NoProfile -Command "${psCommand}"`, {
+    encoding: "utf-8",
+    timeout: timeoutMs,
+    stdio: ["ignore", "pipe", "ignore"],
+    windowsHide: true, // Windows 隐藏控制台窗口
+  }).trim();
+}
+
 // Windows: 从 cmd.exe 往下找真正的 node.exe PID（shell:true 时 cmd.exe 是中间层）
 function getChildPid(parentPid) {
-  // 主路径：WMI 查询（原逻辑不变，WMI 正常机器零变化）
+  // 主路径：WMI 查询（WMI 正常机器零变化）
   try {
-    const out = execSync(
-      `powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter 'ParentProcessId=${parentPid}' | Where-Object { $_.Name -notlike 'conhost*' } | Select-Object -First 1 -ExpandProperty ProcessId"`,
-      {
-        encoding: "utf-8",
-        timeout: 3000,
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true, // Windows 隐藏控制台窗口
-      },
-    ).trim();
-    return parseInt(out, 10) || 0;
+    return (
+      parseInt(
+        runPowerShell(
+          `Get-CimInstance Win32_Process -Filter 'ParentProcessId=${parentPid}' | Where-Object { $_.Name -notlike 'conhost*' } | Select-Object -First 1 -ExpandProperty ProcessId`,
+        ),
+        10,
+      ) || 0
+    );
   } catch {
     // WMI 损坏/禁用时 Get-CimInstance 直接报错，落入 fallback
   }
   // fallback：不依赖 WMI，用 Get-Process（.NET API）按启动时间找
   // cmd.exe 之后最早启动的 node.exe（watchdog spawn 后 3s 才调用，node 应已启动）
   try {
-    const out = execSync(
-      `powershell -NoProfile -Command "$cmd = Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue; if ($cmd) { Get-Process node -ErrorAction SilentlyContinue | Where-Object { $_.StartTime -ge $cmd.StartTime } | Sort-Object StartTime | Select-Object -First 1 -ExpandProperty Id }"`,
-      {
-        encoding: "utf-8",
-        timeout: 3000,
-        stdio: ["ignore", "pipe", "ignore"],
-        windowsHide: true,
-      },
-    ).trim();
-    return parseInt(out, 10) || 0;
+    return (
+      parseInt(
+        runPowerShell(
+          `$cmd = Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue; if ($cmd) { Get-Process node -ErrorAction SilentlyContinue | Where-Object { $_.StartTime -ge $cmd.StartTime } | Sort-Object StartTime | Select-Object -First 1 -ExpandProperty Id }`,
+        ),
+        10,
+      ) || 0
+    );
   } catch {
     return 0;
   }

package/src/watchdog/upgrader.js

@@ -8,7 +8,7 @@
 
 import { exec, spawn, execFile } from "child_process";
 import { promisify } from "util";
-import { readFileSync, openSync } from "fs";
+import { readFileSync, openSync, unlinkSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import { homedir, tmpdir } from "os";
@@ -21,6 +21,12 @@ const homeDir = homedir() || process.env.HOME || process.env.USERPROFILE || "";
 const TT_HELP_CONFIG = join(homeDir, ".tt-help.json");
 const execFileP = promisify(execFile);
 
+// 升级链绕开 WMI 的配套常量（与 agent.js 保持一致）：
+// 部分 Windows 机器 WMI（WinMgmt）损坏，Get-CimInstance 查不到进程表 →
+// 关旧窗改用窗口标题匹配（tasklist /V），存活校验改用新版 watchdog 写出的标记文件
+const STARTED_FILE = join(tmpdir(), "tt-help-watchdog-started.json");
+const WINDOW_TITLE_TAG = "tt-help-watchdog";
+
 /**
  * 升级检测源：TT_HELP_REGISTRY 环境变量 > ~/.tt-help.json 的 npmRegistry > 官方 npmjs.org
  * 注意：检测源应与本机 npm install 使用的 registry 保持一致（默认 npm 自身配置）
@@ -298,22 +304,101 @@ async function waitProcessExit(pid, waitMs) {
   return false;
 }
 
-/** 向上遍历父链，返回 cmd.exe 祖先进程 PID（旧 watchdog 所在窗口，升级后关窗用） */
-function listCmdAncestorPids(rows, pid) {
-  const byId = new Map(rows.map((r) => [r.pid, r]));
+/** 解析一行 CSV（处理引号包裹的逗号/转义引号），用于解析 tasklist /FO CSV 输出 */
+export function parseCsvLine(line) {
   const out = [];
-  const seen = new Set();
-  let cur = byId.get(pid)?.ppid;
-  while (cur && !seen.has(cur)) {
-    seen.add(cur);
-    const r = byId.get(cur);
-    if (!r) break;
-    if (/cmd(\.exe)?\b/i.test(r.cmd || "")) out.push(cur);
-    cur = r.ppid;
+  let cur = "";
+  let inQ = false;
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (inQ) {
+      if (c === '"') {
+        if (line[i + 1] === '"') {
+          cur += '"';
+          i++;
+        } else {
+          inQ = false;
+        }
+      } else {
+        cur += c;
+      }
+    } else if (c === '"') {
+      inQ = true;
+    } else if (c === ",") {
+      out.push(cur);
+      cur = "";
+    } else {
+      cur += c;
+    }
   }
+  out.push(cur);
   return out;
 }
 
+/**
+ * Windows：按窗口标题匹配 tasklist /V 输出中的控制台宿主进程 PID（绕开 WMI）。
+ * 窗口标题在 conhost.exe 行（Win10/11）或 cmd.exe 行（旧系统），两者都返回；
+ * 其余进程（含升级器 U 自身的隐藏 conhost，标题为空）不会误匹配。
+ */
+async function listWindowPidsByTitle(titleSubstr) {
+  if (process.platform !== "win32") return [];
+  try {
+    const { stdout } = await execFileP(
+      "tasklist.exe",
+      ["/V", "/FO", "CSV"],
+      { timeout: 20000, windowsHide: true },
+    );
+    const pids = [];
+    for (const line of String(stdout).split(/\r?\n/)) {
+      if (!line.toLowerCase().includes(titleSubstr.toLowerCase())) continue;
+      const fields = parseCsvLine(line);
+      if (fields.length < 2) continue;
+      const name = (fields[0] || "").toLowerCase();
+      if (!name.includes("conhost") && !name.includes("cmd")) continue;
+      const pid = parseInt(fields[1], 10);
+      if (pid > 0 && pid !== process.pid) pids.push(pid);
+    }
+    return [...new Set(pids)];
+  } catch (e) {
+    console.error(`[upgrade-proc] tasklist 查窗口失败: ${e.message}`);
+    return [];
+  }
+}
+
+/**
+ * 关闭旧 watchdog 所在的 cmd 窗口（绕开 WMI）：
+ * 旧 watchdog 启动时已把窗口标题设为含 WINDOW_TITLE_TAG 的串（agent.js），
+ * 此时新版窗口尚未弹出，匹配到的窗口即旧窗口 → taskkill 杀 conhost/cmd 关窗。
+ * 旧 watchdog 版本过旧（未设标题）或非窗口运行时匹配不到，跳过。
+ */
+async function killOldWatchdogWindow() {
+  if (process.platform !== "win32") return;
+  const pids = await listWindowPidsByTitle(WINDOW_TITLE_TAG);
+  if (pids.length === 0) {
+    console.error(
+      `[upgrade-proc] 未找到标题含 "${WINDOW_TITLE_TAG}" 的窗口（旧 watchdog 非窗口运行或版本过旧未设标题），跳过关旧窗`,
+    );
+    return;
+  }
+  await killPidList(pids, "已关闭旧 cmd 窗口");
+}
+
+/** 读存活标记文件（新版 watchdog 启动后写入 {pid, version, ts}） */
+function readStartedFile() {
+  try {
+    return JSON.parse(readFileSync(STARTED_FILE, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/** 删存活标记文件（spawn 新版前清掉旧 watchdog 的残留，确保读到的是新进程的） */
+function deleteStartedFile() {
+  try {
+    unlinkSync(STARTED_FILE);
+  } catch {}
+}
+
 /** 一次拉取全进程表 [{pid, ppid, cmd}]（Windows: CIM；POSIX: ps） */
 async function snapshotAllProcesses() {
   const rows = [];
@@ -441,24 +526,13 @@ async function killPidList(pids, label) {
   return killed;
 }
 
-/** 枚举当前所有 watchdog 进程 PID（存活校验前后对比用；不含升级器 U 自身） */
+/**
+ * 枚举当前所有 watchdog 进程 PID（仅 POSIX 存活校验前后对比用）。
+ * Windows 不再走这里——部分机器 WMI 损坏时枚举会静默返回空，已改为读
+ * 新版 watchdog 写出的存活标记文件（见 runUpgradeMode 第 5 步）。
+ */
 async function listWatchdogPids() {
   try {
-    if (process.platform === "win32") {
-      const ps =
-        `Get-CimInstance Win32_Process -Filter "Name='node.exe'" ` +
-        `| Where-Object { $_.CommandLine -match 'cli\\.js watchdog' } ` +
-        `| Select-Object -ExpandProperty ProcessId`;
-      const { stdout } = await execFileP(
-        "powershell.exe",
-        ["-NoProfile", "-Command", ps],
-        { timeout: 15000, windowsHide: true },
-      );
-      return String(stdout)
-        .split(/\r?\n/)
-        .map((s) => parseInt(s.trim(), 10))
-        .filter((n) => n > 0);
-    }
     const { stdout } = await execFileP("pgrep", ["-f", "cli.js watchdog"], {
       timeout: 15000,
     });
@@ -467,9 +541,7 @@ async function listWatchdogPids() {
       .map((s) => parseInt(s.trim(), 10))
       .filter((n) => n > 0);
   } catch (e) {
-    console.error(
-      `[upgrader] 枚举 watchdog 进程失败（WMI 不可用？）: ${e.message}`,
-    );
+    console.error(`[upgrader] 枚举 watchdog 进程失败: ${e.message}`);
     return [];
   }
 }
@@ -551,11 +623,11 @@ export async function runUpgradeMode(argv) {
   //      会触发旧 watchdog 的 SIGINT → gracefulShutdown 优雅停业务。因此先向旧 watchdog
   //      的控制台发送 CTRL_C_EVENT（等效手动按键），8s 未退再强杀兜底；随后按【杀旧前】
   //      快照强杀整棵后代树（排除 U 自己；杀旧后中间层死亡会断父链，必须提前快照），
-  //      再兜底清理「父已死」的孤儿业务进程，最后关闭旧 watchdog 所在的 cmd 窗口。
+  //      再兜底清理「父已死」的孤儿业务进程，最后关闭旧 watchdog 所在的 cmd 窗口
+  //      （按窗口标题匹配 tasklist /V，绕开 WMI——部分机器 WMI 损坏时快照为空）。
   console.error(`[upgrade-proc] 通知旧 watchdog (pid=${oldPid}) 退出 ...`);
   const procSnapshot = await snapshotAllProcesses();
   const descPids = listDescendantPids(procSnapshot, oldPid, process.pid);
-  const cmdAncestors = listCmdAncestorPids(procSnapshot, oldPid);
 
   let exited = false;
   const gracefulSent =
@@ -584,8 +656,9 @@ export async function runUpgradeMode(argv) {
   // 兜底：快照时父链已断（中间层先死）的孤儿业务进程，杀旧后按特征清理
   const orphanPids = listOrphanBusinessPids(await snapshotAllProcesses());
   await killPidList(orphanPids, "已清理孤儿业务进程");
-  // 关闭旧 watchdog 所在的 cmd 窗口（业务已停，窗口只剩空壳提示符）
-  await killPidList(cmdAncestors, "已关闭旧 cmd 窗口");
+  // 关闭旧 watchdog 所在的 cmd 窗口（业务已停，窗口只剩空壳提示符）；
+  // 按窗口标题匹配（不依赖 WMI），旧 watchdog 已设标题含 WINDOW_TITLE_TAG
+  await killOldWatchdogWindow();
 
   // 4) 旧进程已退，启新版 watchdog
   //     Windows：显式弹独立交互 cmd 窗口（start → cmd /k），日志直接显示在窗口，
@@ -602,9 +675,12 @@ export async function runUpgradeMode(argv) {
     process.platform === "win32"
       ? undefined
       : openLogFile("tt-help-watchdog", "upgrade-proc", "新版 watchdog 日志");
-  // 记录启动前的 watchdog 进程集合，用于存活校验前后对比（Windows 经 start 启动时
-  // 中间 cmd 秒退，不能检查其 PID）
-  const beforePids = await listWatchdogPids();
+  // Windows 存活校验改读新版 watchdog 写出的标记文件（WMI 损坏时枚举进程表失效），
+  // spawn 前先删掉旧 watchdog 的残留，确保读到的是新进程写的
+  if (process.platform === "win32") deleteStartedFile();
+  // POSIX：记录启动前的 watchdog 进程集合，用于存活校验前后对比
+  const beforePids =
+    process.platform === "win32" ? [] : await listWatchdogPids();
   let child;
   try {
     child = spawnNewWatchdog(cliPath, args, logFd);
@@ -620,20 +696,49 @@ export async function runUpgradeMode(argv) {
     process.exit(1);
   }
 
-  // 5) 存活校验：3s 后确认出现新增的 watchdog 进程；未存活则明确报错，不静默
+  // 5) 存活校验：3s 后确认新版 watchdog 存活；未存活则明确报错，不静默
   await new Promise((r) => setTimeout(r, 3000));
-  const newPids = (await listWatchdogPids()).filter(
-    (p) => !beforePids.includes(p),
-  );
-  if (newPids.length > 0) {
-    console.error(
-      `[upgrade-proc] 新版 watchdog 存活确认 (pid=${newPids.join(",")})，升级完成`,
-    );
+  if (process.platform === "win32") {
+    // Windows：轮询存活标记文件（新版 watchdog 启动即写，含 pid/version），
+    // 版本匹配且 pid 可探测存活才算确认。15s 超时未出现则报错。
+    const deadline = Date.now() + 15_000;
+    let st = null;
+    while (Date.now() < deadline && !st) {
+      const cur = readStartedFile();
+      if (
+        cur &&
+        cur.pid > 0 &&
+        String(cur.version) === String(verify.version) &&
+        (await isProcessAlive(cur.pid))
+      ) {
+        st = cur;
+      }
+      if (!st) await new Promise((r) => setTimeout(r, 1000));
+    }
+    if (st) {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 存活确认 (pid=${st.pid}, v${st.version})，升级完成`,
+      );
+    } else {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 启动后未存活，请查看窗口/日志排障`,
+      );
+      process.exit(1);
+    }
   } else {
-    console.error(
-      `[upgrade-proc] 新版 watchdog 启动后未存活，请查看窗口/日志排障`,
+    const newPids = (await listWatchdogPids()).filter(
+      (p) => !beforePids.includes(p),
     );
-    process.exit(1);
+    if (newPids.length > 0) {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 存活确认 (pid=${newPids.join(",")})，升级完成`,
+      );
+    } else {
+      console.error(
+        `[upgrade-proc] 新版 watchdog 启动后未存活，请查看窗口/日志排障`,
+      );
+      process.exit(1);
+    }
   }
   process.exit(0);
 }