@sleep2agi/commhub-server 0.9.0-preview.33 → 0.9.0-preview.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.33",
+  "version": "0.9.0-preview.34",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and MCP tools (17 collaboration-core + node/provider ops tools; authoritative list: docs-site/docs/api/mcp-tools.md).",
   "type": "module",
   "main": "src/index.ts",

package/src/db.ts

@@ -200,6 +200,8 @@ db.exec(`
     started_at        TEXT,
     runtime_submitted_at TEXT,
     consumed_at       TEXT,
+    thread_id         TEXT,
+    turn_id           TEXT,
     completed_at      TEXT,
     expires_at        TEXT
   );
@@ -1157,6 +1159,11 @@ try { db.exec("ALTER TABLE tasks ADD COLUMN meta_json TEXT"); } catch {}
 // started_at (legacy report_status/content matching). Old binaries ignore them.
 try { db.exec("ALTER TABLE tasks ADD COLUMN runtime_submitted_at TEXT"); } catch {}
 try { db.exec("ALTER TABLE tasks ADD COLUMN consumed_at TEXT"); } catch {}
+// Exact vendor-runtime boundary for SideThread-capable clients. These values
+// are written only by the token-bound target node after attributable runtime
+// evidence; the Hub never derives them from task text or caller input.
+try { db.exec("ALTER TABLE tasks ADD COLUMN thread_id TEXT"); } catch {}
+try { db.exec("ALTER TABLE tasks ADD COLUMN turn_id TEXT"); } catch {}
 
 // #1181 durable outbound terminal cursor.  A task's created_at cannot be used
 // as a recovery watermark because an old task may become terminal after newer

package/src/rest-explicit-columns-http.test.ts

@@ -52,6 +52,7 @@ const GOLDEN_RESPONSE_KEYS = {
     "status", "content", "result", "in_reply_to", "requires_response", "scope",
     "created_at", "delivered_at", "started_at", "runtime_submitted_at", "consumed_at",
     "completed_at", "expires_at", "network_id", "parent_task_id", "meta_json",
+    "thread_id", "turn_id",
   ],
   audit: [
     "id", "user_id", "username", "action", "target_type", "target_id", "detail",

package/src/rest-projections.ts

@@ -36,7 +36,7 @@ export const TASK_REST_COLUMNS = [
   "task_id", "from_node_id", "from_name", "to_node_id", "to_name", "priority",
   "status", "content", "result", "in_reply_to", "requires_response", "scope",
   "created_at", "delivered_at", "started_at", "runtime_submitted_at", "consumed_at", "completed_at", "expires_at",
-  "network_id", "parent_task_id", "meta_json",
+  "network_id", "parent_task_id", "meta_json", "thread_id", "turn_id",
 ] as const;
 
 export const COMPLETION_REST_COLUMNS = [

package/src/task-consumption.test.ts

@@ -92,6 +92,13 @@ function runtimeSubmittedAt(taskId: string): string | null {
   )?.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);
 
@@ -218,6 +225,72 @@ describe("task consumed_at identity and lifecycle", () => {
     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");

package/src/tools.ts

@@ -991,6 +991,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
   const markTaskRuntimeEvidence = (
     taskIds: string[],
     level: "submitted" | "consumed",
+    taskContexts: Array<{ task_id: string; thread_id: string; turn_id: string }> = [],
   ) => {
     const task_ids = taskIds;
     if (!callerTokenIsNetwork || !callerAlias || !enforceNetworkId) {
@@ -1017,6 +1018,24 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         };
       }
 
+      if (level !== "consumed" && taskContexts.length > 0) {
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "runtime_context_requires_consumed" }) }],
+        };
+      }
+      const contextByTaskId = new Map(taskContexts.map((context) => [context.task_id, context]));
+      if (contextByTaskId.size !== taskContexts.length) {
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "duplicate_task_context" }) }],
+        };
+      }
+      const foreignContext = taskContexts.find((context) => !uniqueTaskIds.includes(context.task_id));
+      if (foreignContext) {
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "task_context_not_requested", task_id: foreignContext.task_id }) }],
+        };
+      }
+
       const placeholders = uniqueTaskIds.map((_, i) => `?${i + 2}`).join(", ");
 
       // Keep ownership preflight and every stamp in one SQLite transaction.
@@ -1031,8 +1050,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           enforceNetworkId,
           canonicalCaller,
         );
-        const rows = db.all<{ task_id: string; to_node_id: string | null; to_name: string }>(
-          `SELECT task_id, to_node_id, to_name FROM tasks
+        const rows = db.all<{ task_id: string; to_node_id: string | null; to_name: string; thread_id: string | null; turn_id: string | null }>(
+          `SELECT task_id, to_node_id, to_name, thread_id, turn_id FROM tasks
            WHERE network_id = ?1 AND task_id IN (${placeholders})`,
           enforceNetworkId,
           ...uniqueTaskIds,
@@ -1050,6 +1069,16 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         if (rejectedTaskId) {
           return { ok: false as const, error: "task_not_owned", task_id: rejectedTaskId };
         }
+        const conflictingContext = uniqueTaskIds.find((taskId) => {
+          const context = contextByTaskId.get(taskId);
+          if (!context) return false;
+          const row = owned.get(taskId)!;
+          return (row.thread_id !== null && row.thread_id !== context.thread_id)
+            || (row.turn_id !== null && row.turn_id !== context.turn_id);
+        });
+        if (conflictingContext) {
+          return { ok: false as const, error: "task_runtime_context_conflict", task_id: conflictingContext };
+        }
 
         for (const taskId of uniqueTaskIds) {
           const row = owned.get(taskId)!;
@@ -1059,12 +1088,15 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           const ownerValue = row.to_node_id ?? row.to_name;
           let updateResult;
           if (level === "consumed") {
+            const context = contextByTaskId.get(taskId);
             updateResult = db.run(
               `UPDATE tasks SET
                  runtime_submitted_at = COALESCE(runtime_submitted_at, datetime('now')),
-                 consumed_at = COALESCE(consumed_at, datetime('now'))
+                 consumed_at = COALESCE(consumed_at, datetime('now')),
+                 thread_id = COALESCE(thread_id, ?4),
+                 turn_id = COALESCE(turn_id, ?5)
                WHERE network_id = ?1 AND task_id = ?2 AND ${ownershipSql}`,
-              [enforceNetworkId, taskId, ownerValue],
+              [enforceNetworkId, taskId, ownerValue, context?.thread_id ?? null, context?.turn_id ?? null],
             );
           } else {
             updateResult = db.run(
@@ -1083,8 +1115,10 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           task_id: string;
           runtime_submitted_at: string;
           consumed_at: string | null;
+          thread_id: string | null;
+          turn_id: string | null;
         }>(
-          `SELECT task_id, runtime_submitted_at, consumed_at FROM tasks
+          `SELECT task_id, runtime_submitted_at, consumed_at, thread_id, turn_id FROM tasks
            WHERE network_id = ?1 AND task_id IN (${placeholders})`,
           enforceNetworkId,
           ...uniqueTaskIds,
@@ -1102,20 +1136,25 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
 
   const taskRuntimeEvidenceSchema = {
     task_ids: z.array(z.string().min(1).max(200)).min(1).max(100),
+    task_contexts: z.array(z.object({
+      task_id: z.string().min(1).max(200),
+      thread_id: z.string().min(1).max(500),
+      turn_id: z.string().min(1).max(500),
+    }).strict()).max(100).optional(),
   };
 
   server.tool(
     "mark_tasks_runtime_submitted",
     "Internal agent-node signal: exact task bodies were submitted to this token-bound node's vendor runtime.",
     taskRuntimeEvidenceSchema,
-    async ({ task_ids }) => markTaskRuntimeEvidence(task_ids, "submitted"),
+    async ({ task_ids, task_contexts }) => markTaskRuntimeEvidence(task_ids, "submitted", task_contexts),
   );
 
   server.tool(
     "mark_tasks_consumed",
     "Internal agent-node signal: exact tasks produced attributable turn-start/activity evidence in this token-bound node's runtime.",
     taskRuntimeEvidenceSchema,
-    async ({ task_ids }) => markTaskRuntimeEvidence(task_ids, "consumed"),
+    async ({ task_ids, task_contexts }) => markTaskRuntimeEvidence(task_ids, "consumed", task_contexts),
   );
 
   // ═══════════════════════════════════════════
@@ -2031,7 +2070,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         const tasks = db.all(
           `SELECT t.task_id, t.from_node_id, t.from_name, t.to_node_id, t.to_name, t.priority,
                   t.status, t.content, t.result, t.created_at, t.runtime_submitted_at,
-                  t.consumed_at, t.completed_at, e.terminal_seq
+                  t.consumed_at, t.thread_id, t.turn_id, t.completed_at, e.terminal_seq
              FROM task_terminal_events e
              JOIN tasks t ON t.task_id = e.task_id
             WHERE COALESCE(e.network_id, 'default') = COALESCE(?1, 'default')
@@ -2048,7 +2087,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           has_more: tasks.length === limit,
         }) }] };
       }
-      let sql = "SELECT task_id, from_node_id, from_name, to_node_id, to_name, priority, status, content, result, created_at, runtime_submitted_at, consumed_at, completed_at FROM tasks WHERE 1=1";
+      let sql = "SELECT task_id, from_node_id, from_name, to_node_id, to_name, priority, status, content, result, created_at, runtime_submitted_at, consumed_at, thread_id, turn_id, completed_at FROM tasks WHERE 1=1";
       const params: any[] = [];
       sql = addReadScope(sql, params, readScope);
       if (alias) { sql += ` AND to_name = ?${params.length + 1}`; params.push(alias); }