@sleep2agi/commhub-server 0.9.0-preview.8 → 0.9.0-preview.80

package/src/rules-file-transport.test.ts

@@ -0,0 +1,237 @@
+// app#225 — 节点规则文件远程读写：走真 MCP in-process transport 的端到端。
+//
+// 验的是 #225 验收里 hub 能验的那几条：
+//   1. 客户端只用 node_id 就能发起读/写；工具的 inputSchema 里**没有**任何
+//      路径/文件名字段（验收第 5 条「不能借路径参数写任意文件」在 hub 侧的形状）。
+//   2. 节点用网络 token + alias 拉到的请求里也没有路径字段；ack 后客户端轮询拿到内容。
+//   3. SEC-1：跨网络节点发不了、别的节点 ack 不了、用户 token 拉不了。
+//   4. 单飞 + 超时回收。
+//
+// 跑法：cd server && COMMHUB_DB=/tmp/rules.db bun test src/rules-file-transport.test.ts
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db } from "./db.js";
+import { registerTools } from "./tools.js";
+
+const NET = "net_rules_file";
+const OTHER_NET = "net_rules_file_other";
+const USER = "u_rules_file_owner";
+const NODE_ID = "node_rules_file_claude";
+const NODE_ALIAS = "rules-file-claude";
+const OTHER_NODE_ID = "node_rules_file_other";
+const OTHER_NODE_ALIAS = "rules-file-other";
+const NODE_TOKEN = "tok_rules_file_node";
+const OTHER_NODE_TOKEN = "tok_rules_file_other_node";
+
+function cleanup() {
+  for (const net of [NET, OTHER_NET]) {
+    try { db.run("DELETE FROM node_rules_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 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 {}
+  }
+  try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
+}
+
+function seedWorld() {
+  db.run(
+    `INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))`,
+    [USER, USER],
+  );
+  for (const net of [NET, OTHER_NET]) {
+    db.run(`INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?2, ?3, datetime('now'))`, [net, net, USER]);
+    db.run(`INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))`, [USER, net]);
+  }
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, datetime('now'), datetime('now'))`,
+    [NODE_ID, NODE_ALIAS, NODE_ALIAS, NET],
+  );
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at) VALUES (?1, ?2, ?3, ?4, datetime('now'), datetime('now'))`,
+    [OTHER_NODE_ID, OTHER_NODE_ALIAS, OTHER_NODE_ALIAS, OTHER_NET],
+  );
+  db.run(
+    `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at) VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
+    [NODE_TOKEN, USER, NET, `node:${NODE_ALIAS}`, "hash_rules_file_node"],
+  );
+  db.run(
+    `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at) VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
+    [OTHER_NODE_TOKEN, USER, OTHER_NET, `node:${OTHER_NODE_ALIAS}`, "hash_rules_file_other"],
+  );
+}
+
+type Identity = { net: string; alias: string; isNetworkToken: boolean; tokenId: string };
+const asUser: Identity = { net: NET, alias: USER, isNetworkToken: false, tokenId: "tok_rules_file_user" };
+const asNode: Identity = { net: NET, alias: NODE_ALIAS, isNetworkToken: true, tokenId: NODE_TOKEN };
+const asOtherNode: Identity = { net: OTHER_NET, alias: OTHER_NODE_ALIAS, isNetworkToken: true, tokenId: OTHER_NODE_TOKEN };
+
+async function connect(id: Identity) {
+  const server = new McpServer({ name: "rules-file-test", version: "1" });
+  registerTools(server, undefined, id.net, USER, id.alias, id.isNetworkToken, id.tokenId);
+  const client = new Client({ name: "rules-file-client", version: "1" });
+  const [ct, st] = InMemoryTransport.createLinkedPair();
+  await server.connect(st);
+  await client.connect(ct);
+  const call = async (name: string, args: Record<string, unknown>) => {
+    const r: any = await client.callTool({ name, arguments: args });
+    const first = r.content?.[0];
+    if (!first || first.type !== "text") throw new Error(`no text result from ${name}`);
+    return JSON.parse(first.text);
+  };
+  const close = async () => { await client.close(); await server.close(); };
+  return { client, server, call, close };
+}
+
+beforeEach(() => { cleanup(); seedWorld(); });
+afterAll(cleanup);
+
+describe("app#225 rules file — schema has no path", () => {
+  test("read/write tool inputs are node id + content only; no path / file_name / dir field anywhere", async () => {
+    // 🔴 不走 client.listTools():main 上 report_status / send_desktop_message /
+    // update_node_config / create_node 四个存量工具的 zod 形状让 SDK 的
+    // toJSONSchema 抛 `schema._zod`,listTools 整个失败(与本 PR 无关,实验见
+    // PR 正文)。这里直接看 McpServer 登记表里的 zod shape —— 它就是 hub 校验
+    // 入参用的那份,比 JSON schema 更接近真相。
+    const u = await connect(asUser);
+    try {
+      const reg: Record<string, any> = (u.server as any)._registeredTools;
+      const shapeKeys = (name: string): string[] => {
+        expect(reg[name], name).toBeDefined();
+        const schema = reg[name].inputSchema;
+        const shape = schema?.shape ?? schema?._def?.shape?.() ?? schema ?? {};
+        return Object.keys(shape).sort();
+      };
+      // `alias` (app#225 follow-up) names a TARGET node/session, not a file —
+      // the no-path regex below still covers it.
+      expect(shapeKeys("read_node_rules_file")).toEqual(["alias", "child_node_id", "network_id", "node_id"]);
+      expect(shapeKeys("write_node_rules_file")).toEqual(["alias", "child_node_id", "content", "network_id", "node_id"]);
+      expect(shapeKeys("get_rules_file_request")).toEqual([]);
+      // ack 的 file_name 是节点**回报**它用了哪个文件,不是客户端**指定**用哪个文件。
+      expect(shapeKeys("ack_rules_file_request")).toEqual(["content", "error", "exists", "file_name", "request_id", "status"]);
+      expect(shapeKeys("get_rules_file_result")).toEqual(["network_id", "request_id"]);
+      for (const name of ["read_node_rules_file", "write_node_rules_file", "get_rules_file_request", "get_rules_file_result"]) {
+        for (const k of shapeKeys(name)) expect(k, `${name}.${k}`).not.toMatch(/path|dir|file|cwd/i);
+      }
+    } finally { await u.close(); }
+  }, 20_000);
+});
+
+describe("app#225 rules file — read round trip", () => {
+  test("user enqueues read → node pulls (no path in request) → acks content → user polls done", async () => {
+    const u = await connect(asUser);
+    const n = await connect(asNode);
+    try {
+      const enq = await u.call("read_node_rules_file", { node_id: NODE_ID });
+      expect(enq).toMatchObject({ ok: true, op: "read" });
+      expect(enq.request_id).toMatch(/^rf_/);
+
+      expect(await u.call("get_rules_file_result", { request_id: enq.request_id })).toMatchObject({ ok: true, status: "pending", op: "read" });
+
+      const pulled = await n.call("get_rules_file_request", {});
+      expect(pulled.ok).toBe(true);
+      expect(Object.keys(pulled.request).sort()).toEqual(["op", "request_id"]);
+      expect(pulled.request).toEqual({ request_id: enq.request_id, op: "read" });
+      // 第二次拉:已经 in_progress,不再重复下发
+      expect(await n.call("get_rules_file_request", {})).toEqual({ ok: true, request: null });
+
+      expect(await n.call("ack_rules_file_request", {
+        request_id: enq.request_id, status: "done", file_name: "CLAUDE.md", exists: true, content: "# 规则\n",
+      })).toMatchObject({ ok: true, status: "done" });
+
+      const res = await u.call("get_rules_file_result", { request_id: enq.request_id });
+      expect(res).toMatchObject({ ok: true, status: "done", op: "read", file_name: "CLAUDE.md", exists: true, content: "# 规则\n", error: null });
+    } finally { await u.close(); await n.close(); }
+  }, 20_000);
+
+  test("write: content travels to the node verbatim; result carries no content back", async () => {
+    const u = await connect(asUser);
+    const n = await connect(asNode);
+    try {
+      const body = "# new rules\n\n- 不碰生产 DB\n";
+      const enq = await u.call("write_node_rules_file", { node_id: NODE_ID, content: body });
+      expect(enq).toMatchObject({ ok: true, op: "write" });
+      const pulled = await n.call("get_rules_file_request", {});
+      expect(pulled.request).toEqual({ request_id: enq.request_id, op: "write", content: body });
+      await n.call("ack_rules_file_request", { request_id: enq.request_id, status: "done", file_name: "CLAUDE.md", exists: true });
+      const res = await u.call("get_rules_file_result", { request_id: enq.request_id });
+      expect(res).toMatchObject({ ok: true, status: "done", op: "write", file_name: "CLAUDE.md" });
+      expect(res.content).toBeUndefined();
+    } finally { await u.close(); await n.close(); }
+  }, 20_000);
+
+  test("node failure is surfaced with its reason", async () => {
+    const u = await connect(asUser);
+    const n = await connect(asNode);
+    try {
+      const enq = await u.call("write_node_rules_file", { node_id: NODE_ID, content: "x" });
+      await n.call("get_rules_file_request", {});
+      await n.call("ack_rules_file_request", { request_id: enq.request_id, status: "failed", file_name: "CLAUDE.md", error: "EACCES: permission denied" });
+      expect(await u.call("get_rules_file_result", { request_id: enq.request_id })).toMatchObject({ ok: true, status: "failed", error: "EACCES: permission denied" });
+    } finally { await u.close(); await n.close(); }
+  }, 20_000);
+});
+
+describe("app#225 rules file — SEC-1 and lifecycle", () => {
+  test("cross-network node cannot be targeted", async () => {
+    const u = await connect(asUser);
+    try {
+      expect(await u.call("read_node_rules_file", { node_id: OTHER_NODE_ID })).toMatchObject({ ok: false, error: "cross_network_node" });
+      expect(db.get<{ c: number }>("SELECT COUNT(*) AS c FROM node_rules_requests WHERE node_id = ?1", OTHER_NODE_ID)?.c).toBe(0);
+    } finally { await u.close(); }
+  }, 20_000);
+
+  test("a node in another network can neither pull nor ack this node's request", async () => {
+    const u = await connect(asUser);
+    const o = await connect(asOtherNode);
+    try {
+      const enq = await u.call("read_node_rules_file", { node_id: NODE_ID });
+      expect(await o.call("get_rules_file_request", {})).toEqual({ ok: true, request: null });
+      expect(await o.call("ack_rules_file_request", { request_id: enq.request_id, status: "done", content: "stolen" })).toMatchObject({ ok: true, ignored: "unknown_or_foreign_request" });
+      expect(db.get<{ status: string }>("SELECT status FROM node_rules_requests WHERE request_id = ?1", enq.request_id)?.status).toBe("pending");
+    } finally { await u.close(); await o.close(); }
+  }, 20_000);
+
+  test("user token (not a network token) cannot use the node-side pull/ack", async () => {
+    const u = await connect(asUser);
+    try {
+      expect(await u.call("get_rules_file_request", {})).toMatchObject({ ok: false, error: "network_token_required" });
+      expect(await u.call("ack_rules_file_request", { request_id: "rf_nope", status: "done" })).toMatchObject({ ok: false, error: "network_token_required" });
+    } finally { await u.close(); }
+  }, 20_000);
+
+  test("single flight: a second request while one is pending is refused; a stale one is superseded", async () => {
+    const u = await connect(asUser);
+    try {
+      const first = await u.call("read_node_rules_file", { node_id: NODE_ID });
+      expect(await u.call("read_node_rules_file", { node_id: NODE_ID })).toMatchObject({ ok: false, error: "request_in_flight", existing_request_id: first.request_id });
+      db.run("UPDATE node_rules_requests SET created_at = ?1 WHERE request_id = ?2", [Date.now() - 120_000, first.request_id]);
+      const second = await u.call("read_node_rules_file", { node_id: NODE_ID });
+      expect(second.ok).toBe(true);
+      expect(db.get<{ status: string }>("SELECT status FROM node_rules_requests WHERE request_id = ?1", first.request_id)?.status).toBe("timeout");
+    } finally { await u.close(); }
+  }, 20_000);
+
+  test("polling a request the node never answered flips it to timeout with a readable reason", async () => {
+    const u = await connect(asUser);
+    try {
+      const enq = await u.call("read_node_rules_file", { node_id: NODE_ID });
+      db.run("UPDATE node_rules_requests SET created_at = ?1 WHERE request_id = ?2", [Date.now() - 120_000, enq.request_id]);
+      const res = await u.call("get_rules_file_result", { request_id: enq.request_id });
+      expect(res).toMatchObject({ ok: true, status: "timeout" });
+      expect(res.error).toMatch(/did not answer/);
+    } finally { await u.close(); }
+  }, 20_000);
+
+  test("oversized content is refused before anything is queued", async () => {
+    const u = await connect(asUser);
+    try {
+      const r: any = await u.client.callTool({ name: "write_node_rules_file", arguments: { node_id: NODE_ID, content: "x".repeat(256 * 1024 + 1) } });
+      expect(r.isError).toBe(true);
+      expect(db.get<{ c: number }>("SELECT COUNT(*) AS c FROM node_rules_requests WHERE node_id = ?1", NODE_ID)?.c).toBe(0);
+    } finally { await u.close(); }
+  }, 20_000);
+});

