@sleep2agi/commhub-server 0.9.0-preview.13 → 0.9.0-preview.131

package/src/scoped-secrets.ts

@@ -0,0 +1,124 @@
+// Short-lived management lane, not task/message text and not a secret archive.
+import { randomUUID } from 'node:crypto';
+import { db } from './db';
+import { getUserNetworkRole } from './auth';
+import { providerScanTargets } from './daemon-provider-snapshots';
+import { validScopedSecretKey } from './shared/scoped-secret-contract';
+type Human = { userId?: string | null; isNode: boolean; networkId: string | null };
+type Daemon = { ok: false; error: string } | { ok: true; networkId: string; daemonNodeId: string; daemonAlias: string };
+type Request = { request_id: string; network_id: string; daemon_node_id: string | null; node_id: string | null;
+  action: 'list' | 'put' | 'delete'; key?: string; value?: string; revision?: number;
+  status: 'pending' | 'succeeded' | 'failed' | 'expired'; expires_at: number; snapshot?: any; error?: string };
+const requests = new Map<string, Request>();
+const denied = (error: string) => ({ ok: false as const, error });
+function authorize(h: Human) {
+  return h.isNode || !h.userId ? denied('user_token_required') : !h.networkId
+    || !['owner','admin'].includes(getUserNetworkRole(h.userId, h.networkId) ?? '') ? denied('secret_admin_required') : null;
+}
+function daemonSupported(network: string, daemon: string) {
+  const row = db.get<{ config_snapshot: string }>('SELECT config_snapshot FROM nodes WHERE network_id=?1 AND node_id=?2', network, daemon);
+  try { const s = JSON.parse(row?.config_snapshot ?? '{}'); return s.role === 'host_supervisor' && s.scoped_secrets_capable === true; } catch { return false; }
+}
+function expire() {
+  for (const [id,r] of requests) {
+    if (r.expires_at < Date.now() && r.status === 'pending') { r.status = 'expired'; delete r.value; }
+    if (r.expires_at + 600_000 < Date.now()) requests.delete(id);
+  }
+}
+const timer = setInterval(expire, 10_000); timer.unref();
+function nodeSupported(network: string, node: string) {
+  const row = db.get<{ config_snapshot: string }>('SELECT config_snapshot FROM nodes WHERE network_id=?1 AND node_id=?2', network, node);
+  try { return JSON.parse(row?.config_snapshot ?? '{}').node_secrets_capable === true; } catch { return false; }
+}
+// Independent node lane: no supervisor lookup, binding, or Daemon credential.
+export function requestNodeSecrets(h: Human, node: string, action: Request['action'], key?: string, value?: string, revision?: number) {
+  const refusal = authorize(h); if (refusal) return refusal;
+  if (!nodeSupported(h.networkId!, node)) return denied('node_secrets_upgrade_required');
+  if (action !== 'list' && (!validScopedSecretKey(key) || !Number.isSafeInteger(revision) || revision! < 0
+    || (action === 'put' && (typeof value !== 'string' || !value || Buffer.byteLength(value) > 8192 || value.includes('\0'))))) return denied('invalid_secret_input');
+  expire();
+  if ([...requests.values()].some(r => r.network_id === h.networkId && r.daemon_node_id === null && r.node_id === node && r.status === 'pending')) return denied('secret_store_busy');
+  if (requests.size >= 1000) return denied('secret_queue_busy');
+  const r: Request = { request_id: `nsk_${randomUUID()}`, network_id: h.networkId!, daemon_node_id: null,
+    node_id: node, action, ...(action === 'list' ? {} : { key, revision, ...(action === 'put' ? { value } : {}) }),
+    expires_at: Date.now() + 120_000, status: 'pending' };
+  requests.set(r.request_id, r);
+  return { ok: true as const, request_id: r.request_id, status: r.status, expires_at: r.expires_at };
+}
+export function pullNodeSecrets(d: Daemon) {
+  if (!d.ok || !nodeSupported(d.networkId, d.daemonNodeId)) return denied('caller_not_a_secret_node');
+  expire();
+  return { ok: true, requests: [...requests.values()].filter(r => r.network_id === d.networkId && r.daemon_node_id === null
+    && r.node_id === d.daemonNodeId && r.status === 'pending').map(({ status, snapshot, error, ...input }) => input) };
+}
+export function ackNodeSecrets(d: Daemon, id: string, snapshot: any, failed = false) {
+  if (!d.ok || !nodeSupported(d.networkId, d.daemonNodeId)) return denied('caller_not_a_secret_node');
+  expire(); const r = requests.get(id);
+  if (!r || r.network_id !== d.networkId || r.daemon_node_id !== null || r.node_id !== d.daemonNodeId) return denied('request_not_found');
+  if (r.status !== 'pending') return { ok: r.status === 'succeeded' || r.status === 'failed', status: r.status };
+  if (!failed) {
+    if (!snapshot || Object.keys(snapshot).some(k => !['network_id','daemon_node_id','node_id','revision','activation','keys'].includes(k))
+      || snapshot.network_id !== r.network_id || snapshot.daemon_node_id !== null || snapshot.node_id !== r.node_id
+      || !Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0 || snapshot.activation !== 'next_start'
+      || !Array.isArray(snapshot.keys) || snapshot.keys.length > 128 || new Set(snapshot.keys.map((x:any)=>x?.key)).size !== snapshot.keys.length
+      || snapshot.keys.some((x:any)=>!x || Object.keys(x).some(k=>!['key','source'].includes(k)) || !validScopedSecretKey(x.key) || x.source !== 'node')
+      || (r.action !== 'list' && snapshot.revision !== r.revision! + 1)
+      || (r.action === 'put' && !snapshot.keys.some((x:any)=>x.key === r.key))
+      || (r.action === 'delete' && snapshot.keys.some((x:any)=>x.key === r.key))) return denied('invalid_secret_receipt');
+    r.snapshot = snapshot;
+  }
+  r.status = failed ? 'failed' : 'succeeded'; if (failed) r.error = 'secret_operation_unavailable'; delete r.value;
+  return { ok: true, status: r.status };
+}
+export function requestScopedSecrets(h: Human, daemon: string, node: string | null, action: Request['action'], key?: string, value?: string, revision?: number) {
+  const refusal = authorize(h); if (refusal) return refusal;
+  if (!daemonSupported(h.networkId!, daemon)) return denied('scoped_secrets_upgrade_required');
+  if (node !== null && !providerScanTargets(h.networkId!, daemon).some(t => t.node_id === node)) return denied('secret_target_not_bound');
+  if (action !== 'list' && (!validScopedSecretKey(key)
+    || !Number.isSafeInteger(revision) || revision! < 0 || (action === 'put' && (typeof value !== 'string' || !value || Buffer.byteLength(value) > 8192 || value.includes('\0'))))) return denied('invalid_secret_input');
+  expire();
+  if ([...requests.values()].some(r => r.network_id === h.networkId && r.daemon_node_id === daemon && r.status === 'pending')) return denied('secret_store_busy');
+  if (requests.size >= 1000) return denied('secret_queue_busy');
+  const r: Request = { request_id: `dsk_${randomUUID()}`, network_id: h.networkId!, daemon_node_id: daemon,
+    node_id: node, action, ...(action === 'list' ? {} : { key, revision, ...(action === 'put' ? { value } : {}) }),
+    expires_at: Date.now() + 120_000, status: 'pending' };
+  requests.set(r.request_id, r);
+  return { ok: true as const, request_id: r.request_id, status: r.status, expires_at: r.expires_at };
+}
+export function getScopedSecrets(h: Human, id: string) {
+  const refusal = authorize(h); if (refusal) return refusal; expire();
+  const r = requests.get(id);
+  if (!r || r.network_id !== h.networkId) return denied('request_not_found');
+  return { ok: true as const, request_id: id, daemon_node_id: r.daemon_node_id, node_id: r.node_id,
+    status: r.status, ...(r.snapshot ? { snapshot: r.snapshot } : {}), ...(r.error ? { error: r.error } : {}) };
+}
+export function pullScopedSecrets(d: Daemon) {
+  if (!d.ok || !daemonSupported(d.networkId, d.daemonNodeId)) return denied('caller_not_a_daemon'); expire();
+  const targets = providerScanTargets(d.networkId, d.daemonNodeId);
+  return { ok: true, requests: [...requests.values()].filter(r => r.network_id === d.networkId && r.daemon_node_id === d.daemonNodeId && r.status === 'pending')
+    .flatMap(r => {
+      if (r.node_id !== null && !targets.some(t => t.node_id === r.node_id)) { r.status = 'failed'; r.error = 'secret_target_not_bound'; delete r.value; return []; }
+      const { status, snapshot, error, ...input } = r;
+      return [{ ...input, targets }];
+    }) };
+}
+export function ackScopedSecrets(d: Daemon, id: string, snapshot: any, failed = false) {
+  if (!d.ok || !daemonSupported(d.networkId, d.daemonNodeId)) return denied('caller_not_a_daemon'); expire();
+  const r = requests.get(id);
+  if (!r || r.network_id !== d.networkId || r.daemon_node_id !== d.daemonNodeId) return denied('request_not_found');
+  if (r.status !== 'pending') return { ok: r.status === 'succeeded' || r.status === 'failed', status: r.status };
+  if (!failed) {
+    if (!snapshot || Object.keys(snapshot).some(k => !['network_id','daemon_node_id','node_id','revision','activation','keys'].includes(k))
+      || snapshot.network_id !== r.network_id || snapshot.daemon_node_id !== r.daemon_node_id || snapshot.node_id !== r.node_id
+      || !Number.isSafeInteger(snapshot.revision) || snapshot.revision < 0 || snapshot.activation !== 'next_start'
+      || !Array.isArray(snapshot.keys) || snapshot.keys.length > 256 || new Set(snapshot.keys.map((x:any)=>x.key)).size !== snapshot.keys.length
+      || snapshot.keys.some((x:any) => !x || Object.keys(x).some(k=>!['key','source'].includes(k)) || !validScopedSecretKey(x.key)
+        || !['daemon','node'].includes(x.source) || (r.node_id === null && x.source !== 'daemon'))
+      || (r.action !== 'list' && snapshot.revision !== r.revision! + 1)
+      || (r.action === 'put' && !snapshot.keys.some((x:any)=>x.key === r.key && x.source === (r.node_id ? 'node' : 'daemon')))) return denied('invalid_secret_receipt');
+    if (r.node_id !== null && !providerScanTargets(r.network_id,r.daemon_node_id).some(t=>t.node_id === r.node_id)) return denied('secret_target_not_bound');
+    r.snapshot = snapshot;
+  }
+  r.status = failed ? 'failed' : 'succeeded'; if (failed) r.error = 'secret_operation_unavailable'; delete r.value;
+  return { ok: true, status: r.status };
+}

