@sleep2agi/commhub-server 0.9.0-preview.14 → 0.9.0-preview.140

package/src/scheduled-work-outcome-http.test.ts

@@ -0,0 +1,154 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { createNetworkTokenForNode, register } from "./auth.js";
+import { db, syncScheduledRunForTask } from "./db.js";
+import { runDueScheduledTasks } from "./scheduled-tasks.js";
+
+if (!process.env.COMMHUB_DB) throw new Error("test1274 requires an explicit disposable SQLite COMMHUB_DB");
+let server: any, base = "", network = "", ownerToken = "", ownerId = "";
+const stamp = Date.now(), nodes: Record<string, { id: string; alias: string; token: string; tokenId: string }> = {};
+async function rest(token: string, method: string, path: string, body?: unknown) {
+  const r = await fetch(base + path, { method, headers: { Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json" }, body: body === undefined ? undefined : JSON.stringify(body) });
+  return { status: r.status, body: await r.json() as any };
+}
+async function mcp(token: string, name: string, args: Record<string, unknown>) {
+  const r = await fetch(base + "/mcp", { method: "POST", headers: { Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }) });
+  const raw = await r.text(), line = raw.split("\n").find(x => x.startsWith("data: "));
+  const envelope = JSON.parse(line ? line.slice(6) : raw);
+  try { return JSON.parse(envelope.result.content[0].text); }
+  catch { return { ok: false, transportError: true }; }
+}
+const readRun = (taskId: string) => db.get<any>(
+  "SELECT run_id, schedule_id, status, work_outcome, work_outcome_node_id, schedule_revision FROM scheduled_task_runs WHERE task_id = ?1 AND network_id = ?2", taskId, network)!;
+const readTask = (taskId: string) => db.get<any>("SELECT status, result FROM tasks WHERE task_id = ?1", taskId)!;
+const countReplies = (taskId: string) => db.get<{ n: number }>("SELECT COUNT(*) AS n FROM inbox WHERE in_reply_to = ?1 AND type = 'reply'", taskId)!.n;
+async function fire() {
+  const created = await rest(ownerToken, "POST", "/api/scheduled-tasks", { network_id: network,
+    name: `test1274-${crypto.randomUUID()}`, target_node_id: nodes.a.id, task: "fixture1274 work",
+    schedule: { type: "interval", every_seconds: 120 }, timezone: "UTC" });
+  expect(created.status).toBe(201);
+  const scheduleId = created.body.schedule.schedule_id;
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id != ?2", [new Date(Date.now() + 86400_000).toISOString(), scheduleId]);
+  db.run("UPDATE scheduled_tasks SET next_run_at = ?1 WHERE schedule_id = ?2", [new Date(Date.now() - 1000).toISOString(), scheduleId]);
+  await runDueScheduledTasks();
+  const run = db.get<any>("SELECT task_id FROM scheduled_task_runs WHERE schedule_id = ?1", scheduleId)!;
+  expect(run.task_id).toBeTruthy();
+  return { taskId: run.task_id as string, scheduleId };
+}
+const reply = (taskId: string, meta?: unknown, status = "replied", token = nodes.a.token, extra = {}) =>
+  mcp(token, "send_reply", { in_reply_to: taskId, text: "本轮无新增", status, ...(meta === undefined ? {} : { meta }), ...extra });
+const cadence = (id: string) => db.get<any>("SELECT next_run_at, last_run_at, revision, schedule_json, target_node_id FROM scheduled_tasks WHERE schedule_id = ?1", id)!;
+
+beforeAll(async () => {
+  const owner = register(`work_owner_${stamp}`, "Fixture1274Only!x"); ownerToken = owner.token!;
+  network = owner.network_id!; ownerId = owner.user!.user_id;
+  for (const key of ["a", "b"]) {
+    const id = `n_work_${key}_${stamp}`, alias = `work-${key}-${stamp}`;
+    const token = createNetworkTokenForNode(ownerId, network, alias, id); expect(token.ok).toBe(true);
+    nodes[key] = { id, alias, token: token.token!, tokenId: token.token_id! };
+    db.run("INSERT INTO sessions (resume_id, alias, status, node_id, network_id) VALUES (?1, ?2, 'idle', ?3, ?4)", [`r_${id}`, alias, id, network]);
+  }
+  const mod = await import("./server.js"); server = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  base = `http://127.0.0.1:${server.port}`;
+}, 30_000);
+afterAll(() => server?.stop?.(true));
+
+describe("#1274 exact successful scheduler work outcomes over real HTTP/MCP", () => {
+  test("explicit no_changes persists with the same successful run and is readable; cadence stays unchanged", async () => {
+    const { taskId, scheduleId } = await fire(), before = cadence(scheduleId);
+    expect(readRun(taskId).schedule_revision).toBe(before.revision);
+    const out = await reply(taskId, { scheduled_work_outcome: "no_changes", scheduled_run_id: "forged-and-ignored" });
+    expect(out.ok).toBe(true); expect(out.scheduled_work_outcome).toBe("no_changes");
+    expect(readTask(taskId).status).toBe("replied");
+    expect(readRun(taskId)).toMatchObject({ status: "replied", work_outcome: "no_changes", work_outcome_node_id: nodes.a.id });
+    expect(cadence(scheduleId)).toEqual(before);
+    const history = await rest(ownerToken, "GET", `/api/scheduled-tasks/${scheduleId}/runs`);
+    expect(history.status).toBe(200);
+    expect(history.body.runs[0]).toMatchObject({ task_id: taskId, work_outcome: "no_changes", schedule_revision: before.revision, work_outcome_node_id: nodes.a.id });
+  });
+  test("changed is explicit even when the reply's natural-language text says no changes", async () => {
+    const { taskId } = await fire(); expect((await reply(taskId, { scheduled_work_outcome: "changed" })).ok).toBe(true);
+    expect(readRun(taskId).work_outcome).toBe("changed");
+  });
+  test("legacy success and empty-looking text remain unknown with unchanged response shape", async () => {
+    const { taskId } = await fire(), out = await reply(taskId);
+    expect(out.ok).toBe(true); expect(out.scheduled_work_outcome).toBeUndefined();
+    expect(readRun(taskId)).toMatchObject({ status: "replied", work_outcome: null, work_outcome_node_id: null });
+  });
+  test("malformed, failed and cancelled signals do not write; ordinary terminal failures stay unknown", async () => {
+    for (const [status, value] of [["replied", null], ["replied", "empty"], ["failed", "no_changes"], ["cancelled", "no_changes"]]) {
+      const { taskId } = await fire(); expect((await reply(taskId, { scheduled_work_outcome: value }, status!)).ok).toBe(false);
+      expect(readTask(taskId).status).toBe("delivered"); expect(countReplies(taskId)).toBe(0);
+      expect((await reply(taskId, undefined, status!)).ok).toBe(true); expect(readRun(taskId).work_outcome).toBeNull();
+    }
+  });
+  test("sibling node and a human token cannot classify the assigned node's run", async () => {
+    const { taskId } = await fire();
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", nodes.b.token)).ok).toBe(false);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", ownerToken)).ok).toBe(false);
+    expect(readTask(taskId).status).toBe("delivered"); expect(readRun(taskId).work_outcome).toBeNull(); expect(countReplies(taskId)).toBe(0);
+  });
+  test("a foreign network token cannot classify or terminalize the run", async () => {
+    const { taskId } = await fire(), foreign = register(`work_foreign_${crypto.randomUUID()}`, "Fixture1274Only!x");
+    const token = createNetworkTokenForNode(foreign.user!.user_id, foreign.network_id!, `foreign-${crypto.randomUUID()}`, `n_${crypto.randomUUID()}`);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", token.token!)).ok).toBe(false);
+    expect(readTask(taskId).status).toBe("delivered"); expect(countReplies(taskId)).toBe(0);
+  });
+  test("a legacy unbound node token can still reply normally but cannot report a work signal", async () => {
+    const { taskId } = await fire();
+    db.run("UPDATE api_tokens SET bound_node_id = NULL WHERE token_id = ?1 AND network_id = ?2", [nodes.a.tokenId, network]);
+    try {
+      expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).toBe(false);
+      expect((await reply(taskId)).ok).toBe(true); expect(readRun(taskId).work_outcome).toBeNull();
+    } finally { db.run("UPDATE api_tokens SET bound_node_id = ?1 WHERE token_id = ?2 AND network_id = ?3", [nodes.a.id, nodes.a.tokenId, network]); }
+  });
+  test("forged schedule metadata on an ordinary task cannot become an authoritative occurrence", async () => {
+    const { scheduleId } = await fire(); const sent = await rest(ownerToken, "POST", "/api/task", { network_id: network, alias: nodes.a.alias, task: "ordinary1274" });
+    expect(sent.status).toBe(200);
+    expect((await reply(sent.body.task_id, { scheduled_work_outcome: "no_changes", scheduled_task_id: scheduleId })).ok).toBe(false);
+    expect(readTask(sent.body.task_id).status).toBe("delivered"); expect(countReplies(sent.body.task_id)).toBe(0);
+  });
+  test("multiple authoritative bindings refuse instead of fanning one outcome into two runs", async () => {
+    const { taskId, scheduleId } = await fire(), run = readRun(taskId), duplicate = `srun_dup_${crypto.randomUUID()}`;
+    db.run("INSERT INTO scheduled_task_runs (run_id, schedule_id, network_id, scheduled_for, task_id, status) VALUES (?1, ?2, ?3, ?4, ?5, 'delivered')", [duplicate, scheduleId, network, new Date(Date.now() + 86400_000).toISOString(), taskId]);
+    try { expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).error).toBe("scheduled_work_outcome_run_unresolved");
+      expect(readTask(taskId).status).toBe("delivered"); expect(countReplies(taskId)).toBe(0); }
+    finally { db.run("DELETE FROM scheduled_task_runs WHERE run_id = ?1", duplicate); }
+    expect(readRun(taskId).run_id).toBe(run.run_id); expect(readRun(taskId).work_outcome).toBeNull();
+  });
+  test("expired/late receipts never classify a run or rewrite its original terminal state", async () => {
+    const { taskId } = await fire(), thread_id = `thread_${crypto.randomUUID()}`, turn_id = `turn_${crypto.randomUUID()}`;
+    db.run("UPDATE tasks SET status = 'expired', thread_id = ?1, turn_id = ?2, completed_at = datetime('now') WHERE task_id = ?3", [thread_id, turn_id, taskId]); syncScheduledRunForTask(taskId, network);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" }, "replied", nodes.a.token, { thread_id, turn_id })).error).toBe("scheduled_work_outcome_terminal");
+    expect((await reply(taskId, undefined, "replied", nodes.a.token, { thread_id, turn_id })).late).toBe(true);
+    expect(readTask(taskId).status).toBe("expired"); expect(readRun(taskId)).toMatchObject({ status: "expired", work_outcome: null });
+  });
+  test("success cannot retry; an expired fixture task clears stale outcome on retry and later failure", async () => {
+    const { taskId } = await fire(); expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+    expect((await mcp(ownerToken, "retry_task", { task_id: taskId, network_id: network })).ok).toBe(false);
+    // Fixture-only legacy/corrupt terminal injection: preserve the stale run
+    // signal deliberately so the retry clearing branch is load-bearing.
+    db.run("UPDATE tasks SET status = 'expired' WHERE task_id = ?1", taskId);
+    expect((await mcp(ownerToken, "retry_task", { task_id: taskId, network_id: network })).ok).toBe(true);
+    expect(readRun(taskId)).toMatchObject({ status: "delivered", work_outcome: null, work_outcome_node_id: null });
+    expect((await reply(taskId, undefined, "failed")).ok).toBe(true); expect(readRun(taskId)).toMatchObject({ status: "failed", work_outcome: null });
+  });
+  test("injected outcome write failure rolls back task, inbox and run atomically", async () => {
+    const { taskId } = await fire(), run = readRun(taskId);
+    db.exec(`CREATE TRIGGER test1274_outcome_fault BEFORE UPDATE OF work_outcome ON scheduled_task_runs WHEN NEW.run_id = '${run.run_id}' AND NEW.work_outcome IS NOT NULL BEGIN SELECT RAISE(ABORT, 'test1274_fault'); END`);
+    try { expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).not.toBe(true); }
+    finally { db.exec("DROP TRIGGER test1274_outcome_fault"); }
+    expect(readTask(taskId)).toMatchObject({ status: "delivered", result: null });
+    expect(readRun(taskId)).toMatchObject({ status: "delivered", work_outcome: null }); expect(countReplies(taskId)).toBe(0);
+    expect((await reply(taskId, { scheduled_work_outcome: "changed" })).ok).toBe(true);
+  });
+  test("a later schedule edit cannot relabel the dispatch revision; history alone grants no backoff", async () => {
+    const { taskId, scheduleId } = await fire(), revision = readRun(taskId).schedule_revision;
+    const edit = await rest(ownerToken, "PATCH", `/api/scheduled-tasks/${scheduleId}`, { revision, name: "edited1274" }); expect(edit.status).toBe(200);
+    const before = cadence(scheduleId); expect(before.revision).toBe(revision + 1);
+    expect((await reply(taskId, { scheduled_work_outcome: "no_changes" })).ok).toBe(true);
+    expect(readRun(taskId).schedule_revision).toBe(revision); expect(cadence(scheduleId)).toEqual(before);
+  });
+});