package/src/runtime-label.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test";
+import { normalizeSessionRuntime } from "./runtime-label";
+
+describe("session runtime projection", () => {
+  test("preserves exact co-presence and CLI runtimes", () => {
+    expect(normalizeSessionRuntime("agent-node:codex-app-server")).toBe("codex-app-server");
+    expect(normalizeSessionRuntime("agent-node:grok-build-cli")).toBe("grok-build-cli");
+  });
+  test("keeps legacy labels backward-compatible", () => {
+    expect(normalizeSessionRuntime("agent-node:codex")).toBe("codex-sdk");
+    expect(normalizeSessionRuntime("agent-node:claude")).toBe("claude-agent-sdk");
+    expect(normalizeSessionRuntime("agent-node:grok")).toBe("grok-build-acp");
+    expect(normalizeSessionRuntime("agent-node:opencode")).toBe("opencode-cli");
+    expect(normalizeSessionRuntime("claude-code")).toBe("claude-code-cli");
+  });
+  test("does not invent unknown runtimes", () => {
+    expect(normalizeSessionRuntime("agent-node:future-runtime")).toBeNull();
+    expect(normalizeSessionRuntime("agent-node:codex-app-server-evil")).toBeNull();
+    expect(normalizeSessionRuntime("agent-node:grok-build-cli-preview")).toBeNull();
+    expect(normalizeSessionRuntime(null)).toBeNull();
+  });
+});

