@sleep2agi/commhub-server 0.9.0-preview.30 → 0.9.0-preview.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.30",
+  "version": "0.9.0-preview.32",
   "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/db-timestamp.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "bun:test";
+import { parseDbTimestampMs } from "./db-timestamp.js";
+
+const NAIVE = "2026-08-27 11:23:54";
+const EXPECTED = Date.UTC(2026, 7, 27, 11, 23, 54);
+
+describe("parseDbTimestampMs", () => {
+  // ⚠ 这条在 **TZ=UTC 的环境**下没有分辨力：裸 Date.parse 在 UTC 下恰好正确。
+  // CI runner 与容器默认就是 UTC（本仓 Docker 套件亦然），所以缺陷在常规跑法里
+  // 恒绿。（更正：Bun 是尊重 TZ 的，不存在"bun test 固定 UTC"——通信评审牛 #1279
+  // 独审③ 独立复跑证伪了我最初的说法。）真正稳定见红的门是下面那条强制子进程。
+  it("treats a naive SQLite timestamp as UTC", () => {
+    expect(parseDbTimestampMs(NAIVE)).toBe(EXPECTED);
+  });
+
+  // 分辨力关键：宿主是 UTC 时,裸 Date.parse 与正确写法结果相同,断言恒绿。
+  // 强制子进程 TZ=Asia/Shanghai,让缺陷在任何 CI 时区下都显形。
+  it("is unaffected by a non-UTC host timezone (child process TZ=Asia/Shanghai)", () => {
+    const r = Bun.spawnSync({
+      cmd: ["bun", "-e",
+        `const {parseDbTimestampMs} = await import("${import.meta.dir}/db-timestamp.ts");` +
+        `console.log(parseDbTimestampMs("${NAIVE}"));`],
+      env: { ...process.env, TZ: "Asia/Shanghai" },
+    });
+    expect(Number(r.stdout.toString().trim())).toBe(EXPECTED);
+  });
+
+  it("keeps explicit-offset timestamps intact", () => {
+    expect(parseDbTimestampMs("2026-08-27T11:23:54Z")).toBe(EXPECTED);
+    expect(parseDbTimestampMs("2026-08-27T19:23:54+08:00")).toBe(EXPECTED);
+  });
+
+  it("an online window of 5min holds for a heartbeat written 1s ago", () => {
+    const now = Date.now();
+    const iso = new Date(now - 1000).toISOString().slice(0, 19).replace("T", " ");
+    expect(now - parseDbTimestampMs(iso)).toBeLessThanOrEqual(5 * 60_000);
+  });
+});

package/src/db-timestamp.ts

@@ -0,0 +1,15 @@
+/**
+ * SQLite 里的时间戳列（sessions.last_seen_at、tasks.created_at 等）存的是
+ * **无时区标记的 UTC 串**（`YYYY-MM-DD HH:MM:SS`，由 SQLite `datetime('now')` 写入）。
+ *
+ * 裸 `Date.parse("2026-08-27 11:23:54")` 会按**宿主机本地时区**解释这个串。
+ * 生产机 TZ=CST+0800 时，它比真实 UTC 时刻早 8 小时——所以 `now - parsed`
+ * 恒为 +480 分钟，任何「最近 N 秒内算在线」的判据都会恒判离线。
+ * 在 TZ=UTC 的机器上两种写法结果相同，缺陷不会显形。
+ */
+export function parseDbTimestampMs(value: string): number {
+  const s = String(value).trim();
+  // 已带时区标记（ISO 的 Z / ±HH:MM）就原样交给 Date
+  if (/[Zz]$|[+-]\d{2}:?\d{2}$/.test(s)) return Date.parse(s);
+  return Date.parse(s.replace(" ", "T") + "Z");
+}

package/src/delivered-without-push.test.ts