package/src/scheduled-work-outcome.ts

@@ -0,0 +1,50 @@
+import { db } from "./db.js";
+
+export type ScheduledWorkOutcome = "changed" | "no_changes";
+export function parseScheduledWorkOutcome(meta: unknown, status: string):
+  { ok: true; outcome?: ScheduledWorkOutcome } | { ok: false; error: string } {
+  if (!meta || typeof meta !== "object" || Array.isArray(meta)
+    || !Object.hasOwn(meta, "scheduled_work_outcome")) return { ok: true };
+  const outcome = (meta as Record<string, unknown>).scheduled_work_outcome;
+  if (outcome !== "changed" && outcome !== "no_changes")
+    return { ok: false, error: "invalid_scheduled_work_outcome" };
+  if (status !== "replied") return { ok: false, error: "scheduled_work_outcome_requires_success" };
+  return { ok: true, outcome };
+}
+
+type Binding = { run_id: string; schedule_id: string; task_id: string; network_id: string; node_id: string };
+/** Called within the normal reply transaction, after the existing sender and
+ * recipient checks. Caller metadata never supplies schedule/run bindings. */
+export function qualifyScheduledWorkOutcome(taskId: string, networkId: string, nodeId: string | null):
+  { ok: true; binding: Binding } | { ok: false; error: string } {
+  if (!nodeId) return { ok: false, error: "scheduled_work_outcome_bound_node_required" };
+  if (db.transactionalFeaturesRefusal !== null)
+    return { ok: false, error: "scheduled_work_outcome_backend_unsupported" };
+  const task = db.get<{ to_node_id: string | null; from_name: string; status: string }>(
+    "SELECT to_node_id, from_name, status FROM tasks WHERE task_id = ?1 AND network_id = ?2", taskId, networkId);
+  if (!task || task.to_node_id !== nodeId || task.from_name !== "scheduler"
+    || !["created", "delivered", "acked", "running"].includes(task.status))
+    return { ok: false, error: "scheduled_work_outcome_task_not_owned" };
+  const runs = db.all<{ run_id: string; schedule_id: string; status: string; work_outcome: string | null }>(
+    `SELECT r.run_id, r.schedule_id, r.status, r.work_outcome FROM scheduled_task_runs r
+     WHERE r.task_id = ?1 AND r.network_id = ?2`, taskId, networkId);
+  if (runs.length !== 1 || !["queued", "delivered"].includes(runs[0].status) || runs[0].work_outcome !== null)
+    return { ok: false, error: "scheduled_work_outcome_run_unresolved" };
+  if (!db.get("SELECT schedule_id FROM scheduled_tasks WHERE schedule_id = ?1 AND network_id = ?2", runs[0].schedule_id, networkId))
+    return { ok: false, error: "scheduled_work_outcome_run_unresolved" };
+  return { ok: true, binding: { run_id: runs[0].run_id, schedule_id: runs[0].schedule_id,
+    task_id: taskId, network_id: networkId, node_id: nodeId } };
+}
+
+/** The task has just reached replied in this same transaction. An outcome
+ * write failure must roll back task, inbox and run together. No cadence write. */
+export function saveScheduledWorkOutcome(binding: Binding, outcome: ScheduledWorkOutcome): void {
+  const result = db.run(
+    `UPDATE scheduled_task_runs SET work_outcome = ?1, work_outcome_node_id = ?6
+     WHERE run_id = ?2 AND schedule_id = ?3 AND task_id = ?4 AND network_id = ?5
+       AND work_outcome IS NULL AND status IN ('queued', 'delivered')
+       AND EXISTS (SELECT 1 FROM tasks t WHERE t.task_id = ?4 AND t.network_id = ?5
+                   AND t.to_node_id = ?6 AND t.from_name = 'scheduler' AND t.status = 'replied')`,
+    [outcome, binding.run_id, binding.schedule_id, binding.task_id, binding.network_id, binding.node_id]);
+  if (result.changes !== 1) throw new Error("scheduled_work_outcome_atomic_write_failed");
+}

package/src/scoped-secrets.ts

@@ -0,0 +1,139 @@
+// 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';
+import { observeSecretWrite, transportOf } from './env-transport-gate.js';
+import { refusesPlainTransport } from './env-transport-policy.js';
+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();
+  // #1510 — transport gate (log-only by default). A `put` carries the secret, so
+  // that is the only action worth observing; delete/list leak nothing.
+  if (action === 'put') {
+    const transport = transportOf(h.networkId!, node);
+    if (refusesPlainTransport(transport)) return denied('secret_transport_plain');
+    observeSecretWrite(h.networkId!, node, `node_secret_${action}`);
+  }
+  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();
+  // #1510 — same observation on the daemon lane (the daemon applies the value).
+  if (action === 'put') {
+    const transport = transportOf(h.networkId!, daemon);
+    if (refusesPlainTransport(transport)) return denied('secret_transport_plain');
+    observeSecretWrite(h.networkId!, daemon, `secret_${action}`);
+  }
+  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);
+  });
+});