@sleep2agi/commhub-server 0.9.0-preview.43 → 0.9.0-preview.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.43",
+  "version": "0.9.0-preview.45",
   "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/admin-networks-http.test.ts

@@ -25,6 +25,10 @@ async function listNetworks(token: string): Promise<any[]> {
   return body.networks;
 }
 
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(async () => {
   const { db } = await import("./db.js");
   const { createNetworkTokenForNode, register } = await import("./auth.js");
@@ -51,7 +55,7 @@ beforeAll(async () => {
   const mod = await import("./server.js");
   server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
   base = `http://127.0.0.1:${server.port}`;
-});
+}, 30_000);
 
 afterAll(() => {
   try { server?.stop(true); } catch {}

package/src/api-host-supervisors-can-create-nodes.test.ts

@@ -264,3 +264,87 @@ describe("#1353 Fix ② — /api/host-supervisors surfaces can_create_nodes + bl
     expect(rows.find((r: any) => r.alias === "malformed")).toBeUndefined();
   });
 });
+
+/* #1545 —— `can_create_nodes` 说的是「能不能」,这一组说的是「**那是什么时候测的**」。
+ *
+ * 为什么非要分开:agent-node ≤ 2.5.0-preview.54 用一个进程级缓存只算一次
+ * (`cli.ts` 的 `_createCapCache`)。开机时二进制好、之后被 chmod 掉 ⇒ 它会
+ * **永远上报 ready**。hub 这边,那条记录和一个 3 秒前刚测出来的 ready
+ * 在 `last_seen_at` 上一模一样 —— 心跳是新的,那一格不是。
+ *
+ * 🔴 缺席**不得**当成 0。把「没报」渲染成「刚测的」,正好朝「没问题」方向说谎,
+ *    而这正是 #1545 里比沉默更糟的那一半。
+ */
+describe("#1545 /api/host-supervisors —— can_create_nodes 的年龄", () => {
+  test("daemon 报了年龄 → 原样带出", async () => {
+    clearDaemons();
+    seedDaemon("age-fresh", {
+      role: "host_supervisor",
+      daemon_capabilities: {
+        can_create_nodes: false,
+        create_nodes_blocked_reason: "anet_bin_source",
+        create_capability_observed_ms_ago: 12,
+      },
+    });
+    const d = findDaemon(await listDaemons(), "age-fresh");
+    expect(d.create_capability_observed_ms_ago).toBe(12);
+  });
+
+  test("🔴 daemon 没报年龄 → 这一格必须**缺席**,不能是 0/null", async () => {
+    clearDaemons();
+    seedDaemon("age-absent", {
+      role: "host_supervisor",
+      daemon_capabilities: { can_create_nodes: true },
+    });
+    const d = findDaemon(await listDaemons(), "age-absent");
+    // 能力本身照常带出 —— 加年龄这一格不许把旧 daemon 的既有信息弄丢。
+    expect(d.can_create_nodes).toBe(true);
+    expect("create_capability_observed_ms_ago" in d).toBe(false);
+  });
+
+  /* 🔴 消毒**不是 clamp**:clamp 会把一个坏值变成一个看起来正常的年龄,
+   * 而这一格存在的全部意义就是让人分辨新鲜和陈旧。坏值一律当作「没报」。 */
+  test.each([
+    ["负数", -1],
+    ["超过一年", 400 * 24 * 60 * 60 * 1000],
+    ["null(schema 的 .catch 兜底值)", null],
+    ["字符串(直接写库,绕过 schema)", "12"],
+  ])("坏值当作没报,而不是 clamp 成边界:%s", async (label, value) => {
+    clearDaemons();
+    const alias = `age-bad-${String(label).slice(0, 4)}`;
+    seedDaemon(alias, {
+      role: "host_supervisor",
+      daemon_capabilities: {
+        can_create_nodes: true,
+        create_capability_observed_ms_ago: value,
+      },
+    });
+    const d = findDaemon(await listDaemons(), alias);
+    expect(d.can_create_nodes).toBe(true);           // 能力仍在
+    expect("create_capability_observed_ms_ago" in d).toBe(false);  // 年龄不在
+  });
+
+  /* 边界校准:上面用 400 天证明「太旧被丢」,这里用**刚好一年**证明门不是恒丢。
+   * 只验被丢那一侧的话,一个恒丢的实现能全绿通过。 */
+  test("边界:恰好一年被接受 ⇒ 上面那条不是因为恒丢才绿", async () => {
+    clearDaemons();
+    const oneYear = 365 * 24 * 60 * 60 * 1000;
+    seedDaemon("age-boundary", {
+      role: "host_supervisor",
+      daemon_capabilities: { can_create_nodes: true, create_capability_observed_ms_ago: oneYear },
+    });
+    const d = findDaemon(await listDaemons(), "age-boundary");
+    expect(d.create_capability_observed_ms_ago).toBe(oneYear);
+  });
+
+  test("年龄只在 can_create_nodes 存在时出现(旧 daemon 两格都没有)", async () => {
+    clearDaemons();
+    seedDaemon("age-legacy", {
+      role: "host_supervisor",
+      daemon_capabilities: { runtimes_supported: ["claude-agent-sdk"] },
+    });
+    const d = findDaemon(await listDaemons(), "age-legacy");
+    expect("can_create_nodes" in d).toBe(false);
+    expect("create_capability_observed_ms_ago" in d).toBe(false);
+  });
+});

