@sleep2agi/commhub-server 0.9.0-preview.141 → 0.9.0-preview.143

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.141",
+  "version": "0.9.0-preview.143",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/rest-alias-network-fallback-http.test.ts

@@ -0,0 +1,123 @@
+// #1974 —— 多网络账号给「另一个网络里的 Agent」发消息,hub 侧也要能发出去。
+//
+// 起因(admin 2026-10-21 截图 + hub 拒绝日志):
+//   [15:55:54] tang → /api/task → tang02: REJECTED 404 alias_not_found (net=net_ac567b4ab74e)
+//
+// 客户端的 Agent 列表是跨网络的(GET /api/status?light=1 不带 network_id ⇒ 返回调用者所属的
+// 全部网络),发送却带着「登录时选的那一个网络」。这里用真实 HTTP + 临时库复现那个形状:
+//   * admin 拥有 NET_A,里面有 Agent `cross-agent`;
+//   * tang 注册 ⇒ 自己的个人网络 NET_B(owner),同时是 NET_A 的 admin 成员(agent_access 'all');
+//   * tang 用 NET_B 发给 `cross-agent` ⇒ 修之前 404 alias_not_found,修之后送达 NET_A。
+//
+// 三条红线各有断言:同名在两个网络都有 ⇒ 不猜(仍 404);没授权的网络 ⇒ 不去;不存在的 alias ⇒ 404。
+
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { addNetworkMember, register } from "./auth.js";
+import { db } from "./db.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-1974-alias-net-"));
+let BASE = "";
+let hub: any = null;
+const PW = "AliasNetPassw0rd!x";
+let NET_A = "";
+let NET_B = "";
+let tangToken = "";
+let tangUserId = "";
+
+const stamp = Date.now();
+
+let sessionSeq = 0;
+function insertSession(alias: string, networkId: string, nodeId: string | null = null) {
+  sessionSeq += 1;
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, node_id, network_id, status, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, ?4, 'idle', datetime('now'), datetime('now'))`,
+    [`resume_${alias}_${stamp}_${sessionSeq}`, alias, nodeId, networkId],
+  );
+}
+
+async function postTask(token: string, body: any) {
+  const res = await fetch(`${BASE}/api/task`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+  });
+  const text = await res.text();
+  let json: any = text;
+  try { json = JSON.parse(text); } catch { /* keep text */ }
+  return { status: res.status, json };
+}
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+  process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+  process.env.HOST = "127.0.0.1";
+
+  const admin = register(`aliasnet_admin_${stamp}`, PW, undefined, "Admin");
+  expect(admin.ok).toBe(true);
+  NET_A = admin.network_id!;
+  db.run("UPDATE users SET role = 'admin' WHERE user_id = ?1", [admin.user!.user_id]);
+
+  // admin 名下的 Agent:只在 NET_A 里。
+  insertSession("cross-agent", NET_A, `node_cross_${stamp}`);
+
+  // tang:自己的个人网络 NET_B(owner)+ NET_A 的 admin 成员(两个网络 agent_access 都是 'all',
+  // 这正是现网 tang 的形状:owner 个人网络 + admin 团队网络)。
+  const tang = register(`aliasnet_tang_${stamp}`, PW, undefined, "Tang");
+  expect(tang.ok).toBe(true);
+  NET_B = tang.network_id!;
+  tangToken = tang.token!;
+  tangUserId = tang.user!.user_id;
+  expect(addNetworkMember(NET_A, tangUserId, "admin", admin.user!.user_id, { agentAccess: "all" }).ok).toBe(true);
+
+  // 同名 alias 在**请求的网络之外**的两个网络里都有 ⇒ 不猜。
+  // 需要第三个网络:另一个用户建自己的网络,tang 也是它的成员。
+  const third = register(`aliasnet_third_${stamp}`, PW, undefined, "Third");
+  expect(third.ok).toBe(true);
+  const NET_C = third.network_id!;
+  expect(addNetworkMember(NET_C, tangUserId, "member", third.user!.user_id, { agentAccess: "all" }).ok).toBe(true);
+  insertSession("twin-agent", NET_A, `node_twin_a_${stamp}`);
+  insertSession("twin-agent", NET_C, `node_twin_c_${stamp}`);
+
+  const mod: any = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+});
+
+afterAll(() => {
+  try { hub?.stop?.(); } catch { /* ignore */ }
+  try { rmSync(DIR, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe("POST /api/task across the caller's own networks (#1974)", () => {
+  test("an alias in the caller's other network is delivered there, not 404", async () => {
+    const res = await postTask(tangToken, { alias: "cross-agent", task: "hi", network_id: NET_B });
+    expect(res.status).toBe(200);
+    expect(res.json.ok).toBe(true);
+    // 落在 NET_A(那个 alias 真正所在的网络),不是请求里带的 NET_B。
+    expect(res.json.actual_to?.network_id ?? res.json.actual_to?.networkId).toBe(NET_A);
+    const row = db.get<{ network_id: string }>("SELECT network_id FROM tasks WHERE task_id = ?1", [res.json.task_id]);
+    expect(row?.network_id).toBe(NET_A);
+  });
+
+  test("the same alias in two of the caller's networks is not guessed", async () => {
+    const res = await postTask(tangToken, { alias: "twin-agent", task: "hi", network_id: NET_B });
+    expect(res.status).toBe(404);
+    expect(res.json.error).toBe("alias_not_found");
+  });
+
+  test("an alias nobody has is still 404", async () => {
+    const res = await postTask(tangToken, { alias: "nowhere-agent", task: "hi", network_id: NET_B });
+    expect(res.status).toBe(404);
+    expect(res.json.error).toBe("alias_not_found");
+  });
+
+  test("the requested network still wins when it has the alias", async () => {
+    const res = await postTask(tangToken, { alias: "cross-agent", task: "hi2", network_id: NET_A });
+    expect(res.status).toBe(200);
+    expect(res.json.actual_to?.network_id ?? res.json.actual_to?.networkId).toBe(NET_A);
+  });
+});

package/src/rest-alias-network-fallback.test.ts

@@ -0,0 +1,60 @@
+// #1974 —— alias 不在请求的网络里、但在调用者另一个网络里(且唯一)时,发到那儿去。
+//
+// 三条红线各有���一条断言:只找调用者已加入的网络、同名不猜、没权限不换。
+import { describe, expect, test } from "bun:test";
+import { pickAliasNetwork } from "./rest-alias-network-fallback.js";
+
+const base = {
+  alias: "tang02",
+  requestedNetworkId: "net_own",
+  memberNetworkIds: ["net_own", "net_team"],
+  networksWithAlias: ["net_team"],
+  canWrite: () => true,
+  canMessage: () => true,
+};
+
+describe("pickAliasNetwork (#1974)", () => {
+  test("the alias lives in exactly one other member network ⇒ use it", () => {
+    expect(pickAliasNetwork({ ...base })).toBe("net_team");
+  });
+
+  test("the alias is in the requested network too ⇒ do not switch", () => {
+    expect(pickAliasNetwork({ ...base, networksWithAlias: ["net_own", "net_team"] })).toBeNull();
+  });
+
+  test("the same alias in two other networks ⇒ do not guess", () => {
+    expect(pickAliasNetwork({
+      ...base,
+      memberNetworkIds: ["net_own", "net_a", "net_b"],
+      networksWithAlias: ["net_a", "net_b"],
+    })).toBeNull();
+  });
+
+  test("a network the caller does not belong to is never used", () => {
+    expect(pickAliasNetwork({
+      ...base,
+      memberNetworkIds: ["net_own"],
+      networksWithAlias: ["net_team"],
+    })).toBeNull();
+  });
+
+  test("no write access in that network ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, canWrite: () => false })).toBeNull();
+  });
+
+  test("no message permission in that network ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, canMessage: () => false })).toBeNull();
+  });
+
+  test("the alias is nowhere ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, networksWithAlias: [] })).toBeNull();
+  });
+
+  test("no membership at all ⇒ keep the 404", () => {
+    expect(pickAliasNetwork({ ...base, memberNetworkIds: [] })).toBeNull();
+  });
+
+  test("an empty alias is never sent anywhere", () => {
+    expect(pickAliasNetwork({ ...base, alias: "   " })).toBeNull();
+  });
+});

package/src/rest-alias-network-fallback.ts

@@ -0,0 +1,65 @@
+// #1974 —— 「alias 不在请求的网络里」时,发到调用者**另一个**网络里那个 alias 所在的网络。
+//
+// 起因(admin 2026-10-21 截图 + hub 拒绝日志):
+//   [15:55:54] tang → /api/task → tang02: REJECTED 404 alias_not_found (net=net_ac567b4ab74e)
+//
+// 客户端的 Agent 列表是**跨网络**的:`GET /api/status?light=1` 不带 network_id,
+// hub 就按「调用者属于哪些网络」返回。tang 因此同时看到默认网络(net_399bdf86f528)的
+// tang02/03/04 和自己个人网络(net_ac567b4ab74e)里的 Agent。发送却带着「登录时选定的
+// 那一个网络」—— 多网络账号(自己网络的 owner + 团队网络的 admin)两个网络对它都是
+// agent_access='all',pickDefaultNetworkId 于是选中了自己的个人网络 ⇒ 给团队网络的
+// Agent 发消息一律 404 alias_not_found,客户端只显示「没有找到这个 Agent」+「未送达」。
+//
+// 客户端侧已有修法(用 alias 所在网络发),但那只在**新客户端**里生效;已经在用的旧客户端
+// 仍然发不出去。这里补 Hub 侧:alias 唯一地存在于调用者的另一个网络、且调用者在那个网络
+// 有写权限 ⇒ 就发到那儿去。旧客户端立刻受益,不用等升级。
+//
+// 三条红线:
+//   ① 只在调用者**已加入**的网络里找(不跨租户、不做 alias 探测);
+//   ② 同一个 alias 在调用者的多个网络里都存在 ⇒ **不猜**,保持 404;
+//   ③ 调用者在目标网络没有写权限(受限成员没被授权这个 Agent)⇒ 保持 404/403。
+//
+// 纯函数:不碰 db、不碰 http,好测。
+
+export interface AliasNetworkFallbackInput {
+  /** 请求里带的 alias(已按请求网络 canonical 化)。 */
+  alias: string;
+  /** 请求带/推出的那个网络。 */
+  requestedNetworkId: string | null;
+  /** 调用者所属的全部网络。 */
+  memberNetworkIds: readonly string[];
+  /** 上面这些网络里,真的存在这个 alias 的网络(去重后)。 */
+  networksWithAlias: readonly string[];
+  /** 调用者在这个网络能不能写。 */
+  canWrite: (networkId: string) => boolean;
+  /** 调用者能不能给这个 alias 发消息(受限成员的 Agent 授权)。 */
+  canMessage: (networkId: string) => boolean;
+}
+
+/**
+ * 该发到哪个网络?返回 null = 保持原来的 404。
+ *
+ * 只在「请求的网络里没有这个 alias」时才会换网络;请求网络里有 ⇒ 传 requestedNetworkId
+ * 之外一律不动(调用方只在 not_found 时才问这个函数)。
+ */
+export function pickAliasNetwork(input: AliasNetworkFallbackInput): string | null {
+  const alias = (input.alias ?? '').trim();
+  if (!alias) return null;
+  const requested = (input.requestedNetworkId ?? '').trim();
+  const members = new Set((input.memberNetworkIds ?? []).map(n => (n ?? '').trim()).filter(Boolean));
+  if (members.size === 0) return null;
+
+  // 请求的网络里本来就有这个 alias ⇒ 不换网络(它就在那儿,不用猜)。
+  const withAlias = [...new Set((input.networksWithAlias ?? []).map(n => (n ?? '').trim()).filter(Boolean))];
+  if (requested && withAlias.includes(requested)) return null;
+  // 候选 = 调用者所属、且真的有这个 alias 的网络;请求网络本身不算。
+  const candidates = withAlias.filter(n => n !== requested && members.has(n));
+  if (candidates.length === 0) return null;
+  // 多个网络都有同名 alias ⇒ 不猜(alias 探测的防线)。
+  if (candidates.length > 1) return null;
+
+  const only = candidates[0];
+  if (!input.canWrite(only)) return null;
+  if (!input.canMessage(only)) return null;
+  return only;
+}

package/src/server.ts

@@ -32,6 +32,7 @@ import { notifyExpiredTasks, type ExpiredTaskRow } from "./task-expiry-notice.js
 import { expireStaleOpenTasks } from "./task-stale-open.js";
 import { flagOrphanTasks } from "./task-orphan.js";
 import { addAgentNetworkScope, addHumanNetworkScope, addNetworkScope, addOwnTrafficScope, addAgentTimelineScope, canRestWriteNetwork, canRestWriteNetworkAsHuman, getUserNetworkIds, resolveRestNetworkScope, resolveRestWriteNetworkId, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
+import { pickAliasNetwork } from "./rest-alias-network-fallback.js";
 import { lifecycleProjections, lifecycleRequestResponse } from "./node-lifecycle-read.js";
 import { listAdoptionCandidates, snapshotReportsAdoptionDiscovery } from "./adoption-candidates.js";
 import { restrictedMemberSeesFile, restrictedMemberAttachmentsDenied } from "./restricted-files.js";
@@ -3779,6 +3780,37 @@ return Bun.serve({
           message: "network_id is required when the user token has zero or multiple network memberships",
         }, { status: 400 })));
       }
+      // #1974 —— alias 不在请求的网络里、但在调用者**另一个**网络里(且唯一)⇒ 发到那儿去。
+      // 客户端的 Agent 列表是跨网络的(/api/status?light=1 不带 network_id),发送却带着
+      // 「登录时选的那一个网络」;多网络账号因此给别的网络里的 Agent 发消息一律 404
+      // (tang → tang02,2026-10-21)。旧客户端不改也能立刻受益。
+      // 找不到 / 多个网络同名 / 没权限 ⇒ 不动,保持原来的 404。
+      if (restAuth && taskNetId) {
+        const canonicalAlias = resolveCanonicalAlias(taskNetId, body.alias).alias;
+        const memberNets = getUserNetworkIds(restAuth.userId);
+        const netsWithAlias = memberNets.filter(n => !!db.get(
+          "SELECT 1 AS ok FROM sessions WHERE alias = ?1 AND network_id = ?2",
+          [canonicalAlias, n],
+        ));
+        const alt = pickAliasNetwork({
+          alias: canonicalAlias,
+          requestedNetworkId: taskNetId,
+          memberNetworkIds: memberNets,
+          networksWithAlias: netsWithAlias,
+          canWrite: (net) => canRestWriteNetwork(restAuth, net, isAdmin),
+          canMessage: (net) => {
+            if (isAgentRestricted(restAuth.userId, net)) {
+              const row = db.get<{ node_id: string | null }>(
+                "SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2",
+                [canonicalAlias, net],
+              );
+              return canMessageAgent(restAuth.userId, net, { alias: canonicalAlias, nodeId: row?.node_id ?? null });
+            }
+            return true;
+          },
+        });
+        if (alt) taskNetId = alt;
+      }
       // 多用户 Agent 权限:受限成员只能给授权且 can_message 的 Agent 发;
       // 目标不存在 / 没授权 / 只读授权 → 同一个 403,不留 alias 探测差异。发件人固定为自己的用户名。
       const restrictedSender = !!restAuth && !isAdmin && !restAuth.networkId && isAgentRestricted(restAuth.userId, taskNetId!);

package/src/stop-delete-node.test.ts

@@ -961,6 +961,65 @@ describe("RFC-027 PR1.2a — restart_node resets lifecycle_state to 'active'", (
   });
 });
 
+// ── #1511 — restart_node 在途任务默认拒绝（只提示，不自动重启） ──────
+//
+// 节点侧 exit-75 的 drain 只等 60 秒，超时会硬打断当前回合；所以「正在跑
+// 任务」时 Hub 端在派发前就拒绝，计数规则与 stop_node 完全同一份
+// （#2022/#2029 修订版，实现在 countInFlightTasks）。客户端语义：保存密钥
+// 后若节点忙，不安排重启，只提示等任务完成或去节点机器上手动重启。
+describe("restart_node — in-flight default-refuse (#1511)", () => {
+  test("live task row → node_busy_in_flight, no dispatch row, state untouched", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_1511_live", status: "delivered" });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(1);
+    expect(typeof r.hint).toBe("string");
+    const rows = db.all<{ update_id: string }>(`SELECT update_id FROM node_config_updates WHERE node_id = ?1`, [CHILD_A_ID]);
+    expect(rows.length).toBe(0);
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("active");
+  });
+
+  test("unacked legacy inbox rows count too — same rule as stop", async () => {
+    setupAlphaNetwork();
+    seedInbox(NET_A, CHILD_A_ALIAS, 2);
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(2);
+  });
+
+  test("terminal-only rows → restart dispatches (parity with #2022 stop rule)", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_1511_replied", status: "replied" });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(true);
+    expect(r.apply_mode).toBe("restart_only");
+  });
+
+  test("2h-old live task is never aged out — status wins over age (same as stop)", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, {
+      task_id: "task_1511_running_120m", status: "running",
+      task_age: "-120 minutes", inbox_age: "-120 minutes", expires_in: "-60 minutes",
+    });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+  });
+
+  test("stopped node + live-row corpse → restart still dispatches (un-stop must not be blocked)", async () => {
+    setupAlphaNetwork();
+    db.run(`UPDATE nodes SET lifecycle_state = 'stopped' WHERE node_id = ?1`, [CHILD_A_ID]);
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_1511_corpse", status: "delivered" });
+    const r = await call(buildHandlers(USER_A_ID).restart_node, { node_id: CHILD_A_ID, network_id: NET_A });
+    expect(r.ok).toBe(true);
+    expect(r.apply_mode).toBe("restart_only");
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("active");
+  });
+});
+
 // ── #1286 stale-deleting 重派出口 ──────────────────────────────────
 //
 // 修复前 daemon 丢 ack 会让行永远停在 deleting：重发被挡、force 也一样。

package/src/tools.ts

@@ -4160,6 +4160,28 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
   );
 
 
+  // #1511 — stop_node（§4.3 D4）与 restart_node 共用的「在途任务」计数。
+  // 计数规则见 stop_node 内的长注释（#2022/#2029 修订：能成为「本节点正在做的
+  // 工作」的行才算——tasks 行按状态判、终态不算且不设龄上限；无状态行按 60 分钟
+  // 龄判）。抽成一处后，两个闸门共享同一份 SQL，不再各自漂移。
+  const IN_FLIGHT_MAX_AGE_MINUTES = 60;
+  function countInFlightTasks(alias: string, networkId: string | null): number {
+    const row = db.get<{ n: number }>(
+      `SELECT COUNT(*) AS n FROM inbox i
+         LEFT JOIN tasks t
+           ON i.type = 'task'
+          AND t.task_id = COALESCE(i.task_id, i.id)
+        WHERE i.session_name = ?1 AND i.acked = 0
+          AND COALESCE(i.network_id, ?2) = ?2
+          AND ((t.task_id IS NOT NULL
+                AND t.status NOT IN ('replied', 'failed', 'cancelled', 'expired'))
+            OR (t.task_id IS NULL
+                AND i.created_at >= datetime('now', ?3)))`,
+      alias, networkId, `-${IN_FLIGHT_MAX_AGE_MINUTES} minutes`,
+    );
+    return row?.n ?? 0;
+  }
+
   server.tool(
     "restart_node",
     "Trigger a node restart without changing config. RFC-024 Vincent 2026-06-28 increment. Network-scoped (SEC-1); member+ role suffices (lifecycle ops are not privilege elevation).",
@@ -4189,6 +4211,27 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false,
           error: "adopted_restart_requires_daemon", message: "Use Stop, then Start for this adopted node." }) }] };
       }
+      // #1511 — 正在跑任务时不自动重启，只提示。节点侧 exit-75 的 drain 只等
+      // 60 秒、超时会硬打断当前回合（agent-node cli.ts drainInFlightThink），
+      // 所以 Hub 端在派发前就按 stop_node 同一条在途计数规则拒绝，客户端拿到
+      // 明确二选一：等任务完成后重试，或到节点所在机器手动重启。
+      //
+      // 只对 active 节点生效。stopped 节点的进程已死、任务不可能正在跑，其
+      // unacked 行是 stop 留下的尸体；restart_node 在 stopped 节点上是把
+      // lifecycle 翻回 active 的出口，不能用尸体行把这条路堵死。
+      // lifecycle_state 需单独取：resolveTargetNode 的 SELECT 不含该列。
+      const restartLifecycle = db.get<{ lifecycle_state: string | null }>(
+        "SELECT lifecycle_state FROM nodes WHERE node_id = ?1", nodeId,
+      )?.lifecycle_state ?? null;
+      if (restartLifecycle === "active") {
+        const busyCount = countInFlightTasks(node.alias, node.network_id);
+        if (busyCount > 0) {
+          return { content: [{ type: "text" as const, text: JSON.stringify({
+            ok: false, error: "node_busy_in_flight", in_flight_count: busyCount,
+            hint: "节点正在执行任务，本次未安排重启；等它完成后再试，或到节点所在机器手动重启",
+          }) }] };
+        }
+      }
       // F-B reaper: same stale-supersede semantics as update_node_config,
       // with same acked_at-anchored liveness clock (see update_node_config
       // for the 通信龙 polish reasoning).
@@ -5449,21 +5492,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     //      ever retire them, so they get the age ceiling
     //      IN_FLIGHT_MAX_AGE_MINUTES on inbox.created_at.
     // The count stays a per-alias inbox count: one PK join per row.
-    const IN_FLIGHT_MAX_AGE_MINUTES = 60;
-    const inFlightRow = db.get<{ n: number }>(
-      `SELECT COUNT(*) AS n FROM inbox i
-         LEFT JOIN tasks t
-           ON i.type = 'task'
-          AND t.task_id = COALESCE(i.task_id, i.id)
-        WHERE i.session_name = ?1 AND i.acked = 0
-          AND COALESCE(i.network_id, ?2) = ?2
-          AND ((t.task_id IS NOT NULL
-                AND t.status NOT IN ('replied', 'failed', 'cancelled', 'expired'))
-            OR (t.task_id IS NULL
-                AND i.created_at >= datetime('now', ?3)))`,
-      node.alias, node.network_id, `-${IN_FLIGHT_MAX_AGE_MINUTES} minutes`,
-    );
-    const inFlight = inFlightRow?.n ?? 0;
+    // 计数实现在上方 countInFlightTasks。#1511 让 restart_node 共用同一份规则，判据本身未变。
+    const inFlight = countInFlightTasks(node.alias, node.network_id);
     if (inFlight > 0 && !args.force) {
       return { ok: false, error: "node_busy_in_flight", in_flight_count: inFlight, hint: "set force=true to override (audit logged)" };
     }