@sleep2agi/commhub-server 0.9.0-preview.60 → 0.9.0-preview.64

package/src/requirements.ts

@@ -0,0 +1,256 @@
+// 需求池。长期卡片，存在 Hub 上，手机和电脑读同一份。
+// 不是 tasks：tasks 是正在派给节点的活，状态由节点收尾。
+import { db } from "./db.js";
+import { addNetworkScope, canRestWriteNetwork, resolveRestWriteNetworkId, type RestNetworkScope } from "./network-scope.js";
+
+type RequestAuth = { userId: string; networkId: string | null; username: string } | null;
+
+export type RequirementsRequestContext = {
+  req: Request;
+  url: URL;
+  auth: RequestAuth;
+  isAdmin: boolean;
+  isNodeToken: boolean;
+  scope: RestNetworkScope;
+};
+
+const COLUMNS = new Set(["pool", "doing", "done"]);
+const PRIORITIES = new Set(["high", "normal", "low"]);
+const DUE = /^\d{4}-\d{2}-\d{2}$/;
+
+type Row = {
+  owner_json: string | null;
+  participants_json: string;
+  requirement_id: string;
+  network_id: string;
+  title: string;
+  column_name: string;
+  priority: string;
+  due_on: string | null;
+  assignee: string | null;
+  issues_json: string | null;
+  created_at: string;
+};
+
+function jsonError(error: string, status: number): Response {
+  return Response.json({ ok: false, error }, { status });
+}
+
+function dueOk(due: string): boolean {
+  if (!DUE.test(due)) return false;
+  const [y, m, d] = due.split("-").map(Number);
+  const dt = new Date(Date.UTC(y, m - 1, d));
+  return dt.getUTCFullYear() === y && dt.getUTCMonth() === m - 1 && dt.getUTCDate() === d;
+}
+
+const REPO = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const ISSUE_URL = /^https:\/\/github\.com\/([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)\/issues\/(\d+)\/?$/;
+
+function clipTitle(value: unknown): string {
+  return typeof value === "string" ? value.replace(/[\r\n\t]/g, " ").trim().slice(0, 120) : "";
+}
+
+function issueFromParts(repo: string, number: number, title: string) {
+  if (!REPO.test(repo) || !Number.isInteger(number) || number < 1 || number > 10_000_000) return null;
+  return { repo, number, title: clipTitle(title) };
+}
+
+function oneIssue(item: unknown) {
+  if (typeof item === "string") {
+    const m = ISSUE_URL.exec(item.trim());
+    return m ? issueFromParts(`${m[1]}/${m[2]}`, Number(m[3]), "") : null;
+  }
+  if (!item || typeof item !== "object") return null;
+  const row = item as Record<string, unknown>;
+  if (typeof row.url === "string") {
+    const m = ISSUE_URL.exec(row.url.trim());
+    if (m) return issueFromParts(`${m[1]}/${m[2]}`, Number(m[3]), clipTitle(row.title));
+  }
+  const repo = typeof row.repo === "string" ? row.repo.trim() : "";
+  const number = typeof row.number === "number" ? row.number : Number(row.number);
+  return issueFromParts(repo, number, clipTitle(row.title));
+}
+
+function normalizeIssues(raw: unknown) {
+  if (!Array.isArray(raw) || raw.length > 8) return null;
+  const out: { repo: string; number: number; title: string }[] = [];
+  const seen = new Set<string>();
+  for (const item of raw) {
+    const issue = oneIssue(item);
+    if (!issue) return null;
+    const key = `${issue.repo}#${issue.number}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(issue);
+  }
+  return out;
+}
+
+function storedIssues(raw: string | null) {
+  if (!raw) return [];
+  try {
+    const parsed = normalizeIssues(JSON.parse(raw));
+    return parsed ?? [];
+  } catch {
+    return [];
+  }
+}
+
+function toPublic(row: Row) {
+  return {
+    owner: row.owner_json ? JSON.parse(row.owner_json) : null,
+    participants: JSON.parse(row.participants_json || '[]'),
+    id: row.requirement_id,
+    name: row.title,
+    priority: row.priority,
+    assignee: row.assignee || "",
+    due: row.due_on || "",
+    column: row.column_name,
+    createdAt: row.created_at,
+    issues: storedIssues(row.issues_json),
+  };
+}
+
+async function bodyObject(req: Request): Promise<Record<string, unknown>> {
+  const value = await req.json();
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("invalid_json");
+  return value as Record<string, unknown>;
+}
+
+function writeNetwork(body: Record<string, unknown>, ctx: RequirementsRequestContext): string | null {
+  if (ctx.auth?.networkId) return ctx.auth.networkId;
+  if (typeof body.network_id === "string" && body.network_id.trim()) return body.network_id.trim();
+  return resolveRestWriteNetworkId(ctx.scope, ctx.auth, ctx.isAdmin);
+}
+
+function canWrite(ctx: RequirementsRequestContext, networkId: string | null): boolean {
+  return !ctx.isNodeToken && canRestWriteNetwork(ctx.auth, networkId, ctx.isAdmin);
+}
+
+const SELECT = "requirement_id, network_id, title, column_name, priority, due_on, assignee, issues_json, created_at, owner_json, participants_json";
+
+type PersonRef = { kind: 'user' | 'node'; id: string };
+function personRef(value: unknown, networkId: string): PersonRef {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('invalid_person');
+  const row = value as Record<string, unknown>;
+  if ((row.kind !== 'user' && row.kind !== 'node') || typeof row.id !== 'string' || !row.id.trim()) throw new Error('invalid_person');
+  const exists = row.kind === 'user'
+    ? db.get("SELECT 1 FROM network_members m JOIN users u ON u.user_id=m.user_id WHERE m.network_id=?1 AND m.user_id=?2", networkId, row.id)
+    : db.get("SELECT 1 FROM nodes WHERE network_id=?1 AND node_id=?2", networkId, row.id);
+  if (!exists) throw new Error('person_not_in_network');
+  return { kind: row.kind, id: row.id };
+}
+
+function assignments(body: Record<string, unknown>, networkId: string, current?: Row) {
+  const owner = 'owner' in body ? body.owner === null ? null : personRef(body.owner, networkId) : current?.owner_json ? JSON.parse(current.owner_json) : null;
+  let participants = current ? JSON.parse(current.participants_json || '[]') : [];
+  if ('participants' in body) {
+    if (!Array.isArray(body.participants) || body.participants.length > 100) throw new Error('invalid_participants');
+    const refs = body.participants.map(value => personRef(value, networkId));
+    participants = [...new Map(refs.map(ref => [`${ref.kind}:${ref.id}`, ref])).values()];
+  }
+  return { ownerJson: owner === null ? null : JSON.stringify(owner), participantsJson: JSON.stringify(participants) };
+}
+
+export async function handleRequirementsRequest(ctx: RequirementsRequestContext): Promise<Response | null> {
+  const { req, url } = ctx;
+  if (url.pathname !== "/api/requirements" && !url.pathname.startsWith("/api/requirements/")) return null;
+  if (ctx.isNodeToken) return jsonError("user_token_required", 403);
+
+  if (url.pathname === '/api/requirements/people' && req.method === 'GET') {
+    const networkId = resolveRestWriteNetworkId(ctx.scope, ctx.auth, ctx.isAdmin);
+    if (!networkId) return jsonError('network_id_required', 400);
+    const users = db.all<{ id: string; name: string }>(
+      "SELECT u.user_id AS id, COALESCE(NULLIF(u.display_name,''), u.username) AS name FROM network_members m JOIN users u ON u.user_id=m.user_id WHERE m.network_id=?1 ORDER BY name, id", networkId,
+    );
+    const nodes = db.all<{ id: string; name: string }>(
+      "SELECT node_id AS id, COALESCE(NULLIF(display_name,''), NULLIF(alias,''), node_name) AS name FROM nodes WHERE network_id=?1 ORDER BY name, id", networkId,
+    );
+    return Response.json({ ok: true, people: [...users.map(row => ({ ...row, kind: 'user', networkId })), ...nodes.map(row => ({ ...row, kind: 'node', networkId }))] });
+  }
+
+  if (url.pathname === "/api/requirements" && req.method === "GET") {
+    const params: unknown[] = [];
+    let sql = `SELECT ${SELECT} FROM requirements WHERE 1=1`;
+    sql = addNetworkScope(sql, params, ctx.scope);
+    sql += " ORDER BY created_at DESC LIMIT 500";
+    const rows = db.all<Row>(sql, ...params).map(toPublic);
+    return Response.json({ ok: true, requirements: rows });
+  }
+
+  if (url.pathname === "/api/requirements" && req.method === "POST") {
+    let body: Record<string, unknown>;
+    try { body = await bodyObject(req); } catch { return jsonError("invalid_json", 400); }
+    const networkId = writeNetwork(body, ctx);
+    if (!networkId) return jsonError("network_id_required", 400);
+    if (!canWrite(ctx, networkId)) return jsonError("permission_denied", 403);
+    const name = typeof body.name === "string" ? body.name.trim() : "";
+    if (!name || name.length > 80) return jsonError("invalid_name", 400);
+    const priority = typeof body.priority === "string" ? body.priority : "normal";
+    if (!PRIORITIES.has(priority)) return jsonError("invalid_priority", 400);
+    const due = typeof body.due === "string" ? body.due.trim() : "";
+    if (due && !dueOk(due)) return jsonError("invalid_due", 400);
+    const assignee = typeof body.assignee === "string" ? body.assignee.trim().slice(0, 80) : "";
+    const clientId = typeof body.client_id === "string" ? body.client_id.trim() : "";
+    if (clientId && !/^[A-Za-z0-9._-]{1,80}$/.test(clientId)) return jsonError("invalid_client_id", 400);
+    const column = typeof body.column === "string" && COLUMNS.has(body.column) ? body.column : "pool";
+    const issues = body.issues === undefined ? [] : normalizeIssues(body.issues);
+    if (issues === null) return jsonError("invalid_issues", 400);
+    if (clientId) {
+      const existing = db.get<Row>(
+        `SELECT ${SELECT} FROM requirements WHERE network_id = ?1 AND client_id = ?2`,
+        networkId, clientId,
+      );
+      if (existing) return Response.json({ ok: true, requirement: toPublic(existing) });
+    }
+    const id = `req_${crypto.randomUUID()}`;
+    const createdAt = new Date().toISOString();
+    let people;
+    try { people = assignments(body, networkId); } catch (e) { return jsonError((e as Error).message, 400); }
+    try {
+      db.run(
+        `INSERT INTO requirements
+         (requirement_id, network_id, title, column_name, priority, due_on, assignee, client_id, issues_json, created_by, created_at, updated_at, owner_json, participants_json)
+         VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?11, ?12, ?13)`,
+        [id, networkId, name, column, priority, due || null, assignee, clientId || null, JSON.stringify(issues), ctx.auth?.userId ?? null, createdAt, people.ownerJson, people.participantsJson],
+      );
+    } catch {
+      if (!clientId) return jsonError("insert_failed", 500);
+      const existing = db.get<Row>(
+        `SELECT ${SELECT} FROM requirements WHERE network_id = ?1 AND client_id = ?2`,
+        networkId, clientId,
+      );
+      if (!existing) return jsonError("insert_failed", 500);
+      return Response.json({ ok: true, requirement: toPublic(existing) });
+    }
+    const created = db.get<Row>(`SELECT ${SELECT} FROM requirements WHERE requirement_id = ?1`, id)!;
+    return Response.json({ ok: true, requirement: toPublic(created) }, { status: 201 });
+  }
+
+  const match = url.pathname.match(/^\/api\/requirements\/([^/]+)$/);
+  if (!match || req.method !== "PATCH") return jsonError("not_found", 404);
+  const id = decodeURIComponent(match[1]);
+  let body: Record<string, unknown>;
+  try { body = await bodyObject(req); } catch { return jsonError("invalid_json", 400); }
+  const hasColumn = 'column' in body;
+  const hasIssues = Object.prototype.hasOwnProperty.call(body, "issues");
+  if (!hasColumn && !hasIssues && !('owner' in body) && !('participants' in body)) return jsonError('empty_patch', 400);
+  if (hasColumn && !COLUMNS.has(String(body.column))) return jsonError("invalid_column", 400);
+  const issues = hasIssues ? normalizeIssues(body.issues) : null;
+  if (hasIssues && issues === null) return jsonError("invalid_issues", 400);
+  const params: unknown[] = [id];
+  let sql = `SELECT ${SELECT} FROM requirements WHERE requirement_id = ?1`;
+  sql = addNetworkScope(sql, params, ctx.scope);
+  const row = db.get<Row>(sql, ...params);
+  if (!row) return jsonError("requirement_not_found", 404);
+  if (!canWrite(ctx, row.network_id)) return jsonError("permission_denied", 403);
+  let people;
+  try { people = assignments(body, row.network_id, row); } catch (e) { return jsonError((e as Error).message, 400); }
+  const updatedAt = new Date().toISOString();
+  db.run(
+    "UPDATE requirements SET column_name = ?1, updated_at = ?2, owner_json = ?4, participants_json = ?5, issues_json = ?6 WHERE requirement_id = ?3",
+    [hasColumn ? body.column : row.column_name, updatedAt, row.requirement_id, people.ownerJson, people.participantsJson, hasIssues ? JSON.stringify(issues) : row.issues_json],
+  );
+  const updated = db.get<Row>(`SELECT ${SELECT} FROM requirements WHERE requirement_id = ?1`, row.requirement_id)!;
+  return Response.json({ ok: true, requirement: toPublic(updated) });
+}

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_dedup.test.ts

@@ -146,6 +146,60 @@ describe("SendDedup", () => {
   });
 });
 
+describe("SendDedup key selection (client_request_id vs content)", () => {
+  const t0 = 1_700_000_000_000;
+  const A = "dreq_00000000000000000000000000000001";
+  const B = "dreq_00000000000000000000000000000002";
+
+  it("keyFor picks the request id when present, content hash otherwise", () => {
+    const withId = SendDedup.keyFor("alice", "bob", "好", { requestId: A, networkId: "net1" });
+    expect(withId.kind).toBe("request_id");
+    expect(withId.key).toBe(`rid|net1|alice|bob|${A}`);
+    const noId = SendDedup.keyFor("alice", "bob", "好", {});
+    expect(noId.kind).toBe("content");
+    expect(noId.key).toBe(SendDedup.key("alice", "bob", "好"));
+    // Empty / null ids fall back to the content key.
+    expect(SendDedup.keyFor("alice", "bob", "好", { requestId: "" }).kind).toBe("content");
+    expect(SendDedup.keyFor("alice", "bob", "好", { requestId: null }).kind).toBe("content");
+  });
+
+  it("same text with different request ids is never a duplicate", () => {
+    const d = new SendDedup({ windowMs: 300_000, maxKeys: 64 });
+    d.record("alice", "bob", "好", t0, { requestId: A });
+    expect(d.check("alice", "bob", "好", t0 + 1000, { requestId: B })).toEqual({ duplicate: false });
+  });
+
+  it("same request id is a duplicate even with different content (one id = one message)", () => {
+    const d = new SendDedup({ windowMs: 300_000, maxKeys: 64 });
+    d.record("alice", "bob", "first", t0, { requestId: A });
+    const again = d.check("alice", "bob", "second", t0 + 1000, { requestId: A });
+    expect(again.duplicate).toBe(true);
+    if (again.duplicate) expect(again.kind).toBe("request_id");
+  });
+
+  it("request-id keys are scoped by network, sender and target", () => {
+    const d = new SendDedup({ windowMs: 300_000, maxKeys: 64 });
+    d.record("alice", "bob", "x", t0, { requestId: A, networkId: "net1" });
+    expect(d.check("alice", "bob", "x", t0 + 1, { requestId: A, networkId: "net2" })).toEqual({ duplicate: false });
+    expect(d.check("carol", "bob", "x", t0 + 1, { requestId: A, networkId: "net1" })).toEqual({ duplicate: false });
+    expect(d.check("alice", "dave", "x", t0 + 1, { requestId: A, networkId: "net1" })).toEqual({ duplicate: false });
+  });
+
+  it("#212 regression guard: without an id, same content is still a duplicate and reports kind=content", () => {
+    const d = new SendDedup({ windowMs: 300_000, maxKeys: 64 });
+    d.record("agent", "peer", "same task", t0);
+    const again = d.check("agent", "peer", "same task", t0 + 1000);
+    expect(again.duplicate).toBe(true);
+    if (again.duplicate) expect(again.kind).toBe("content");
+  });
+
+  it("an id-bearing send does not shadow a later id-less send of the same text", () => {
+    const d = new SendDedup({ windowMs: 300_000, maxKeys: 64 });
+    d.record("alice", "bob", "好", t0, { requestId: A });
+    expect(d.check("alice", "bob", "好", t0 + 1000)).toEqual({ duplicate: false });
+  });
+});
+
 describe("buildDuplicateSendPayload", () => {
   it("contains the Chinese LLM-facing hint with target alias and window minutes", () => {
     const payload = buildDuplicateSendPayload({

package/src/send_dedup.ts

@@ -33,6 +33,26 @@
 //   - The structured response shape is identical between MCP and REST
 //     callers so the LLM gets the same parseable hint regardless of
 //     transport.
+//
+// Key selection (#2043, follow-up to #212): the content-hash key above is
+// only right for callers that have no other notion of "one message".
+// Human chat clients (the desktop/mobile app, the web Dashboard) mint a
+// fresh `meta.client_request_id` per message bubble and reuse it only
+// when retrying that same bubble. For those sends the content hash is the
+// WRONG identity: a user who types 「好」 twice within five minutes sent
+// two messages, and dropping the second one (while the app maps the 429
+// to "delivered") silently loses it. So:
+//   - a send WITH a valid client_request_id is keyed on
+//     (network, from, to, client_request_id) — a new id always proceeds,
+//     identical text or not; a same-id retry is answered from the durable
+//     tasks row by the handler (task-idempotency.ts) before this index is
+//     even consulted, so this key is defence in depth, not the primary
+//     replay mechanism;
+//   - a send WITHOUT one (agent / MCP / scripted traffic) keeps the #212
+//     content-hash window unchanged.
+// One id is one message: re-using an id with different content is a
+// client bug and the handlers fail it closed (`idempotency_conflict`)
+// rather than storing a second row or silently replaying the first.
 
 import { createHash } from "crypto";
 
@@ -61,9 +81,23 @@ export function readDedupConfig(env: NodeJS.ProcessEnv = process.env): DedupConf
   };
 }
 
+/** Which identity a dedup key was built from. Logged on every drop. */
+export type DedupKeyKind = "request_id" | "content";
+
+/**
+ * Optional per-send scope. When `requestId` is a non-empty string the key
+ * is the request id (scoped by network/from/to) instead of the content hash.
+ * Callers must pass the already-validated id (clientRequestIdFromMeta), not
+ * raw client input.
+ */
+export type DedupScope = {
+  requestId?: string | null;
+  networkId?: string | null;
+};
+
 export type DedupCheck =
   | { duplicate: false }
-  | { duplicate: true; lastSentMs: number; ageMs: number };
+  | { duplicate: true; lastSentMs: number; ageMs: number; kind: DedupKeyKind };
 
 export class SendDedup {
   private last = new Map<string, number>();
@@ -93,6 +127,18 @@ export class SendDedup {
     return `${from}|${to}|${hash}`;
   }
 
+  /**
+   * Pick the dedup identity for one send. A validated client request id
+   * wins over the content hash; see the header comment for why.
+   */
+  static keyFor(from: string, to: string, content: string, scope: DedupScope = {}): { key: string; kind: DedupKeyKind } {
+    const requestId = typeof scope.requestId === "string" && scope.requestId.length > 0 ? scope.requestId : null;
+    if (requestId) {
+      return { key: `rid|${scope.networkId ?? ""}|${from}|${to}|${requestId}`, kind: "request_id" };
+    }
+    return { key: SendDedup.key(from, to, content), kind: "content" };
+  }
+
   /**
    * Check whether (from, to, content) was sent recently. Returns
    * `{ duplicate: false }` when the call should proceed, or
@@ -103,10 +149,10 @@ export class SendDedup {
    * AFTER the underlying side effect (inbox insert + pushEvent) succeeds,
    * so failed sends don't accidentally block legitimate retries.
    */
-  check(from: string, to: string, content: string, nowMs: number = Date.now()): DedupCheck {
+  check(from: string, to: string, content: string, nowMs: number = Date.now(), scope: DedupScope = {}): DedupCheck {
     if (!this.enabled) return { duplicate: false };
     this.evictExpired(nowMs);
-    const k = SendDedup.key(from, to, content);
+    const { key: k, kind } = SendDedup.keyFor(from, to, content, scope);
     const lastSentMs = this.last.get(k);
     if (lastSentMs === undefined) return { duplicate: false };
     const ageMs = nowMs - lastSentMs;
@@ -114,13 +160,13 @@ export class SendDedup {
       this.last.delete(k);
       return { duplicate: false };
     }
-    return { duplicate: true, lastSentMs, ageMs };
+    return { duplicate: true, lastSentMs, ageMs, kind };
   }
 
   /** Record a successful send for future dedup checks. */
-  record(from: string, to: string, content: string, nowMs: number = Date.now()): void {
+  record(from: string, to: string, content: string, nowMs: number = Date.now(), scope: DedupScope = {}): void {
     if (!this.enabled) return;
-    const k = SendDedup.key(from, to, content);
+    const k = SendDedup.keyFor(from, to, content, scope).key;
     this.last.set(k, nowMs);
     if (this.last.size > this.cfg.maxKeys) this.evictOldest();
   }