@sleep2agi/commhub-server 0.5.0-preview.9 → 0.5.0

package/src/tools.ts

@@ -2,12 +2,46 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod/v4";
 import { db, uuidv4, logTaskEvent } from "./db.js";
 import { pushEvent, pushBroadcast } from "./push.js";
+import { getUserNetworkRole } from "./auth.js";
 
 function ts(): string {
   return new Date().toTimeString().slice(0, 8);
 }
 
-export function registerTools(server: McpServer, clientIP?: string) {
+export function registerTools(server: McpServer, clientIP?: string, enforceNetworkId?: string | null, enforceUserId?: string | null, callerAlias?: string | null) {
+  // Default from_session for outbound tools — extracted from the calling
+  // token's binding (ntok_ → node alias, utok_ → username). Without this,
+  // an agent's send_task call always claimed from='hub' and peer agents
+  // couldn't tell who actually asked them. Tool callers can still override
+  // by passing from_session explicitly.
+  const defaultFrom = (clientFrom?: string) => clientFrom || callerAlias || "hub";
+  // If enforceNetworkId is set, override any client-supplied network_id
+  const getNetworkId = (clientNetId?: string | null) => enforceNetworkId ?? clientNetId ?? null;
+
+  // Check write access. For ntok_ the network is enforced by the token.
+  // For utok_ (no enforced network) we accept the network_id supplied in the
+  // request and verify the user has a write role on it.
+  const canWrite = (effectiveNetworkId?: string | null): boolean => {
+    if (!enforceUserId) return true; // legacy global token mode, allow
+    const netId = enforceNetworkId ?? effectiveNetworkId ?? null;
+    if (!netId) return false; // no network resolvable
+    const role = getUserNetworkRole(enforceUserId, netId);
+    return !!role && role !== "viewer"; // owner/admin/member can write
+  };
+
+  const addScope = (sql: string, params: any[], networkId?: string | null, column = "network_id"): string => {
+    if (!networkId) return sql;
+    sql += ` AND ${column} = ?${params.length + 1}`;
+    params.push(networkId);
+    return sql;
+  };
+
+  const scopedSessionStatus = (alias: string, networkId?: string | null) => {
+    const params: any[] = [alias];
+    let sql = "SELECT status FROM sessions WHERE alias = ?1";
+    sql = addScope(sql, params, networkId);
+    return db.get<any>(sql, ...params);
+  };
   // ═══════════════════════════════════════════
   //  Child Agent Tools (4)
   // ═══════════════════════════════════════════
@@ -36,58 +70,56 @@ export function registerTools(server: McpServer, clientIP?: string) {
       channels: z.string().max(2000).optional().describe("JSON array of channels"),
       model: z.string().max(200).optional().describe("AI model name"),
       node_name: z.string().max(200).optional().describe("Stable node display name (may differ from alias)"),
+      network_id: z.string().max(200).optional().describe("Network this agent belongs to"),
     },
-    async ({ resume_id, alias, status, task, output, score, progress, server: srv, hostname: hn, agent: ag, project_dir: pd, version: ver, tmux_name: tmux, node_id, session_id, config_path, channels, model: mdl, node_name: nn }) => {
-      console.log(`[${ts()}] ${alias} (${resume_id.slice(0, 8)}) → report_status: ${status}${task ? " | " + task.slice(0, 60) : ""}`);
+    async ({ resume_id, alias, status, task, output, score, progress, server: srv, hostname: hn, agent: ag, project_dir: pd, version: ver, tmux_name: tmux, node_id, session_id, config_path, channels, model: mdl, node_name: nn, network_id: netId }) => {
+      const effectiveNetId = getNetworkId(netId);
+      if (!canWrite(effectiveNetId)) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
+      }
+      console.log(`[${ts()}] ${alias} (${resume_id.slice(0, 8)}) → report_status: ${status}${task ? " | " + task.slice(0, 60) : ""}${effectiveNetId ? " [net]" : ""}`);
       const trimmedOutput = output?.slice(0, 4000);
 
-      try {
-        db.run("BEGIN IMMEDIATE");
-        db.run("DELETE FROM sessions WHERE alias = ?1 AND resume_id != ?2", [alias, resume_id]);
+      db.transaction(() => {
+        // Only delete same-alias sessions within the same network
+        if (effectiveNetId) {
+          db.run("DELETE FROM sessions WHERE alias = ?1 AND resume_id != ?2 AND network_id = ?3", [alias, resume_id, effectiveNetId]);
+        } else {
+          db.run("DELETE FROM sessions WHERE alias = ?1 AND resume_id != ?2", [alias, resume_id]);
+        }
         db.run(
-          `INSERT INTO sessions (resume_id, alias, tmux_name, server, ip, hostname, agent, project_dir, version, status, task, output, progress, score, node_id, session_id, config_path, channels, last_seen_at, updated_at)
-           VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, datetime('now'), datetime('now'))
+          `INSERT INTO sessions (resume_id, alias, tmux_name, server, ip, hostname, agent, project_dir, version, status, task, output, progress, score, node_id, session_id, config_path, channels, network_id, last_seen_at, updated_at)
+           VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, datetime('now'), datetime('now'))
            ON CONFLICT(resume_id) DO UPDATE SET
-             alias = COALESCE(?2, sessions.alias),
-             tmux_name = COALESCE(?3, sessions.tmux_name),
-             server = COALESCE(?4, sessions.server),
-             ip = COALESCE(?5, sessions.ip),
-             hostname = COALESCE(?6, sessions.hostname),
-             agent = COALESCE(?7, sessions.agent),
-             project_dir = COALESCE(?8, sessions.project_dir),
-             version = COALESCE(?9, sessions.version),
-             status = ?10,
-             task = COALESCE(?11, sessions.task),
-             output = COALESCE(?12, sessions.output),
-             progress = COALESCE(?13, sessions.progress),
-             score = COALESCE(?14, sessions.score),
-             node_id = COALESCE(?15, sessions.node_id),
-             session_id = COALESCE(?16, sessions.session_id),
-             config_path = COALESCE(?17, sessions.config_path),
-             channels = COALESCE(?18, sessions.channels),
-             last_seen_at = datetime('now'),
-             updated_at = datetime('now')`,
-          [resume_id, alias, tmux ?? null, srv ?? null, clientIP ?? null, hn ?? null, ag ?? null, pd ?? null, ver ?? null, status, task ?? null, trimmedOutput ?? null, progress ?? null, score ?? null, node_id ?? null, session_id ?? null, config_path ?? null, channels ?? null]
+             alias = COALESCE(?2, sessions.alias), tmux_name = COALESCE(?3, sessions.tmux_name),
+             server = COALESCE(?4, sessions.server), ip = COALESCE(?5, sessions.ip),
+             hostname = COALESCE(?6, sessions.hostname), agent = COALESCE(?7, sessions.agent),
+             project_dir = COALESCE(?8, sessions.project_dir), version = COALESCE(?9, sessions.version),
+             status = ?10, task = COALESCE(?11, sessions.task),
+             output = COALESCE(?12, sessions.output), progress = COALESCE(?13, sessions.progress),
+             score = COALESCE(?14, sessions.score), node_id = COALESCE(?15, sessions.node_id),
+             session_id = COALESCE(?16, sessions.session_id), config_path = COALESCE(?17, sessions.config_path),
+             channels = COALESCE(?18, sessions.channels), network_id = COALESCE(?19, sessions.network_id),
+             last_seen_at = datetime('now'), updated_at = datetime('now')`,
+          [resume_id, alias, tmux ?? null, srv ?? null, clientIP ?? null, hn ?? null, ag ?? null, pd ?? null, ver ?? null, status, task ?? null, trimmedOutput ?? null, progress ?? null, score ?? null, node_id ?? null, session_id ?? null, config_path ?? null, channels ?? null, effectiveNetId ?? null]
         );
-        db.run("COMMIT");
-      } catch (e) {
-        try { db.run("ROLLBACK"); } catch {}
-        throw e;
-      }
+      });
 
       // V2: sync tasks table — report_status(working) → tasks.running
       if (status === "working" && task) {
         try {
-          const runResult = db.run(
-            `UPDATE tasks SET status = 'running', started_at = datetime('now')
-             WHERE to_name = ?1 AND status IN ('delivered', 'acked') AND content = ?2`,
-            [alias, task]
-          );
+          const runParams: any[] = [alias, task];
+          let runSql = `UPDATE tasks SET status = 'running', started_at = datetime('now')
+             WHERE to_name = ?1 AND status IN ('delivered', 'acked') AND content = ?2`;
+          runSql = addScope(runSql, runParams, effectiveNetId);
+          const runResult = db.run(runSql, runParams);
           if (runResult.changes > 0) {
             // Find task_id for logging
-            const t = db.query<{ task_id: string }, [string, string]>(
-              "SELECT task_id FROM tasks WHERE to_name = ?1 AND content = ?2 AND status = 'running' ORDER BY started_at DESC LIMIT 1"
-            ).get(alias, task);
+            const findParams: any[] = [alias, task];
+            let findSql = "SELECT task_id FROM tasks WHERE to_name = ?1 AND content = ?2 AND status = 'running'";
+            findSql = addScope(findSql, findParams, effectiveNetId);
+            findSql += " ORDER BY started_at DESC LIMIT 1";
+            const t = db.get<{ task_id: string }>(findSql, ...findParams);
             if (t) logTaskEvent(t.task_id, null, "running", alias);
           }
         } catch {}
@@ -99,8 +131,8 @@ export function registerTools(server: McpServer, clientIP?: string) {
           // Extract runtime from agent field (e.g., "agent-node:codex" → "codex-sdk")
           const nodeRuntime = ag?.includes(":") ? ag.split(":")[1] + "-sdk" : ag ?? null;
           db.run(
-            `INSERT INTO nodes (node_id, node_name, alias, runtime, model, config_path, channels, server, hostname, updated_at)
-             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, datetime('now'))
+            `INSERT INTO nodes (node_id, node_name, alias, runtime, model, config_path, channels, server, hostname, network_id, updated_at)
+             VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, datetime('now'))
              ON CONFLICT(node_id) DO UPDATE SET
                node_name = COALESCE(?2, nodes.node_name),
                alias = COALESCE(?3, nodes.alias),
@@ -110,16 +142,18 @@ export function registerTools(server: McpServer, clientIP?: string) {
                channels = COALESCE(?7, nodes.channels),
                server = COALESCE(?8, nodes.server),
                hostname = COALESCE(?9, nodes.hostname),
+               network_id = COALESCE(?10, nodes.network_id),
                updated_at = datetime('now')`,
-            [node_id, nn || alias, alias, nodeRuntime, mdl ?? null, config_path ?? null, channels ?? null, srv ?? null, hn ?? null]
+            [node_id, nn || alias, alias, nodeRuntime, mdl ?? null, config_path ?? null, channels ?? null, srv ?? null, hn ?? null, effectiveNetId ?? null]
           );
         } catch {}
       }
 
       // inbox uses alias for routing
-      const row = db.query<{ cnt: number }, [string]>(
-        "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0"
-      ).get(alias);
+      const inboxParams: any[] = [alias];
+      let inboxSql = "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0";
+      inboxSql = addScope(inboxSql, inboxParams, effectiveNetId);
+      const row = db.get<{ cnt: number }>(inboxSql, ...inboxParams);
 
       return {
         content: [
@@ -147,55 +181,54 @@ export function registerTools(server: McpServer, clientIP?: string) {
       artifacts: z.array(z.string().max(2000)).max(50).optional().describe("Output URLs or file paths"),
       score: z.number().min(0).max(10).optional(),
       duration_minutes: z.number().min(0).optional(),
+      network_id: z.string().max(200).optional().describe("Network scope"),
     },
-    async ({ alias, task, result, artifacts, score, duration_minutes }) => {
-      console.log(`[${ts()}] ${alias} → report_completion: ${task.slice(0, 60)}`);
+    async ({ alias, task, result, artifacts, score, duration_minutes, network_id: netId }) => {
+      const effectiveNetId = getNetworkId(netId);
+      if (!canWrite(effectiveNetId)) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
+      }
+      console.log(`[${ts()}] ${alias} → report_completion: ${task.slice(0, 60)}${effectiveNetId ? " [net]" : ""}`);
       const id = uuidv4();
-      try {
-        db.run("BEGIN IMMEDIATE");
-        db.run(
-          `INSERT INTO completions (id, session_name, task, result, artifacts, score, duration_minutes)
-           VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7)`,
-          [id, alias, task, result, artifacts ? JSON.stringify(artifacts) : null, score ?? null, duration_minutes ?? null]
-        );
-
+      let updatedTaskId: string | null = null;
+      db.transaction(() => {
         db.run(
-          `UPDATE sessions SET status = 'idle', task = NULL, progress = 0, updated_at = datetime('now')
-           WHERE alias = ?1`,
-          [alias]
+          `INSERT INTO completions (id, session_name, task, result, artifacts, score, duration_minutes, network_id)
+           VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)`,
+          [id, alias, task, result, artifacts ? JSON.stringify(artifacts) : null, score ?? null, duration_minutes ?? null, effectiveNetId ?? null]
         );
+        const sessionParams: any[] = [alias];
+        let sessionSql = `UPDATE sessions SET status = 'idle', task = NULL, progress = 0, updated_at = datetime('now')
+           WHERE alias = ?1`;
+        sessionSql = addScope(sessionSql, sessionParams, effectiveNetId);
+        db.run(sessionSql, sessionParams);
 
         // V2: sync tasks table — try by task_id first, then by content
-        const taskUpdate = db.run(
-          `UPDATE tasks SET status = 'replied', result = ?1, completed_at = datetime('now')
-           WHERE task_id = ?2 AND status IN ('delivered', 'acked', 'running')`,
-          [result.slice(0, 4000), task]
-        );
-        if (taskUpdate.changes === 0) {
-          // fallback: match most recent task by to_name + content (legacy path)
-          const match = db.query<{ task_id: string }, [string, string]>(
-            `SELECT task_id FROM tasks WHERE to_name = ?1 AND content = ?2
-             AND status IN ('delivered', 'acked', 'running') ORDER BY created_at DESC LIMIT 1`
-          ).get(alias, task);
+        const taskParams: any[] = [result.slice(0, 4000), task];
+        let taskSql = `UPDATE tasks SET status = 'replied', result = ?1, completed_at = datetime('now')
+           WHERE task_id = ?2 AND status IN ('delivered', 'acked', 'running')`;
+        taskSql = addScope(taskSql, taskParams, effectiveNetId);
+        const tu = db.run(taskSql, taskParams);
+        if (tu.changes === 0) {
+          const matchParams: any[] = [alias, task];
+          let matchSql = `SELECT task_id FROM tasks WHERE to_name = ?1 AND content = ?2
+             AND status IN ('delivered', 'acked', 'running')`;
+          matchSql = addScope(matchSql, matchParams, effectiveNetId);
+          matchSql += " ORDER BY created_at DESC LIMIT 1";
+          const match = db.get<{ task_id: string }>(matchSql, ...matchParams);
           if (match) {
-            db.run(
-              `UPDATE tasks SET status = 'replied', result = ?1, completed_at = datetime('now')
-               WHERE task_id = ?2`,
-              [result.slice(0, 4000), match.task_id]
-            );
+            const matchUpdateParams: any[] = [result.slice(0, 4000), match.task_id];
+            let matchUpdateSql = "UPDATE tasks SET status = 'replied', result = ?1, completed_at = datetime('now') WHERE task_id = ?2";
+            matchUpdateSql = addScope(matchUpdateSql, matchUpdateParams, effectiveNetId);
+            db.run(matchUpdateSql, matchUpdateParams);
+            updatedTaskId = match.task_id;
           }
+        } else {
+          updatedTaskId = task;
         }
-
-        db.run("COMMIT");
-        // Log event after commit
-        const updatedTaskId = taskUpdate.changes > 0 ? task : (db.query<{ task_id: string }, [string]>(
-          "SELECT task_id FROM tasks WHERE to_name = ?1 AND status = 'replied' ORDER BY completed_at DESC LIMIT 1"
-        ).get(alias)?.task_id);
-        if (updatedTaskId) logTaskEvent(updatedTaskId, null, "replied", alias, "report_completion");
-      } catch (e) {
-        try { db.run("ROLLBACK"); } catch {}
-        throw e;
-      }
+      });
+      // Log event after transaction
+      if (updatedTaskId) logTaskEvent(updatedTaskId, null, "replied", alias, "report_completion");
 
       return {
         content: [{ type: "text" as const, text: JSON.stringify({ ok: true, completion_id: id }) }],
@@ -211,16 +244,20 @@ export function registerTools(server: McpServer, clientIP?: string) {
       limit: z.number().min(1).max(100).optional().default(10),
     },
     async ({ alias, limit }) => {
-      const rows0 = db.query<{ cnt: number }, [string]>(
-        "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0"
-      ).get(alias);
+      const effectiveNetId = getNetworkId(null);
+      const countParams: any[] = [alias];
+      let countSql = "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0";
+      countSql = addScope(countSql, countParams, effectiveNetId);
+      const rows0 = db.get<{ cnt: number }>(countSql, ...countParams);
       console.log(`[${ts()}] ${alias} → get_inbox: ${rows0?.cnt ?? 0} pending messages`);
-      const rows = db.query<any, [string, number]>(
-        `SELECT id, type, priority, content, context, from_session, created_at
-         FROM inbox WHERE session_name = ?1 AND acked = 0
-         ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'normal' THEN 1 ELSE 2 END, created_at
-         LIMIT ?2`
-      ).all(alias, limit);
+      const rowsParams: any[] = [alias];
+      let rowsSql = `SELECT id, type, priority, content, context, from_session, created_at, network_id
+         FROM inbox WHERE session_name = ?1 AND acked = 0`;
+      rowsSql = addScope(rowsSql, rowsParams, effectiveNetId);
+      rowsSql += ` ORDER BY CASE priority WHEN 'high' THEN 0 WHEN 'normal' THEN 1 ELSE 2 END, created_at
+         LIMIT ?${rowsParams.length + 1}`;
+      rowsParams.push(limit);
+      const rows = db.all(rowsSql, ...rowsParams);
 
       return {
         content: [{ type: "text" as const, text: JSON.stringify({ ok: true, messages: rows }) }],
@@ -237,8 +274,13 @@ export function registerTools(server: McpServer, clientIP?: string) {
       response: z.string().max(10000).optional(),
     },
     async ({ alias, message_id, response }) => {
+      const effectiveNetId = getNetworkId(null);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
       console.log(`[${ts()}] ${alias} → ack_inbox: ${message_id.slice(0, 8)}`);
-      const result = db.run("UPDATE inbox SET acked = 1 WHERE id = ?1 AND session_name = ?2", [message_id, alias]);
+      const ackParams: any[] = [message_id, alias];
+      let ackSql = "UPDATE inbox SET acked = 1 WHERE id = ?1 AND session_name = ?2";
+      ackSql = addScope(ackSql, ackParams, effectiveNetId);
+      const result = db.run(ackSql, ackParams);
       if (result.changes === 0) {
         return {
           content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "message not found or not yours" }) }],
@@ -246,10 +288,10 @@ export function registerTools(server: McpServer, clientIP?: string) {
       }
       // V2: sync tasks table — ack_inbox means delivered→acked
       try {
-        const ackResult = db.run(
-          `UPDATE tasks SET status = 'acked' WHERE task_id = ?1 AND status = 'delivered'`,
-          [message_id]
-        );
+        const taskParams: any[] = [message_id];
+        let taskSql = "UPDATE tasks SET status = 'acked' WHERE task_id = ?1 AND status = 'delivered'";
+        taskSql = addScope(taskSql, taskParams, effectiveNetId);
+        const ackResult = db.run(taskSql, taskParams);
         if (ackResult.changes > 0) logTaskEvent(message_id, "delivered", "acked", alias);
       } catch {}
       return {
@@ -268,25 +310,33 @@ export function registerTools(server: McpServer, clientIP?: string) {
     {
       filter_status: z.string().max(50).optional(),
       filter_server: z.string().max(200).optional(),
+      network_id: z.string().max(200).optional().describe("Filter by network"),
     },
-    async ({ filter_status, filter_server }) => {
-      console.log(`[${ts()}] hub → get_all_status${filter_status ? ": filter=" + filter_status : ""}${filter_server ? " server=" + filter_server : ""}`);
+    async ({ filter_status, filter_server, network_id: netId }) => {
+      const effectiveNetId = getNetworkId(netId);
+      console.log(`[${ts()}] hub → get_all_status${filter_status ? ": filter=" + filter_status : ""}${effectiveNetId ? " net=" + effectiveNetId.slice(0, 12) : ""}`);
 
       const sessions = db.transaction(() => {
         const cutoff = new Date(Date.now() - 10 * 60 * 1000).toISOString().replace("T", " ").slice(0, 19);
-        db.run("UPDATE sessions SET status = 'offline' WHERE updated_at < ?1 AND status != 'offline'", [cutoff]);
+        const staleParams: any[] = [cutoff];
+        let staleSql = "UPDATE sessions SET status = 'offline' WHERE updated_at < ?1 AND status != 'offline'";
+        staleSql = addScope(staleSql, staleParams, effectiveNetId);
+        db.run(staleSql, staleParams);
 
         let sql = "SELECT * FROM sessions WHERE 1=1";
         const params: any[] = [];
+        if (effectiveNetId) { sql += " AND network_id = ?"; params.push(effectiveNetId); }
         if (filter_status) { sql += " AND status = ?"; params.push(filter_status); }
         if (filter_server) { sql += " AND server = ?"; params.push(filter_server); }
         sql += " ORDER BY updated_at DESC";
-        return db.query(sql).all(...params);
-      })();
+        return db.all(sql, ...params);
+      });
 
-      const summary = db.query<any, []>(
-        "SELECT status, COUNT(*) as count FROM sessions GROUP BY status"
-      ).all();
+      const summaryParams: any[] = [];
+      let summarySql = "SELECT status, COUNT(*) as count FROM sessions WHERE 1=1";
+      summarySql = addScope(summarySql, summaryParams, effectiveNetId);
+      summarySql += " GROUP BY status";
+      const summary = db.all(summarySql, ...summaryParams);
 
       return {
         content: [
@@ -304,14 +354,23 @@ export function registerTools(server: McpServer, clientIP?: string) {
     "Get detailed status of a specific session by alias.",
     { alias: z.string().min(1).max(200).describe("Session alias") },
     async ({ alias }) => {
+      const effectiveNetId = getNetworkId(null);
       console.log(`[${ts()}] hub → get_session_status: ${alias}`);
-      const session = db.query("SELECT * FROM sessions WHERE alias = ?1").get(alias);
-      const pending = db.query<{ cnt: number }, [string]>(
-        "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0"
-      ).get(alias);
-      const recent = db.query(
-        "SELECT * FROM completions WHERE session_name = ?1 ORDER BY completed_at DESC LIMIT 5"
-      ).all(alias);
+      const sessionParams: any[] = [alias];
+      let sessionSql = "SELECT * FROM sessions WHERE alias = ?1";
+      sessionSql = addScope(sessionSql, sessionParams, effectiveNetId);
+      const session = db.get(sessionSql, ...sessionParams);
+
+      const pendingParams: any[] = [alias];
+      let pendingSql = "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0";
+      pendingSql = addScope(pendingSql, pendingParams, effectiveNetId);
+      const pending = db.get<{ cnt: number }>(pendingSql, ...pendingParams);
+
+      const recentParams: any[] = [alias];
+      let recentSql = "SELECT * FROM completions WHERE session_name = ?1";
+      recentSql = addScope(recentSql, recentParams, effectiveNetId);
+      recentSql += " ORDER BY completed_at DESC LIMIT 5";
+      const recent = db.all(recentSql, ...recentParams);
 
       return {
         content: [
@@ -332,38 +391,60 @@ export function registerTools(server: McpServer, clientIP?: string) {
       task: z.string().min(1).max(10000).describe("Task content"),
       priority: z.enum(["high", "normal", "low"]).optional().default("normal"),
       context: z.string().max(10000).optional(),
-      from_session: z.string().max(200).optional().default("hub"),
+      from_session: z.string().max(200).optional(),
       ttl_seconds: z.number().min(1).max(86400).optional().describe("Task TTL in seconds (default: 3600)"),
+      network_id: z.string().max(200).optional().describe("Network scope"),
     },
-    async ({ alias, task, priority, context, from_session, ttl_seconds }) => {
+    async ({ alias, task, priority, context, from_session: _fromIn, ttl_seconds, network_id: netId }) => { const from_session = defaultFrom(_fromIn);
+      const effectiveNetId = getNetworkId(netId);
+
+      // Role check: viewer cannot send tasks
+      if (!canWrite(effectiveNetId)) {
+        return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied", message: "Viewer role cannot send tasks" }) }] };
+      }
+
+      // License check
+      const license = db.get<any>("SELECT type, expires_at FROM licenses ORDER BY created_at LIMIT 1");
+      if (license?.expires_at) {
+        const now = new Date().toISOString().replace("T", " ").slice(0, 19);
+        if (license.expires_at < now) {
+          return { content: [{ type: "text" as const, text: JSON.stringify({
+            ok: false, error: "license_expired",
+            message: "Trial expired. Activate a license: anet activate <key>",
+          }) }] };
+        }
+      }
+
       console.log(`[${ts()}] ${from_session} → send_task → ${alias}: ${task.slice(0, 60)}${priority === "high" ? " [HIGH]" : ""}`);
       const id = uuidv4();
       // 事务：inbox + tasks 双写
-      try {
-        db.run("BEGIN IMMEDIATE");
+      db.transaction(() => {
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, context, from_session, requires_response)
-           VALUES (?1, ?2, 'task', ?3, ?4, ?5, ?6, 'reply')`,
-          [id, alias, priority, task, context ?? null, from_session]
+          `INSERT INTO inbox (id, session_name, type, priority, content, context, from_session, requires_response, network_id)
+           VALUES (?1, ?2, 'task', ?3, ?4, ?5, ?6, 'reply', ?7)`,
+          [id, alias, priority, task, context ?? null, from_session, effectiveNetId ?? null]
         );
         db.run(
-          `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response, created_at, delivered_at, expires_at)
-           VALUES (?1, ?2, ?3, ?4, 'delivered', ?5, 'reply', datetime('now'), datetime('now'), datetime('now', ?6))`,
-          [id, from_session, alias, priority, task, `+${ttl_seconds || 3600} seconds`]
+          `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response, created_at, delivered_at, expires_at, network_id)
+           VALUES (?1, ?2, ?3, ?4, 'delivered', ?5, 'reply', datetime('now'), datetime('now'), datetime('now', ?6), ?7)`,
+          [id, from_session, alias, priority, task, `+${ttl_seconds || 3600} seconds`, effectiveNetId ?? null]
         );
-        db.run("COMMIT");
-        logTaskEvent(id, null, "delivered", from_session, `→ ${alias}`);
-      } catch (e) {
-        try { db.run("ROLLBACK"); } catch {}
-        throw e;
-      }
-
-      const session = db.query<any, [string]>("SELECT status FROM sessions WHERE alias = ?1").get(alias);
-
-      // SSE push by alias
-      const pending = db.query<{ cnt: number }, [string]>(
-        "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0"
-      ).get(alias);
+      });
+      logTaskEvent(id, null, "delivered", from_session, `→ ${alias}`);
+
+      const session = scopedSessionStatus(alias, effectiveNetId);
+
+      // SSE push by alias.
+      // The SSE channel is keyed by alias (subscribers connected to /events/<alias>),
+      // not by network_id. Earlier we gated the push on a network-scoped session
+      // lookup, which silently dropped pushes whenever an agent registered with
+      // network_id=null but the sender supplied an explicit network_id (the
+      // exact mismatch hit by Dashboard tasks). Push unconditionally; the
+      // subscriber's own auth (ntok_) constrains who can listen.
+      const pendingParams: any[] = [alias];
+      let pendingSql = "SELECT COUNT(*) as cnt FROM inbox WHERE session_name = ?1 AND acked = 0";
+      pendingSql = addScope(pendingSql, pendingParams, effectiveNetId);
+      const pending = db.get<{ cnt: number }>(pendingSql, ...pendingParams);
       pushEvent(alias, { type: "new_task", inbox_count: pending?.cnt ?? 1, priority, from: from_session });
 
       return {
@@ -387,18 +468,20 @@ export function registerTools(server: McpServer, clientIP?: string) {
     {
       alias: z.string().min(1).max(200).describe("Target session alias"),
       message: z.string().min(1).max(10000).describe("Message content"),
-      from_session: z.string().max(200).optional().default("hub"),
+      from_session: z.string().max(200).optional(),
     },
-    async ({ alias, message, from_session }) => {
+    async ({ alias, message, from_session: _fromIn }) => { const from_session = defaultFrom(_fromIn);
+      const effectiveNetId = getNetworkId(null);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
       console.log(`[${ts()}] ${from_session} → send_message → ${alias}: ${message.slice(0, 60)}`);
       const id = uuidv4();
       db.run(
-        `INSERT INTO inbox (id, session_name, type, priority, content, from_session)
-         VALUES (?1, ?2, 'message', 'normal', ?3, ?4)`,
-        [id, alias, message, from_session]
+        `INSERT INTO inbox (id, session_name, type, priority, content, from_session, network_id)
+         VALUES (?1, ?2, 'message', 'normal', ?3, ?4, ?5)`,
+        [id, alias, message, from_session, effectiveNetId ?? null]
       );
 
-      const session = db.query<any, [string]>("SELECT status FROM sessions WHERE alias = ?1").get(alias);
+      const session = scopedSessionStatus(alias, effectiveNetId);
 
       pushEvent(alias, { type: "new_message", message, from: from_session, message_id: id });
 
@@ -426,43 +509,40 @@ export function registerTools(server: McpServer, clientIP?: string) {
       text: z.string().min(1).max(10000).describe("Reply content"),
       in_reply_to: z.string().max(200).optional().describe("Original task/message ID"),
       status: z.enum(["replied", "failed", "cancelled"]).optional().default("replied").describe("Task outcome"),
-      from_session: z.string().max(200).optional().default("hub"),
+      from_session: z.string().max(200).optional(),
     },
-    async ({ alias, text, in_reply_to, status: replyStatus, from_session }) => {
+    async ({ alias, text, in_reply_to, status: replyStatus, from_session: _fromIn }) => { const from_session = defaultFrom(_fromIn);
+      const effectiveNetId = getNetworkId(null);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
       console.log(`[${ts()}] ${from_session} → send_reply (${replyStatus}) → ${alias}: ${text.slice(0, 60)}`);
       const id = uuidv4();
-      let replyLogged = false;
-      try {
-        db.run("BEGIN IMMEDIATE");
+      const replyLogged = db.transaction(() => {
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, in_reply_to, requires_response)
-           VALUES (?1, ?2, 'reply', 'normal', ?3, ?4, ?5, 'none')`,
-          [id, alias, text, from_session, in_reply_to ?? null]
+          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, in_reply_to, requires_response, network_id)
+           VALUES (?1, ?2, 'reply', 'normal', ?3, ?4, ?5, 'none', ?6)`,
+          [id, alias, text, from_session, in_reply_to ?? null, effectiveNetId ?? null]
         );
 
         // 更新 tasks 表
         if (in_reply_to) {
-          const result = db.run(
-            `UPDATE tasks SET status = ?1, result = ?2, completed_at = datetime('now')
-             WHERE task_id = ?3 AND status IN ('created', 'delivered', 'acked', 'running')`,
-            [replyStatus, text, in_reply_to]
-          );
+          const updateParams: any[] = [replyStatus, text, in_reply_to];
+          let updateSql = `UPDATE tasks SET status = ?1, result = ?2, completed_at = datetime('now')
+             WHERE task_id = ?3 AND status IN ('created', 'delivered', 'acked', 'running')`;
+          updateSql = addScope(updateSql, updateParams, effectiveNetId);
+          const result = db.run(updateSql, updateParams);
           if (result.changes === 0) {
             console.log(`[${ts()}] ⚠ send_reply: task ${in_reply_to?.slice(0, 8)} not found or already terminal`);
-          } else {
-            replyLogged = true;
+            return false;
           }
+          return true;
         }
-        db.run("COMMIT");
-      } catch (e) {
-        try { db.run("ROLLBACK"); } catch {}
-        throw e;
-      }
+        return false;
+      });
 
       // Log event after commit (outside transaction)
       if (replyLogged && in_reply_to) logTaskEvent(in_reply_to, null, replyStatus, from_session, text.slice(0, 200));
 
-      const session = db.query<any, [string]>("SELECT status FROM sessions WHERE alias = ?1").get(alias);
+      const session = scopedSessionStatus(alias, effectiveNetId);
       pushEvent(alias, { type: "new_reply", from: from_session, message_id: id, in_reply_to, status: replyStatus });
 
       return {
@@ -480,14 +560,16 @@ export function registerTools(server: McpServer, clientIP?: string) {
     "Acknowledge receipt of a task. Does NOT enter inbox. Updates task status only.",
     {
       task_id: z.string().min(1).max(200).describe("Task ID to acknowledge"),
-      from_session: z.string().max(200).optional().default("hub"),
+      from_session: z.string().max(200).optional(),
     },
-    async ({ task_id, from_session }) => {
+    async ({ task_id, from_session: _fromIn }) => { const from_session = defaultFrom(_fromIn);
+      const effectiveNetId = getNetworkId(null);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
       console.log(`[${ts()}] ${from_session} → send_ack → task ${task_id.slice(0, 8)}`);
-      const result = db.run(
-        `UPDATE tasks SET status = 'acked' WHERE task_id = ?1 AND status IN ('created', 'delivered')`,
-        [task_id]
-      );
+      const updateParams: any[] = [task_id];
+      let updateSql = "UPDATE tasks SET status = 'acked' WHERE task_id = ?1 AND status IN ('created', 'delivered')";
+      updateSql = addScope(updateSql, updateParams, effectiveNetId);
+      const result = db.run(updateSql, updateParams);
       if (result.changes > 0) logTaskEvent(task_id, "delivered", "acked", from_session);
       return {
         content: [{
@@ -504,42 +586,40 @@ export function registerTools(server: McpServer, clientIP?: string) {
     "Retry a failed, expired, or cancelled task. Resets status to delivered and re-queues in inbox.",
     {
       task_id: z.string().min(1).max(200).describe("Task ID to retry"),
-      from_session: z.string().max(200).optional().default("hub"),
+      from_session: z.string().max(200).optional(),
     },
-    async ({ task_id, from_session }) => {
+    async ({ task_id, from_session: _fromIn }) => { const from_session = defaultFrom(_fromIn);
+      const effectiveNetId = getNetworkId(null);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
       console.log(`[${ts()}] ${from_session} → retry_task → ${task_id.slice(0, 8)}`);
       // Find the original task
-      const task = db.query<any, [string]>(
-        "SELECT * FROM tasks WHERE task_id = ?1"
-      ).get(task_id);
+      const taskParams: any[] = [task_id];
+      let taskSql = "SELECT * FROM tasks WHERE task_id = ?1";
+      taskSql = addScope(taskSql, taskParams, effectiveNetId);
+      const task = db.get<any>(taskSql, ...taskParams);
       if (!task) {
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "task not found" }) }] };
       }
       if (!["failed", "expired", "cancelled"].includes(task.status)) {
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: `task status is ${task.status}, not retryable` }) }] };
       }
-      try {
-        db.run("BEGIN IMMEDIATE");
+      db.transaction(() => {
         // Reset task status
-        db.run(
-          `UPDATE tasks SET status = 'delivered', result = NULL, completed_at = NULL, started_at = NULL, delivered_at = datetime('now'), expires_at = datetime('now', '+1 hour')
-           WHERE task_id = ?1`,
-          [task_id]
-        );
+        const updateParams: any[] = [task_id];
+        let updateSql = `UPDATE tasks SET status = 'delivered', result = NULL, completed_at = NULL, started_at = NULL, delivered_at = datetime('now'), expires_at = datetime('now', '+1 hour')
+           WHERE task_id = ?1`;
+        updateSql = addScope(updateSql, updateParams, effectiveNetId);
+        db.run(updateSql, updateParams);
         // Re-queue in inbox with new ID (original ID may already exist)
         const retryInboxId = uuidv4();
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, requires_response)
-           VALUES (?1, ?2, 'task', ?3, ?4, ?5, 'reply')`,
-          [retryInboxId, task.to_name, task.priority, task.content, from_session]
+          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, requires_response, network_id)
+           VALUES (?1, ?2, 'task', ?3, ?4, ?5, 'reply', ?6)`,
+          [retryInboxId, task.to_name, task.priority, task.content, from_session, effectiveNetId ?? task.network_id ?? null]
         );
-        db.run("COMMIT");
-        logTaskEvent(task_id, task.status, "delivered", from_session, "retry");
-      } catch (e) {
-        try { db.run("ROLLBACK"); } catch {}
-        throw e;
-      }
-      // SSE push
+      });
+      logTaskEvent(task_id, task.status, "delivered", from_session, "retry");
+      // SSE push (unconditional — channel is keyed by alias, not network)
       pushEvent(task.to_name, { type: "new_task", inbox_count: 1, priority: task.priority, from: from_session });
       return {
         content: [{ type: "text" as const, text: JSON.stringify({ ok: true, task_id, retried_to: task.to_name }) }],
@@ -555,7 +635,11 @@ export function registerTools(server: McpServer, clientIP?: string) {
       task_id: z.string().min(1).max(200).describe("Task ID to query"),
     },
     async ({ task_id }) => {
-      const task = db.query<any, [string]>("SELECT * FROM tasks WHERE task_id = ?1").get(task_id);
+      const effectiveNetId = getNetworkId(null);
+      const params: any[] = [task_id];
+      let sql = "SELECT * FROM tasks WHERE task_id = ?1";
+      sql = addScope(sql, params, effectiveNetId);
+      const task = db.get<any>(sql, ...params);
       return {
         content: [{
           type: "text" as const,
@@ -573,22 +657,27 @@ export function registerTools(server: McpServer, clientIP?: string) {
       alias: z.string().max(200).optional().describe("Filter by to_name (target agent)"),
       status: z.string().max(50).optional().describe("Filter by status"),
       from_name: z.string().max(200).optional().describe("Filter by sender"),
+      network_id: z.string().max(200).optional().describe("Filter by network"),
       limit: z.number().min(1).max(100).optional().default(20),
     },
-    async ({ alias, status, from_name, limit }) => {
+    async ({ alias, status, from_name, network_id: netId, limit }) => {
+      const effectiveNetId = getNetworkId(netId);
       let sql = "SELECT task_id, from_name, to_name, priority, status, content, result, created_at, completed_at FROM tasks WHERE 1=1";
       const params: any[] = [];
+      if (effectiveNetId) { sql += ` AND network_id = ?${params.length + 1}`; params.push(effectiveNetId); }
       if (alias) { sql += ` AND to_name = ?${params.length + 1}`; params.push(alias); }
       if (status) { sql += ` AND status = ?${params.length + 1}`; params.push(status); }
       if (from_name) { sql += ` AND from_name = ?${params.length + 1}`; params.push(from_name); }
       sql += ` ORDER BY created_at DESC LIMIT ?${params.length + 1}`;
       params.push(limit);
-      const tasks = db.query(sql).all(...params);
+      const tasks = db.all(sql, ...params);
 
       // Stats
-      const stats = db.query<any, []>(
-        "SELECT status, COUNT(*) as count FROM tasks GROUP BY status"
-      ).all();
+      const statsParams: any[] = [];
+      let statsSql = "SELECT status, COUNT(*) as count FROM tasks WHERE 1=1";
+      statsSql = addScope(statsSql, statsParams, effectiveNetId);
+      statsSql += " GROUP BY status";
+      const stats = db.all(statsSql, ...statsParams);
 
       return {
         content: [{
@@ -606,18 +695,23 @@ export function registerTools(server: McpServer, clientIP?: string) {
     {
       task_id: z.string().min(1).max(200).describe("Task ID to cancel"),
       reason: z.string().max(1000).optional().describe("Cancellation reason"),
-      from_session: z.string().max(200).optional().default("hub"),
+      from_session: z.string().max(200).optional(),
     },
-    async ({ task_id, reason, from_session }) => {
+    async ({ task_id, reason, from_session: _fromIn }) => { const from_session = defaultFrom(_fromIn);
+      const effectiveNetId = getNetworkId(null);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
       console.log(`[${ts()}] ${from_session} → cancel_task → ${task_id.slice(0, 8)}`);
-      const result = db.run(
-        `UPDATE tasks SET status = 'cancelled', result = ?1, completed_at = datetime('now')
-         WHERE task_id = ?2 AND status IN ('created', 'delivered', 'acked', 'running')`,
-        [reason || "cancelled by " + from_session, task_id]
-      );
+      const updateParams: any[] = [reason || "cancelled by " + from_session, task_id];
+      let updateSql = `UPDATE tasks SET status = 'cancelled', result = ?1, completed_at = datetime('now')
+         WHERE task_id = ?2 AND status IN ('created', 'delivered', 'acked', 'running')`;
+      updateSql = addScope(updateSql, updateParams, effectiveNetId);
+      const result = db.run(updateSql, updateParams);
       // Also ack the inbox entry to prevent agent from picking it up
       if (result.changes > 0) {
-        db.run("UPDATE inbox SET acked = 1 WHERE id = ?1 AND acked = 0", [task_id]);
+        const inboxParams: any[] = [task_id];
+        let inboxSql = "UPDATE inbox SET acked = 1 WHERE id = ?1 AND acked = 0";
+        inboxSql = addScope(inboxSql, inboxParams, effectiveNetId);
+        db.run(inboxSql, inboxParams);
         logTaskEvent(task_id, null, "cancelled", from_session, reason || undefined);
       }
       return {
@@ -633,30 +727,38 @@ export function registerTools(server: McpServer, clientIP?: string) {
     {
       task_id: z.string().min(1).max(200).describe("Task ID to reassign"),
       new_alias: z.string().min(1).max(200).describe("Target agent alias"),
-      from_session: z.string().max(200).optional().default("hub"),
+      from_session: z.string().max(200).optional(),
     },
-    async ({ task_id, new_alias, from_session }) => {
+    async ({ task_id, new_alias, from_session: _fromIn }) => { const from_session = defaultFrom(_fromIn);
+      const effectiveNetId = getNetworkId(null);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
       console.log(`[${ts()}] ${from_session} → reassign_task → ${task_id.slice(0, 8)} → ${new_alias}`);
-      const task = db.query<any, [string]>("SELECT * FROM tasks WHERE task_id = ?1").get(task_id);
+      const taskParams: any[] = [task_id];
+      let taskSql = "SELECT * FROM tasks WHERE task_id = ?1";
+      taskSql = addScope(taskSql, taskParams, effectiveNetId);
+      const task = db.get<any>(taskSql, ...taskParams);
       if (!task) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "task not found" }) }] };
       if (["replied", "failed", "cancelled", "expired"].includes(task.status)) {
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: `task is terminal (${task.status})` }) }] };
       }
       const oldAlias = task.to_name;
-      try {
-        db.run("BEGIN IMMEDIATE");
+      db.transaction(() => {
         // Ack old inbox to prevent original agent from picking it up
-        db.run("UPDATE inbox SET acked = 1 WHERE id = ?1 AND acked = 0", [task_id]);
-        db.run("UPDATE tasks SET to_name = ?1, status = 'delivered', started_at = NULL, delivered_at = datetime('now') WHERE task_id = ?2", [new_alias, task_id]);
+        const inboxParams: any[] = [task_id];
+        let inboxSql = "UPDATE inbox SET acked = 1 WHERE id = ?1 AND acked = 0";
+        inboxSql = addScope(inboxSql, inboxParams, effectiveNetId);
+        db.run(inboxSql, inboxParams);
+
+        const updateParams: any[] = [new_alias, task_id];
+        let updateSql = "UPDATE tasks SET to_name = ?1, status = 'delivered', started_at = NULL, delivered_at = datetime('now') WHERE task_id = ?2";
+        updateSql = addScope(updateSql, updateParams, effectiveNetId);
+        db.run(updateSql, updateParams);
+
         const newInboxId = uuidv4();
-        db.run("INSERT INTO inbox (id, session_name, type, priority, content, from_session, requires_response) VALUES (?1, ?2, 'task', ?3, ?4, ?5, 'reply')",
-          [newInboxId, new_alias, task.priority, task.content, from_session]);
-        db.run("COMMIT");
-        logTaskEvent(task_id, task.status, "delivered", from_session, `reassign: ${oldAlias} → ${new_alias}`);
-      } catch (e) {
-        try { db.run("ROLLBACK"); } catch {}
-        throw e;
-      }
+        db.run("INSERT INTO inbox (id, session_name, type, priority, content, from_session, requires_response, network_id) VALUES (?1, ?2, 'task', ?3, ?4, ?5, 'reply', ?6)",
+          [newInboxId, new_alias, task.priority, task.content, from_session, effectiveNetId ?? task.network_id ?? null]);
+      });
+      logTaskEvent(task_id, task.status, "delivered", from_session, `reassign: ${oldAlias} → ${new_alias}`);
       pushEvent(new_alias, { type: "new_task", inbox_count: 1, priority: task.priority, from: from_session });
       return { content: [{ type: "text" as const, text: JSON.stringify({ ok: true, task_id, reassigned_from: oldAlias, reassigned_to: new_alias }) }] };
     }
@@ -669,23 +771,27 @@ export function registerTools(server: McpServer, clientIP?: string) {
       message: z.string().min(1).max(10000),
       filter_server: z.string().max(200).optional(),
       filter_status: z.string().max(50).optional(),
+      network_id: z.string().max(200).optional().describe("Broadcast within a specific network"),
     },
-    async ({ message, filter_server, filter_status }) => {
-      console.log(`[${ts()}] hub → broadcast: ${message.slice(0, 60)}${filter_server ? " [server=" + filter_server + "]" : ""}`);
-      let sql = "SELECT alias FROM sessions WHERE alias IS NOT NULL";
+    async ({ message, filter_server, filter_status, network_id: netId }) => {
+      const effectiveNetId = getNetworkId(netId);
+      if (!canWrite(effectiveNetId)) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: "permission_denied" }) }] };
+      console.log(`[${ts()}] hub → broadcast: ${message.slice(0, 60)}${effectiveNetId ? " [net=" + effectiveNetId.slice(0, 12) + "]" : ""}`);
+      let sql = "SELECT alias, network_id FROM sessions WHERE alias IS NOT NULL";
       const params: any[] = [];
+      sql = addScope(sql, params, effectiveNetId);
       if (filter_server) { sql += " AND server = ?"; params.push(filter_server); }
       if (filter_status) { sql += " AND status = ?"; params.push(filter_status); }
 
-      const targets = db.query<{ alias: string }, any[]>(sql).all(...params);
+      const targets = db.all<{ alias: string; network_id: string | null }>(sql, ...params);
       const ids: string[] = [];
 
       for (const t of targets) {
         const id = uuidv4();
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, from_session)
-           VALUES (?1, ?2, 'broadcast', 'normal', ?3, 'hub')`,
-          [id, t.alias, message]
+          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, network_id)
+           VALUES (?1, ?2, 'broadcast', 'normal', ?3, 'hub', ?4)`,
+          [id, t.alias, message, effectiveNetId ?? t.network_id ?? null]
         );
         ids.push(id);
       }
@@ -709,16 +815,19 @@ export function registerTools(server: McpServer, clientIP?: string) {
     {
       since: z.string().optional().describe("ISO 8601 datetime, default last 24h"),
       alias: z.string().max(200).optional().describe("Filter by session alias"),
+      network_id: z.string().max(200).optional().describe("Filter by network"),
       limit: z.number().min(1).max(500).optional().default(50),
     },
-    async ({ since, alias, limit }) => {
+    async ({ since, alias, network_id: netId, limit }) => {
+      const effectiveNetId = getNetworkId(netId);
       console.log(`[${ts()}] hub → get_completions${alias ? ": " + alias : ""}`);
       const cutoff = since ?? new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
       let sql = "SELECT * FROM completions WHERE completed_at >= ?1";
       const params: any[] = [cutoff];
+      sql = addScope(sql, params, effectiveNetId);
 
       if (alias) {
-        sql += " AND session_name = ?2";
+        sql += ` AND session_name = ?${params.length + 1}`;
         params.push(alias);
       }
 
@@ -726,7 +835,7 @@ export function registerTools(server: McpServer, clientIP?: string) {
       sql += ` ORDER BY completed_at DESC LIMIT ?${paramIdx}`;
       params.push(limit);
 
-      const rows = db.query(sql).all(...params);
+      const rows = db.all(sql, ...params);
       return {
         content: [{ type: "text" as const, text: JSON.stringify({ ok: true, completions: rows }) }],
       };