package/src/api-host-supervisors-fallback.test.ts

@@ -38,6 +38,10 @@ let soloNetworkId = "";
 let multiNetworkA = "", multiNetworkB = "";
 let soloDaemonAlias = "";
 
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(async () => {
   process.env.HOST = "127.0.0.1";
 
@@ -116,7 +120,7 @@ beforeAll(async () => {
   server = bootServer({ port: 0, hostname: "127.0.0.1" });
   BASE = `http://127.0.0.1:${server.port}`;
   await new Promise((r) => setTimeout(r, 100));
-});
+}, 30_000);
 
 // Insert a minimal `nodes` row + `api_tokens` row so the daemon shows up
 // in /api/host-supervisors' JOIN-then-role-filter query (index.ts

package/src/auth-validate.test.ts

@@ -10,13 +10,17 @@ import { register } from "./auth.js";
 
 // First user gets RELAXED rules (admin bootstrap allows 4-char "anethub" etc.)
 // To test full-strength rules, seed a dummy admin first.
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(() => {
   // Idempotent: if DB file already has users (from a previous run on the
   // same temp path), this errors with "username already taken" → that's
   // fine, the goal is just "ensure at least one user exists so subsequent
   // registers hit the strict path".
   register("_seed_admin", "BootstrapPw1", undefined, "seed");
-});
+}, 30_000);
 
 describe("register — username rules", () => {
   it("rejects empty username", () => {

package/src/create-node-blocked-gate.test.ts

@@ -31,6 +31,7 @@ function cleanup() {
   try { db.run("DELETE FROM node_create_requests WHERE network_id = ?1", [NET]); } catch {}
   try { db.run("DELETE FROM audit_log WHERE network_id = ?1", [NET]); } catch {}
   try { db.run("DELETE FROM nodes WHERE network_id = ?1", [NET]); } catch {}
+  try { db.run("DELETE FROM sessions WHERE network_id = ?1", [NET]); } catch {}
   try { db.run("DELETE FROM api_tokens WHERE network_id = ?1", [NET]); } catch {}
   try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
   try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
@@ -39,6 +40,18 @@ function cleanup() {
 beforeEach(cleanup);
 afterAll(cleanup);
 
+/** #1545 —— 可选:写一条 sessions 心跳行。
+ *  默认**不写**,这样既有那 9 条测试的行为逐字不变;
+ *  只有要断言绝对年龄的用例才显式给 `heartbeatAgoMs`。 */
+function seedHeartbeat(agoMs: number) {
+  const iso = new Date(Date.now() - agoMs).toISOString();
+  db.run(
+    `INSERT INTO sessions (alias, node_id, network_id, status, last_seen_at, updated_at)
+     VALUES (?1, ?2, ?3, 'idle', ?4, ?4)`,
+    [DAEMON_ALIAS, DAEMON_ID, NET, iso],
+  );
+}
+
 function seed(snapshot: object | string | null) {
   db.run(
     `INSERT INTO users (user_id, username, password_hash, role, created_at)
@@ -229,3 +242,115 @@ describe("#1353 Fix ① — hub gates create_node on daemon-reported can_create_
     expect(r.error).not.toBe("daemon_cannot_create_nodes");
   });
 });
+
+/* #1545 —— 拒绝的时候还要说**那个判断是什么时候做出来的**。
+ *
+ * 为什么这一格落在拒绝路径上最要紧:用户被挡住的这一刻,正好在决定"去修哪台机器"。
+ *   刚测的 blocked      ⇒ 去那台机器按 reason 修
+ *   三周前测的 blocked  ⇒ 那台 daemon 是**开机算一次就永久缓存**的旧版本
+ *                        (agent-node ≤ 2.5.0-preview.54),它可能早就好了 —— 先重启/升级它
+ * 只给 `blocked_reason` 的话,这两种情况给用户的字**一模一样**。 */
+describe("#1545 拒绝文案带上「这个判断是多久以前做的」", () => {
+  const blockedSnap = (extra: object) => ({
+    role: "host_supervisor",
+    daemon_capabilities: {
+      can_create_nodes: false,
+      create_nodes_blocked_reason: "anet_bin_permission",
+      ...extra,
+    },
+  });
+
+  /* 🔴 报出去的是**到现在为止**的绝对年龄,不是 daemon 报的那个原始时长。
+   * daemon 报的是「测完到**这份 report 发出**」;直接透传会漏掉心跳那一段,
+   * **朝更新鲜的方向低报** —— 正是这一格要防的方向。
+   *   绝对年龄 = (now − last_seen_at) + daemon 报的时长 */
+  test("daemon 报了年龄 + 有心跳时间 → 补上心跳那一段,标记 known", async () => {
+    seed(blockedSnap({ create_capability_observed_ms_ago: 12_345 }));
+    seedHeartbeat(60_000);            // 上次心跳在 60s 前
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: spec });
+    expect(r.ok).toBe(false);
+    expect(r.blocked_reason).toBe("anet_bin_permission");
+    expect(r.capability_age).toBe("known");
+    // 允许 ±5s 的执行抖动;关键是它**明显大于** 12,345,即心跳那一段确实被加上了
+    const got = r.capability_observed_ms_ago as number;
+    expect(got).toBeGreaterThanOrEqual(12_345 + 60_000 - 5_000);
+    expect(got).toBeLessThanOrEqual(12_345 + 60_000 + 5_000);
+    // 🔴 反向锚:如果实现是"原样透传",这个数会恰好等于 12,345
+    expect(got).not.toBe(12_345);
+  });
+
+  /* 🔴 第三种 unknown,不能和「旧 daemon 没报」塌成同一个:
+   * 它报了,但 hub 这边没有可用的心跳时间 ⇒ **补不出绝对年龄**,而不是"年龄是 0"。 */
+  test("报了年龄但 hub 没有心跳时间 → unknown_no_heartbeat_time(不是 legacy,也不是 0)", async () => {
+    seed(blockedSnap({ create_capability_observed_ms_ago: 12_345 }));
+    // 故意不 seedHeartbeat
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: spec });
+    expect(r.capability_age).toBe("unknown_no_heartbeat_time");
+    expect(r.capability_observed_ms_ago).toBeNull();
+  });
+
+  /* 🔴 本组的重点:年龄未知时给的是**显式 null + 说明为什么的枚举**,
+   * 而不是省略这两个键。省略读起来像"没有这个问题",而调用方(常常是个 agent)
+   * 会默认它是刚测的 —— 那是朝「更可信」方向撒谎,比不给更糟。 */
+  test("🔴 daemon 没报年龄 → 两个键都在:null + unknown_legacy_daemon(不是省略)", async () => {
+    seed(blockedSnap({}));
+    seedHeartbeat(1_000);   // 心跳齐全 ⇒ 唯一缺的就是 daemon 没报那一格
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: spec });
+    expect(r.ok).toBe(false);
+    expect("capability_observed_ms_ago" in r).toBe(true);
+    expect(r.capability_observed_ms_ago).toBeNull();
+    expect(r.capability_age).toBe("unknown_legacy_daemon");
+    // 🔴 绝不能渲染成"刚测的"
+    expect(r.capability_observed_ms_ago).not.toBe(0);
+  });
+
+  test.each([
+    ["负数", -1],
+    ["超过一年", 400 * 24 * 60 * 60 * 1000],
+    ["非数字", "12"],
+    ["null", null],
+  ])("坏值当作没报(不 clamp 成一个看起来正常的年龄):%s", async (_l, v) => {
+    seed(blockedSnap({ create_capability_observed_ms_ago: v }));
+    // 🔴 必须给心跳:否则这几条会因为"没有心跳时间"而变成
+    //    unknown_no_heartbeat_time,**坏值那一维根本没被测到**
+    //    (夹具只该在被测的那一维上不合法)。
+    seedHeartbeat(1_000);
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: spec });
+    expect(r.capability_age).toBe("unknown_legacy_daemon");
+    expect(r.capability_observed_ms_ago).toBeNull();
+    // 分母自证:拒绝本身仍然发生了,不是因为整条路径没走到才"没有年龄"
+    expect(r.error).toBe("daemon_cannot_create_nodes");
+  });
+
+  test("边界:恰好一年被接受 ⇒ 上面那些不是因为恒判 unknown 才绿", async () => {
+    const oneYear = 365 * 24 * 60 * 60 * 1000;
+    seed(blockedSnap({ create_capability_observed_ms_ago: oneYear }));
+    seedHeartbeat(1_000);
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: spec });
+    expect(r.capability_age).toBe("known");
+    expect(r.capability_observed_ms_ago as number).toBeGreaterThanOrEqual(oneYear);
+  });
+
+  /* 🔴 hub 出**代码**,不出渲染好的修法命令 —— 那张 code → 命令 的表只有一个作者
+   * (@sleep2agi/agent-network 的 daemon-capability-display)。抄一份到 hub,
+   * 两份就会各自漂移,而「hub 教的修法」和「CLI 教的修法」不一致时没有任何东西会红。 */
+  test("🔴 hub 不返回具体修法命令,只把人指到那唯一一份", async () => {
+    seed(blockedSnap({ create_capability_observed_ms_ago: 0 }));
+    seedHeartbeat(1_000);
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: spec });
+    const blob = JSON.stringify(r);
+    for (const leaked of ["chmod go-w", "npm i -g", "readlink -f", "/etc/anet-daemon"]) {
+      expect(blob).not.toContain(leaked);
+    }
+    expect(String(r.remediation_hint)).toContain("anet daemon list");
+    // 正控:这四条不是恒真 —— 它们确实是那份表里的真实内容
+    expect("该二进制 group/other 可写。一行修:chmod go-w \"$(command -v anet)\"").toContain("chmod go-w");
+  });
+
+  test("健康 daemon 不受影响:正常派发,不带这两个键", async () => {
+    seed({ role: "host_supervisor", daemon_capabilities: { can_create_nodes: true } });
+    const r = await call(tools().create_node, { daemon_node_id: DAEMON_ID, node_spec: spec });
+    expect(r.ok).not.toBe(false);
+    expect("capability_age" in r).toBe(false);
+  });
+});

package/src/dashboard-slash-routing-http.test.ts

@@ -18,6 +18,10 @@ let nodeToken = "";
 let networkId = "";
 let requestSequence = 0;
 
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(async () => {
   process.env.COMMHUB_DB = process.env.COMMHUB_DB || join(PRIVATE_DB_DIR, "hub.db");
   const username = `dashboard_slash_${Date.now()}`;
@@ -42,7 +46,7 @@ beforeAll(async () => {
   const mod: any = await import("./server.js");
   server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
   base = `http://127.0.0.1:${server.port}`;
-});
+}, 30_000);
 
 afterAll(() => {
   try { server?.stop?.(true); } catch {}

package/src/db.ts

@@ -540,6 +540,37 @@ try {
   console.warn(`[commhub] partial unique index uniq_ncu_node_inflight skipped: ${e?.message || e}`);
 }
 
+// ── app#225: 节点规则文件（AGENTS.md / CLAUDE.md）远程读写请求 ──
+//
+// 形状照抄 node_config_updates（上面）：客户端落一行 + 门铃，节点拉走做完回报，
+// 客户端轮询结果。network_id 同样在插入时从 nodes 反规范化。
+//
+// 🔴 这张表**故意没有路径列**：文件名由节点按自己的 RUNTIME 决定
+// （claude → CLAUDE.md，其余 → AGENTS.md），目录固定是节点进程的 cwd。
+// hub 侧只存 op + 内容，客户端连文件名都指定不了（#225 验收第 5 条）。
+// file_name 是节点**回报**的实际文件名，只用于显示。
+db.exec(`
+  CREATE TABLE IF NOT EXISTS node_rules_requests (
+    request_id       TEXT PRIMARY KEY,
+    node_id          TEXT NOT NULL,
+    network_id       TEXT NOT NULL,
+    op               TEXT NOT NULL,
+    content          TEXT,
+    status           TEXT NOT NULL,
+    file_name        TEXT,
+    file_exists      INTEGER,
+    result_content   TEXT,
+    error            TEXT,
+    created_at       INTEGER NOT NULL,
+    created_by_token TEXT NOT NULL,
+    pulled_at        INTEGER,
+    acked_at         INTEGER
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_nrr_node_status ON node_rules_requests(node_id, status);
+  CREATE INDEX IF NOT EXISTS idx_nrr_network ON node_rules_requests(network_id);
+`);
+
 // ── V3: networks table ──
 db.exec(`
   CREATE TABLE IF NOT EXISTS networks (

package/src/external-schedule-edits-http.test.ts

@@ -51,6 +51,10 @@ function snapshot(revision: number, extra: Record<string, unknown> = {}) {
   });
 }
 
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(async () => {
   const admin = register(`b4_admin_${stamp}`, "B4Admin123!", undefined, "B4 Admin");
   const owner = register(`b4_owner_${stamp}`, "B4Owner123!", undefined, "B4 Owner");
@@ -83,7 +87,7 @@ beforeAll(async () => {
   const mod: any = await import("./server.js");
   server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
   base = `http://127.0.0.1:${server.port}`;
-});
+}, 30_000);
 
 afterAll(() => {
   try { server?.stop?.(true); } catch {}

package/src/external-schedule-edits-timestamps.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from "bun:test";
+import { parseHubTimestamp } from "./hub-timestamp";
+
+// #1650 —— external-schedule-edits 的 publicEdit() 原先对四个时间列直接
+// `new Date(row.x).toISOString()`。这些列是 SQLite `datetime('now')` 家族:
+// **UTC 但不带时区标记**,而 JS 对「有时间、无偏移」的串按**本机时区**解析,
+// 且不报错 ⇒ 发给 API 消费方的是一个错的时刻。
+
+function hubIso(raw: unknown): string | null {
+  const ms = parseHubTimestamp(raw);
+  return ms === null ? null : new Date(ms).toISOString();
+}
+
+describe("#1650 hub 时间戳按 UTC 解析", () => {
+  it("🔴 无时区标记的串按 UTC 解析,不按本机时区", () => {
+    expect(hubIso("2026-08-30 21:04:11")).toBe("2026-08-30T21:04:11.000Z");
+  });
+
+  it("🔴 反向见证:旧写法在非 UTC 机器上会给出不同的结果", () => {
+    const old = new Date("2026-08-30 21:04:11").toISOString();
+    const now = hubIso("2026-08-30 21:04:11")!;
+    // 只有当本机恰好是 UTC 时两者才相同;此处断言的是「新写法等于 UTC 语义」,
+    // 而 old 的值取决于运行机器 —— 所以只在两者不同时才有对比意义。
+    const offsetMin = new Date("2026-08-30T21:04:11Z").getTimezoneOffset();
+    if (offsetMin !== 0) expect(old).not.toBe(now);
+    expect(now).toBe("2026-08-30T21:04:11.000Z");
+  });
+
+  it("带 Z 的串保持原意", () => {
+    expect(hubIso("2026-08-30T21:04:11Z")).toBe("2026-08-30T21:04:11.000Z");
+  });
+
+  it("🔴 垃圾串返回 null,而不是抛 RangeError(旧写法会把接口打成 500)", () => {
+    expect(hubIso("not-a-date")).toBeNull();
+    expect(hubIso(null)).toBeNull();
+    expect(hubIso(undefined)).toBeNull();
+    expect(() => new Date("not-a-date").toISOString()).toThrow();
+  });
+});
+
+// 🔴 上面四条测的是 helper 的语义。真正要钉住的是**那个文件用了它**——
+//    否则 helper 再对,publicEdit 里改回 `new Date(row.x)` 也照样全绿。
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+describe("#1650 publicEdit 必须走 hubIso,不能有裸 new Date(row.*)", () => {
+  const SRC = readFileSync(join(import.meta.dir, "external-schedule-edits.ts"), "utf-8");
+  const CODE = SRC.split("\n").filter(l => !/^\s*(\/\/|\*|\/\*)/.test(l)).join("\n");
+
+  it("🔴 源码里不再有裸 new Date(row.…)", () => {
+    expect(/new Date\(row\./.test(CODE)).toBe(false);
+  });
+
+  it("四个时间列都走 hubIso", () => {
+    for (const f of ["expires_at", "created_at", "delivered_at", "acked_at"]) {
+      expect(CODE).toContain(`${f}: hubIso(row.${f})`);
+    }
+  });
+
+  it("hubIso 复用 parseHubTimestamp,没有第二套判据", () => {
+    expect(CODE).toContain('from "./hub-timestamp"');
+    expect(CODE).toContain("parseHubTimestamp(raw)");
+  });
+});

package/src/external-schedule-edits.ts

@@ -2,6 +2,7 @@ import { db } from "./db.js";
 import { getUserNetworkRole } from "./auth.js";
 import { pushEvent } from "./push.js";
 import { parseExternalSchedulePatch, type ExternalSchedulePatch } from "./shared/external-schedule-contract.js";
+import { parseHubTimestamp } from "./hub-timestamp";
 
 type Auth = {
   userId: string;
@@ -109,6 +110,18 @@ function reportedSchedule(node: NodeRow, scheduleId: string): Record<string, unk
   }
 }
 
+// 🔴 #1650 —— 这些列是 SQLite `datetime('now')` 家族:**UTC 但不带时区标记**。
+//   `new Date("2026-08-30 21:04:11")` 会按**本机时区**解析(ES 规范:带时间且无偏移
+//   的形式视为本地时间),而且不报错 —— 于是发给 API 消费方的是一个错的时刻,
+//   误差就是这台机器的 offset。
+//   另外原写法在字段是垃圾串时 `new Date(x).toISOString()` 会**抛 RangeError**,
+//   足以把这个接口打成 500;`parseHubTimestamp` 解析失败返回 null,这里也返回 null。
+//   复用 server.ts:1010 已在用的那个 helper,不自造第二套判据。
+function hubIso(raw: unknown): string | null {
+  const ms = parseHubTimestamp(raw);
+  return ms === null ? null : new Date(ms).toISOString();
+}
+
 function publicEdit(row: EditRow): Record<string, unknown> {
   let patch: ExternalSchedulePatch = {};
   try { patch = JSON.parse(row.patch_json); } catch {}
@@ -119,10 +132,10 @@ function publicEdit(row: EditRow): Record<string, unknown> {
     base_revision: row.base_revision,
     patch,
     status: row.status,
-    expires_at: new Date(row.expires_at).toISOString(),
-    created_at: new Date(row.created_at).toISOString(),
-    delivered_at: row.delivered_at ? new Date(row.delivered_at).toISOString() : null,
-    acked_at: row.acked_at ? new Date(row.acked_at).toISOString() : null,
+    expires_at: hubIso(row.expires_at),
+    created_at: hubIso(row.created_at),
+    delivered_at: hubIso(row.delivered_at),
+    acked_at: hubIso(row.acked_at),
     result_revision: row.result_revision,
     error_code: row.error_code,
   };

package/src/health-redaction.test.ts

@@ -30,6 +30,10 @@ let userNetworkId = "";
 let userName = "";
 let adminToken = "";
 
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(async () => {
   process.env.COMMHUB_DB = process.env.COMMHUB_DB || SERVER_DB;
   process.env.HOST = "127.0.0.1";
@@ -72,7 +76,7 @@ beforeAll(async () => {
   if (res.status !== 200) throw new Error("SSE subscribe failed: " + res.status);
   sseReader = res.body!.getReader();
   await sseReader.read(); // consume the connected frame → registration done
-});
+}, 30_000);
 
 afterAll(() => {
   try { sseReader?.cancel(); } catch {}

package/src/hub-timestamp.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { parseHubTimestamp } from "./hub-timestamp";
+
+const RAW = "2026-08-30 21:11:24";                    // sessions.last_seen_at 的真实取值
+const TRUE_UTC = Date.UTC(2026, 7, 30, 21, 11, 24);
+
+describe("parseHubTimestamp (#1650)", () => {
+  test("🔴 非 UTC 时区下也必须解出同一个 UTC 时刻", () => {
+    // `bun test` 把测试进程时区固定成 UTC(getTimezoneOffset() === 0)。
+    // 在 UTC 下,「补 Z」和「不补 Z」解析出**同一个数** —— 这个函数存在的那个
+    // 缺陷在测试进程里**结构上不可见**。所以这一条必须开 TZ≠UTC 的子进程。
+    // 实测:去掉补 Z,本文件其余各条**全绿**。
+    const child = `import { parseHubTimestamp } from ${JSON.stringify(import.meta.dir + "/hub-timestamp.ts")};
+process.stdout.write(new Date().getTimezoneOffset() + "," + parseHubTimestamp(${JSON.stringify(RAW)}));`;
+    const r = Bun.spawnSync(["bun", "-e", child], { env: { ...process.env, TZ: "Asia/Shanghai" } });
+    const [offset, parsed] = r.stdout.toString().trim().split(",");
+    // 🔴 先断言控制生效:子进程真的不在 UTC。否则 TZ 被忽略时这条又变成空测试。
+    expect(Number(offset)).not.toBe(0);
+    expect(parsed).toBe(String(TRUE_UTC));
+  });
+
+  test("已带 Z / ±HH:MM 的串不再追加时区", () => {
+    expect(parseHubTimestamp("2026-08-30T21:11:24Z")).toBe(TRUE_UTC);
+    expect(parseHubTimestamp("2026-08-30T22:11:24+01:00")).toBe(TRUE_UTC);
+  });
+
+  test("拿不到就返回 null,不返回一个看起来合理的数", () => {
+    for (const bad of [undefined, null, "", "  ", 0, 1788124284000, {}, [], "2026-08-30", "垃圾"]) {
+      expect(parseHubTimestamp(bad as unknown)).toBeNull();
+    }
+  });
+
+  test("🔴 INTEGER 列(epoch 毫秒)不归它管 —— 传数字必须返回 null,而不是悄悄接受", () => {
+    // external_schedule_edits.* 是 INTEGER。如果有人把本函数用在那儿,
+    // 应当立刻拿到 null 而不是一个错的时刻。
+    expect(parseHubTimestamp(TRUE_UTC)).toBeNull();
+  });
+});

package/src/hub-timestamp.ts

@@ -0,0 +1,27 @@
+/**
+ * #1650 — hub 的 TEXT 时间戳列是 SQLite `datetime('now')` 写的，
+ * 形如 `2026-08-30 21:11:24`：**UTC，但不带任何时区标记**。
+ *
+ * 🔴 `new Date(raw)` / `Date.parse(raw)` 对这种串按**本地时间**解析（ES 规范：
+ *    带时间的形式无偏移时视为本地时间），误差恰好等于主机时区偏移，**而且不报错**：
+ *
+ *      TZ=UTC                   误差  0h
+ *      TZ=Asia/Shanghai         误差 -8h   （看起来更陈旧）
+ *      TZ=America/Los_Angeles   误差 +7h   （看起来更新鲜 ← 朝好的一侧错）
+ *
+ * 🔴 **只对 TEXT 列用它。** 同一个字段名在不同表里可能是不同类型：
+ *      sessions.last_seen_at / licenses.expires_at   → TEXT（要用本函数）
+ *      external_schedule_edits.expires_at 等 4 列     → INTEGER（epoch 毫秒，直接 new Date 就对）
+ *    按字段名判会判错 —— 见 #1650 里的更正。
+ *
+ * 与 agent-network 侧的同名函数是**有意的重复**：server 包不依赖 agent-network，
+ * 仓里也没有共享 lib。两边各自带测试。
+ */
+export function parseHubTimestamp(raw: unknown): number | null {
+  if (typeof raw !== "string") return null;
+  const t = raw.trim();
+  if (!/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}/.test(t)) return null;
+  const hasZone = /([Zz]|[+-]\d{2}:?\d{2})$/.test(t);
+  const ms = Date.parse(t.replace(" ", "T") + (hasZone ? "" : "Z"));
+  return Number.isFinite(ms) ? ms : null;
+}

package/src/network-name-http.test.ts

@@ -13,6 +13,10 @@ let nodeToken = "";
 let networkId = "";
 let username = "";
 
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(async () => {
   process.env.COMMHUB_DB = process.env.COMMHUB_DB || join(PRIVATE_DB_DIR, "hub.db");
   username = `network_name_${Date.now()}_${process.pid}`;
@@ -30,7 +34,7 @@ beforeAll(async () => {
   const mod: any = await import("./server.js");
   server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
   base = `http://127.0.0.1:${server.port}`;
-});
+}, 30_000);
 
 afterAll(() => {
   try { server?.stop?.(true); } catch {}

package/src/node-attrs.test.ts

@@ -45,6 +45,10 @@ const LEGACY_ALIAS = "attrs-legacy-node";
 let token = "";
 let server: { stop: (force?: boolean) => void } | null = null;
 
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
 beforeAll(async () => {
   db.run(`INSERT INTO users (user_id, username, password_hash, role) VALUES (?1, 'attrs-user', 'x', 'user')`, [USER]);
   db.run(`INSERT INTO networks (network_id, network_name, owner_id) VALUES (?1, 'attrs-net', ?2)`, [NET, USER]);
@@ -58,7 +62,7 @@ beforeAll(async () => {
   token = issueUserToken(USER, "attrs-test").token;
   server = bootServer({ port: PORT, hostname: "127.0.0.1" }) as never;
   await new Promise((r) => setTimeout(r, 120));
-});
+}, 30_000);
 
 afterAll(() => {
   try { server?.stop(true); } catch { /* already down */ }