package/src/send-dedup-request-id.test.ts

@@ -0,0 +1,229 @@
+// Handler-level regression for the #212 dedup window swallowing human chat
+// messages (see send_dedup.ts header, "Key selection").
+//
+// Before the fix, POST /api/task keyed the dedup window on
+// (from, to, sha256(content)) only and ignored meta.client_request_id, so a
+// user sending the same short text twice within 5 minutes got 200/429/429 and
+// ONE stored row — and the app maps that 429 to "delivered". The table below
+// is the repro, run against both transports:
+//
+//   case                              | before (REST) | after
+//   ----------------------------------+---------------+-------------------------
+//   same text, 3 different ids        | 1 row         | 3 rows, 3 x ok
+//   same text, same id (retry)        | 1 row         | 1 row, 2 x replay (same id)
+//   different text, same id           | 3 rows        | 1 row, 2 x idempotency_conflict
+//   same text, no id (#212 agents)    | 1 row         | 1 row, 2 x duplicate_send
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { register } from "./auth.js";
+import { db } from "./db.js";
+import { registerTools } from "./tools.js";
+import { sharedSendDedup } from "./send_dedup.js";
+
+const PRIVATE_DB_DIR = mkdtempSync(join(tmpdir(), "anet-send-dedup-rid-"));
+const TARGET = `dedup-rid-target-${process.pid}`;
+const TARGET_NODE_ID = `node_dedup_rid_${process.pid}`;
+
+let server: any;
+let base = "";
+let userToken = "";
+let restNet = "";
+let restUser = "";
+
+const MCP_NET = `net_dedup_rid_${process.pid}`;
+const MCP_USER = `user_dedup_rid_${process.pid}`;
+
+function rid(n: number): string {
+  // App shape: dreq_ + 32 lowercase hex.
+  return `dreq_${n.toString(16).padStart(32, "0")}`;
+}
+
+function seedTarget(networkId: string, suffix: string) {
+  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'))`,
+    [`resume_${TARGET_NODE_ID}_${suffix}`, TARGET, `${TARGET_NODE_ID}_${suffix}`, networkId],
+  );
+  db.run(
+    `INSERT INTO nodes (node_id, node_name, alias, network_id, created_at, updated_at, lifecycle_state)
+     VALUES (?1, ?2, ?2, ?3, datetime('now'), datetime('now'), 'active')`,
+    [`${TARGET_NODE_ID}_${suffix}`, TARGET, networkId],
+  );
+}
+
+beforeAll(async () => {
+  process.env.COMMHUB_DB = process.env.COMMHUB_DB || join(PRIVATE_DB_DIR, "hub.db");
+  restUser = `dedup_rid_${Date.now()}`;
+  const registered = register(restUser, "DedupRid123!", undefined, "seed");
+  expect(registered.ok).toBe(true);
+  userToken = registered.token!;
+  restNet = registered.network_id!;
+  seedTarget(restNet, "rest");
+
+  db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [MCP_USER]);
+  db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [MCP_NET, MCP_USER]);
+  db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [MCP_USER, MCP_NET]);
+  seedTarget(MCP_NET, "mcp");
+
+  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 {}
+  try { rmSync(PRIVATE_DB_DIR, { recursive: true, force: true }); } catch {}
+});
+
+beforeEach(() => {
+  for (const net of [restNet, MCP_NET]) {
+    if (!net) continue;
+    for (const table of ["tasks", "inbox", "task_events"]) {
+      try { db.run(`DELETE FROM ${table} WHERE network_id = ?1`, [net]); } catch {}
+    }
+  }
+  sharedSendDedup.clear();
+});
+
+function rowCount(networkId: string): number {
+  return db.get<{ n: number }>("SELECT COUNT(*) AS n FROM tasks WHERE network_id = ?1", [networkId])!.n;
+}
+function inboxCount(networkId: string): number {
+  return db.get<{ n: number }>("SELECT COUNT(*) AS n FROM inbox WHERE network_id = ?1", [networkId])!.n;
+}
+
+// ── REST ────────────────────────────────────────────────────────────────
+
+async function rest(task: string, requestId?: string): Promise<{ status: number; body: any }> {
+  const res = await fetch(`${base}/api/task`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${userToken}`, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      alias: TARGET,
+      task,
+      priority: "normal",
+      network_id: restNet,
+      from: restUser,
+      meta: requestId
+        ? { source: "dashboard-chat", client_request_id: requestId }
+        : { source: "dashboard-chat" },
+    }),
+  });
+  return { status: res.status, body: await res.json() };
+}
+
+describe("POST /api/task dedup key selection", () => {
+  test("same text with 3 different request ids -> 3 rows (the reported data loss)", async () => {
+    const results = [await rest("好", rid(1)), await rest("好", rid(2)), await rest("好", rid(3))];
+    expect(results.map((r) => r.status)).toEqual([200, 200, 200]);
+    const ids = results.map((r) => r.body.task_id);
+    expect(new Set(ids).size).toBe(3);
+    expect(rowCount(restNet)).toBe(3);
+    expect(inboxCount(restNet)).toBe(3);
+  });
+
+  test("same text with the same request id -> 1 row, retries replay the same task id", async () => {
+    const first = await rest("好", rid(7));
+    const second = await rest("好", rid(7));
+    const third = await rest("好", rid(7));
+    expect(first.status).toBe(200);
+    expect(second.status).toBe(200);
+    expect(third.status).toBe(200);
+    expect(second.body).toMatchObject({ ok: true, task_id: first.body.task_id, message_id: first.body.task_id, idempotent_replay: true });
+    expect(third.body.task_id).toBe(first.body.task_id);
+    expect(rowCount(restNet)).toBe(1);
+    expect(inboxCount(restNet)).toBe(1);
+  });
+
+  test("different text with the same request id -> 1 row, reuse fails closed (409)", async () => {
+    const first = await rest("第一条", rid(9));
+    const second = await rest("第二条", rid(9));
+    const third = await rest("第三条", rid(9));
+    expect(first.status).toBe(200);
+    expect(second.status).toBe(409);
+    expect(second.body.error).toBe("idempotency_conflict");
+    expect(third.status).toBe(409);
+    expect(rowCount(restNet)).toBe(1);
+  });
+
+  test("#212 guard: same text WITHOUT a request id is still deduped (429 duplicate_send)", async () => {
+    const results = [await rest("继续"), await rest("继续"), await rest("继续")];
+    expect(results.map((r) => r.status)).toEqual([200, 429, 429]);
+    expect(results[1].body.error).toBe("duplicate_send");
+    expect(rowCount(restNet)).toBe(1);
+  });
+
+  test("no request id, different text -> each goes through", async () => {
+    const results = [await rest("a"), await rest("b"), await rest("c")];
+    expect(results.map((r) => r.status)).toEqual([200, 200, 200]);
+    expect(rowCount(restNet)).toBe(3);
+  });
+});
+
+// ── MCP send_task ──────────────────────────────────────────────────────
+
+type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function mcpSendTask(): ToolHandler {
+  const mcp = new McpServer({ name: "dedup-rid-test", version: "0" }) as any;
+  let handler: ToolHandler | undefined;
+  const original = mcp.tool.bind(mcp);
+  mcp.tool = (name: string, description: string, schema: any, candidate: ToolHandler) => {
+    if (name === "send_task") handler = candidate;
+    return original(name, description, schema, candidate);
+  };
+  registerTools(mcp, undefined, MCP_NET, MCP_USER, MCP_USER, false, null);
+  if (!handler) throw new Error("send_task handler missing");
+  return handler;
+}
+
+async function mcp(handler: ToolHandler, task: string, requestId?: string): Promise<any> {
+  const result = await handler({
+    alias: TARGET,
+    task,
+    priority: "normal",
+    ...(requestId ? { meta: { source: "dashboard-chat", client_request_id: requestId } } : {}),
+  });
+  return JSON.parse(result.content[0].text);
+}
+
+describe("MCP send_task dedup key selection", () => {
+  test("same text with 3 different request ids -> 3 rows", async () => {
+    const h = mcpSendTask();
+    const results = [await mcp(h, "好", rid(11)), await mcp(h, "好", rid(12)), await mcp(h, "好", rid(13))];
+    expect(results.map((r) => r.ok)).toEqual([true, true, true]);
+    expect(new Set(results.map((r) => r.message_id)).size).toBe(3);
+    expect(rowCount(MCP_NET)).toBe(3);
+  });
+
+  test("same text with the same request id -> 1 row, replay returns the same task id", async () => {
+    const h = mcpSendTask();
+    const first = await mcp(h, "好", rid(17));
+    const second = await mcp(h, "好", rid(17));
+    const third = await mcp(h, "好", rid(17));
+    expect(first.ok).toBe(true);
+    expect(second).toMatchObject({ ok: true, task_id: first.message_id, idempotent_replay: true });
+    expect(third.task_id).toBe(first.message_id);
+    expect(rowCount(MCP_NET)).toBe(1);
+  });
+
+  test("different text with the same request id -> 1 row, idempotency_conflict", async () => {
+    const h = mcpSendTask();
+    expect((await mcp(h, "第一条", rid(19))).ok).toBe(true);
+    expect((await mcp(h, "第二条", rid(19))).error).toBe("idempotency_conflict");
+    expect((await mcp(h, "第三条", rid(19))).error).toBe("idempotency_conflict");
+    expect(rowCount(MCP_NET)).toBe(1);
+  });
+
+  test("#212 guard: same text WITHOUT a request id is still deduped", async () => {
+    const h = mcpSendTask();
+    const results = [await mcp(h, "继续"), await mcp(h, "继续"), await mcp(h, "继续")];
+    expect(results[0].ok).toBe(true);
+    expect(results[1].error).toBe("duplicate_send");
+    expect(results[2].error).toBe("duplicate_send");
+    expect(rowCount(MCP_NET)).toBe(1);
+  });
+});

package/src/send-reply-agent-warning.test.ts

@@ -0,0 +1,202 @@
+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";
+
+// #498 compatibility warning remains load-bearing during the mixed-version
+// rollout. Capability-negotiated agents use send_peer_reply; old send_reply
+// callers targeting an agent get explicit migration guidance while Dashboard
+// targets stay quiet.
+
+const NET_ID = "net_498_warn";
+const USER_ID = "u_498_warn";
+const NODE_ID = "node_498_warn";
+const AGENT_ALIAS = "peer-agent-498";
+const DISPATCHER_NODE_ID = "node_498_dispatcher";
+const DISPATCHER_ALIAS = "dispatcher";
+const AGENT_TOK_ID = "tok_498_warn";
+
+interface ToolHandler {
+  (args: any, extra?: any): Promise<{ content: Array<{ type: "text"; text: string }> }>;
+}
+interface Reply {
+  ok?: boolean;
+  message_id?: string;
+  session_status?: string;
+  warning?: string;
+  error?: string;
+  [k: string]: unknown;
+}
+
+function cleanup() {
+  try { db.run("DELETE FROM tasks WHERE network_id = ?1", [NET_ID]); } catch {}
+  try { db.run("DELETE FROM inbox WHERE network_id = ?1", [NET_ID]); } catch {}
+  try { db.run("DELETE FROM task_events WHERE network_id = ?1", [NET_ID]); } catch {}
+  try { db.run("DELETE FROM sessions WHERE network_id = ?1", [NET_ID]); } catch {}
+  try { db.run("DELETE FROM nodes WHERE network_id = ?1", [NET_ID]); } catch {}
+  try { db.run("DELETE FROM api_tokens WHERE network_id = ?1", [NET_ID]); } catch {}
+  try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET_ID]); } catch {}
+  try { db.run("DELETE FROM networks 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() {
+  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 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')`,
+    [DISPATCHER_NODE_ID, DISPATCHER_ALIAS, DISPATCHER_ALIAS, NET_ID, `host-${DISPATCHER_ALIAS}`],
+  );
+  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 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_${DISPATCHER_ALIAS}`, DISPATCHER_ALIAS, DISPATCHER_NODE_ID, NET_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],
+  );
+  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)`,
+    [AGENT_TOK_ID, USER_ID, NET_ID, `node:${AGENT_ALIAS}`, `hash_${AGENT_TOK_ID}`],
+  );
+}
+
+function makeTask(from: string): string {
+  const id = "t_" + Math.random().toString(36).slice(2, 14);
+  db.run(
+    `INSERT INTO tasks (task_id, from_name, to_name, to_node_id, priority, status, content, requires_response, created_at, network_id)
+     VALUES (?1, ?2, ?3, ?4, 'normal', 'delivered', 'test', 'reply', datetime('now'), ?5)`,
+    [id, from, AGENT_ALIAS, NODE_ID, NET_ID],
+  );
+  return id;
+}
+
+function buildHandlers(): Record<string, ToolHandler> {
+  const server = new McpServer({ name: "test", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const origTool = server.tool.bind(server);
+  server.tool = (name: string, _desc: string, _schema: any, handler: ToolHandler) => {
+    tools[name] = handler;
+    return origTool(name, _desc, _schema, handler);
+  };
+  const origRegisterTool = server.registerTool?.bind(server);
+  if (origRegisterTool) {
+    server.registerTool = (name: string, _cfg: any, handler: ToolHandler) => {
+      tools[name] = handler;
+      return origRegisterTool(name, _cfg, handler);
+    };
+  }
+  // Bind as a network token whose caller alias is the sender.
+  registerTools(
+    server,
+    undefined,
+    /* enforceNetworkId */ NET_ID,
+    /* enforceUserId */ USER_ID,
+    /* callerAlias */ AGENT_ALIAS,
+    /* callerTokenIsNetwork */ true,
+    /* callerTokenId */ AGENT_TOK_ID,
+  );
+  return tools;
+}
+
+async function call(handler: ToolHandler, args: any): Promise<Reply> {
+  const r = await handler(args);
+  return JSON.parse(r.content[0].text) as Reply;
+}
+
+describe("send_reply legacy/Dashboard compatibility (#698)", () => {
+  test("legacy call still closes the original and enqueues one no-response result", async () => {
+    seed();
+    const tools = buildHandlers();
+    const sendReply = tools["send_reply"];
+    expect(sendReply).toBeDefined();
+
+    const taskId = makeTask(DISPATCHER_ALIAS);
+    const reply = await call(sendReply, {
+      alias: DISPATCHER_ALIAS,
+      text: "peer reply (atomic)",
+      in_reply_to: taskId,
+      status: "replied",
+      from_session: AGENT_ALIAS,
+    });
+
+    expect(reply.ok).toBe(true);
+    expect(reply.warning).toContain("commhub_send_peer_reply");
+    expect(reply.warning).toContain("terminalized the original task");
+    expect(reply.warning).not.toContain("commhub_send_task");
+    expect(reply.warning).toContain("mixed-version");
+    expect(db.get<{ status: string; result: string }>(
+      "SELECT status, result FROM tasks WHERE task_id = ?1", taskId,
+    )).toEqual(expect.objectContaining({ status: "replied", result: "peer reply (atomic)" }));
+    expect(db.all<{ type: string; requires_response: string; session_name: string }>(
+      "SELECT type, requires_response, session_name FROM inbox WHERE in_reply_to = ?1", taskId,
+    )).toEqual([{ type: "reply", requires_response: "none", session_name: DISPATCHER_ALIAS }]);
+    expect(db.get<{ n: number }>(
+      "SELECT COUNT(*) AS n FROM tasks WHERE parent_task_id = ?1", taskId,
+    )?.n).toBe(0);
+  });
+
+  test("target alias is `hub` (Dashboard path) → NO warning field", async () => {
+    seed();
+    const tools = buildHandlers();
+    const sendReply = tools["send_reply"];
+
+    const taskId = makeTask("hub");
+    const reply = await call(sendReply, {
+      alias: "hub",
+      text: "dashboard reply",
+      in_reply_to: taskId,
+      status: "replied",
+      from_session: AGENT_ALIAS,
+    });
+
+    expect(reply.ok).toBe(true);
+    // Silence-affirms the Dashboard path. Every reply carrying a
+    // warning would train the LLM to ignore it, so absence here is
+    // load-bearing.
+    expect(reply.warning).toBeUndefined();
+  });
+
+  test("target alias is `api` (Dashboard path) → NO warning field", async () => {
+    seed();
+    const tools = buildHandlers();
+    const sendReply = tools["send_reply"];
+
+    const taskId = makeTask("api");
+    const reply = await call(sendReply, {
+      alias: "api",
+      text: "dashboard reply via api",
+      in_reply_to: taskId,
+      status: "replied",
+      from_session: AGENT_ALIAS,
+    });
+
+    expect(reply.ok).toBe(true);
+    expect(reply.warning).toBeUndefined();
+  });
+});