@@ -0,0 +1,140 @@
+// f015d9d6 症状①：tasks.status 被置为 'delivered'，而 SSE 推送根本没发出。
+//
+// send_task 无条件以字面量 'delivered' 插入 tasks 行，推送却另外被
+// `if (target.state === "online")` 挡着（tools.ts:1432）。同一段代码里给
+// network observer 的事件把同一件事标成 "queued" —— 也就是说代码**知道**
+// 它没投出去，却仍然把 delivered 写进了 tasks.status。
+//
+// 而 "online" 的判据是 resolveDeliveryTarget 里的
+//   stale = now - (last_seen_at || updated_at) > 5 分钟
+// 且 last_seen_at 只在 report_status 时刷新（tools.ts:674/702）。
+// 全网「停发心跳/状态类消息」的省额度规则之下，一个安静的 MCP 会话必然变 stale。
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db } from "./db.js";
+import { registerTools } from "./tools.js";
+import { __resetSSEClientsForTest, createSSEStream } from "./push.js";
+
+const NET = "net_delivered_push_f015";
+const USER = "user_delivered_push_f015";
+const SENDER = "sender-f015b";
+const TARGET = "quiet-mcp-f015b";
+
+type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup() {
+  __resetSSEClientsForTest();
+  for (const t of ["tasks", "inbox", "task_events", "sessions", "api_tokens", "nodes", "rename_txn"]) {
+    try { db.run(`DELETE FROM ${t} 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 {}
+}
+
+/** minutesAgo 控制目标会话的 last_seen_at —— 这是本文件唯一要动的变量。 */
+function seed(minutesAgo: number) {
+  db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'admin', datetime('now'))", [USER]);
+  db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
+  db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
+  for (const alias of [SENDER, TARGET]) {
+    db.run(
+      "INSERT INTO api_tokens (token_id, token_hash, user_id, network_id, name, scope) VALUES (?1, ?2, ?3, ?4, ?5, 'network')",
+      [`token-${alias}`, `hash-${alias}`, USER, NET, `node:${alias}`],
+    );
+  }
+  db.run(
+    "INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at) VALUES (?1, ?1, 'idle', NULL, ?2, datetime('now'), datetime('now', ?3))",
+    [SENDER, NET, "-1 minutes"],
+  );
+  // 🔴 目标：MCP 挂载的 claude-code 会话形状（node_id NULL），
+  //    status 是 'idle'（不是 offline），只是安静了 minutesAgo 分钟。
+  db.run(
+    "INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at) VALUES (?1, ?2, 'idle', NULL, ?3, datetime('now', ?4), datetime('now', ?4))",
+    [`cc-n_${TARGET}`, TARGET, NET, `-${minutesAgo} minutes`],
+  );
+}
+
+function toolsFor(alias: string): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "delivered-push-f015", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const original = server.tool.bind(server);
+  server.tool = (name: string, description: string, schema: any, handler: ToolHandler) => {
+    tools[name] = handler; return original(name, description, schema, handler);
+  };
+  registerTools(server, undefined, NET, USER, alias, true, `token-${alias}`);
+  return tools;
+}
+
+/** 从订阅者那一侧真正读出字节 —— 地面真相，不是连接计数。 */
+async function readUntil(reader: ReadableStreamDefaultReader<Uint8Array>, needle: string, ms = 1500): Promise<string | null> {
+  const dec = new TextDecoder();
+  let buf = "";
+  const deadline = Date.now() + ms;
+  while (Date.now() < deadline) {
+    const chunk = await Promise.race([
+      reader.read(),
+      new Promise<{ done: true; value: undefined }>((r) => setTimeout(() => r({ done: true, value: undefined }), 200)),
+    ]);
+    if (chunk.value) buf += dec.decode(chunk.value, { stream: true });
+    if (buf.includes(needle)) return buf;
+  }
+  return null;
+}
+
+let sendSeq = 0;
+/** minutesAgo = 目标安静了多久；withSubscriber = 是否真的有人连着。 */
+async function send(minutesAgo: number, withSubscriber = true) {
+  cleanup(); seed(minutesAgo);
+  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
+  if (withSubscriber) {
+    const res = createSSEStream(TARGET, NET);
+    reader = res.body!.getReader();
+  }
+  const r = await toolsFor(SENDER).send_task({ alias: TARGET, task: `ping-${++sendSeq}`, priority: "normal" });
+  const out = JSON.parse(r.content[0].text);
+  const row = db.get<{ status: string }>("SELECT status FROM tasks WHERE to_name = ?1 AND network_id = ?2", TARGET, NET);
+  const received = reader ? await readUntil(reader, "new_task") : null;
+  return { out, taskStatus: row?.status ?? null, received };
+}
+
+describe("f015d9d6 症状① — delivered 置位与实际推送不同步", () => {
+  beforeEach(() => cleanup());
+  afterAll(() => cleanup());
+
+  test("对照：目标 1 分钟前还活跃 ⇒ 订阅者收到 new_task", async () => {
+    const { taskStatus, received } = await send(1);
+    expect(taskStatus).toBe("delivered");
+    expect(received).toContain("new_task");
+  });
+
+  test("🔴 核心：目标安静 10 分钟但订阅者连着 ⇒ 仍然收得到（修复前这里收到 null）", async () => {
+    const { taskStatus, received } = await send(10);
+    expect(received).toContain("new_task");
+    expect(taskStatus).toBe("delivered");   // 现在这个 delivered 是真话了
+  });
+
+  test("🔴 可达性判据必须来自订阅者注册表，不是 last_seen_at 的时间戳猜测", async () => {
+    // 安静 10 分钟 = 时间戳判据会说 offline；而实际上有人在听。
+    const quiet = await send(10);
+    expect(quiet.received).toContain("new_task");
+    // 真没人听的时候，pushEvent 本来就是 no-op，不需要额外的闸来保护。
+    const nobody = await send(10, false);
+    expect(nobody.received).toBeNull();
+  });
+
+  test("真的没有订阅者时，tasks 行仍写 delivered —— 本 PR 刻意不改，记录在案", async () => {
+    const { taskStatus, received } = await send(10, false);
+    expect(received).toBeNull();
+    // 这一条钉的是**当前行为**，不是我认为对的行为：没人收到，行仍自称 delivered。
+    expect(taskStatus).toBe("delivered");
+  });
+
+  test("活性判据的输入 last_seen_at 只由 report_status 刷新 —— 发送方不刷新它", async () => {
+    cleanup(); seed(4);
+    const before = db.get<{ last_seen_at: string }>("SELECT last_seen_at FROM sessions WHERE alias = ?1 AND network_id = ?2", TARGET, NET);
+    await toolsFor(SENDER).send_task({ alias: TARGET, task: `ping-${++sendSeq}`, priority: "normal" });
+    const after = db.get<{ last_seen_at: string }>("SELECT last_seen_at FROM sessions WHERE alias = ?1 AND network_id = ?2", TARGET, NET);
+    expect(after?.last_seen_at).toBe(before!.last_seen_at);
+  });
+});

package/src/package-version-consistency.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+type PackageManifest = { version: string };
+type PackageLock = {
+  version: string;
+  packages: { "": { version: string } };
+};
+
+const readJson = <T>(name: string): T =>
+  JSON.parse(readFileSync(join(import.meta.dir, "..", name), "utf8")) as T;
+
+describe("server package version consistency", () => {
+  const manifest = readJson<PackageManifest>("package.json");
+  const lock = readJson<PackageLock>("package-lock.json");
+
+  test("package-lock top-level version matches package.json", () => {
+    expect(lock.version).toBe(manifest.version);
+  });
+
+  test("package-lock root package version matches package.json", () => {
+    expect(lock.packages[""].version).toBe(manifest.version);
+  });
+});

package/src/push.ts

@@ -382,6 +382,17 @@ eventBus.on("rename-committed", (event: RenameCommittedEvent) => {
 });
 
 /** 推送事件给指定 session 的所有 SSE 连接 */
+/** 这个 alias 上此刻是否真的有活着的 SSE 订阅者。
+ *
+ *  这是投递可达性的**实测**，区别于 resolveDeliveryTarget 里那个基于
+ *  last_seen_at 的**猜测**。一个安静但连着的会话（例如遵守「停发心跳」
+ *  规则的 MCP 会话）在时间戳判据下是 offline，在这里是 true。 */
+export function hasSubscribers(sessionName: string, networkId?: string | null): boolean {
+  const arr = clients.get(clientKey(sessionName, networkId));
+  if (!arr) return false;
+  return arr.some((c) => !c.closed);
+}
+
 export function pushEvent(sessionName: string, event: Record<string, unknown>, networkId?: string | null): void {
   const key = clientKey(sessionName, networkId ?? (event.network_id as string | null | undefined));
   const arr = clients.get(key);

package/src/reply-target-derivation.test.ts

@@ -0,0 +1,96 @@
+// f015d9d6 根因隔离：admin(dashboard/人类) 发给「无 node_id 的 MCP 会话」的任务，
+// 其回执被 reply_target_mismatch 拒绝。
+//
+// 上报时给出的假设是「校验依赖投递绑定 ⇒ 任务还没真正 deliver 进会话时回执会被拒」。
+// 本文件把两个变量分开量，一次只动一个：
+//   变量 1 = 任务是否已投递（status created vs delivered，有无 SSE 订阅者）
+//   变量 2 = 调用方是否显式传 alias
+// 如果假设成立，变量 1 应当决定结果；如果 alias 推导才是决定因素，变量 2 才会。
+import { beforeEach, afterAll, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db } from "./db.js";
+import { registerTools } from "./tools.js";
+import { __resetSSEClientsForTest, createSSEStream } from "./push.js";
+
+const NET = "net_admin_reply_f015";
+const USER = "user_admin_reply_f015";
+const ADMIN = "admin-f015";           // 人类/dashboard 发起方，无 node
+const AGENT = "agent-mcp-f015";       // MCP 会话：sessions 行 node_id = NULL
+const AGENT_NODE = "node-agent-f015"; // token 绑定的 node（会话本身仍无 node_id）
+
+type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup() {
+  __resetSSEClientsForTest();
+  for (const t of ["tasks", "inbox", "task_events", "sessions", "api_tokens", "nodes", "rename_txn"]) {
+    try { db.run(`DELETE FROM ${t} 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 seed() {
+  db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'admin', datetime('now'))", [USER]);
+  db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [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, hostname, config_snapshot, created_at, updated_at, lifecycle_state) VALUES (?1, ?2, ?2, ?3, 'host', '{}', datetime('now'), datetime('now'), 'active')",
+    [AGENT_NODE, AGENT, NET],
+  );
+  // 🔴 关键夹具属性：会话行 node_id 为 NULL —— 这正是 MCP 挂载的 claude-code 会话的形状
+  db.run(
+    "INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at) VALUES (?1, ?2, 'idle', NULL, ?3, datetime('now'), datetime('now'))",
+    [`cc-n_${AGENT}`, AGENT, NET],
+  );
+  db.run(
+    "INSERT INTO api_tokens (token_id, token_hash, user_id, network_id, name, scope, bound_node_id) VALUES (?1, ?2, ?3, ?4, ?5, 'network', ?6)",
+    [`token-${AGENT}`, `hash-${AGENT}`, USER, NET, `node:${AGENT}`, AGENT_NODE],
+  );
+}
+
+function toolsFor(alias: string): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "admin-reply-f015", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const original = server.tool.bind(server);
+  server.tool = (name: string, description: string, schema: any, handler: ToolHandler) => {
+    tools[name] = handler; return original(name, description, schema, handler);
+  };
+  registerTools(server, undefined, NET, USER, alias, true, `token-${alias}`);
+  return tools;
+}
+
+function parse(res: { content: Array<{ text: string }> }) { return JSON.parse(res.content[0].text); }
+
+/** 造一条 admin(人类) → AGENT 的任务；delivered 控制「是否已投递」这一个变量。 */
+function seedAdminTask(taskId: string, delivered: boolean) {
+  db.run(
+    `INSERT INTO tasks (task_id, from_name, from_node_id, to_name, to_node_id, content, status, priority, network_id, created_at)
+     VALUES (?1, ?2, NULL, ?3, NULL, 'ping', ?4, 'normal', ?5, datetime('now'))`,
+    [taskId, ADMIN, AGENT, delivered ? "delivered" : "created", NET],
+  );
+}
+
+describe("f015d9d6 — admin→无 node_id 的 MCP 会话，回执绑定", () => {
+  beforeEach(() => { cleanup(); seed(); });
+  afterAll(() => cleanup());
+
+  test("变量1：任务【未投递】+ 省略 alias（走 #1085 推导）⇒ 回执应当成功", async () => {
+    seedAdminTask("t-undelivered", false);
+    const r = parse(await toolsFor(AGENT).send_reply({ in_reply_to: "t-undelivered", text: "done", status: "completed" }));
+    expect(r).toEqual(expect.objectContaining({ ok: true }));
+  });
+
+  test("变量1 对照：任务【已投递且有 SSE 订阅者】+ 省略 alias ⇒ 同样成功", async () => {
+    seedAdminTask("t-delivered", true);
+    createSSEStream(AGENT, NET);
+    const r = parse(await toolsFor(AGENT).send_reply({ in_reply_to: "t-delivered", text: "done", status: "completed" }));
+    expect(r).toEqual(expect.objectContaining({ ok: true }));
+  });
+
+  test("变量2：显式传一个不等于任务发起方的 alias ⇒ reply_target_mismatch", async () => {
+    seedAdminTask("t-wrong-alias", true);
+    const r = parse(await toolsFor(AGENT).send_reply({ alias: "someone-else", in_reply_to: "t-wrong-alias", text: "done", status: "completed" }));
+    expect(r).toEqual(expect.objectContaining({ ok: false, error: "reply_target_mismatch" }));
+  });
+});

package/src/send-reply-alias-optional.test.ts

@@ -0,0 +1,131 @@
+// #1085 — send_reply must not require `alias` when `in_reply_to` is set.
+//
+// Symptom (deployed SDK-runtime nodes): `mcp__commhub__send_reply(task_id,
+// text)` → `-32602 Invalid input: expected string, received undefined at
+// alias`. That is the HUB's Zod schema rejecting a required `alias` the
+// client never sent — the request dies before the handler runs, so the
+// original task is never terminalized and its inbox row stays unacked
+// (pending inflation).
+//
+// Fix (two parts, both in tools.ts):
+//   1. `replyToolSchema.alias` → optional (stops the MCP-layer Zod -32602).
+//   2. `handleReply` derives the target from the in_reply_to task's
+//      `from_name` when alias is omitted — the target was always knowable
+//      from the task the hub already looks up, so the param was redundant.
+//
+// This suite drives the registered handler directly (MCP Zod layer is
+// exercised separately by the framework), so it pins part (2): omit alias
+// → derive → reply lands on the original sender; omit both → clean error.
+//
+// 改坏报红 gate: revert the derive block (require alias again) and
+// "alias omitted → derives to original sender" flips to a resolve failure.
+
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { db } from "./db.js";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerTools } from "./tools.js";
+
+const NET_ID = "net_1085";
+const USER_ID = "u_1085";
+const NODE_ID = "node_1085";
+const AGENT_ALIAS = "worker-1085";
+const ORIGIN_ALIAS = "boss-1085"; // the task's from_name — the derive target
+const AGENT_TOK_ID = "tok_1085";
+
+interface ToolHandler {
+  (args: any, extra?: any): Promise<{ content: Array<{ type: "text"; text: string }> }>;
+}
+interface Reply { ok?: boolean; message_id?: string; error?: string; message?: string; [k: string]: unknown; }
+
+function cleanup() {
+  for (const t of ["tasks", "inbox", "task_events", "sessions", "nodes", "api_tokens", "network_members", "networks"]) {
+    try { db.run(`DELETE FROM ${t} WHERE network_id = ?1`, [NET_ID]); } catch {}
+  }
+  try { db.run("DELETE FROM users WHERE user_id = ?1", [USER_ID]); } catch {}
+}
+beforeEach(cleanup);
+afterAll(cleanup);
+
+function seed(): { taskId: string } {
+  db.run(`INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?2, 'x', 'user', datetime('now'))`, [USER_ID, USER_ID]);
+  db.run(`INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?2, ?3, datetime('now'))`, [NET_ID, NET_ID, USER_ID]);
+  db.run(`INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))`, [USER_ID, NET_ID]);
+  db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, hostname, created_at, updated_at, lifecycle_state) VALUES (?1, ?2, ?3, ?4, ?5, datetime('now'), datetime('now'), 'active')`, [NODE_ID, AGENT_ALIAS, AGENT_ALIAS, NET_ID, `host-${AGENT_ALIAS}`]);
+  db.run(`INSERT INTO sessions (resume_id, alias, status, node_id, network_id, updated_at, last_seen_at) VALUES (?1, ?2, 'idle', ?3, ?4, datetime('now'), datetime('now'))`, [`res_${AGENT_ALIAS}`, AGENT_ALIAS, NODE_ID, NET_ID]);
+  // The reply TARGET session (the task originator). Its alias is what the
+  // handler must derive from the task's from_name.
+  db.run(`INSERT INTO sessions (resume_id, alias, status, network_id, updated_at, last_seen_at) VALUES (?1, ?2, 'idle', ?3, datetime('now'), datetime('now'))`, [`res_${ORIGIN_ALIAS}`, ORIGIN_ALIAS, NET_ID]);
+  // A task from ORIGIN_ALIAS → the worker. Replying to it should land on
+  // ORIGIN_ALIAS even when the caller omits alias.
+  const taskId = `task_1085_${Date.now()}${Math.floor(Math.random() * 1000)}`;
+  db.run(`INSERT INTO tasks (task_id, from_name, to_name, status, content, requires_response, created_at, delivered_at, expires_at, network_id, priority) VALUES (?1, ?2, ?3, 'delivered', 'do the thing', 'reply', datetime('now'), datetime('now'), datetime('now', '+1 hour'), ?4, 'normal')`, [taskId, ORIGIN_ALIAS, AGENT_ALIAS, NET_ID]);
+  return { taskId };
+}
+
+async function getHandler(): Promise<ToolHandler> {
+  const server = new McpServer({ name: "test", version: "0" });
+  const tools: Record<string, ToolHandler> = {};
+  const originalTool = (server as any).tool.bind(server);
+  (server as any).tool = (name: string, ...rest: any[]) => {
+    const handler = rest[rest.length - 1];
+    if (typeof handler === "function") tools[name] = handler;
+    return originalTool(name, ...rest);
+  };
+  registerTools(server, {
+    enforceNetworkId: NET_ID,
+    enforceUserId: USER_ID,
+    callerAlias: AGENT_ALIAS,
+    callerTokenIsNetwork: true,
+    callerTokenId: AGENT_TOK_ID,
+  } as any);
+  const handler = tools.send_reply;
+  if (!handler) throw new Error("send_reply handler not registered");
+  return handler;
+}
+
+async function call(h: ToolHandler, args: any): Promise<Reply> {
+  return JSON.parse((await h(args)).content[0].text) as Reply;
+}
+
+describe("#1085 send_reply — alias optional, derived from in_reply_to", () => {
+  test("alias OMITTED + in_reply_to set → derives target from task from_name, reply lands on originator", async () => {
+    const { taskId } = seed();
+    const h = await getHandler();
+    const r = await call(h, { in_reply_to: taskId, text: "done", status: "replied", from_session: AGENT_ALIAS });
+    expect(r.ok).toBe(true);
+    // The reply inbox row must be addressed to the derived originator.
+    const row = db.get<{ session_name: string; in_reply_to: string }>(
+      "SELECT session_name, in_reply_to FROM inbox WHERE id = ?1", [r.message_id],
+    );
+    expect(row?.session_name).toBe(ORIGIN_ALIAS);
+    expect(row?.in_reply_to).toBe(taskId);
+    // And the original task is terminalized (no longer pending).
+    const task = db.get<{ status: string }>("SELECT status FROM tasks WHERE task_id = ?1", [taskId]);
+    expect(task?.status).toBe("replied");
+  });
+
+  test("alias EXPLICIT still works (unchanged path)", async () => {
+    const { taskId } = seed();
+    const h = await getHandler();
+    const r = await call(h, { alias: ORIGIN_ALIAS, in_reply_to: taskId, text: "done", from_session: AGENT_ALIAS });
+    expect(r.ok).toBe(true);
+    const row = db.get<{ session_name: string }>("SELECT session_name FROM inbox WHERE id = ?1", [r.message_id]);
+    expect(row?.session_name).toBe(ORIGIN_ALIAS);
+  });
+
+  test("alias OMITTED + no in_reply_to → clean error, not a crash", async () => {
+    seed();
+    const h = await getHandler();
+    const r = await call(h, { text: "orphan reply", from_session: AGENT_ALIAS });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("reply_target_required");
+  });
+
+  test("alias OMITTED + in_reply_to points at nonexistent task → resolve error", async () => {
+    seed();
+    const h = await getHandler();
+    const r = await call(h, { in_reply_to: "task_does_not_exist_1085", text: "x", from_session: AGENT_ALIAS });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("reply_target_unresolved");
+  });
+});

package/src/server.ts

@@ -1,4 +1,5 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { parseDbTimestampMs } from "./db-timestamp.js";
 import { resolvePort } from "./resolve-port.js";
 import { normalizeSessionRuntime } from "./runtime-label.js";
 import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
@@ -51,6 +52,7 @@ import { handleExternalScheduleEditRequest } from "./external-schedule-edits.js"
 import { recordDeliveredStaleEvents } from "./task-lifecycle-watcher.js";
 import { SIDE_THREAD_FEATURE_FLAG, SideThreadCoordinator, SideThreadPortRegistry, SideThreadStore, type SideThreadActor, type SideThreadAttachmentRef, type SideThreadExecutionPort } from "./side-thread.js";
 import { handleSideThreadHttpRequest } from "./side-thread-http.js";
+import { createProductionSideThreadTransport } from "./side-thread-production.js";
 
 const PORT = resolvePort(process.env.PORT);
 const HOST = process.env.HOST || "127.0.0.1";
@@ -77,6 +79,10 @@ const sideThreadCoordinator = new SideThreadCoordinator(new SideThreadStore(db),
   authorizeNode: (actor, networkId, nodeId) => authorizeSideThreadNode(actor, networkId, nodeId),
   authorizeAttachment: (actor, networkId, ref) => authorizeSideThreadAttachment(actor, networkId, ref),
 });
+const productionSideThreadTransport = process.env[SIDE_THREAD_FEATURE_FLAG] === "1"
+  ? createProductionSideThreadTransport(db)
+  : null;
+if (productionSideThreadTransport) installSideThreadExecutionPort(productionSideThreadTransport.port);
 
 if (AUTH_TOKEN) {
   console.warn("[commhub] COMMHUB_AUTH_TOKEN is deprecated and will be removed in v1.0. See RFC-001.");
@@ -1519,11 +1525,22 @@ return Bun.serve({
       return withCors(req, Response.json({ ok: false, error: restScope.denied }, { status: 403 }));
     }
 
+    const sideActor = resolveSideThreadActor(req, resolveRequestAuth(req, { allowQueryToken: false }), isAdmin);
+    const nodeCommandActor = sideActor?.kind === "node" && sideActor.boundNodeId && sideActor.boundNetworkId
+      ? { tokenId: sideActor.tokenId, networkId: sideActor.boundNetworkId, nodeId: sideActor.boundNodeId }
+      : null;
+    if (productionSideThreadTransport) {
+      const attachmentResponse = await productionSideThreadTransport.attachment(req, url, nodeCommandActor);
+      if (attachmentResponse) return withCors(req, attachmentResponse);
+      const commandResponse = await productionSideThreadTransport.handle({ req, url, actor: nodeCommandActor });
+      if (commandResponse) return withCors(req, commandResponse);
+    }
+
     const sideThreadResponse = await handleSideThreadHttpRequest({
       req,
       url,
       // Durable prompts/results never accept query-string credentials.
-      actor: resolveSideThreadActor(req, resolveRequestAuth(req, { allowQueryToken: false }), isAdmin),
+      actor: sideActor,
       coordinator: sideThreadCoordinator,
       resolveCapabilityTarget: resolveSideThreadCapabilityTarget,
     });
@@ -2992,7 +3009,10 @@ return Bun.serve({
       `, effectiveNetId);
 
       const nowMs = Date.now();
-      const ONLINE_MS = 60_000;
+      // 心跳周期是 3 分钟（agent-node/src/cli.ts 的 report_status 定时器），
+      // 窗口必须大于它，否则每次心跳后的 60s~180s 之间必然抖成 offline
+      // （通信评审牛 #1279 独审④）。取 5min，与仓内既有 stale 口径一致。
+      const ONLINE_MS = 5 * 60_000;
       const daemons = sqlRows
         .map(r => {
           let snapRole: string | null = null;
@@ -3010,7 +3030,7 @@ return Bun.serve({
           let lastSeenAt: string | null = null;
           if (r.session_last_seen) {
             lastSeenAt = r.session_last_seen;
-            const t = Date.parse(r.session_last_seen);
+            const t = parseDbTimestampMs(r.session_last_seen);
             if (!isNaN(t)) online = (nowMs - t) <= ONLINE_MS;
           }
           let runtimes: string[] = [];