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

package/src/task-consumption.test.ts

@@ -0,0 +1,482 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { db } from "./db.js";
+import { dispatchScheduledOccurrence } from "./scheduled-tasks.js";
+import { registerTools } from "./tools.js";
+
+const NET = "net_task_consumption";
+const USER = "user_task_consumption";
+const NODE_A = "node_consumption_a";
+const NODE_B = "node_consumption_b";
+
+type ToolHandler = (args: any) => Promise<{ content: Array<{ type: "text"; text: string }> }>;
+
+function cleanup() {
+  for (const table of ["scheduled_task_runs", "scheduled_tasks", "tasks", "inbox", "task_events", "sessions", "nodes"]) {
+    try { db.run(`DELETE FROM ${table} WHERE network_id = ?1`, [NET]); } catch {}
+  }
+  try { db.run("DELETE FROM network_members WHERE network_id = ?1", [NET]); } catch {}
+  try { db.run("DELETE FROM networks WHERE network_id = ?1", [NET]); } catch {}
+  try { db.run("DELETE FROM users WHERE user_id = ?1", [USER]); } catch {}
+  try { db.run("DELETE FROM api_tokens WHERE network_id = ?1", [NET]); } catch {}
+}
+
+function seed() {
+  db.run("INSERT INTO users (user_id, username, password_hash, role, created_at) VALUES (?1, ?1, 'x', 'user', datetime('now'))", [USER]);
+  db.run("INSERT INTO networks (network_id, network_name, owner_id, created_at) VALUES (?1, ?1, ?2, datetime('now'))", [NET, USER]);
+  db.run("INSERT INTO network_members (user_id, network_id, role, joined_at) VALUES (?1, ?2, 'owner', datetime('now'))", [USER, NET]);
+  for (const alias of [NODE_A, NODE_B]) {
+    db.run(
+      "INSERT INTO nodes (node_id, node_name, alias, network_id, hostname, created_at, updated_at, lifecycle_state) VALUES (?1, ?2, ?2, ?3, 'host', datetime('now'), datetime('now'), 'active')",
+      [`id_${alias}`, alias, NET],
+    );
+    db.run(
+      "INSERT INTO api_tokens (token_id, token_hash, user_id, network_id, name, bound_node_id) VALUES (?1, ?1, ?2, ?3, ?4, ?5)",
+      [`token_${alias}`, USER, NET, alias, `id_${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'))",
+      [`resume_${alias}`, alias, `id_${alias}`, NET],
+    );
+  }
+}
+
+function toolsFor(opts: { alias?: string; nodeToken?: boolean } = {}) {
+  const server = new McpServer({ name: "task-consumption-test", version: "0" }) as any;
+  const tools: Record<string, ToolHandler> = {};
+  const original = server.tool.bind(server);
+  server.tool = (name: string, description: string, schema: any, handler: ToolHandler) => {
+    tools[name] = handler;
+    return original(name, description, schema, handler);
+  };
+  registerTools(
+    server,
+    undefined,
+    NET,
+    USER,
+    opts.alias ?? USER,
+    opts.nodeToken ?? false,
+    opts.nodeToken ? `token_${opts.alias}` : null,
+  );
+  return tools;
+}
+
+async function call(handler: ToolHandler, args: any) {
+  const result = await handler(args);
+  return JSON.parse(result.content[0].text);
+}
+
+async function createTask(content: string, target = NODE_A): Promise<string> {
+  // The test calls the registered handler directly, bypassing MCP/Zod's
+  // default-value application, so spell out the production default.
+  const sent = await call(toolsFor()["send_task"], {
+    alias: target,
+    task: content,
+    priority: "normal",
+  });
+  expect(sent.ok).toBe(true);
+  return sent.task_id ?? sent.message_id;
+}
+
+function consumedAt(taskId: string): string | null {
+  return db.get<{ consumed_at: string | null }>(
+    "SELECT consumed_at FROM tasks WHERE task_id = ?1",
+    taskId,
+  )?.consumed_at ?? null;
+}
+
+function runtimeSubmittedAt(taskId: string): string | null {
+  return db.get<{ runtime_submitted_at: string | null }>(
+    "SELECT runtime_submitted_at FROM tasks WHERE task_id = ?1",
+    taskId,
+  )?.runtime_submitted_at ?? null;
+}
+
+function runtimeContext(taskId: string): { thread_id: string | null; turn_id: string | null } {
+  return db.get<{ thread_id: string | null; turn_id: string | null }>(
+    "SELECT thread_id, turn_id FROM tasks WHERE task_id = ?1",
+    taskId,
+  )!;
+}
+
+beforeEach(() => { cleanup(); seed(); });
+afterAll(cleanup);
+
+describe("task consumed_at identity and lifecycle", () => {
+  test("immutable node cursor paginates beyond 100 without alias or cross-node leakage", async () => {
+    for (let i = 0; i < 125; i++) {
+      db.run(
+        `INSERT INTO tasks (task_id, from_node_id, from_name, to_name, status, content, network_id, created_at)
+         VALUES (?1, ?2, ?3, ?4, 'replied', 'x', ?5, ?6)`,
+        [`page-${String(i).padStart(3, "0")}`, `id_${NODE_A}`, i < 60 ? "old-alias" : NODE_A, NODE_B, NET, `2026-01-01 00:${String(Math.floor(i / 60)).padStart(2, "0")}:${String(i % 60).padStart(2, "0")}`],
+      );
+    }
+    db.run(
+      `INSERT INTO tasks (task_id, from_node_id, from_name, to_name, status, content, network_id)
+       VALUES ('foreign-node-row', ?1, ?2, ?3, 'replied', 'x', ?4)`,
+      [`id_${NODE_B}`, NODE_A, NODE_A, NET],
+    );
+    const handler = toolsFor({ alias: NODE_A, nodeToken: true }).list_tasks;
+    const first = await call(handler, { from_node_id: `id_${NODE_A}`, durable_cursor: true, limit: 100 });
+    expect(first.capability).toBe("list_tasks.immutable-node-cursor.v1");
+    expect(first.tasks).toHaveLength(100);
+    const second = await call(handler, { from_node_id: `id_${NODE_A}`, durable_cursor: true, limit: 100, ...first.next_cursor });
+    expect(second.tasks).toHaveLength(25);
+    expect(new Set([...first.tasks, ...second.tasks].map((task: any) => task.task_id)).size).toBe(125);
+    expect([...first.tasks, ...second.tasks].some((task: any) => task.task_id === "foreign-node-row")).toBe(false);
+    expect((await call(handler, { from_node_id: `id_${NODE_B}`, durable_cursor: true, limit: 100 })).error).toBe("from_node_id_identity_mismatch");
+  });
+  test("a legacy unbound node token is refused the durable cursor even for its own node", async () => {
+    // Pre-RFC-036 tokens carry no immutable node binding. The durable outbox
+    // cursor must stay closed to them (no bind-on-first-use); agent-node
+    // degrades to inbox-only compensation on this exact error code.
+    db.run("UPDATE api_tokens SET bound_node_id = NULL WHERE token_id = ?1", [`token_${NODE_A}`]);
+    const handler = toolsFor({ alias: NODE_A, nodeToken: true }).list_tasks;
+    expect((await call(handler, { from_node_id: `id_${NODE_A}`, durable_cursor: true, limit: 10 })).error).toBe("from_node_id_identity_mismatch");
+    expect((await call(handler, { from_node_id: `id_${NODE_B}`, durable_cursor: true, limit: 10 })).error).toBe("from_node_id_identity_mismatch");
+    const bound = db.get<{ bound_node_id: string | null }>("SELECT bound_node_id FROM api_tokens WHERE token_id = ?1", `token_${NODE_A}`);
+    expect(bound?.bound_node_id).toBeNull();
+  });
+  test("terminal sequence paginates beyond 2000 and admits late completion of an old task", async () => {
+    db.run(
+      `INSERT INTO tasks (task_id, from_node_id, from_name, to_name, status, content, network_id, created_at)
+       VALUES ('old-open-task', ?1, 'renamed-sender', ?2, 'running', 'late', ?3, '2020-01-01 00:00:00')`,
+      [`id_${NODE_A}`, NODE_B, NET],
+    );
+    for (let i = 0; i < 2_001; i++) {
+      db.run(
+        `INSERT INTO tasks (task_id, from_node_id, from_name, to_name, status, content, network_id, created_at, completed_at)
+         VALUES (?1, ?2, ?3, ?4, 'replied', 'x', ?5, ?6, datetime('now'))`,
+        [`terminal-page-${String(i).padStart(4, "0")}`, `id_${NODE_A}`, i < 1_000 ? "old-alias" : NODE_A, NODE_B, NET, `2026-01-01 00:00:${String(i % 60).padStart(2, "0")}`],
+      );
+    }
+    db.run(
+      `INSERT INTO tasks (task_id, from_node_id, from_name, to_name, status, content, network_id)
+       VALUES ('terminal-cross-network', ?1, ?2, ?3, 'replied', 'x', 'other-network')`,
+      [`id_${NODE_A}`, NODE_A, NODE_B],
+    );
+    const handler = toolsFor({ alias: NODE_A, nodeToken: true }).list_tasks;
+    let after = 0;
+    const ids: string[] = [];
+    for (let page = 0; page < 30; page++) {
+      const response = await call(handler, {
+        from_node_id: `id_${NODE_A}`, durable_cursor: true, durable_terminal_cursor: true,
+        after_terminal_seq: after, limit: 100,
+      });
+      expect(response.capability).toBe("list_tasks.immutable-terminal-sequence.v2");
+      ids.push(...response.tasks.map((task: any) => task.task_id));
+      after = response.next_terminal_seq;
+      if (!response.has_more) break;
+    }
+    expect(ids).toHaveLength(2_001);
+    expect(new Set(ids).size).toBe(2_001);
+    expect(ids).not.toContain("terminal-cross-network");
+    db.run("UPDATE tasks SET status = 'failed', completed_at = datetime('now') WHERE task_id = 'old-open-task'");
+    const late = await call(handler, {
+      from_node_id: `id_${NODE_A}`, durable_cursor: true, durable_terminal_cursor: true,
+      after_terminal_seq: after, limit: 100,
+    });
+    expect(late.tasks.map((task: any) => task.task_id)).toEqual(["old-open-task"]);
+  }, 60_000);  // #1627 —— 原 20_000。历史基线 4196ms;2026-08-31 实测 21018ms(5.0×),撞上限。
+  test("enqueue and process-level ack keep consumed_at null", async () => {
+    const content = "connected process has not started a model turn";
+    const before = db.get<{ last_seen_at: string; task: string | null }>(
+      "SELECT last_seen_at, task FROM sessions WHERE network_id = ?1 AND alias = ?2",
+      NET,
+      NODE_A,
+    );
+    const taskId = await createTask(content);
+    const nodeTools = toolsFor({ alias: NODE_A, nodeToken: true });
+    const pending = await call(nodeTools.get_inbox, { alias: NODE_A, limit: 20 });
+    expect(pending.messages.find((row: any) => row.id === taskId)?.task_id).toBe(taskId);
+    expect(runtimeSubmittedAt(taskId)).toBeNull();
+    expect(consumedAt(taskId)).toBeNull();
+    const queued = db.get<{ last_seen_at: string; task: string | null }>(
+      "SELECT last_seen_at, task FROM sessions WHERE network_id = ?1 AND alias = ?2",
+      NET,
+      NODE_A,
+    );
+    // Preserve the issue's witnessed-red shape: dispatch echoes the sender's
+    // own text into the legacy session.task field while the receiver's
+    // heartbeat remains frozen. consumed_at must not inherit that false cue.
+    expect(queued?.task).toBe(content);
+    expect(queued?.last_seen_at).toBe(before?.last_seen_at);
+
+    expect((await call(nodeTools.ack_inbox, { alias: NODE_A, message_id: taskId })).ok).toBe(true);
+    expect(runtimeSubmittedAt(taskId)).toBeNull();
+    expect(consumedAt(taskId)).toBeNull();
+  });
+
+  test("runtime submission is visible without claiming authoritative consumption", async () => {
+    const taskId = await createTask("vendor request accepted but no turn event yet");
+    const handler = toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_runtime_submitted;
+    expect((await call(handler, { task_ids: [taskId] })).ok).toBe(true);
+    expect(typeof runtimeSubmittedAt(taskId)).toBe("string");
+    expect(consumedAt(taskId)).toBeNull();
+  });
+
+  test("token-bound target marks exact task idempotently", async () => {
+    const taskId = await createTask("runtime emitted an attributable event");
+    const handler = toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_consumed;
+
+    const first = await call(handler, { task_ids: [taskId] });
+    expect(first.ok).toBe(true);
+    expect(first.tasks).toHaveLength(1);
+    expect(typeof runtimeSubmittedAt(taskId)).toBe("string");
+    expect(typeof consumedAt(taskId)).toBe("string");
+    const timestamp = consumedAt(taskId);
+
+    const replay = await call(handler, { task_ids: [taskId] });
+    expect(replay.ok).toBe(true);
+    expect(consumedAt(taskId)).toBe(timestamp);
+
+    const listed = await call(toolsFor().list_tasks, { alias: NODE_A, limit: 20 });
+    const listedTask = listed.tasks.find((task: any) => task.task_id === taskId);
+    expect(listedTask?.runtime_submitted_at).toBe(runtimeSubmittedAt(taskId));
+    expect(listedTask?.consumed_at).toBe(timestamp);
+  });
+
+  test("token-bound consumed evidence persists and exposes an exact BTW boundary", async () => {
+    const taskId = await createTask("runtime emitted exact Codex context");
+    const handler = toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_consumed;
+    const context = { task_id: taskId, thread_id: "thread_btw_exact", turn_id: "turn_btw_exact" };
+
+    const first = await call(handler, { task_ids: [taskId], task_contexts: [context] });
+    expect(first.ok).toBe(true);
+    expect(first.tasks[0]).toMatchObject(context);
+    expect(runtimeContext(taskId)).toEqual({
+      thread_id: context.thread_id,
+      turn_id: context.turn_id,
+    });
+
+    const listed = await call(toolsFor().list_tasks, { alias: NODE_A, limit: 20 });
+    expect(listed.tasks.find((task: any) => task.task_id === taskId)).toMatchObject(context);
+
+    const replay = await call(handler, { task_ids: [taskId], task_contexts: [context] });
+    expect(replay.ok).toBe(true);
+    const conflict = await call(handler, {
+      task_ids: [taskId],
+      task_contexts: [{ ...context, turn_id: "turn_sibling" }],
+    });
+    expect(conflict).toEqual({
+      ok: false,
+      error: "task_runtime_context_conflict",
+      task_id: taskId,
+    });
+    expect(runtimeContext(taskId)).toEqual({
+      thread_id: context.thread_id,
+      turn_id: context.turn_id,
+    });
+  });
+
+  test("runtime context rejects user tokens, foreign tasks, and unrequested ids without partial writes", async () => {
+    const ownTask = await createTask("owned context", NODE_A);
+    const foreignTask = await createTask("foreign context", NODE_B);
+    const ownContext = { task_id: ownTask, thread_id: "thread_owned", turn_id: "turn_owned" };
+    const foreignContext = { task_id: foreignTask, thread_id: "thread_foreign", turn_id: "turn_foreign" };
+
+    expect(await call(toolsFor().mark_tasks_consumed, {
+      task_ids: [ownTask], task_contexts: [ownContext],
+    })).toEqual({ ok: false, error: "node_token_required" });
+    expect(await call(toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_consumed, {
+      task_ids: [ownTask, foreignTask], task_contexts: [ownContext, foreignContext],
+    })).toEqual({ ok: false, error: "task_not_owned", task_id: foreignTask });
+    expect(await call(toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_consumed, {
+      task_ids: [ownTask], task_contexts: [foreignContext],
+    })).toEqual({ ok: false, error: "task_context_not_requested", task_id: foreignTask });
+    expect(runtimeContext(ownTask)).toEqual({ thread_id: null, turn_id: null });
+    expect(runtimeContext(foreignTask)).toEqual({ thread_id: null, turn_id: null });
+  });
+
+  test("submitted evidence cannot smuggle a runtime context", async () => {
+    const taskId = await createTask("submission has no authoritative turn yet");
+    const result = await call(
+      toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_runtime_submitted,
+      {
+        task_ids: [taskId],
+        task_contexts: [{ task_id: taskId, thread_id: "thread_early", turn_id: "turn_early" }],
+      },
+    );
+    expect(result).toEqual({ ok: false, error: "runtime_context_requires_consumed" });
+    expect(runtimeSubmittedAt(taskId)).toBeNull();
+    expect(runtimeContext(taskId)).toEqual({ thread_id: null, turn_id: null });
+  });
+
+  test("one runtime wake can mark an exact batch of owned tasks", async () => {
+    const firstTask = await createTask("batched wake first");
+    const secondTask = await createTask("batched wake second");
+    const result = await call(
+      toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_consumed,
+      { task_ids: [firstTask, secondTask] },
+    );
+    expect(result.ok).toBe(true);
+    expect(new Set(result.tasks.map((row: any) => row.task_id)))
+      .toEqual(new Set([firstTask, secondTask]));
+    expect(typeof consumedAt(firstTask)).toBe("string");
+    expect(typeof consumedAt(secondTask)).toBe("string");
+  });
+
+  test("foreign or missing row rejects the whole batch with zero partial writes", async () => {
+    const ownTask = await createTask("owned", NODE_A);
+    const foreignTask = await createTask("foreign", NODE_B);
+    const handler = toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_consumed;
+
+    expect(await call(handler, { task_ids: [ownTask, foreignTask] })).toEqual({
+      ok: false,
+      error: "task_not_owned",
+      task_id: foreignTask,
+    });
+    expect(consumedAt(ownTask)).toBeNull();
+    expect(consumedAt(foreignTask)).toBeNull();
+    expect(runtimeSubmittedAt(ownTask)).toBeNull();
+    expect(runtimeSubmittedAt(foreignTask)).toBeNull();
+  });
+
+  test("user token cannot forge runtime consumption", async () => {
+    const taskId = await createTask("user token must not stamp node evidence");
+    const result = await call(toolsFor().mark_tasks_consumed, { task_ids: [taskId] });
+    expect(result).toEqual({ ok: false, error: "node_token_required" });
+    expect(runtimeSubmittedAt(taskId)).toBeNull();
+    expect(consumedAt(taskId)).toBeNull();
+  });
+
+  test("token-bound canonical alias is the fail-closed fallback only for tasks without node_id", async () => {
+    const taskId = await createTask("legacy direct session has no immutable node id");
+    db.run("UPDATE tasks SET to_node_id = NULL WHERE task_id = ?1", [taskId]);
+    db.run("UPDATE sessions SET node_id = NULL WHERE network_id = ?1 AND alias = ?2", [NET, NODE_A]);
+
+    const ownerResult = await call(
+      toolsFor({ alias: NODE_A, nodeToken: true }).mark_tasks_consumed,
+      { task_ids: [taskId] },
+    );
+    expect(ownerResult.ok).toBe(true);
+    expect(typeof consumedAt(taskId)).toBe("string");
+
+    const foreignTask = await createTask("alias fallback must not cross target aliases", NODE_A);
+    db.run("UPDATE tasks SET to_node_id = NULL WHERE task_id = ?1", [foreignTask]);
+    const foreignResult = await call(
+      toolsFor({ alias: NODE_B, nodeToken: true }).mark_tasks_consumed,
+      { task_ids: [foreignTask] },
+    );
+    expect(foreignResult).toEqual({ ok: false, error: "task_not_owned", task_id: foreignTask });
+    expect(consumedAt(foreignTask)).toBeNull();
+  });
+
+  test("retry keeps task-lifetime evidence and exposes the logical task id on the new inbox row", async () => {
+    const taskId = await createTask("task-lifetime evidence");
+    const nodeTools = toolsFor({ alias: NODE_A, nodeToken: true });
+    expect((await call(nodeTools.ack_inbox, { alias: NODE_A, message_id: taskId })).ok).toBe(true);
+    expect((await call(nodeTools.mark_tasks_consumed, { task_ids: [taskId] })).ok).toBe(true);
+    const submitted = runtimeSubmittedAt(taskId);
+    const consumed = consumedAt(taskId);
+    expect(typeof submitted).toBe("string");
+    expect(typeof consumed).toBe("string");
+
+    db.run("UPDATE tasks SET status = 'failed' WHERE task_id = ?1", [taskId]);
+    expect((await call(toolsFor().retry_task, { task_id: taskId })).ok).toBe(true);
+    expect(runtimeSubmittedAt(taskId)).toBe(submitted);
+    expect(consumedAt(taskId)).toBe(consumed);
+
+    const retriedInbox = await call(nodeTools.get_inbox, { alias: NODE_A, limit: 20 });
+    const retryRow = retriedInbox.messages.find((row: any) => row.id !== taskId && row.task_id === taskId);
+    expect(retryRow).toBeDefined();
+    expect((await call(nodeTools.ack_inbox, { alias: NODE_A, message_id: retryRow.task_id })).ok).toBe(true);
+    expect(db.get<{ acked: number }>("SELECT acked FROM inbox WHERE id = ?1", retryRow.id)?.acked).toBe(1);
+    expect(db.get<{ status: string }>("SELECT status FROM tasks WHERE task_id = ?1", taskId)?.status).toBe("acked");
+  });
+
+  test("an unconsumed first attempt can report against the linked task after retry", async () => {
+    const taskId = await createTask("retry must not lose logical task identity");
+    const nodeTools = toolsFor({ alias: NODE_A, nodeToken: true });
+    expect((await call(nodeTools.ack_inbox, { alias: NODE_A, message_id: taskId })).ok).toBe(true);
+    db.run("UPDATE tasks SET status = 'failed' WHERE task_id = ?1", [taskId]);
+    expect((await call(toolsFor().retry_task, { task_id: taskId })).ok).toBe(true);
+
+    const retriedInbox = await call(nodeTools.get_inbox, { alias: NODE_A, limit: 20 });
+    const retryRow = retriedInbox.messages.find((row: any) => row.id !== taskId && row.task_id === taskId);
+    expect(retryRow).toBeDefined();
+    // Backward compatibility: an older consumer may still ACK the transport
+    // inbox.id even though all task lifecycle operations use logical task_id.
+    expect((await call(nodeTools.ack_inbox, { alias: NODE_A, message_id: retryRow.id })).ok).toBe(true);
+    expect((await call(nodeTools.mark_tasks_consumed, { task_ids: [retryRow.task_id] })).ok).toBe(true);
+    expect(typeof runtimeSubmittedAt(taskId)).toBe("string");
+    expect(typeof consumedAt(taskId)).toBe("string");
+  });
+
+  test("reassign preserves task-lifetime evidence and binds the new inbox row to the same task", async () => {
+    const taskId = await createTask("reassign keeps logical task evidence");
+    const oldOwnerTools = toolsFor({ alias: NODE_A, nodeToken: true });
+    expect((await call(oldOwnerTools.ack_inbox, { alias: NODE_A, message_id: taskId })).ok).toBe(true);
+    expect((await call(oldOwnerTools.mark_tasks_consumed, { task_ids: [taskId] })).ok).toBe(true);
+    const submitted = runtimeSubmittedAt(taskId);
+    const consumed = consumedAt(taskId);
+
+    expect((await call(toolsFor().reassign_task, { task_id: taskId, new_alias: NODE_B })).ok).toBe(true);
+    expect(runtimeSubmittedAt(taskId)).toBe(submitted);
+    expect(consumedAt(taskId)).toBe(consumed);
+
+    const newOwnerTools = toolsFor({ alias: NODE_B, nodeToken: true });
+    const reassignedInbox = await call(newOwnerTools.get_inbox, { alias: NODE_B, limit: 20 });
+    const row = reassignedInbox.messages.find((message: any) => message.task_id === taskId);
+    expect(row).toBeDefined();
+    expect(row.id).not.toBe(taskId);
+    expect((await call(newOwnerTools.ack_inbox, { alias: NODE_B, message_id: row.task_id })).ok).toBe(true);
+    expect(db.get<{ acked: number }>("SELECT acked FROM inbox WHERE id = ?1", row.id)?.acked).toBe(1);
+    expect(await call(oldOwnerTools.mark_tasks_consumed, { task_ids: [taskId] })).toEqual({
+      ok: false,
+      error: "task_not_owned",
+      task_id: taskId,
+    });
+    expect((await call(newOwnerTools.mark_tasks_consumed, { task_ids: [taskId] })).ok).toBe(true);
+  });
+
+  test("scheduler delivery writes and exposes the same logical task id", async () => {
+    const scheduleId = `sched_${crypto.randomUUID()}`;
+    const scheduledFor = new Date(Date.now() + 60_000).toISOString();
+    const row = {
+      schedule_id: scheduleId,
+      network_id: NET,
+      created_by: USER,
+      name: "task linkage schedule",
+      target_node_id: `id_${NODE_A}`,
+      target_alias: NODE_A,
+      task_content: "scheduler must preserve logical task identity",
+      priority: "normal",
+      schedule_type: "once",
+      schedule_json: JSON.stringify({ type: "once", run_at: scheduledFor }),
+      timezone: "UTC",
+      overlap_policy: "skip",
+      misfire_policy: "catch_up_once",
+      status: "active",
+      next_run_at: scheduledFor,
+      last_run_at: null,
+      revision: 1,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+    } as any;
+    db.run(
+      `INSERT INTO scheduled_tasks
+       (schedule_id, network_id, created_by, name, target_node_id, target_alias,
+        task_content, priority, schedule_type, schedule_json, timezone,
+        overlap_policy, misfire_policy, status, next_run_at)
+       VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15)`,
+      [scheduleId, NET, USER, row.name, row.target_node_id, NODE_A, row.task_content,
+       row.priority, row.schedule_type, row.schedule_json, row.timezone,
+       row.overlap_policy, row.misfire_policy, row.status, row.next_run_at],
+    );
+
+    const dispatched = dispatchScheduledOccurrence(row, scheduledFor, false);
+    expect(dispatched.taskId).toBeTruthy();
+    const inbox = db.get<{ id: string; task_id: string }>(
+      "SELECT id, task_id FROM inbox WHERE id = ?1",
+      [dispatched.taskId],
+    );
+    expect(inbox).toEqual({ id: dispatched.taskId!, task_id: dispatched.taskId! });
+    const pending = await call(
+      toolsFor({ alias: NODE_A, nodeToken: true }).get_inbox,
+      { alias: NODE_A, limit: 20 },
+    );
+    expect(pending.messages.find((message: any) => message.id === dispatched.taskId)?.task_id)
+      .toBe(dispatched.taskId);
+  });
+});

package/src/task-diagnostic-http.test.ts

@@ -0,0 +1,149 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const PRIVATE_DB_DIR = mkdtempSync(join(tmpdir(), "anet-task-diagnostic-"));
+process.env.COMMHUB_DB = join(PRIVATE_DB_DIR, "hub.db");
+
+let db: typeof import("./db.js").db;
+let server: ReturnType<typeof Bun.serve>;
+let base = "";
+let tokenA = "";
+let tokenB = "";
+let networkA = "";
+let networkB = "";
+
+const ALIAS = "diagnostic-worker";
+
+async function detail(token: string, taskId: string): Promise<{ status: number; body: any }> {
+  const response = await fetch(`${base}/api/tasks/${encodeURIComponent(taskId)}`, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  return { status: response.status, body: await response.json() };
+}
+
+function insertTask(taskId: string, patch: {
+  status?: string;
+  runtimeSubmittedAt?: string | null;
+  consumedAt?: string | null;
+} = {}) {
+  db.run(
+    `INSERT INTO tasks
+       (task_id, from_name, to_node_id, to_name, status, content, priority,
+        network_id, runtime_submitted_at, consumed_at)
+     VALUES (?1, 'diagnostic-sender', 'node-diagnostic-a', ?2, ?3,
+             'diagnose me', 'normal', ?4, ?5, ?6)`,
+    [taskId, ALIAS, patch.status ?? "delivered", networkA, patch.runtimeSubmittedAt ?? null, patch.consumedAt ?? null],
+  );
+}
+
+async function openSse(token: string, networkId: string): Promise<ReadableStreamDefaultReader<Uint8Array>> {
+  const response = await fetch(`${base}/events/${encodeURIComponent(ALIAS)}?network_id=${encodeURIComponent(networkId)}`, {
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  expect(response.status).toBe(200);
+  const reader = response.body!.getReader();
+  const first = await reader.read();
+  expect(new TextDecoder().decode(first.value)).toContain('"type":"connected"');
+  return reader;
+}
+
+// 30s 而不是 bun 默认的 5s:这个 hook 跑 register()(KDF)+bootServer(),
+// 本机空载基线 ~620ms,而 2026-08-17 与 2026-08-31 两次 CI 上它被 5s 上限打死
+// (0 pass / 1 fail / Ran 1 test —— 见 #928、#1627)。5247ms 是**被截断的下界**,
+// 不是测量值,所以余量按基线的 ~48x 取,而不是按那个数取。
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { register } = await import("./auth.js");
+  const authA = register(`diagnostic_a_${Date.now()}`, "Diagnostic-A-Strong-1!", undefined, "diagnostic-a");
+  const authB = register(`diagnostic_b_${Date.now()}`, "Diagnostic-B-Strong-1!", undefined, "diagnostic-b");
+  expect(authA.ok).toBe(true);
+  expect(authB.ok).toBe(true);
+  tokenA = authA.token!;
+  tokenB = authB.token!;
+  networkA = authA.network_id!;
+  networkB = authB.network_id!;
+
+  for (const [networkId, suffix] of [[networkA, "a"], [networkB, "b"]] as const) {
+    db.run(
+      `INSERT INTO nodes
+         (node_id, node_name, alias, network_id, hostname, created_at, updated_at, lifecycle_state)
+       VALUES (?1, ?2, ?2, ?3, 'diagnostic-host', datetime('now'), datetime('now'), 'active')`,
+      [`node-diagnostic-${suffix}`, ALIAS, networkId],
+    );
+    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-diagnostic-${suffix}`, ALIAS, `node-diagnostic-${suffix}`, networkId],
+    );
+  }
+
+  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(() => {
+  try { server?.stop(true); } catch {}
+  try { rmSync(PRIVATE_DB_DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("#166 scoped single-task diagnostics", () => {
+  test("does not count another network's same-alias SSE connection", async () => {
+    insertTask("diag-cross-network");
+    const foreignReader = await openSse(tokenB, networkB);
+    try {
+      const own = await detail(tokenA, "diag-cross-network");
+      expect(own.status).toBe(200);
+      expect(own.body.diagnostic).toMatchObject({
+        code: "target_no_live_sse",
+        evidence: { live_sse_connections: 0 },
+      });
+      const foreign = await detail(tokenB, "diag-cross-network");
+      expect(foreign.status).toBe(404);
+      expect(foreign.body).toMatchObject({ ok: false, error: "task_not_found" });
+    } finally {
+      await foreignReader.cancel();
+    }
+  });
+
+  test("reports a live same-network SSE without claiming runtime consumption", async () => {
+    insertTask("diag-live-sse");
+    const reader = await openSse(tokenA, networkA);
+    try {
+      const result = await detail(tokenA, "diag-live-sse");
+      expect(result.body.diagnostic).toMatchObject({
+        code: "delivered_waiting_for_agent",
+        evidence: {
+          target_session_status: "idle",
+          live_sse_connections: 1,
+          runtime_submitted: false,
+          runtime_consumed: false,
+        },
+      });
+    } finally {
+      await reader.cancel();
+    }
+  });
+
+  test("uses authoritative runtime evidence before current connectivity", async () => {
+    insertTask("diag-submitted", { runtimeSubmittedAt: "2026-08-10T00:00:00Z" });
+    insertTask("diag-consumed", {
+      runtimeSubmittedAt: "2026-08-10T00:00:00Z",
+      consumedAt: "2026-08-10T00:00:01Z",
+    });
+    db.run("UPDATE sessions SET status = 'offline' WHERE node_id = 'node-diagnostic-a' AND network_id = ?1", [networkA]);
+    expect((await detail(tokenA, "diag-submitted")).body.diagnostic.code).toBe("runtime_submitted_waiting_for_signal");
+    expect((await detail(tokenA, "diag-consumed")).body.diagnostic.code).toBe("runtime_consumed_nonterminal");
+  });
+
+  test("distinguishes offline and missing target sessions", async () => {
+    insertTask("diag-offline");
+    expect((await detail(tokenA, "diag-offline")).body.diagnostic.code).toBe("target_session_offline");
+    db.run("DELETE FROM sessions WHERE node_id = 'node-diagnostic-a' AND network_id = ?1", [networkA]);
+    insertTask("diag-missing");
+    expect((await detail(tokenA, "diag-missing")).body.diagnostic.code).toBe("target_session_missing");
+  });
+});