package/src/runtime-label.ts

@@ -0,0 +1,21 @@
+/** Preserve exact agent-node runtimes before applying legacy family aliases. */
+export function normalizeSessionRuntime(agent: unknown): string | null {
+  if (typeof agent !== "string" || agent.length === 0) return null;
+  if (agent === "claude-code") return "claude-code-cli";
+  const reported = agent.startsWith("agent-node:") ? agent.slice("agent-node:".length) : "";
+  const exact: Record<string, string> = {
+    "codex-app-server": "codex-app-server",
+    "grok-build-cli": "grok-build-cli",
+    opencode: "opencode-cli",
+    "opencode-cli": "opencode-cli",
+    codex: "codex-sdk",
+    "codex-sdk": "codex-sdk",
+    claude: "claude-agent-sdk",
+    "claude-agent-sdk": "claude-agent-sdk",
+    grok: "grok-build-acp",
+    "grok-build-acp": "grok-build-acp",
+  };
+  if (exact[reported]) return exact[reported];
+  if (agent === "http-api" || agent === "http" || agent === "api") return "http-api";
+  return null;
+}

package/src/scheduled-doorbell-nodeless-session.test.ts

@@ -0,0 +1,130 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { db } from "./db.js";
+import { createSSEStream } from "./push.js";
+import { dispatchScheduledOccurrence } from "./scheduled-tasks.js";
+
+// A claude-code node's channel server reports status without node_id, so its
+// sessions row has node_id NULL. The scheduler used to look the session up by
+// node_id only, judged every occurrence "queued" and never rang the doorbell:
+// the task sat in the inbox until an unrelated push drained it (20–36 min in
+// production).
+
+const NET = "net_sched_doorbell_nodeless";
+const NODE = "n_sched_doorbell_cc";
+const ALIAS = "sched-doorbell-cc";
+
+function cleanup(): void {
+  for (const table of ["task_events", "inbox", "scheduled_task_runs", "scheduled_tasks", "tasks", "sessions", "nodes"]) {
+    try { db.run(`DELETE FROM ${table} WHERE network_id = ?1`, [NET]); } catch {}
+  }
+}
+
+function seedNode(): void {
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, runtime, network_id, lifecycle_state)
+     VALUES (?1, ?2, ?2, 'claude-code-cli', ?3, 'active')`,
+    [NODE, ALIAS, NET],
+  );
+}
+
+function seedSession(status: string, nodeId: string | null): void {
+  db.run(
+    `INSERT INTO sessions (resume_id, alias, status, node_id, network_id, agent, updated_at, last_seen_at)
+     VALUES (?1, ?2, ?3, ?4, ?5, 'claude-code', datetime('now'), datetime('now'))`,
+    [`cc-${crypto.randomUUID()}`, ALIAS, status, nodeId, NET],
+  );
+}
+
+function seedSchedule(): any {
+  const scheduleId = `sched_${crypto.randomUUID()}`;
+  db.run(
+    `INSERT INTO scheduled_tasks
+       (schedule_id, network_id, name, target_node_id, target_alias, task_content, priority,
+        schedule_type, schedule_json, timezone, status, next_run_at)
+     VALUES (?1, ?2, 'doorbell', ?3, ?4, 'scheduled doorbell task', 'normal', 'interval',
+             '{"type":"interval","every_seconds":3600}', 'UTC', 'active', datetime('now', '+1 hour'))`,
+    [scheduleId, NET, NODE, ALIAS],
+  );
+  return db.get("SELECT * FROM scheduled_tasks WHERE schedule_id = ?1", scheduleId);
+}
+
+/** Subscribe like the channel server does and collect decoded SSE frames. */
+function subscribe(): { frames: any[]; close: () => Promise<void> } {
+  const res = createSSEStream(ALIAS, NET);
+  const reader = res.body!.getReader();
+  const decoder = new TextDecoder();
+  const frames: any[] = [];
+  let buffer = "";
+  let open = true;
+  (async () => {
+    while (open) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const blocks = buffer.split("\n\n");
+      buffer = blocks.pop() || "";
+      for (const block of blocks) {
+        const line = block.split("\n").find((l) => l.startsWith("data: "));
+        if (line) frames.push(JSON.parse(line.slice(6)));
+      }
+    }
+  })().catch(() => {});
+  return {
+    frames,
+    close: async () => {
+      open = false;
+      await reader.cancel().catch(() => {});
+    },
+  };
+}
+
+async function settle(): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, 20));
+}
+
+beforeEach(() => {
+  cleanup();
+  seedNode();
+});
+
+afterAll(cleanup);
+
+describe("scheduler doorbell for sessions reported without node_id", () => {
+  test("idle node_id-less session is delivered and its subscriber receives new_task", async () => {
+    seedSession("idle", null);
+    const sub = subscribe();
+    try {
+      await settle();
+      const result = dispatchScheduledOccurrence(seedSchedule(), new Date().toISOString(), false);
+      await settle();
+      expect(result.status).toBe("delivered");
+      expect(db.get<{ status: string }>("SELECT status FROM scheduled_task_runs WHERE run_id = ?1", result.runId)?.status).toBe("delivered");
+      const wake = sub.frames.filter((f) => f.type === "new_task");
+      expect(wake).toHaveLength(1);
+      expect(wake[0].from).toBe("scheduler");
+      expect(wake[0].inbox_count).toBe(1);
+    } finally {
+      await sub.close();
+    }
+  });
+
+  test("a live subscriber counts even when the session row says offline", async () => {
+    seedSession("offline", null);
+    const sub = subscribe();
+    try {
+      await settle();
+      const result = dispatchScheduledOccurrence(seedSchedule(), new Date().toISOString(), false);
+      await settle();
+      expect(result.status).toBe("delivered");
+      expect(sub.frames.filter((f) => f.type === "new_task")).toHaveLength(1);
+    } finally {
+      await sub.close();
+    }
+  });
+
+  test("offline session with nobody listening stays queued", () => {
+    seedSession("offline", null);
+    const result = dispatchScheduledOccurrence(seedSchedule(), new Date().toISOString(), false);
+    expect(result.status).toBe("queued");
+  });
+});

package/src/scheduled-reply-unread-http.test.ts

@@ -0,0 +1,212 @@
+// 定时任务的回复要进建排程那个人的未读(Vincent 2026-09-30「定时任务触发的…那个红点它是不显示的」)。
+//
+// scheduler 派的任务 from_name='scheduler',回复以前按 from_name 落进 inbox(session_name='scheduler'):
+// app 会话里看得到(会话取自 tasks 表),但 unread_by_agent 只数 session_name=用户名 的行 ⇒ 永远没红点。
+// 这里走真 Hub(bootServer)+ 真节点令牌回复路径(send_reply,callerTokenIsNetwork=true)。
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { addNetworkMember, createNetworkTokenForNode, register } from "./auth.js";
+import { db } from "./db.js";
+import { runDueScheduledTasks } from "./scheduled-tasks.js";
+import { registerTools } from "./tools.js";
+
+const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
+if (!activeDbPath) throw new Error("scheduled-reply-unread requires COMMHUB_DB (or COMMHUB_TEST_PG_URL) before module import");
+
+let server: any;
+let base = "";
+let ownerToken = "";
+let ownerName = "";
+let memberToken = "";
+let memberName = "";
+let networkId = "";
+let ownerId = "";
+const stamp = Date.now();
+const ALIAS = `sched-reply-node-${stamp}`;
+const nodeId = `n_sched_reply_${stamp}`;
+
+async function api(token: string, path: string, init?: RequestInit) {
+  const res = await fetch(`${base}${path}`, {
+    ...init,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json", ...(init?.headers || {}) },
+  });
+  return { status: res.status, body: await res.json() as any };
+}
+
+/** 节点令牌身份调 send_reply(与真节点的 commhub_reply 同一个 handler、同一组归属校验)。 */
+async function nodeReply(args: Record<string, unknown>): Promise<any> {
+  const mcp = new McpServer({ name: "sched-reply", version: "0" }) as any;
+  const handlers: Record<string, (a: any) => Promise<any>> = {};
+  const original = mcp.tool.bind(mcp);
+  mcp.tool = (name: string, ...rest: any[]) => {
+    const handler = rest.at(-1);
+    if (typeof handler === "function") handlers[name] = handler;
+    return original(name, ...rest);
+  };
+  registerTools(mcp, undefined, networkId, ownerId, ALIAS, true, null);
+  const out = await handlers.send_reply(args);
+  return JSON.parse(out.content[0].text);
+}
+
+async function unreadFor(token: string): Promise<Record<string, number>> {
+  const res = await api(token, "/api/messages?scope=user&limit=50");
+  expect(res.status).toBe(200);
+  return res.body.unread_by_agent ?? {};
+}
+
+async function ackAgent(token: string) {
+  const res = await api(token, "/api/messages/ack", { method: "POST", body: JSON.stringify({ agent: ALIAS }) });
+  expect(res.status).toBe(200);
+  return res.body;
+}
+
+/** 建一个排程、让它立刻到期、跑一次,返回它派出的 task_id。 */
+async function fireSchedule(token: string, name: string): Promise<{ scheduleId: string; taskId: string }> {
+  const created = await api(token, "/api/scheduled-tasks", {
+    method: "POST",
+    body: JSON.stringify({
+      network_id: networkId, name, target_node_id: nodeId, task: `${name} tick`,
+      timezone: "UTC", schedule: { type: "interval", every_seconds: 120 },
+    }),
+  });
+  expect(created.status).toBe(201);
+  const scheduleId = created.body.schedule.schedule_id as string;
+  // 别的排程不许在这次 sweep 里一起跑
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id != ?2", [new Date(Date.now() + 24 * 3600_000).toISOString(), scheduleId]);
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [new Date(Date.now() - 60_000).toISOString(), scheduleId]);
+  await runDueScheduledTasks();
+  const run = db.get<{ task_id: string | null }>(
+    "SELECT task_id FROM scheduled_task_runs WHERE schedule_id = ?1 ORDER BY scheduled_for DESC LIMIT 1", scheduleId,
+  );
+  expect(run?.task_id).toBeTruthy();
+  const task = db.get<{ from_name: string }>("SELECT from_name FROM tasks WHERE task_id = ?1", run!.task_id!);
+  expect(task?.from_name).toBe("scheduler");
+  return { scheduleId, taskId: run!.task_id! };
+}
+
+function replyRow(taskId: string) {
+  return db.get<{ session_name: string; from_session: string; acked: number }>(
+    "SELECT session_name, from_session, acked FROM inbox WHERE type = 'reply' AND in_reply_to = ?1", taskId,
+  );
+}
+
+beforeAll(async () => {
+  ownerName = `sched_reply_owner_${stamp}`;
+  const owner = register(ownerName, "SchedReplyOwner123!", undefined, "seed");
+  expect(owner.ok).toBe(true);
+  ownerToken = owner.token!;
+  networkId = owner.network_id!;
+  ownerId = db.get<{ owner_id: string }>("SELECT owner_id FROM networks WHERE network_id = ?1", networkId)!.owner_id;
+
+  memberName = `sched_reply_member_${stamp}`;
+  const member = register(memberName, "SchedReplyMember123!", undefined, "seed");
+  expect(member.ok).toBe(true);
+  memberToken = member.token!;
+  const memberId = db.get<{ user_id: string }>("SELECT user_id FROM users WHERE username = ?1", memberName)!.user_id;
+  expect(addNetworkMember(networkId, memberId, "member", ownerId, { agentAccess: "all" }).ok).toBe(true);
+
+  expect(createNetworkTokenForNode(ownerId, networkId, ALIAS).ok).toBe(true);
+  db.run(
+    "INSERT INTO nodes (node_id, node_name, alias, runtime, network_id) VALUES (?1, ?2, ?2, 'claude-code', ?3)",
+    [nodeId, ALIAS, networkId],
+  );
+  db.run(
+    "INSERT INTO sessions (resume_id, alias, status, node_id, network_id) VALUES (?1, ?2, 'idle', ?3, ?4)",
+    [`r_sched_reply_${stamp}`, ALIAS, nodeId, networkId],
+  );
+  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 {}
+});
+
+describe("scheduled-task replies reach the schedule creator's unread", () => {
+  test("a direct reply still lands on the sender and counts once", async () => {
+    await ackAgent(ownerToken);
+    const sent = await api(ownerToken, "/api/task", { method: "POST", body: JSON.stringify({ network_id: networkId, alias: ALIAS, task: "direct hello" }) });
+    expect(sent.status).toBe(200);
+    const taskId = sent.body.task_id as string;
+    const reply = await nodeReply({ in_reply_to: taskId, text: "direct answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe(ownerName);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+  });
+
+  test("a scheduled-task reply counts for the creator, and ack-by-agent clears it", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "owner-every-2m");
+    // 节点不带 alias(SDK 运行时)——收件人由 in_reply_to 推出
+    const reply = await nodeReply({ in_reply_to: taskId, text: "tick answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)).toEqual({ session_name: ownerName, from_session: ALIAS, acked: 0 });
+    expect(db.get<{ status: string; result: string }>("SELECT status, result FROM tasks WHERE task_id = ?1", taskId))
+      .toEqual({ status: "replied", result: "tick answer" });
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+
+    const acked = await ackAgent(ownerToken);
+    expect(acked.acked_inbox).toBe(1);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+    expect(replyRow(taskId)?.acked).toBe(1);
+  });
+
+  test("a node that names alias='scheduler' explicitly is routed the same way", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "owner-explicit-alias");
+    const reply = await nodeReply({ alias: "scheduler", in_reply_to: taskId, text: "explicit answer", status: "replied" });
+    expect(reply.ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe(ownerName);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+  });
+
+  test("another member of the network does not get the owner's scheduled reply, and gets their own", async () => {
+    await ackAgent(ownerToken);
+    await ackAgent(memberToken);
+    const ownerRun = await fireSchedule(ownerToken, "owner-only");
+    expect((await nodeReply({ in_reply_to: ownerRun.taskId, text: "for owner", status: "replied" })).ok).toBe(true);
+    expect((await unreadFor(memberToken))[ALIAS]).toBeUndefined();
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+
+    const memberRun = await fireSchedule(memberToken, "member-only");
+    expect((await nodeReply({ in_reply_to: memberRun.taskId, text: "for member", status: "replied" })).ok).toBe(true);
+    expect(replyRow(memberRun.taskId)?.session_name).toBe(memberName);
+    expect((await unreadFor(memberToken))[ALIAS]).toBe(1);
+    expect((await unreadFor(ownerToken))[ALIAS]).toBe(1);
+    await ackAgent(ownerToken);
+    await ackAgent(memberToken);
+  });
+
+  test("a schedule with no creator falls back to 'scheduler'", async () => {
+    await ackAgent(ownerToken);
+    const { scheduleId, taskId } = await fireSchedule(ownerToken, "creatorless");
+    db.run("UPDATE scheduled_tasks SET created_by = NULL WHERE schedule_id = ?1", [scheduleId]);
+    expect((await nodeReply({ in_reply_to: taskId, text: "nobody's", status: "replied" })).ok).toBe(true);
+    expect(replyRow(taskId)?.session_name).toBe("scheduler");
+    expect((await unreadFor(ownerToken))[ALIAS]).toBeUndefined();
+  });
+
+  test("a creator whose username is also a node alias falls back to 'scheduler' (the collision guard)", async () => {
+    await ackAgent(ownerToken);
+    const { taskId } = await fireSchedule(ownerToken, "colliding-creator");
+    const clashNodeId = `n_clash_${stamp}`;
+    db.run(
+      "INSERT INTO nodes (node_id, node_name, alias, runtime, network_id) VALUES (?1, ?2, ?2, 'claude-code', ?3)",
+      [clashNodeId, ownerName, networkId],
+    );
+    try {
+      expect((await nodeReply({ in_reply_to: taskId, text: "not a todo", status: "replied" })).ok).toBe(true);
+      // 那个同名节点收不到这条(它不是节点的待办),用户名也拿不到(inbox 半边整体跳过)
+      expect(replyRow(taskId)?.session_name).toBe("scheduler");
+      expect(db.get<{ n: number }>(
+        "SELECT COUNT(*) AS n FROM inbox WHERE session_name = ?1 AND in_reply_to = ?2", ownerName, taskId,
+      )?.n).toBe(0);
+    } finally {
+      db.run("DELETE FROM nodes WHERE node_id = ?1", [clashNodeId]);
+    }
+  });
+});