tt-help-cli-ycl 1.4.161 → 1.4.163

package/package.json

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

package/src/clash/daemon.js

@@ -175,20 +175,31 @@ export class ClashDaemon {
 
   /**
    * 逐个尝试候选节点并内容验证（巡检/failover/白名单守卫共用切换循环）
+   * @param {object} [opts]
+   * @param {Set<string>} [opts.occupied] 同订阅其它实例已占用的节点（互斥避让）；
+   *   有空闲候选时跳过被占用节点；候选全被占/仅一个候选时放行（“只允许一个节点”例外）
    * @returns {{target: string|null, h2: object|null}} 第一个满足（健康或壳页）的候选；全部失败返回 {target:null}
    */
-  async _tryRotateCandidates(c, ordered, currentNode, reason = "") {
+  async _tryRotateCandidates(c, ordered, currentNode, reason = "", opts = {}) {
     const tag = reason ? ` [原因: ${reason}]` : "";
+    // 同订阅互斥: 计算空闲候选（排除被占用与当前节点）；全被占时不排除（放行）
+    const occ = opts.occupied || null;
+    const free = occ ? ordered.filter((x) => !occ.has(x) && x !== currentNode) : null;
     let target = null;
     let h2 = null;
     for (const cand of ordered) {
       if (cand === currentNode) continue;
+      if (free && free.length > 0 && !free.includes(cand)) {
+        this._log(`  ⏭ [${c.proxyPort}] ${cand} 被同订阅其它实例占用，跳过`);
+        continue;
+      }
       this._log(`↺ [${c.proxyPort}] 尝试候选: ${cand}${tag}`);
       if (!(await checker.switchToNode(cand))) {
         this._log(`  ↺ ${cand} 切换失败，下一个`);
         continue;
       }
       this._markSwitch(c, cand);
+      c._currentNode = cand; // 同订阅互斥: 维护当前节点内存快照
       h2 = checker.checkNodeHealth();
       if (h2.healthy || this._isShellPage(h2)) {
         target = cand;
@@ -199,6 +210,120 @@ export class ClashDaemon {
     return { target, h2 };
   }
 
+  // ── 同订阅节点互斥（同 URL 多实例不允许同时使用同一节点，除非无空闲可用节点） ──
+
+  /** 内置实例序号（proxyPort 推导；0 = 非内置段如外部 Verge，不参与互斥） */
+  _instanceIndexOf(c) {
+    const idx = (c?.proxyPort || 0) - DISCOVER_DEFAULTS.proxyPort + 1;
+    return idx >= 1 && idx <= RUNTIME_MAX_INSTANCES ? idx : 0;
+  }
+
+  /** 同 URL 订阅的同组其它实例控制器（before=true 仅序号比自己小的） */
+  _mutexPeers(c, beforeOnly = false) {
+    const idx = this._instanceIndexOf(c);
+    if (!idx) return [];
+    let stored;
+    try {
+      stored = runtime.readStoredSubscriptions();
+    } catch {
+      return [];
+    }
+    const myUrl = stored[idx - 1]?.url;
+    if (!myUrl) return [];
+    const out = [];
+    for (let i = 1; i <= stored.length; i++) {
+      if (i === idx || stored[i - 1]?.url !== myUrl) continue;
+      if (beforeOnly && i > idx) continue;
+      const peer = this._controllers.find((x) => this._instanceIndexOf(x) === i);
+      if (peer && peer !== c) out.push(peer);
+    }
+    return out;
+  }
+
+  /** 当前被同组其它实例占用的节点集合（无同组返回 null = 不启用避让） */
+  _occupiedNodes(c) {
+    const peers = this._mutexPeers(c);
+    if (!peers.length) return null;
+    const occ = new Set();
+    for (const p of peers) if (p._currentNode) occ.add(p._currentNode);
+    return occ.size ? occ : null;
+  }
+
+  /**
+   * 巡检常驻互斥对齐（与白名单守卫同口径，不受 failover 冷却约束）:
+   * 与序号更小的同组实例撞节点 → 自己让位（序号小的保留）；10 分钟防抖。
+   * 让位无空闲可用节点（候选全被占/全不可用）→ 保留现状，下轮再试。
+   * @returns {Promise<boolean>} true=已让位切换（调用方跳过自身 health 写入）
+   */
+  async _enforceMutex(c, node) {
+    if (!node || node === "?") return false;
+    const conflict = this._mutexPeers(c, true).find((p) => p._currentNode === node);
+    if (!conflict) return false;
+    if (Date.now() - (c._lastMutexAlignAt || 0) < 600_000) return false;
+    c._lastMutexAlignAt = Date.now();
+    this._log(
+      `🔒 [${c.proxyPort}] 同订阅互斥: 节点 ${node} 已被实例@${conflict.proxyPort} 占用，让位切换`,
+    );
+    const { nodes } = checker.loadHealthyList();
+    if (!nodes.length) return false;
+    const ordered = this._sortCandidates(nodes, c);
+    const { target, h2 } = await this._tryRotateCandidates(
+      c, ordered, node, "同订阅节点互斥", { occupied: this._occupiedNodes(c) },
+    );
+    if (!target) {
+      await checker.switchToNode(node).catch(() => {});
+      this._log(`🔒 [${c.proxyPort}] 互斥让位失败（无空闲可用节点），暂保留 ${node}`);
+      return false;
+    }
+    await this._disconnect(c);
+    this._markSwitchTime(c);
+    this._writeHealth(c, {
+      node: target,
+      healthy: h2.healthy,
+      httpCode: h2.httpCode,
+      timeTotal: h2.timeTotal,
+      sizeDownload: h2.sizeDownload,
+      title: h2.title,
+      lastSwitch: `同订阅互斥: ${node} → ${target}`,
+    });
+    return true;
+  }
+
+  /**
+   * 手动切换后让位: 同组其它实例若占用了新节点 → 挪它（用户显式意图优先，不挪切换者）
+   */
+  async _mutexYieldTo(c, node) {
+    for (const p of this._mutexPeers(c)) {
+      if (p._currentNode !== node || p._probing) continue;
+      this._useController(p);
+      this._log(
+        `🔒 [${p.proxyPort}] 同订阅互斥: 节点 ${node} 被手动切换给 [${c.proxyPort}]，让位`,
+      );
+      const { nodes } = checker.loadHealthyList();
+      if (!nodes.length) continue;
+      const ordered = this._sortCandidates(nodes, p);
+      const { target, h2 } = await this._tryRotateCandidates(
+        p, ordered, node, "同订阅互斥(手动让位)", { occupied: this._occupiedNodes(p) },
+      );
+      if (!target) {
+        await checker.switchToNode(node).catch(() => {});
+        continue;
+      }
+      await this._disconnect(p);
+      this._markSwitchTime(p);
+      this._writeHealth(p, {
+        node: target,
+        healthy: h2.healthy,
+        httpCode: h2.httpCode,
+        timeTotal: h2.timeTotal,
+        sizeDownload: h2.sizeDownload,
+        title: h2.title,
+        lastSwitch: `同订阅互斥(手动): ${node} → ${target}`,
+      });
+    }
+    this._useController(c); // 恢复切换者上下文
+  }
+
   /** 将全局 api/checker 上下文指向指定控制器 */
   _useController(c) {
     api.configure({ port: c.port, secret: c.secret });
@@ -443,6 +568,7 @@ export class ClashDaemon {
       if (r.status === "started") {
         started++;
         this._log(`✓ 实例${idx} (${spec.apiPort}/${spec.mixedPort}) 自愈拉起成功，下轮发现将接管`);
+        await this._rediscover("实例自愈拉起");
       } else if (r.status === "failed" || r.status === "no-vendor") {
         failed++;
         this._log(`⚠ 实例${idx} 自愈拉起失败: ${r.error || r.status}`);
@@ -485,8 +611,7 @@ export class ClashDaemon {
       const node = await api
         .getCurrentNode(checker.CONFIG.groupName)
         .catch(() => "?");
-
-      // 订阅信息 + 流量采样（随巡检周期，差分算速率）
+      if (node && node !== "?") c._currentNode = node; // 同订阅互斥: 维护当前节点内存快照
       c._subsSnapshot = await api.getSubscriptionSummaries().catch(() => null);
       const conn = await api.getConnections().catch(() => null);
       if (conn) {
@@ -554,25 +679,26 @@ export class ClashDaemon {
       }
 
       if (h.healthy) {
-        c._apiFailCount = 0;
         if (Math.random() < 0.17)
           this._log(
             `✓ [${c.proxyPort}] ${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB`,
           );
-        // 白名单守卫：节点健康但不在咱们节点列表内（如人工在 Clash Verge 界面手动切换）→ 强制切回
-        await this._enforceWhitelist(c, node);
+        // 白名单守卫 + 同订阅互斥：节点健康但不在咱们节点列表内 → 强制切回；
+        // 与序号更小的同组实例撞节点 → 让位
+        if (await this._enforceWhitelist(c, node)) return;
+        if (await this._enforceMutex(c, node)) return;
         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)`,
         );
-        // 白名单守卫与主分支同口径：壳页=链路正常，但列表外节点仍不允许
+        // 白名单守卫与互斥：壳页=链路正常，但列表外节点仍不允许；撞节点让位同口径
         if (await this._enforceWhitelist(c, node)) return;
+        if (await this._enforceMutex(c, node)) return;
         return this._writeHealth(c, {
           node,
           healthy: true,
@@ -593,8 +719,9 @@ export class ClashDaemon {
         this._log(
           `~ [${c.proxyPort}] 复测恢复（首次异常: ${firstReason}），不切换`,
         );
-        // 白名单守卫：复测恢复同样守口径（列表外节点不允许）
+        // 白名单守卫与互斥：复测恢复同样守口径（列表外不允许；撞节点让位）
         if (await this._enforceWhitelist(c, node)) return;
+        if (await this._enforceMutex(c, node)) return;
         return this._writeHealth(c, {
           node,
           healthy: true,
@@ -637,13 +764,15 @@ export class ClashDaemon {
         `✗ [${c.proxyPort}] 巡检异常 [${reason}]，开始从候选集切换 (当前 ${node})`,
       );
       // 逐个切换候选 + 内容验证，第一个满足即采用
-      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点；
+      // 同订阅互斥: 避开同组其它实例占用的节点
       const ordered = this._sortCandidates(nodes, c);
       const { target, h2 } = await this._tryRotateCandidates(
         c,
         ordered,
         node,
         reason,
+        { occupied: this._occupiedNodes(c) },
       );
 
       if (!target) {
@@ -689,33 +818,62 @@ export class ClashDaemon {
   }
 
   /**
-   * API 连续失败时的控制端重发现
-   * 连续 2 次巡检异常触发一次完整重发现，防止端口漂移后失联
+   * 重新发现控制端（订阅应用/自愈拉起新实例后调用，或 API 连续失败时）
+   * 背景: controllers 是 start() 时的快照，正常运行期新拉起的内置实例（9098+）
+   * 不会自动进入巡检列表 —— 必须主动重发现才能接管（否则新实例永远不被巡检/上报）
+   * 防抖: 30s 内多次触发只执行一次（多实例同时拉起时避免重复探测）
    */
-  async _maybeRediscover(e) {
-    this._apiFailCount = (this._apiFailCount || 0) + 1;
-    if (this._apiFailCount < 2) return;
-    this._apiFailCount = 0;
+  async _rediscover(reason) {
+    const now = Date.now();
+    if (now - (this._lastRediscoverAt || 0) < 30_000) return;
+    this._lastRediscoverAt = now;
     invalidateDiscoverCache();
-    this._log(`API 连续失败，重新发现控制端... (${e?.message || e})`);
     try {
       const discs = await discoverAll(this._discoverOpts);
+      // 按端口迁移旧控制器运行状态（切换历史/冷却锚点/订阅快照等），
+      // 避免重发现后 failover 冷却锚点丢失导致反复切换
+      const prev = new Map(this._controllers.map((c) => [c.port, c]));
       const seen = new Set();
       this._controllers = discs.filter((d) => {
         if (seen.has(d.port)) return false;
         seen.add(d.port);
+        const old = prev.get(d.port);
+        if (old) {
+          d._meta = old._meta;
+          d._switchHistory = old._switchHistory;
+          d._lastSwitchAt = old._lastSwitchAt;
+          d._restartSeq = old._restartSeq;
+          d._trafficLast = old._trafficLast;
+          d._traffic = old._traffic;
+          d._subsSnapshot = old._subsSnapshot;
+          d._applyResult = old._applyResult;
+          d._lastProbeAt = old._lastProbeAt;
+          d._currentNode = old._currentNode;
+          d._lastMutexAlignAt = old._lastMutexAlignAt;
+        }
         return true;
       });
       this._primary = this._controllers[0] || null;
-      this._lastDiscoverKey = "";
+      this._lastDiscoverKey = ""; // 强制下轮日志重新打印控制端列表
       this._log(
-        `✓ 重新选定 ${this._controllers.length} 个控制端: ${this._controllers.map((c) => `${c.clientName}@${c.port}`).join(", ") || "无"}`,
+        `✓ ${reason}: 重新发现 ${this._controllers.length} 个控制端: ${this._controllers.map((c) => `${c.clientName}@${c.port}`).join(", ") || "无"}`,
       );
     } catch (err) {
-      this._log(`重新发现控制端失败: ${err.message}`);
+      this._log(`${reason}: 重新发现控制端失败: ${err.message}`);
     }
   }
 
+  /**
+   * API 连续失败时的控制端重发现
+   * 连续 2 次巡检异常触发一次完整重发现，防止端口漂移后失联
+   */
+  async _maybeRediscover(e) {
+    this._apiFailCount = (this._apiFailCount || 0) + 1;
+    if (this._apiFailCount < 2) return;
+    this._apiFailCount = 0;
+    await this._rediscover(`API 连续失败 (${e?.message || e})`);
+  }
+
   /**
    * 白名单守卫：当前 Clash Verge 正在使用的节点必须 ∈ 候选集（咱们节点列表）
    *
@@ -748,6 +906,7 @@ export class ClashDaemon {
       ordered,
       node,
       "白名单守卫",
+      { occupied: this._occupiedNodes(c) },
     );
     if (!target) {
       // 与 failover/巡检切换口径一致：候选全部不可用时恢复原节点
@@ -898,9 +1057,12 @@ export class ClashDaemon {
       }
       this._markSwitch(c, cmd.node);
       this._markSwitchTime(c);
+      c._currentNode = cmd.node; // 同订阅互斥: 维护当前节点内存快照
       const h = checker.checkNodeHealth();
       // 切换后优雅断连：回收空闲连接，活跃放行（同巡检切换）
       await this._disconnect(c);
+      // 同订阅互斥: 让同组占用新节点的其它实例让位（用户显式意图优先，不挪切换者）
+      await this._mutexYieldTo(c, cmd.node);
       this._log(
         `🔄 看门狗指令: [${c.proxyPort}] 切换完成 (${h.timeTotal.toFixed(1)}s ${(h.sizeDownload / 1024).toFixed(0)}KB, ${h.healthy ? "健康" : "异常"})`,
       );
@@ -986,13 +1148,15 @@ export class ClashDaemon {
         return;
       }
       // 逐个切换候选 + 内容验证，第一个满足即采用（跳过当前节点）
-      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点
+      // 排序：切过的节点按切换时间沉底（后进后出），优先尝试"最久没被切过"的节点；
+      // 同订阅互斥: 避开同组其它实例占用的节点
       const ordered = this._sortCandidates(nodes, c);
       const { target, h2 } = await this._tryRotateCandidates(
         c,
         ordered,
         node,
         reason,
+        { occupied: this._occupiedNodes(c) },
       );
       // 本次 failover 已尽力处置（成功切换或恢复原节点）：更新锚点，给新节点干净观察期
       this._markSwitchTime(c);
@@ -1048,6 +1212,8 @@ export class ClashDaemon {
         c._applyResult = { ok: true, changed: true, cleared: true, at: Date.now() };
         this._log(`📋 订阅已清空: 回收内置 mihomo ${killed} 个进程，不再接管端口`);
         this._writeHealth(c, { node: "?", healthy: null });
+        // 实例已回收 → 重发现让死实例退出巡检列表（否则每轮巡检持续报"未运行"）
+        await this._rediscover("订阅清空");
         return;
       }
       this._log(`📋 收到订阅配置: ${subs.length} 条，按条启动独立实例（9097+每条递增）...`);
@@ -1077,6 +1243,9 @@ export class ClashDaemon {
       } else {
         this._log(`⚠ ${failed.length}/${subs.length} 个实例应用失败（未持久化，待下轮心跳重试）: ${failed.map((f) => `实例${f.index}`).join(",")}`);
       }
+      // 实例集可能已变化（成功拉起新实例/回收多余实例，含部分失败场景）→ 重发现同步巡检列表
+      // （controllers 是启动快照；不重发现则新实例永远不被巡检/上报，214 实采踩坑）
+      await this._rediscover("订阅应用");
       c._subsSnapshot = await api.getSubscriptionSummaries().catch(() => null);
       c._applyResult = {
         ok: allOk,

package/src/clash/runtime.js

@@ -78,12 +78,13 @@ const UI_MANIFEST = { file: "metacubexd-dist.tgz", sha256: "93eb334af7e37d213317
 
 /**
  * 内核/面板下载源（顺序 failover）:
- *   1. ~/.tt-help.json → clash.vendorBase 或环境变量 TT_VENDOR_BASE（覆盖）
- *   2. 配置的服务端（~/.tt-help.json → server）→ {server}/scripts/vendor
- *      （内网 watch 优先：213 等内网机器走内网下载，不绕公网）
- *   3. 自建服务器公网（201 watch 静态路由 /scripts/vendor，免鉴权）
- *   4. 自建服务器内网（农场机器直连）
- *   5. GitHub Releases（仅海外/兜底；农场不可达属预期）
+ *   1. ~/.tt-help.json → clash.vendorBase / 环境变量 TT_VENDOR_BASE（显式覆盖，逃生舱）
+ *   2. HTTPS 域名镜像（最优默认源：域名+TLS+CDN，比公网 IP 直连更稳）
+ *   3. 配置的服务端（~/.tt-help.json → server）→ {server}/scripts/vendor
+ *      （内网机器的 server 为内网地址，作为 CDN 不可达时的就近回退）
+ *   4. 自建服务器公网（201 watch 静态路由 /scripts/vendor，免鉴权）
+ *   5. 自建服务器内网（农场机器直连）
+ *   6. GitHub Releases（仅海外/兜底；农场不可达属预期）
  */
 export function vendorBases() {
   const urls = [];
@@ -95,6 +96,14 @@ export function vendorBases() {
     if (existsSync(cfgPath)) {
       const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
       push(cfg?.clash?.vendorBase);
+    }
+  } catch {}
+  push(process.env.TT_VENDOR_BASE);
+  push("https://call.huochedejia.com/vendor");
+  try {
+    const cfgPath = join(homedir(), ".tt-help.json");
+    if (existsSync(cfgPath)) {
+      const cfg = JSON.parse(readFileSync(cfgPath, "utf-8"));
       const server = String(cfg?.server || "").replace(/\/+$/, "");
       // 显式配置的服务端地址 → 推导 vendor 下载源（未配置/非 http 则跳过，避免污染 127.0.0.1 默认值）
       if (/^https?:\/\//.test(server) && !/^https?:\/\/127\.0\.0\.1/.test(server)) {
@@ -102,7 +111,6 @@ export function vendorBases() {
       }
     }
   } catch {}
-  push(process.env.TT_VENDOR_BASE);
   push("http://117.71.53.99:17301/scripts/vendor");
   push("http://172.18.154.201:3001/scripts/vendor");
   push("https://github.com/MetaCubeX/mihomo/releases/download");
@@ -446,7 +454,9 @@ export function buildConfig({ subscriptions, apiPort, secret, mixedPort }) {
         `  ${s.name}:`,
         "    type: http",
         `    url: ${s.url}`,
-        "    interval: 86400",
+        // 订阅文件+userinfo（subscription-userinfo 响应头）刷新周期: 1 小时。
+        // 同一订阅可配多实例，各自快照时刻不同；24h 周期会导致页面剩余流量显示差异巨大（214 实测一天差 447GB）
+        "    interval: 3600",
         `    path: ./providers/${s.name}.yaml`,
         "    proxy: DIRECT",
         "    health-check:",

package/src/watch/public/app.js

@@ -4779,6 +4779,10 @@ async function wdSaveProxySettings() {
       return s.trim();
     })
     .filter(Boolean);
+  if (lines.length > 8) {
+    alert("最多 8 条订阅（每条一个独立 mihomo 实例，超出部分无法巡检）；当前 " + lines.length + " 行");
+    return;
+  }
   try {
     var res = await fetch("/api/watchdog/set-proxy-settings", {
       method: "POST",
@@ -5278,16 +5282,53 @@ async function wdSetErrorTrigger() {
 
 // ── 代理节点区域（看门狗面板中每个客户端卡片，支持多控制端通道） ──
 
+/** 内置实例端口段（与 discover.js RUNTIME_MAX_INSTANCES=8 对齐）：代理 7897+n / API 9097+n */
+var _SUBS_BASE_PROXY_PORT = 7897;
+var _SUBS_BASE_API_PORT = 9097;
+var _SUBS_MAX_INSTANCES = 8;
+
+/** 服务端配置的订阅列表（proxySettings[userId].subscriptions） */
+function wdSubsConfigured(userId) {
+  if (_wdData && _wdData.proxySettings && _wdData.proxySettings[userId]) {
+    return _wdData.proxySettings[userId].subscriptions || [];
+  }
+  return [];
+}
+
+/**
+ * 代理区域入口:
+ *   内置实例通道（7897+n）→ 订阅总览表（一行 = 一条订阅 = 一个实例）
+ *   外部通道（Verge 等）   → 独立通道行（节点 + 自身订阅摘要）
+ *   无通道                 → 配置过订阅显示总览（实例离线态）；否则单控制端旧视图
+ */
 function renderProxySection(c, userId) {
-  var channels = c.clashHealthChannels || [];
+  var channels = (c.clashHealthChannels || []).slice();
+  channels.sort(function (a, b) {
+    return (a.port || 0) - (b.port || 0);
+  });
   if (channels.length > 0) {
-    var html = "";
+    var builtin = [];
+    var external = [];
     for (var i = 0; i < channels.length; i++) {
-      html += renderProxyChannel(channels[i], userId);
+      var idx = (channels[i].port || 0) - _SUBS_BASE_PROXY_PORT;
+      if (idx >= 0 && idx < _SUBS_MAX_INSTANCES) builtin.push(channels[i]);
+      else external.push(channels[i]);
+    }
+    var html = renderSubsOverview(c, userId, builtin, channels);
+    for (var j = 0; j < external.length; j++) {
+      // 外部通道的订阅配置入口：仅当没有总览区时显示（配置入口全局收敛为一个）
+      html += renderExternalChannel(external[j], userId, !html);
     }
     return html;
   }
-  // 兼容旧版：仅主控制端（legacy clashHealth）
+  if (wdSubsConfigured(userId).length > 0) {
+    return renderSubsOverview(c, userId, [], []);
+  }
+  return renderProxyLegacy(c, userId);
+}
+
+/** 兼容旧版：仅主控制端（legacy clashHealth） */
+function renderProxyLegacy(c, userId) {
   var h = c.clashHealth;
   if (!h || !h.node) return "";
   var nodes = (h.meta && h.meta.healthyNodes) || [];
@@ -5300,8 +5341,8 @@ function renderProxySection(c, userId) {
   );
 }
 
-/** 单个控制端通道的代理区域 */
-function renderProxyChannel(ch, userId) {
+/** 外部代理通道（Verge 等非内置实例）：节点行 + 节点列表 + 自身订阅摘要 */
+function renderExternalChannel(ch, userId, withConfig) {
   if (!ch || !ch.node) return "";
   var nodes = (ch.meta && ch.meta.healthyNodes) || [];
   var delays = (ch.meta && ch.meta.healthyNodeDelays) || {};
@@ -5309,10 +5350,284 @@ function renderProxyChannel(ch, userId) {
   return (
     renderProxyLine(ch, nodes, userId, ch.port || 0, hasNodes) +
     renderNodeList(nodes, ch.node, userId, ch.port || 0, delays) +
-    renderSubscriptions(ch.meta && ch.meta.proxy, userId)
+    renderSubscriptions(ch.meta && ch.meta.proxy, userId, withConfig !== false)
+  );
+}
+
+// ── 订阅总览区（每客户端一个） ──
+
+/** 订阅应用结果提示（daemon 最近一次 setSubscription 执行反馈） */
+function renderApplyResult(ar) {
+  if (!ar || !ar.at) return "";
+  if (ar.ok === false) {
+    return styled(
+      "div",
+      "font-size:11px;margin:2px 0 4px;padding:4px 6px;background:#3b1d1d;border:1px solid #7f1d1d;border-radius:4px;color:#f87171;line-height:1.4;width:100%;box-sizing:border-box",
+      "❌ 订阅应用失败: " + (ar.error || "未知错误") +
+        styled("span", "color:#94a3b8;margin-left:6px;font-size:10px", new Date(ar.at).toLocaleTimeString()),
+    );
+  }
+  if (ar.changed) {
+    return styled(
+      "div",
+      "font-size:11px;color:#4ade80;width:100%",
+      "✓ 订阅应用成功 (" + (ar.count || "?") + " 条，" + new Date(ar.at).toLocaleTimeString() + ")",
+    );
+  }
+  return "";
+}
+
+
+/**
+ * 订阅总览表:
+ *   订阅名 | 实例 | 代理端口(业务 --proxy 用) | 当前节点(可展开切换) | 用量/到期/速率
+ *   一行 = 一条订阅 = 一个内置 mihomo 实例；通道离线时显示占位行（配置可见，实例自愈中）
+ */
+function renderSubsOverview(c, userId, builtinChannels, allChannels) {
+  var configured = wdSubsConfigured(userId);
+  var byPort = {};
+  for (var i = 0; i < builtinChannels.length; i++) {
+    byPort[builtinChannels[i].port] = builtinChannels[i];
+  }
+  var count = configured.length;
+  for (var p in byPort) {
+    var n = parseInt(p, 10) - _SUBS_BASE_PROXY_PORT + 1;
+    if (n > count) count = n;
+  }
+  if (!count) return "";
+
+  // 订阅应用结果（主控制端默认健康文件优先，回退任一通道快照）
+  var ar = null;
+  if (c.clashHealth && c.clashHealth.meta && c.clashHealth.meta.proxy) {
+    ar = c.clashHealth.meta.proxy.applyResult;
+  }
+  if (!ar || !ar.at) {
+    for (var k = 0; k < (allChannels || []).length; k++) {
+      var pp = allChannels[k].meta && allChannels[k].meta.proxy;
+      if (pp && pp.applyResult && pp.applyResult.at) {
+        ar = pp.applyResult;
+        break;
+      }
+    }
+  }
+
+  // 标题行：入口收敛为全局唯一一个配置按钮
+  var head = styled(
+    "div",
+    "padding:6px 8px;background:#111;display:flex;align-items:center;gap:8px;font-size:12px;flex-wrap:wrap",
+    styled("span", "font-size:14px", "🛜") +
+      styled("span", "color:#e0e0e0;font-weight:bold", "代理订阅") +
+      styled("span", "color:#94a3b8", count + " 条") +
+      tag(
+        "button",
+        {
+          onclick: "wdShowProxyModal('" + esc(userId) + "')",
+          style:
+            "padding:2px 8px;font-size:11px;background:#333;color:#fbbf24;" +
+            "border:1px solid #444;border-radius:3px;cursor:pointer",
+          title: "配置该客户端的代理订阅（每行一个地址，保存后自动热应用，无需重启）",
+        },
+        "配置 ⚙️",
+      ) +
+      styled(
+        "span",
+        "color:#555;font-size:10px;margin-left:auto",
+        "一条订阅 = 一个独立 mihomo 实例",
+      ) +
+      renderApplyResult(ar),
+  );
+
+  // tab 栏（即概览: 状态点+订阅名+端口；临期/超量红标、离线灰）+ 详情区（仅激活显示）
+  // 选中态跨刷新保留（_wdSubsActiveTab），点击纯 DOM 切换不重渲染
+  var activePort = _wdSubsActiveTab[wdEscId(userId)] || _SUBS_BASE_PROXY_PORT;
+  var tabsBar = styled(
+    "div",
+    "display:flex;gap:2px;padding:0 8px;background:#16161e;border-bottom:1px solid #2a2a3a;overflow-x:auto;flex-wrap:wrap",
+    (function () {
+      var out = "";
+      for (var m = 1; m <= count; m++) {
+        out += renderSubsTab(m, configured[m - 1], byPort[_SUBS_BASE_PROXY_PORT + m - 1], userId,
+          _SUBS_BASE_PROXY_PORT + m - 1 === activePort);
+      }
+      return out;
+    })(),
+  );
+  var bodies = "";
+  for (var m2 = 1; m2 <= count; m2++) {
+    bodies += renderSubsBody(m2, configured[m2 - 1], byPort[_SUBS_BASE_PROXY_PORT + m2 - 1], userId,
+      _SUBS_BASE_PROXY_PORT + m2 - 1 === activePort);
+  }
+  return styled(
+    "div",
+    "margin-top:6px;border:1px solid #2a2a3a;border-radius:8px;overflow:hidden",
+    head + tabsBar + bodies,
+  );
+}
+
+/** 订阅选中 tab（userId → 代理端口），跨刷新保留 */
+var _wdSubsActiveTab = {};
+
+/** tab 点击切换（纯 DOM 操作，不重渲染；与节点展开/切换命令同用代理端口路由） */
+function wdSubsTab(userId, port) {
+  _wdSubsActiveTab[wdEscId(userId)] = port;
+  for (var i = 0; i < _SUBS_MAX_INSTANCES; i++) {
+    var p = _SUBS_BASE_PROXY_PORT + i;
+    var tab = document.getElementById("wdSubsTab-" + wdEscId(userId) + "-" + p);
+    var body = document.getElementById("wdSubsBody-" + wdEscId(userId) + "-" + p);
+    if (!tab || !body) continue;
+    var active = p === port;
+    tab.style.background = active ? "#2a2a3a" : "transparent";
+    tab.style.color = active ? "#fff" : "#94a3b8";
+    tab.style.borderBottom = active ? "2px solid #60a5fa" : "2px solid transparent";
+    body.style.display = active ? "block" : "none";
+  }
+}
+
+/** tab 按钮（即概览条目）: 状态点 + 订阅名 + 端口；临期/超量红标、离线灰 */
+function renderSubsTab(n, conf, ch, userId, active) {
+  var port = _SUBS_BASE_PROXY_PORT + n - 1;
+  var meta = (ch && ch.meta) || {};
+  var sub = ((meta.proxy || {}).subscriptions || [])[0] || null;
+  var online = !!(ch && ch.node);
+  var name = (sub && sub.name) || (conf && conf.name) || "实例" + n;
+  // 临期/超量判定（与详情区同口径）
+  var danger = false;
+  if (sub) {
+    var used = (sub.upload || 0) + (sub.download || 0);
+    var total = sub.total || 0;
+    var pct = total > 0 ? Math.round(((total - used) / total) * 100) : null;
+    var daysLeft = sub.expire ? Math.round((sub.expire * 1000 - Date.now()) / 86400000) : null;
+    danger = (pct !== null && pct < 10) || (daysLeft !== null && daysLeft < 7);
+  }
+  var dot = !online ? "○" : ch.healthy ? "●" : "●";
+  var dotColor = !online ? "#555" : ch.healthy ? "#4ade80" : "#f87171";
+  return tag(
+    "button",
+    {
+      id: "wdSubsTab-" + wdEscId(userId) + "-" + port,
+      onclick: "wdSubsTab('" + esc(userId) + "'," + port + ")",
+      style:
+        "padding:5px 10px;font-size:11px;cursor:pointer;white-space:nowrap;border:none;flex-shrink:0;" +
+        "background:" + (active ? "#2a2a3a" : "transparent") + ";" +
+        "color:" + (active ? "#fff" : "#94a3b8") + ";" +
+        "border-bottom:2px solid " + (active ? "#60a5fa" : "transparent") + ";" +
+        (online ? "" : "opacity:0.6;"),
+      title: "实例" + n + " · 代理 " + port + " · API " + (_SUBS_BASE_API_PORT + n - 1) + (online ? (ch.healthy ? " · 健康" : " · 异常") : " · 未上线"),
+    },
+    styled("span", "color:" + dotColor, dot) +
+      " " + name + styled("span", "color:#60a5fa;font-size:10px", " :" + port) +
+      (danger ? styled("span", "color:#f87171;margin-left:2px", "⚠️") : ""),
+  );
+}
+
+/** tab 详情区: 当前节点 + 端口/实例 + 用量/到期 + 速率 + 节点列表（可展开） */
+function renderSubsBody(n, conf, ch, userId, active) {
+  var port = _SUBS_BASE_PROXY_PORT + n - 1;
+  var apiPort = _SUBS_BASE_API_PORT + n - 1;
+  var meta = (ch && ch.meta) || {};
+  var proxy = meta.proxy || {};
+  var sub = (proxy.subscriptions || [])[0] || null;
+  var online = !!(ch && ch.node);
+  var nodes = meta.healthyNodes || [];
+  var delays = meta.healthyNodeDelays || {};
+
+  // 行1: 当前节点 + 健康状态 + 节点列表展开
+  var line1;
+  if (online) {
+    var dotColor = ch.healthy ? "#4ade80" : "#f87171";
+    var status = ch.healthy
+      ? (ch.timeTotal || 0).toFixed(1) + "s " + ((ch.sizeDownload || 0) / 1024).toFixed(0) + "KB"
+      : ch.error || "异常";
+    line1 = styled(
+      "div",
+      "display:flex;align-items:center;gap:8px;padding:8px 10px 4px;font-size:13px;flex-wrap:wrap",
+      styled("span", "color:" + dotColor, "●") +
+        styled("span", "color:#e0e0e0;font-weight:bold;word-break:break-all", ch.node) +
+        styled("span", "color:#666;font-size:11px", "| " + status) +
+        (ch.stale ? styled("span", "color:#fbbf24;font-size:10px", "数据过期" + ch.ageSeconds + "s") : "") +
+        (nodes.length
+          ? tag(
+              "button",
+              {
+                onclick: "wdToggleNodes('" + esc(userId) + "'," + port + ")",
+                style:
+                  "margin-left:auto;padding:2px 8px;font-size:11px;background:#333;color:#60a5fa;" +
+                  "border:1px solid #444;border-radius:3px;cursor:pointer;flex-shrink:0",
+                title: "查看/切换该实例的可用节点",
+              },
+              nodes.length + " 个节点 ▸",
+            )
+          : ""),
+    );
+  } else {
+    line1 = styled(
+      "div",
+      "display:flex;align-items:center;gap:8px;padding:8px 10px 4px;font-size:12px",
+      styled("span", "color:#555", "○") +
+        styled("span", "color:#888", "实例未运行（等待自愈拉起，配置保留）"),
+    );
+  }
+
+  // 行2: 实例/端口（业务 --proxy 用代理端口）
+  var line2 = styled(
+    "div",
+    "padding:2px 10px;font-size:11px;color:#888;display:flex;gap:10px;flex-wrap:wrap",
+    styled("span", null, "实例 #" + n) +
+      tag(
+        "span",
+        {
+          style: "color:#60a5fa;font-family:monospace",
+          title: "业务命令 --proxy 用此端口",
+        },
+        "代理 127.0.0.1:" + port,
+      ) +
+      styled("span", "color:#555;font-family:monospace", "API " + apiPort) +
+      (proxy.runtime && proxy.runtime.status ? styled("span", "color:#555", "内核" + (proxy.runtime.status || "")) : ""),
+  );
+
+  // 行3: 用量/到期 + 行4: 速率
+  var line34 = "";
+  if (sub) {
+    var used = (sub.upload || 0) + (sub.download || 0);
+    var total = sub.total || 0;
+    var remain = total > 0 ? total - used : 0;
+    var pct = total > 0 ? Math.round((remain / total) * 100) : null;
+    var daysLeft = sub.expire ? Math.round((sub.expire * 1000 - Date.now()) / 86400000) : null;
+    var danger = (pct !== null && pct < 10) || (daysLeft !== null && daysLeft < 7);
+    var parts = [];
+    if (sub.proxies) parts.push(sub.proxies + " 节点");
+    parts.push(total > 0 ? "剩 " + fmtGB(remain) + (pct !== null ? " (" + pct + "%)" : "") : "用量未知");
+    if (sub.expire) {
+      parts.push("到 " + new Date(sub.expire * 1000).toLocaleDateString() + (daysLeft !== null ? "（剩" + daysLeft + "天）" : ""));
+    }
+    line34 = styled(
+      "div",
+      "padding:2px 10px 4px;font-size:11px" + (danger ? ";background:#3b1d1d" : ""),
+      styled("span", "color:" + (danger ? "#f87171" : "#94a3b8"), "📡 " + parts.join(" · ") + (danger ? " ⚠️" : "")),
+    );
+  }
+  var t = proxy.traffic;
+  if (t && (t.downRate > 0 || t.upRate > 0)) {
+    line34 += styled(
+      "div",
+      "padding:2px 10px 6px;font-size:11px;color:#666",
+      "⚡ ↓" + fmtSpeed(t.downRate) + " / ↑" + fmtSpeed(t.upRate),
+    );
+  }
+
+  var bodyInner = line1 + line2 + line34 +
+    (online && nodes.length ? renderNodeList(nodes, ch.node, userId, port, delays) : "");
+  return tag(
+    "div",
+    {
+      id: "wdSubsBody-" + wdEscId(userId) + "-" + port,
+      style: "display:" + (active ? "block" : "none") + ";border-top:1px solid #22222f",
+    },
+    bodyInner,
   );
 }
 
+
 function fmtGB(bytes) {
   if (!bytes || bytes <= 0) return "0";
   var gb = bytes / 1073741824;
@@ -5328,31 +5643,14 @@ function fmtSpeed(bytesPerSec) {
 /**
  * 订阅用量/到期 + 实时速率 + 订阅配置入口（数据: clashHealth.meta.proxy）
  * 临期（<7天）或超量（剩余<10%）标红
+ * @param {boolean} [withConfig] 是否渲染配置入口按钮（默认 true；多实例总览区已收敛唯一入口时传 false）
  */
-function renderSubscriptions(proxy, userId) {
+function renderSubscriptions(proxy, userId, withConfig) {
   proxy = proxy || {};
   var subs = proxy.subscriptions || [];
   var rows = "";
   // 订阅应用结果（daemon 最近一次 setSubscription 执行反馈；随下次应用/daemon 重启刷新）
-  var ar = proxy.applyResult;
-  if (ar && ar.at) {
-    if (ar.ok === false) {
-      rows +=
-        styled(
-          "div",
-          "font-size:11px;margin:2px 0 4px;padding:4px 6px;background:#3b1d1d;border:1px solid #7f1d1d;border-radius:4px;color:#f87171;line-height:1.4",
-          "❌ 订阅应用失败: " + esc(ar.error || "未知错误") +
-            styled("span", "color:#94a3b8;margin-left:6px;font-size:10px", new Date(ar.at).toLocaleTimeString()),
-        );
-    } else if (ar.changed) {
-      rows +=
-        styled(
-          "div",
-          "font-size:11px;margin:2px 0 4px;color:#4ade80",
-          "✓ 订阅应用成功 (" + (ar.count || "?") + " 条，" + new Date(ar.at).toLocaleTimeString() + ")",
-        );
-    }
-  }
+  rows += renderApplyResult(proxy.applyResult);
   // 实时速率
   var t = proxy.traffic;
   if (t && (t.downRate > 0 || t.upRate > 0)) {
@@ -5389,7 +5687,8 @@ function renderSubscriptions(proxy, userId) {
       );
   }
   // 配置入口（摘要双来源: 后台配置优先，回退 daemon 实际生效快照；显示条数+订阅名）
-  var configured = (window._wdData && _wdData.proxySettings && _wdData.proxySettings[userId] && _wdData.proxySettings[userId].subscriptions) || proxy.subscriptions || [];
+  if (withConfig !== false) {
+    var configured = (window._wdData && _wdData.proxySettings && _wdData.proxySettings[userId] && _wdData.proxySettings[userId].subscriptions) || proxy.subscriptions || [];
   var cfgNames = configured
     .map(function (s) {
       return s.name || String(s.url || "").replace(/^https?:\/\//, "").split("/")[0];
@@ -5416,6 +5715,7 @@ function renderSubscriptions(proxy, userId) {
           "配置 ⚙️",
         ),
     );
+  }
   return rows;
 }
 

package/src/watch/public/index.html

@@ -786,7 +786,7 @@
     style="display:none;position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(0,0,0,0.6);z-index:9999;align-items:center;justify-content:center">
     <div style="background:#1e1e2e;border:1px solid #333;border-radius:12px;padding:24px;width:90%;max-width:560px">
       <div style="font-size:16px;color:#fbbf24;margin-bottom:4px">🛜 代理订阅配置 — <span id="wdProxyUserId"></span></div>
-      <div style="color:#888;font-size:12px;margin-bottom:12px">每行一个订阅地址（http/https），<b style="color:#fbbf24">一条订阅 = 一个独立 mihomo 实例</b>：代理端口依次 127.0.0.1:7897、7898、7899…（API 端口 9097 起，同步 +1），各命令用 --proxy 参数指定使用哪个。<br>保存后客户端下次心跳时自动热应用（无需重启），应用成功后此处可看到剩余流量与到期时间；临期（&lt;7天）或超量（剩余&lt;10%）会标红。</div>
+      <div style="color:#888;font-size:12px;margin-bottom:12px">每行一个订阅地址（http/https），<b style="color:#fbbf24">一行 = 一个独立 mihomo 实例，最多 8 行</b>；<b style="color:#fbbf24">同一地址可配置多行</b>（各自独立使用不同节点）：按行序分配实例 1/2/3…，代理端口依次 127.0.0.1:7897、7898、7899…（API 管理端口 9097 起，同步 +1），业务命令用 --proxy 指定使用哪个端口（客户端卡片“代理订阅”tabs 可查映射）。<br>保存后客户端下次心跳时自动热应用（约 15～30 秒）；订阅名按行序自动编号 sub-1、sub-2…，<b style="color:#f87171">在中间插入/删除行会使后续实例重新编号并重载配置</b>，建议只在末尾追加。临期（&lt;7天）或超量（剩余&lt;10%）在 tab 上标红。</div>
       <textarea id="wdProxySubsText" rows="6" placeholder="https://example.com/api/v1/client/subscribe?token=xxxx\nhttps://another-airport.com/sub?token=yyyy"
         style="width:100%;box-sizing:border-box;padding:10px;background:#16161e;border:1px solid #333;border-radius:8px;color:#e0e0e0;font-size:12px;font-family:monospace;resize:vertical"></textarea>
       <div style="display:flex;justify-content:flex-end;gap:8px;margin-top:16px">

package/src/watch/watchdog-server.js

@@ -831,7 +831,12 @@ async function handleSetErrorTrigger(params, body, res) {
   sendJSON(res, 200, { ok: true, config: cleaned });
 }
 
-/** 配置某 agent 的代理订阅（心跳下发 → daemon 热应用；空列表表示清空） */
+/**
+ * 配置某 agent 的代理订阅（心跳下发 → daemon 热应用；空列表表示清空）
+ * 允许同一订阅地址配置多行（每行一个独立实例，可各自使用不同节点）
+ * 上限 8 条: 与 discover.js RUNTIME_MAX_INSTANCES=8 对齐（第 9 条实例端口会超出
+ * 巡检枚举段 9097-9104，永远进不了 daemon 巡检列表）
+ */
 async function handleSetProxySettings(params, body, res) {
   const { userId, subscriptions } = body || {};
   if (!userId) {
@@ -842,16 +847,19 @@ async function handleSetProxySettings(params, body, res) {
     sendJSON(res, 400, { error: "subscriptions 须为数组" });
     return;
   }
-  // 归一化: 字符串或 {name,url}，去重去空
-  const seen = new Set();
+  // 归一化: 字符串或 {name,url}，去空去非法；不去重（同 URL 多行 = 多实例）
+  const MAX_SUBS = 8;
   const cleaned = [];
   for (const it of subscriptions) {
     const url = typeof it === "string" ? it.trim() : it && String(it.url || "").trim();
-    if (!url || !/^https?:\/\//.test(url) || seen.has(url)) continue;
-    seen.add(url);
+    if (!url || !/^https?:\/\//.test(url)) continue;
     const name = typeof it === "object" && it.name ? String(it.name).trim() : "";
     cleaned.push({ name, url });
   }
+  if (cleaned.length > MAX_SUBS) {
+    sendJSON(res, 400, { error: `最多 ${MAX_SUBS} 条（每条一个独立 mihomo 实例，超出部分无法巡检）` });
+    return;
+  }
   setProxySettingsStored(userId, { subscriptions: cleaned });
   const ts = new Date().toLocaleTimeString("zh-CN", { hour12: false });
   console.error(`[watchdog ${ts}] ${userId} 代理订阅配置已更新: ${cleaned.length} 条`);

package/src/watchdog/agent.js

@@ -113,7 +113,7 @@ const NETWORK_ERROR_PATTERNS = [
 ];
 const NETWORK_ERROR_RE = new RegExp(NETWORK_ERROR_PATTERNS.join("|"), "i");
 const ERROR_SCAN_INTERVAL_MS = 30_000; // 日志扫描间隔
-const SWITCH_SCAN_INTERVAL_MS = 15_000; // 代理切换感知检查间隔（daemon restartSeq 变化 → 重启全部命令）
+const SWITCH_SCAN_INTERVAL_MS = 15_000; // 代理切换感知检查间隔（daemon restartSeq 变化 → 重启对应通道命令）
 const ERROR_TRIGGER_COUNT = 10; // 连续错误阈值
 const ERROR_MIN_MS = 5 * 60 * 1000; // 最小持续时间（时间只做最小值判断）
 const ERROR_BREAK_MS = 120_000; // 两次错误间隔超过则视为连续中断，重置计数
@@ -145,6 +145,27 @@ function isWebserverMode(cmdDef) {
   return /--webserver(?=\s|=|$)/.test(cmdDef?.command || "");
 }
 
+/**
+ * 解析命令使用的代理端口（多实例通道路由）:
+ *   --proxy http://127.0.0.1:7898 / --proxy 127.0.0.1:7898 / --proxy=:7898 → 7898
+ *   无 --proxy（走系统代理 = 主控制端）→ null
+ * 用于: 错误触发 failover / 代理切换重启 时路由到出错命令实际使用的实例，
+ * 避免多实例下切错对象（用 7898 的命令报错却切了 7897 的节点）。
+ */
+function parseCmdProxyPort(cmdDef) {
+  const s = cmdDef?.command || "";
+  const m = s.match(/--proxy(?:=|\s+)(\S+)/);
+  if (!m) return null;
+  const pm = m[1].match(/:(\d{2,5})(?:\/|$)/);
+  return pm ? parseInt(pm[1], 10) : null;
+}
+
+/** 从 daemon 健康数据提取主控制端代理端口（meta.proxyUrl = http://127.0.0.1:7897） */
+function mainProxyPortOf(health) {
+  const m = String(health?.meta?.proxyUrl || "").match(/:(\d{2,5})\/?$/);
+  return m ? parseInt(m[1], 10) : null;
+}
+
 /** 自动发现 daemon.js 路径 */
 function findDaemonPath() {
   // 1. 内部打包路径优先（npm publish 后 src/clash/daemon.js，升级即最新）
@@ -459,35 +480,54 @@ export class WatchdogAgent {
     try {
       const health = getClashHealth();
       if (!health) return; // daemon 未就绪，暂不初始化基线
+      // 通道 → seq 映射: 主控制端（默认文件）与其代理端口通道是同一控制器双写，
+      // 用代理端口作 key 自动合并，避免同一次切换被当成两个通道
+      const mainPort = mainProxyPortOf(health);
       const seqMap = new Map();
-      seqMap.set("main", Number(health.restartSeq) || 0);
+      seqMap.set(mainPort || "main", Number(health.restartSeq) || 0);
       for (const ch of getClashHealthChannels()) {
-        seqMap.set(`ch${ch.port}`, Number(ch.restartSeq) || 0);
+        if (mainPort && ch.port === mainPort) continue; // 已并入主控制端 key
+        seqMap.set(ch.port, Number(ch.restartSeq) || 0);
       }
       if (this._restartSeqBaseline === null) {
         this._restartSeqBaseline = seqMap; // 首次读取建基线（watchdog 重启不误触发）
         return;
       }
-      let switched = false;
+      // 收集发生切换的通道（多实例各自独立切换，互不影响）
+      const switchedPorts = []; // 代理端口（数字）；主控制端无端口信息时为 null
+      let mainSwitched = false;
       for (const [key, seq] of seqMap) {
         if (seq > (this._restartSeqBaseline.get(key) || 0)) {
-          switched = true;
-          break;
+          if (key === "main") mainSwitched = true;
+          else {
+            switchedPorts.push(key);
+            if (key === mainPort) mainSwitched = true; // 主控制端端口通道切换
+          }
         }
       }
       this._restartSeqBaseline = seqMap;
-      if (!switched) return;
+      if (!switchedPorts.length && !mainSwitched) return;
+      const switchedDesc = switchedPorts.length
+        ? switchedPorts.join(",") + (mainSwitched ? ",主控制端" : "")
+        : "主控制端";
       if (!this._switchRestartEnabled) {
         console.error(
-          `[watchdog] 检测到代理切换但重启功能未启用（后台可开启），跳过重启`,
+          `[watchdog] 检测到代理切换(通道 ${switchedDesc})但重启功能未启用（后台可开启），跳过重启`,
         );
         return;
       }
       const reason = health.lastSwitch
         ? `代理切换(${health.lastSwitch})`
         : "代理切换";
-      console.error(`[watchdog] 检测到${reason}，强制重启全部命令...`);
-      await this.processManager.restartAll(reason);
+      // 只重启使用切换通道的命令（按 --proxy 匹配；无 --proxy 的命令走系统代理=主控制端）
+      // 避免多实例下误伤其它通道的命令
+      await this.processManager.restartMatching(
+        `代理切换(通道 ${switchedDesc}, ${reason})`,
+        (cmdDef) => {
+          const p = parseCmdProxyPort(cmdDef);
+          return p === null ? mainSwitched : switchedPorts.includes(p);
+        },
+      );
     } catch (e) {
       console.error(`[watchdog] 代理切换感知检查失败: ${e.message}`);
     }
@@ -548,18 +588,21 @@ export class WatchdogAgent {
     if (!this.running || !this._errorTriggerEnabled) return;
     const now = Date.now();
     const scanned = this.processManager.scanErrorLogs(NETWORK_ERROR_RE);
-    let failoverTriggered = false; // 本轮是否已触发全局切换
+    // 本轮已触发切换的通道（同通道只触发一次；不同通道互不阻塞——多实例各自出口独立）
+    const triggeredChannels = new Set();
     for (const { cmdId, cmdDef, newErrors } of scanned) {
       if (!isCollectorCommand(cmdDef)) continue;
       // webserver 模式：错误发生在远端出口，本地切节点无法解决，不计入错误触发统计
       if (isWebserverMode(cmdDef)) continue;
+      // 通道键: 命令实际使用的代理端口（多实例各切各的）；无 --proxy = 主控制端
+      const channelKey = parseCmdProxyPort(cmdDef) || "main";
       let st = this._errorStates.get(cmdId) || {
         consecutive: 0,
         firstErrorAt: 0,
         lastErrorAt: 0,
       };
-      if (failoverTriggered) {
-        // 本轮已有进程触发全局切换 → 该进程也从新计数开始（防同轮接力触发）
+      if (triggeredChannels.has(channelKey)) {
+        // 本轮该通道已触发切换 → 该进程也从新计数开始（防同轮接力触发）
         st = { consecutive: 0, firstErrorAt: 0, lastErrorAt: 0 };
       }
       const hadNew = newErrors.length > 0;
@@ -581,14 +624,13 @@ export class WatchdogAgent {
           now - st.firstErrorAt >= this._errorTriggerMinMs
         ) {
           console.error(
-            `[watchdog] ${cmdId} 连续 ${st.consecutive} 次错误（≥${this._errorTriggerCount}次，持续≥${this._errorTriggerMinMs / 60000}min），触发节点切换`,
+            `[watchdog] ${cmdId} 连续 ${st.consecutive} 次错误（≥${this._errorTriggerCount}次，持续≥${this._errorTriggerMinMs / 60000}min），触发节点切换 (通道 ${channelKey})`,
           );
-          this._triggerFailover(cmdId);
-          // 切换是全局的（所有子进程共用节点）：清空全部错误计数，
-          // 让新节点有干净的观察窗口，旧节点错误不再驱动后续切换；
-          // 触发者自身也重新计数（含本轮后续错误行，从 0 累计）。
+          this._triggerFailover(cmdId, parseCmdProxyPort(cmdDef));
+          // 切换作用于该命令实际使用的代理通道；同通道命令共用出口，
+          // 全部重新计数给新节点干净观察窗口（含触发者自身，从本轮后续错误重新累计）。
           this._errorStates.clear();
-          failoverTriggered = true;
+          triggeredChannels.add(channelKey);
           st = { consecutive: 0, firstErrorAt: 0, lastErrorAt: 0 };
         }
       }
@@ -616,31 +658,59 @@ export class WatchdogAgent {
     }
   }
 
-  /** 下发 failover 命令给 daemon（候选集切下一个可用节点） */
-  async _triggerFailover(cmdId) {
+  /**
+   * 下发 failover 命令给 daemon（候选集切下一个可用节点）
+   * @param {string} cmdId 触发源命令 id（日志用）
+   * @param {number|null} proxyPort 命令实际使用的代理端口（多实例路由；null=主控制端）
+   */
+  async _triggerFailover(cmdId, proxyPort = null) {
     try {
       const ipc = await import("../clash/ipc.js");
-      ipc.writeCommand({
-        action: "failover",
-        reason: `业务进程${cmdId ? ` ${cmdId}` : ""} 连续错误触发`,
-      });
-      console.error(`[watchdog] 已下发 failover 命令 (触发源: ${cmdId})`);
+      ipc.writeCommand(
+        {
+          action: "failover",
+          reason: `业务进程${cmdId ? ` ${cmdId}` : ""} 连续错误触发`,
+          ...(proxyPort ? { proxyPort } : {}),
+        },
+        proxyPort || 0,
+      );
+      console.error(
+        `[watchdog] 已下发 failover 命令 (触发源: ${cmdId}, 通道: ${proxyPort || "主控制端"})`,
+      );
     } catch (e) {
       console.error(`[watchdog] 下发 failover 失败: ${e.message}`);
     }
   }
 
-  /** 下发强切 failover（force: 无视 daemon 冷却期，直接轮换候选） */
+  /**
+   * 下发强切 failover（force: 无视 daemon 冷却期，直接轮换候选）
+   * 客户端异常告警无法归因到具体通道 → 对全部代理通道各发一条强切
+   * （默认通道=主控制端 + 其余实例通道；主控制端的代理端口通道与默认通道
+   *  是同一控制器双写，跳过避免同一次切换被切两次）
+   */
   async _forceFailover(reason) {
     try {
       const ipc = await import("../clash/ipc.js");
-      ipc.writeCommand({
-        action: "failover",
-        force: true,
-        reason: reason || "客户端异常强切",
-      });
+      const mainPort = mainProxyPortOf(getClashHealth());
+      const ports = [
+        0,
+        ...getClashHealthChannels()
+          .map((ch) => ch.port)
+          .filter((p) => p !== mainPort),
+      ];
+      for (const p of ports) {
+        ipc.writeCommand(
+          {
+            action: "failover",
+            force: true,
+            reason: reason || "客户端异常强切",
+            ...(p ? { proxyPort: p } : {}),
+          },
+          p,
+        );
+      }
       console.error(
-        `[watchdog] 已下发强切命令 (原因: ${reason || "客户端异常"})`,
+        `[watchdog] 已下发强切命令 (${ports.length} 个通道, 原因: ${reason || "客户端异常"})`,
       );
     } catch (e) {
       console.error(`[watchdog] 下发强切失败: ${e.message}`);

package/src/watchdog/env-init.js

@@ -146,11 +146,24 @@ async function killTree(pid) {
  */
 export async function takeoverEnvironment({ spawnDaemon, selfPid, log = () => {} } = {}) {
   const procs = listProcesses();
+  // 自身祖先链一律跳过: 启动包装层（schtasks 的 cmd /c node cli.js watchdog…、
+  // Start-Process 的 powershell 等）命令行同样命中 agent 签名，若误判为"旧 agent"
+  // 会 taskkill /T 树杀连坐树内的自己（214 实采踩坑：watchdog 启动后即自杀）。
+  // 祖先链只可能是本次启动的包装层，绝不可能是需要接管的"旧实例"。
+  const byPid = new Map(procs.map((p) => [p.pid, p]));
+  const ancestors = new Set();
+  let cur = byPid.get(selfPid)?.ppid;
+  while (cur && cur > 1 && !ancestors.has(cur) && ancestors.size < 32) {
+    ancestors.add(cur);
+    cur = byPid.get(cur)?.ppid;
+  }
+
   const agents = [];
   const daemons = [];
 
   for (const p of procs) {
     if (p.pid === selfPid) continue;
+    if (ancestors.has(p.pid)) continue; // 祖先链跳过（防树杀自杀）
     if (isAgentCmd(p.cmd)) agents.push(p);
     else if (spawnDaemon && isDaemonCmd(p.cmd)) daemons.push(p);
   }

package/src/watchdog/process-manager.js

@@ -740,18 +740,29 @@ export class ProcessManager extends EventEmitter {
    * @returns {Promise<{restarted:number}>}
    */
   async restartAll(reason) {
+    return this.restartMatching(reason, () => true);
+  }
+
+  /**
+   * 按条件选择性强制重启（错峰停止 + 错峰启动，同 restartAll 语义）
+   * 多实例场景: 代理切换/故障切换只重启使用对应通道（--proxy 端口）的命令，
+   * 避免误伤其它通道的命令。
+   * @param {string} reason 重启原因（日志）
+   * @param {(cmdDef: object) => boolean} matchFn 命令匹配函数
+   */
+  async restartMatching(reason, matchFn) {
     const toRestart = [];
     for (const [, info] of this.processes) {
-      if (!info.stopped && info.child && info.cmdDef) {
+      if (!info.stopped && info.child && info.cmdDef && matchFn(info.cmdDef)) {
         toRestart.push(info.cmdDef);
       }
     }
     if (!toRestart.length) {
-      console.error(`[watchdog] ${reason}，无运行中的命令，跳过重启`);
+      console.error(`[watchdog] ${reason}，无匹配的运行中命令，跳过重启`);
       return { restarted: 0 };
     }
     console.error(
-      `[watchdog] ${reason}，强制重启全部命令 (${toRestart.length}个)...`,
+      `[watchdog] ${reason}，强制重启匹配命令 (${toRestart.length}个)...`,
     );
     // 错峰停止：第一个立即停，之后每个间隔 RESTART_STOP_STAGGER_MS（平滑释放资源，避免同时杀 N 个浏览器）
     for (let i = 0; i < toRestart.length; i++) {