@sleep2agi/commhub-server 0.8.6-preview.0 → 0.8.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.8.6-preview.0",
+  "version": "0.8.6",
   "description": "CommHub Server — AI Agent communication hub with MCP protocol, multi-network isolation, user auth, and 17 MCP tools.",
   "type": "module",
   "main": "src/index.ts",
@@ -46,6 +46,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "bun-types": "^1.3.13"
+    "bun-types": "^1.3.13",
+    "hono": "^4.12.25"
   }
 }

package/src/auth_login_guard.test.ts

@@ -0,0 +1,130 @@
+import { describe, expect, test } from "bun:test";
+import {
+  LOGIN_FAILURE_THRESHOLD,
+  LOGIN_LOCK_BASE_MS,
+  LOGIN_LOCK_MAX_MS,
+  LOGIN_IP_MAX_PER_WINDOW,
+  LOGIN_IP_WINDOW_MS,
+  getLoginClientIp,
+  LoginFailureLockout,
+  LoginIpRateLimiter,
+  normalizeLoginUsername,
+} from "./auth_login_guard";
+
+describe("LoginIpRateLimiter", () => {
+  test("allows the first N attempts and blocks N+1 within the window", () => {
+    const lim = new LoginIpRateLimiter(60_000, 3);
+    expect(lim.check("203.0.113.10", 1000).allowed).toBe(true);
+    expect(lim.check("203.0.113.10", 1001).allowed).toBe(true);
+    expect(lim.check("203.0.113.10", 1002).allowed).toBe(true);
+    const blocked = lim.check("203.0.113.10", 1003);
+    expect(blocked.allowed).toBe(false);
+    expect(blocked.retryAfterMs).toBeGreaterThan(0);
+  });
+
+  test("default public IP limit is 10/min", () => {
+    expect(LOGIN_IP_WINDOW_MS).toBe(60_000);
+    expect(LOGIN_IP_MAX_PER_WINDOW).toBe(10);
+  });
+
+  test("evicts expired entries before enforcing the cap", () => {
+    const lim = new LoginIpRateLimiter(100, 10, 2);
+    expect(lim.check("192.0.2.1", 0).allowed).toBe(true);
+    expect(lim.check("192.0.2.2", 0).allowed).toBe(true);
+    expect(lim.check("192.0.2.3", 101).allowed).toBe(true);
+
+    expect(lim.check("192.0.2.1", 102).remaining).toBe(9);
+  });
+
+  test("evicts the oldest active entry when the cap is full", () => {
+    const lim = new LoginIpRateLimiter(60_000, 1, 2);
+    expect(lim.check("192.0.2.1", 0).allowed).toBe(true);
+    expect(lim.check("192.0.2.2", 1).allowed).toBe(true);
+    expect(lim.check("192.0.2.3", 2).allowed).toBe(true);
+
+    expect(lim.check("192.0.2.1", 3).allowed).toBe(true);
+  });
+});
+
+describe("LoginFailureLockout", () => {
+  test("locks on the fifth failure and doubles subsequent lock durations", () => {
+    const lockout = new LoginFailureLockout(5, 30_000, 900_000);
+    const t0 = 1_700_000_000_000;
+    for (let i = 0; i < 4; i++) {
+      const r = lockout.recordFailure("Alice", t0 + i);
+      expect(r.locked).toBe(false);
+      expect(r.failures).toBe(i + 1);
+    }
+
+    const first = lockout.recordFailure(" alice ", t0 + 5);
+    expect(first.locked).toBe(true);
+    expect(first.lockMs).toBe(30_000);
+    expect(lockout.check("ALICE", t0 + 6).locked).toBe(true);
+
+    const second = lockout.recordFailure("alice", t0 + 30_006);
+    expect(second.locked).toBe(true);
+    expect(second.lockMs).toBe(60_000);
+  });
+
+  test("caps exponential lock duration and success clears failure state", () => {
+    const lockout = new LoginFailureLockout(2, 1000, 4000);
+    const t0 = 10_000;
+    expect(lockout.recordFailure("bob", t0).locked).toBe(false);
+    expect(lockout.recordFailure("bob", t0 + 1).lockMs).toBe(1000);
+    expect(lockout.recordFailure("bob", t0 + 1001).lockMs).toBe(2000);
+    expect(lockout.recordFailure("bob", t0 + 3002).lockMs).toBe(4000);
+    expect(lockout.recordFailure("bob", t0 + 7003).lockMs).toBe(4000);
+
+    lockout.recordSuccess("bob");
+    expect(lockout.check("bob", t0 + 7004).locked).toBe(false);
+    expect(lockout.recordFailure("bob", t0 + 7005).locked).toBe(false);
+  });
+
+  test("default failure policy is 5 failures, 30s base, 15min cap", () => {
+    expect(LOGIN_FAILURE_THRESHOLD).toBe(5);
+    expect(LOGIN_LOCK_BASE_MS).toBe(30_000);
+    expect(LOGIN_LOCK_MAX_MS).toBe(15 * 60_000);
+  });
+
+  test("evicts expired failure entries before enforcing the cap", () => {
+    const lockout = new LoginFailureLockout(2, 100, 1000, 2);
+    expect(lockout.recordFailure("alice", 0).locked).toBe(false);
+    expect(lockout.recordFailure("bob", 0).locked).toBe(false);
+    expect(lockout.recordFailure("carol", 1).locked).toBe(false);
+
+    expect(lockout.recordFailure("alice", 2).locked).toBe(false);
+  });
+
+  test("evicts the oldest active failure entry when the cap is full", () => {
+    const lockout = new LoginFailureLockout(2, 1000, 1000, 2);
+    expect(lockout.recordFailure("alice", 0).locked).toBe(false);
+    expect(lockout.recordFailure("bob", 1).locked).toBe(false);
+    expect(lockout.recordFailure("carol", 2).locked).toBe(false);
+
+    expect(lockout.recordFailure("alice", 3).locked).toBe(false);
+  });
+});
+
+describe("normalizeLoginUsername", () => {
+  test("normalizes for case-insensitive lockout keys", () => {
+    expect(normalizeLoginUsername(" Alice ")).toBe("alice");
+    expect(normalizeLoginUsername(undefined)).toBe("");
+  });
+});
+
+describe("getLoginClientIp", () => {
+  test("uses the last x-forwarded-for hop so spoofed first hops do not bypass login rate limits", () => {
+    const req = new Request("http://127.0.0.1/api/auth/login", {
+      headers: { "x-forwarded-for": "198.51.100.99, 203.0.113.10" },
+    });
+    expect(getLoginClientIp(req)).toBe("203.0.113.10");
+  });
+
+  test("falls back to x-real-ip, then unknown", () => {
+    const withRealIp = new Request("http://127.0.0.1/api/auth/login", {
+      headers: { "x-real-ip": "203.0.113.20" },
+    });
+    expect(getLoginClientIp(withRealIp)).toBe("203.0.113.20");
+    expect(getLoginClientIp(new Request("http://127.0.0.1/api/auth/login"))).toBe("unknown");
+  });
+});

package/src/auth_login_guard.ts

@@ -0,0 +1,142 @@
+// #226 — public login brute-force guard.
+// In-memory by design: zero dependency, process-local defence-in-depth for the
+// public /api/auth/login surface. Bearer token auth paths do not use this file.
+
+export const LOGIN_IP_WINDOW_MS = 60_000;
+export const LOGIN_IP_MAX_PER_WINDOW = 10;
+export const LOGIN_FAILURE_THRESHOLD = 5;
+export const LOGIN_LOCK_BASE_MS = 30_000;
+export const LOGIN_LOCK_MAX_MS = 15 * 60_000;
+export const LOGIN_GUARD_MAX_ENTRIES = 50_000;
+
+type WindowState = { count: number; resetAt: number };
+
+export class LoginIpRateLimiter {
+  private state = new Map<string, WindowState>();
+
+  constructor(
+    private readonly windowMs: number = LOGIN_IP_WINDOW_MS,
+    private readonly maxPerWindow: number = LOGIN_IP_MAX_PER_WINDOW,
+    private readonly maxEntries: number = LOGIN_GUARD_MAX_ENTRIES,
+  ) {}
+
+  check(key: string, nowMs: number = Date.now()): { allowed: boolean; remaining: number; resetAt: number; retryAfterMs?: number } {
+    if (this.state.size >= this.maxEntries && !this.state.has(key)) {
+      pruneExpired(this.state, nowMs, (entry) => nowMs >= entry.resetAt);
+      evictOldestUntilBelowCap(this.state, this.maxEntries);
+    }
+    const entry = this.state.get(key);
+    if (!entry || nowMs >= entry.resetAt) {
+      const resetAt = nowMs + this.windowMs;
+      this.state.set(key, { count: 1, resetAt });
+      return { allowed: true, remaining: this.maxPerWindow - 1, resetAt };
+    }
+    if (entry.count >= this.maxPerWindow) {
+      return { allowed: false, remaining: 0, resetAt: entry.resetAt, retryAfterMs: entry.resetAt - nowMs };
+    }
+    entry.count++;
+    return { allowed: true, remaining: this.maxPerWindow - entry.count, resetAt: entry.resetAt };
+  }
+
+  reset(): void {
+    this.state.clear();
+  }
+}
+
+type FailureState = { failures: number; lockedUntil: number };
+
+export class LoginFailureLockout {
+  private state = new Map<string, FailureState>();
+
+  constructor(
+    private readonly threshold: number = LOGIN_FAILURE_THRESHOLD,
+    private readonly baseLockMs: number = LOGIN_LOCK_BASE_MS,
+    private readonly maxLockMs: number = LOGIN_LOCK_MAX_MS,
+    private readonly maxEntries: number = LOGIN_GUARD_MAX_ENTRIES,
+  ) {}
+
+  check(username: string, nowMs: number = Date.now()): { locked: boolean; retryAfterMs?: number; lockedUntil?: number } {
+    const key = normalizeLoginUsername(username);
+    if (!key) return { locked: false };
+    const entry = this.state.get(key);
+    if (!entry || !entry.lockedUntil || nowMs >= entry.lockedUntil) return { locked: false };
+    return { locked: true, retryAfterMs: entry.lockedUntil - nowMs, lockedUntil: entry.lockedUntil };
+  }
+
+  recordFailure(username: string, nowMs: number = Date.now()): { locked: boolean; failures: number; lockMs?: number; lockedUntil?: number } {
+    const key = normalizeLoginUsername(username);
+    if (!key) return { locked: false, failures: 0 };
+    if (this.state.size >= this.maxEntries && !this.state.has(key)) {
+      pruneExpired(this.state, nowMs, (entry) => !entry.lockedUntil || nowMs >= entry.lockedUntil);
+      evictOldestUntilBelowCap(this.state, this.maxEntries);
+    }
+    const current = this.state.get(key);
+    const failures = (current?.failures ?? 0) + 1;
+    if (failures < this.threshold) {
+      this.state.set(key, { failures, lockedUntil: 0 });
+      return { locked: false, failures };
+    }
+
+    const exponent = failures - this.threshold;
+    const lockMs = Math.min(this.baseLockMs * Math.pow(2, exponent), this.maxLockMs);
+    const lockedUntil = nowMs + lockMs;
+    this.state.set(key, { failures, lockedUntil });
+    return { locked: true, failures, lockMs, lockedUntil };
+  }
+
+  recordSuccess(username: string): void {
+    const key = normalizeLoginUsername(username);
+    if (key) this.state.delete(key);
+  }
+
+  reset(): void {
+    this.state.clear();
+  }
+}
+
+export function normalizeLoginUsername(username: unknown): string {
+  return typeof username === "string" ? username.trim().toLowerCase() : "";
+}
+
+export function getLoginClientIp(req: Request): string {
+  const fwd = req.headers.get("x-forwarded-for");
+  if (fwd) {
+    const last = fwd.split(",").map((s) => s.trim()).filter(Boolean).at(-1);
+    if (last) return last;
+  }
+  return req.headers.get("x-real-ip")?.trim() || "unknown";
+}
+
+function pruneExpired<T>(map: Map<string, T>, nowMs: number, expired: (entry: T, nowMs: number) => boolean): void {
+  for (const [key, entry] of map) {
+    if (expired(entry, nowMs)) map.delete(key);
+  }
+}
+
+function evictOldestUntilBelowCap<T>(map: Map<string, T>, maxEntries: number): void {
+  while (map.size >= maxEntries) {
+    const oldest = map.keys().next().value as string | undefined;
+    if (!oldest) return;
+    map.delete(oldest);
+  }
+}
+
+function envInt(name: string, fallback: number): number {
+  const raw = process.env[name];
+  if (!raw) return fallback;
+  const n = Number(raw);
+  return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+
+export const sharedLoginIpRateLimiter = new LoginIpRateLimiter(
+  envInt("COMMHUB_LOGIN_IP_WINDOW_MS", LOGIN_IP_WINDOW_MS),
+  envInt("COMMHUB_LOGIN_IP_MAX", LOGIN_IP_MAX_PER_WINDOW),
+  envInt("COMMHUB_LOGIN_GUARD_MAX_ENTRIES", LOGIN_GUARD_MAX_ENTRIES),
+);
+
+export const sharedLoginFailureLockout = new LoginFailureLockout(
+  envInt("COMMHUB_LOGIN_FAILURE_THRESHOLD", LOGIN_FAILURE_THRESHOLD),
+  envInt("COMMHUB_LOGIN_LOCK_BASE_MS", LOGIN_LOCK_BASE_MS),
+  envInt("COMMHUB_LOGIN_LOCK_MAX_MS", LOGIN_LOCK_MAX_MS),
+  envInt("COMMHUB_LOGIN_GUARD_MAX_ENTRIES", LOGIN_GUARD_MAX_ENTRIES),
+);

package/src/db.ts

@@ -123,13 +123,14 @@ db.exec(`
     ON agent_telemetry(network_id, alias, created_at);
 `);
 
-// inbox: add in_reply_to, requires_response, expires_at, scope
+// inbox: add in_reply_to, requires_response, expires_at, scope, node identity
 for (const col of [
   { name: "in_reply_to", def: "TEXT" },
   { name: "requires_response", def: "TEXT DEFAULT 'reply'" },
   { name: "expires_at", def: "TEXT" },
   { name: "scope", def: "TEXT DEFAULT 'single'" },
   { name: "meta_json", def: "TEXT" },
+  { name: "node_id", def: "TEXT" },
 ]) {
   try { db.exec(`ALTER TABLE inbox ADD COLUMN ${col.name} ${col.def}`); } catch {}
 }
@@ -138,6 +139,7 @@ for (const col of [
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_type ON inbox(type)"); } catch {}
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_from ON inbox(from_session)"); } catch {}
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_reply ON inbox(in_reply_to)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_node ON inbox(node_id)"); } catch {}
 try { db.exec("CREATE INDEX IF NOT EXISTS idx_sessions_node ON sessions(node_id)"); } catch {}
 
 // tasks table (V2)
@@ -384,6 +386,185 @@ for (const table of ["sessions", "nodes", "tasks", "inbox", "task_events", "comp
   try { db.exec(`ALTER TABLE ${table} ADD COLUMN network_id TEXT`); } catch {}
 }
 
+// PR-1 (#146): durable node identity on historical inbox/tasks rows. Some
+// existing databases created `tasks` before from_node_id/to_node_id were in the
+// CREATE TABLE statement, so keep these ALTERs explicit and idempotent.
+for (const col of [
+  { table: "tasks", name: "from_node_id", def: "TEXT" },
+  { table: "tasks", name: "to_node_id", def: "TEXT" },
+  { table: "inbox", name: "node_id", def: "TEXT" },
+]) {
+  try { db.exec(`ALTER TABLE ${col.table} ADD COLUMN ${col.name} ${col.def}`); } catch {}
+}
+
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_from_node ON tasks(from_node_id)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_tasks_to_node ON tasks(to_node_id)"); } catch {}
+try { db.exec("CREATE INDEX IF NOT EXISTS idx_inbox_node ON inbox(node_id)"); } catch {}
+
+function backfillMessageNodeIds() {
+  let inboxDirect = 0;
+  let inboxRenamed = 0;
+  let tasksToDirect = 0;
+  let tasksToRenamed = 0;
+  let tasksFromDirect = 0;
+  let tasksFromRenamed = 0;
+
+  try {
+    inboxDirect = db.run(`
+      UPDATE inbox
+      SET node_id = (
+        SELECT s.node_id FROM sessions s
+        WHERE s.node_id IS NOT NULL
+          AND s.alias = inbox.session_name
+          AND COALESCE(s.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        ORDER BY s.updated_at DESC
+        LIMIT 1
+      )
+      WHERE node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM sessions s
+          WHERE s.node_id IS NOT NULL
+            AND s.alias = inbox.session_name
+            AND COALESCE(s.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    inboxRenamed = db.run(`
+      UPDATE inbox
+      SET node_id = (
+        SELECT s.node_id FROM rename_txn r
+        JOIN sessions s
+          ON s.alias = r.new_alias
+         AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+        WHERE s.node_id IS NOT NULL
+          AND r.status = 'committed'
+          AND r.old_alias = inbox.session_name
+          AND COALESCE(r.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        ORDER BY r.committed_at DESC
+        LIMIT 1
+      )
+      WHERE node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM rename_txn r
+          JOIN sessions s
+            ON s.alias = r.new_alias
+           AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+          WHERE s.node_id IS NOT NULL
+            AND r.status = 'committed'
+            AND r.old_alias = inbox.session_name
+            AND COALESCE(r.network_id, 'default') = COALESCE(inbox.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksToDirect = db.run(`
+      UPDATE tasks
+      SET to_node_id = (
+        SELECT s.node_id FROM sessions s
+        WHERE s.node_id IS NOT NULL
+          AND s.alias = tasks.to_name
+          AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY s.updated_at DESC
+        LIMIT 1
+      )
+      WHERE to_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM sessions s
+          WHERE s.node_id IS NOT NULL
+            AND s.alias = tasks.to_name
+            AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksToRenamed = db.run(`
+      UPDATE tasks
+      SET to_node_id = (
+        SELECT s.node_id FROM rename_txn r
+        JOIN sessions s
+          ON s.alias = r.new_alias
+         AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+        WHERE s.node_id IS NOT NULL
+          AND r.status = 'committed'
+          AND r.old_alias = tasks.to_name
+          AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY r.committed_at DESC
+        LIMIT 1
+      )
+      WHERE to_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM rename_txn r
+          JOIN sessions s
+            ON s.alias = r.new_alias
+           AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+          WHERE s.node_id IS NOT NULL
+            AND r.status = 'committed'
+            AND r.old_alias = tasks.to_name
+            AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksFromDirect = db.run(`
+      UPDATE tasks
+      SET from_node_id = (
+        SELECT s.node_id FROM sessions s
+        WHERE s.node_id IS NOT NULL
+          AND s.alias = tasks.from_name
+          AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY s.updated_at DESC
+        LIMIT 1
+      )
+      WHERE from_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM sessions s
+          WHERE s.node_id IS NOT NULL
+            AND s.alias = tasks.from_name
+            AND COALESCE(s.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  try {
+    tasksFromRenamed = db.run(`
+      UPDATE tasks
+      SET from_node_id = (
+        SELECT s.node_id FROM rename_txn r
+        JOIN sessions s
+          ON s.alias = r.new_alias
+         AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+        WHERE s.node_id IS NOT NULL
+          AND r.status = 'committed'
+          AND r.old_alias = tasks.from_name
+          AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        ORDER BY r.committed_at DESC
+        LIMIT 1
+      )
+      WHERE from_node_id IS NULL
+        AND EXISTS (
+          SELECT 1 FROM rename_txn r
+          JOIN sessions s
+            ON s.alias = r.new_alias
+           AND COALESCE(s.network_id, 'default') = COALESCE(r.network_id, 'default')
+          WHERE s.node_id IS NOT NULL
+            AND r.status = 'committed'
+            AND r.old_alias = tasks.from_name
+            AND COALESCE(r.network_id, 'default') = COALESCE(tasks.network_id, 'default')
+        )
+    `).changes;
+  } catch {}
+
+  const total = inboxDirect + inboxRenamed + tasksToDirect + tasksToRenamed + tasksFromDirect + tasksFromRenamed;
+  console.log(`[commhub] node_id backfill: inbox=${inboxDirect + inboxRenamed}, tasks.to=${tasksToDirect + tasksToRenamed}, tasks.from=${tasksFromDirect + tasksFromRenamed}, total=${total}`);
+}
+
+backfillMessageNodeIds();
+
 // ── P0: sessions alias uniqueness is network-scoped.
 // Older SQLite databases created `alias TEXT UNIQUE`, which prevents the same
 // agent alias from existing in two networks. SQLite cannot drop a UNIQUE
@@ -588,10 +769,14 @@ export function chainReplyToParent(childTaskId: string, replyText: string, reply
     if (parent.from_name && parent.from_name !== "hub" && parent.from_name !== "api") {
       try {
         const notifyId = `chain_${crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+        const notifyNode = db.get<{ node_id: string | null }>(
+          "SELECT node_id FROM sessions WHERE alias = ?1 AND COALESCE(network_id, 'default') = COALESCE(?2, 'default') ORDER BY updated_at DESC LIMIT 1",
+          [parent.from_name, parent.network_id ?? null]
+        );
         db.run(
-          `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)`,
-          [notifyId, parent.from_name, `[${childAlias} 子任务完成]\n${currentReply.slice(0, 4000)}`, parent.to_name, parent.task_id, parent.network_id ?? null]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, in_reply_to, requires_response, network_id)
+           VALUES (?1, ?2, ?3, 'reply', 'normal', ?4, ?5, ?6, 'none', ?7)`,
+          [notifyId, parent.from_name, notifyNode?.node_id ?? null, `[${childAlias} 子任务完成]\n${currentReply.slice(0, 4000)}`, parent.to_name, parent.task_id, parent.network_id ?? null]
         );
       } catch {}
     }

package/src/event_bus.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "events";
+
+export type RenameCommittedEvent = {
+  networkId: string | null;
+  old_alias: string;
+  new_alias: string;
+  node_id?: string | null;
+};
+
+export const eventBus = new EventEmitter();

package/src/index.ts

@@ -7,6 +7,7 @@ import { createSSEStream, pushEvent, getSSEStats } from "./push.js";
 import { register, login, resolveToken, getUserNetworks, getUserAllNetworks, createNetwork, deleteNetwork, renameNetwork, changePassword, issueUserToken, listTokens, createToken, revokeToken, getNetworkMembers, getUserNetworkRole, addNetworkMember, updateMemberRole, removeNetworkMember, createInvite, joinByInvite, createNetworkTokenForNode, type AuthUser } from "./auth.js";
 import { abortRename, cleanupCommittedRenameSessions, commitRename, prepareRename, resolveCanonicalAlias } from "./rename.js";
 import { sharedSendDedup, buildDuplicateSendPayload } from "./send_dedup.js";
+import { getLoginClientIp, sharedLoginFailureLockout, sharedLoginIpRateLimiter } from "./auth_login_guard.js";
 import {
   FILE_ID_REGEX,
   MAX_REQUEST_CONTENT_LENGTH,
@@ -364,7 +365,7 @@ type RestDeliveryTarget =
 
 function resolveRestDeliveryTarget(alias: string, networkId: string | null): RestDeliveryTarget {
   const params: any[] = [alias];
-  let sql = "SELECT status, updated_at, last_seen_at FROM sessions WHERE alias = ?1";
+  let sql = "SELECT status, updated_at, last_seen_at, node_id FROM sessions WHERE alias = ?1";
   if (networkId) {
     sql += " AND network_id = ?2";
     params.push(networkId);
@@ -387,6 +388,13 @@ function resolveRestDeliveryTarget(alias: string, networkId: string | null): Res
   return { state: "online", alias, session };
 }
 
+function resolveRestNodeIdForAlias(alias: string, networkId: string | null): string | null {
+  if (!alias || alias === "hub" || alias === "api") return null;
+  const canonical = resolveCanonicalAlias(networkId, alias);
+  const target = resolveRestDeliveryTarget(canonical.alias, networkId);
+  return target.state === "not_found" ? null : (target.session?.node_id ?? null);
+}
+
 // ── REST input schema ───────────────────────────────
 const TaskSchema = z.object({
   alias: z.string().min(1).max(200),
@@ -605,16 +613,37 @@ Bun.serve({
     }
 
     if (url.pathname === "/api/auth/login" && req.method === "POST") {
-      const clientIP = req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "unknown";
-      if (!checkRateLimit(clientIP, 10)) {
+      const clientIP = getLoginClientIp(req);
+      const ipRate = sharedLoginIpRateLimiter.check(clientIP || "unknown");
+      if (!ipRate.allowed) {
         logAudit(null, null, "login_rate_limited", "auth", undefined, clientIP);
-        return withCors(req, Response.json({ ok: false, error: "too many attempts, try again later" }, { status: 429 }));
+        return withCors(req, Response.json(
+          { ok: false, error: "rate_limited", message: "Too many login attempts. Try again later.", retry_after_ms: ipRate.retryAfterMs },
+          { status: 429, headers: { "Retry-After": String(Math.ceil((ipRate.retryAfterMs ?? 1000) / 1000)) } }
+        ));
       }
       try {
         const body = await req.json() as any;
+        const lock = sharedLoginFailureLockout.check(body.username);
+        if (lock.locked) {
+          logAudit(null, body.username, "login_locked", "auth", undefined, `retry_after_ms=${lock.retryAfterMs ?? 0}`);
+          return withCors(req, Response.json(
+            { ok: false, error: "login_locked", message: "Too many failed login attempts. Try again later.", retry_after_ms: lock.retryAfterMs },
+            { status: 429, headers: { "Retry-After": String(Math.ceil((lock.retryAfterMs ?? 1000) / 1000)) } }
+          ));
+        }
         const result = login(body.username, body.password);
-        if (result.ok) logAudit(result.user!.user_id, body.username, "login", "user", result.user!.user_id);
-        else logAudit(null, body.username, "login_failed", "user", undefined, "invalid credentials");
+        if (result.ok) {
+          sharedLoginFailureLockout.recordSuccess(body.username);
+          logAudit(result.user!.user_id, body.username, "login", "user", result.user!.user_id);
+        } else {
+          const failure = sharedLoginFailureLockout.recordFailure(body.username);
+          if (failure.locked) {
+            const safeUsername = String(body.username ?? "").replace(/[\r\n\t]/g, " ").slice(0, 80);
+            console.warn(`[auth] login locked for username=${safeUsername} failures=${failure.failures} retry_after_ms=${failure.lockMs}`);
+          }
+          logAudit(null, body.username, "login_failed", "user", undefined, "invalid credentials");
+        }
         return withCors(req, Response.json(result, { status: result.ok ? 200 : 401 }));
       } catch (e: any) {
         return withCors(req, Response.json({ ok: false, error: e.message }, { status: 400 }));
@@ -706,7 +735,7 @@ Bun.serve({
         }
         const result = prepareRename(resolved.user.user_id, body.network_id, body.old_alias, body.new_alias);
         if (result.ok) logAudit(resolved.user.user_id, resolved.user.username, "node_rename_prepared", "node", body.old_alias, body.new_alias);
-        return withCors(req, Response.json(result, { status: result.ok ? 200 : 400 }));
+        return withCors(req, Response.json(result, { status: result.ok || result.code === "node_local_only" ? 200 : 400 }));
       } catch (e: any) {
         return withCors(req, Response.json({ ok: false, error: e.message }, { status: 400 }));
       }
@@ -984,37 +1013,60 @@ Bun.serve({
       staleSql = addNetworkScope(staleSql, staleParams, restScope);
       db.run(staleSql, staleParams);
       cleanupCommittedRenameSessions(restScope.networkId ? [restScope.networkId] : restScope.networkIds ?? null);
+      // `?light=1` returns a narrow projection (alias / status / agent / task /
+      // server / updated_at + runtime + network_id) — used by the mobile APP
+      // list view, where pulling 30+ fields × 150 agents was making cold open
+      // take 12s+ on flaky cellular (Vincent tg, #220 PWA). Default response
+      // is unchanged so the dashboard / scripts that read full telemetry are
+      // unaffected.
+      const isLight = url.searchParams.get("light") === "1";
       const params: any[] = [];
-      let sql = "SELECT * FROM sessions WHERE 1=1";
+      let sql = isLight
+        ? "SELECT alias, status, agent, task, server, updated_at, network_id FROM sessions WHERE 1=1"
+        : "SELECT * FROM sessions WHERE 1=1";
       sql = addNetworkScope(sql, params, restScope);
       sql += " ORDER BY updated_at DESC";
       // `model` comes straight from the sessions row (SELECT *); `runtime` is
       // derived from the raw `agent` field. Both default to null for old nodes
       // that never reported a model — the dashboard falls back to a placeholder.
-      const sessions = db.all(sql, ...params).map((s: any) => ({
-        ...s,
-        model: s.model ?? null,
-        runtime: normalizeRuntime(s.agent),
-        host: {
-          hostname: s.hostname ?? null,
-          ip: s.ip ?? null,
-          cpu_load_1min: s.cpu_load_1min ?? null,
-          cpu_cores: s.cpu_cores ?? null,
-          mem_total_gb: s.mem_total_gb ?? null,
-          mem_used_gb: s.mem_used_gb ?? null,
-          mem_avail_gb: s.mem_avail_gb ?? null,
-          disk_total_gb: s.disk_total_gb ?? null,
-          disk_used_gb: s.disk_used_gb ?? null,
-          disk_avail_gb: s.disk_avail_gb ?? null,
-        },
-        process_telemetry: {
-          rss_bytes: s.process_rss_bytes ?? null,
-          rss_mb: s.process_rss_mb ?? null,
-          cpu_pct: s.process_cpu_pct ?? null,
-          uptime_seconds: s.process_uptime_seconds ?? null,
-          in_flight_count: s.process_in_flight_count ?? null,
-        },
-      }));
+      const sessions = db.all(sql, ...params).map((s: any) => {
+        if (isLight) {
+          return {
+            alias: s.alias,
+            status: s.status,
+            agent: s.agent ?? null,
+            task: s.task ?? null,
+            server: s.server ?? null,
+            updated_at: s.updated_at ?? null,
+            runtime: normalizeRuntime(s.agent),
+            network_id: s.network_id ?? null,
+          };
+        }
+        return {
+          ...s,
+          model: s.model ?? null,
+          runtime: normalizeRuntime(s.agent),
+          host: {
+            hostname: s.hostname ?? null,
+            ip: s.ip ?? null,
+            cpu_load_1min: s.cpu_load_1min ?? null,
+            cpu_cores: s.cpu_cores ?? null,
+            mem_total_gb: s.mem_total_gb ?? null,
+            mem_used_gb: s.mem_used_gb ?? null,
+            mem_avail_gb: s.mem_avail_gb ?? null,
+            disk_total_gb: s.disk_total_gb ?? null,
+            disk_used_gb: s.disk_used_gb ?? null,
+            disk_avail_gb: s.disk_avail_gb ?? null,
+          },
+          process_telemetry: {
+            rss_bytes: s.process_rss_bytes ?? null,
+            rss_mb: s.process_rss_mb ?? null,
+            cpu_pct: s.process_cpu_pct ?? null,
+            uptime_seconds: s.process_uptime_seconds ?? null,
+            in_flight_count: s.process_in_flight_count ?? null,
+          },
+        };
+      });
       const summary = sessions.reduce((acc: any, session: any) => {
         const raw = String(session.status || "").toLowerCase();
         if (raw === "offline") acc.offline++;
@@ -1486,6 +1538,8 @@ Bun.serve({
       const id = crypto.randomUUID();
       const fromSession = body.from || "api";
       const ttlSeconds = (body as any).ttl_seconds || 3600;
+      const fromNodeId = resolveRestNodeIdForAlias(fromSession, taskNetId);
+      const targetNodeId = target.session?.node_id ?? null;
       // #221 — fold top-level `attachments` into `meta.attachments` so
       // the REST and MCP send_task transports produce identical
       // tasks.meta_json shape downstream. Top-level wins over any
@@ -1525,14 +1579,14 @@ Bun.serve({
       // dispatched via REST (anet demo, dashboard Dispatch button, etc.).
       db.transaction(() => {
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, requires_response, network_id, meta_json)
-           VALUES (?1, ?2, 'task', ?3, ?4, ?5, 'reply', ?6, ?7)`,
-          [id, targetAlias, body.priority, body.task, fromSession, taskNetId, metaJson]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, requires_response, network_id, meta_json)
+           VALUES (?1, ?2, ?3, 'task', ?4, ?5, ?6, 'reply', ?7, ?8)`,
+          [id, targetAlias, targetNodeId, body.priority, body.task, fromSession, taskNetId, metaJson]
         );
         db.run(
-          `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response, created_at, delivered_at, expires_at, network_id, parent_task_id, meta_json)
-           VALUES (?1, ?2, ?3, ?4, 'delivered', ?5, 'reply', datetime('now'), datetime('now'), datetime('now', ?6), ?7, ?8, ?9)`,
-          [id, fromSession, targetAlias, body.priority, body.task, `+${ttlSeconds} seconds`, taskNetId, body.parent_task_id ?? null, metaJson]
+          `INSERT INTO tasks (task_id, from_node_id, from_name, to_node_id, to_name, priority, status, content, requires_response, created_at, delivered_at, expires_at, network_id, parent_task_id, meta_json)
+           VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'delivered', ?7, 'reply', datetime('now'), datetime('now'), datetime('now', ?8), ?9, ?10, ?11)`,
+          [id, fromNodeId, fromSession, targetNodeId, targetAlias, body.priority, body.task, `+${ttlSeconds} seconds`, taskNetId, body.parent_task_id ?? null, metaJson]
         );
         // Touch session row so the dashboard reflects "task in flight"
         // immediately, without waiting for the agent's report_status to
@@ -1590,19 +1644,19 @@ Bun.serve({
       if (!canRestWriteNetwork(restAuth, restScope.networkId, isAdmin)) {
         return withCors(req, Response.json({ ok: false, error: "permission_denied" }, { status: 403 }));
       }
-      let sql = "SELECT alias, network_id FROM sessions WHERE alias IS NOT NULL";
+      let sql = "SELECT alias, node_id, network_id FROM sessions WHERE alias IS NOT NULL";
       const params: any[] = [];
       sql = addNetworkScope(sql, params, restScope);
       if (body.filter_server) { sql += " AND server = ?"; params.push(body.filter_server); }
       if (body.filter_status) { sql += " AND status = ?"; params.push(body.filter_status); }
-      const targets = db.all<{ alias: string; network_id: string | null }>(sql, ...params);
+      const targets = db.all<{ alias: string; node_id: string | null; network_id: string | null }>(sql, ...params);
       const ids: string[] = [];
       for (const t of targets) {
         const id = crypto.randomUUID();
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, from_session, network_id)
-           VALUES (?1, ?2, 'broadcast', 'normal', ?3, 'api', ?4)`,
-          [id, t.alias, body.message, t.network_id]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, network_id)
+           VALUES (?1, ?2, ?3, 'broadcast', 'normal', ?4, 'api', ?5)`,
+          [id, t.alias, t.node_id ?? null, body.message, t.network_id]
         );
         ids.push(id);
       }

package/src/push.test.ts

@@ -0,0 +1,47 @@
+import { afterEach, expect, test } from "bun:test";
+import { eventBus } from "./event_bus";
+import { __resetSSEClientsForTest, createSSEStream, getSSEStats } from "./push";
+
+afterEach(() => {
+  __resetSSEClientsForTest();
+});
+
+test("rename-committed rekeys existing SSE clients from old alias to new alias (case 8)", async () => {
+  const res = createSSEStream("old-agent", "net-rekey-8");
+  const reader = res.body!.getReader();
+
+  expect(getSSEStats().sessions["net-rekey-8:old-agent"]).toBe(1);
+  eventBus.emit("rename-committed", {
+    networkId: "net-rekey-8",
+    old_alias: "old-agent",
+    new_alias: "new-agent",
+    node_id: "node-8",
+  });
+
+  const stats = getSSEStats().sessions;
+  expect(stats["net-rekey-8:old-agent"]).toBeUndefined();
+  expect(stats["net-rekey-8:new-agent"]).toBe(1);
+  await reader.cancel();
+});
+
+test("rename-committed merges old and new SSE client buckets without dropping clients (case 11)", async () => {
+  const oldRes = createSSEStream("old-agent", "net-rekey-11");
+  const newRes = createSSEStream("new-agent", "net-rekey-11");
+  const oldReader = oldRes.body!.getReader();
+  const newReader = newRes.body!.getReader();
+
+  expect(getSSEStats().sessions["net-rekey-11:old-agent"]).toBe(1);
+  expect(getSSEStats().sessions["net-rekey-11:new-agent"]).toBe(1);
+  eventBus.emit("rename-committed", {
+    networkId: "net-rekey-11",
+    old_alias: "old-agent",
+    new_alias: "new-agent",
+    node_id: "node-11",
+  });
+
+  const stats = getSSEStats().sessions;
+  expect(stats["net-rekey-11:old-agent"]).toBeUndefined();
+  expect(stats["net-rekey-11:new-agent"]).toBe(2);
+  await oldReader.cancel();
+  await newReader.cancel();
+});

package/src/push.ts

@@ -2,6 +2,8 @@
 // Agent 连 GET /events/:session → 保持 SSE 长连接
 // send_task 写 inbox 后 → pushEvent() → 秒达
 
+import { eventBus, type RenameCommittedEvent } from "./event_bus";
+
 type SSEClient = {
   controller: ReadableStreamDefaultController;
   encoder: TextEncoder;
@@ -72,6 +74,28 @@ function clientKey(sessionName: string, networkId?: string | null): string {
   return `${networkId || "global"}:${sessionName}`;
 }
 
+function rekeyClient(oldSessionName: string, newSessionName: string, networkId?: string | null): number {
+  if (!oldSessionName || !newSessionName || oldSessionName === newSessionName) return 0;
+  const oldKey = clientKey(oldSessionName, networkId);
+  const newKey = clientKey(newSessionName, networkId);
+  const oldClients = clients.get(oldKey);
+  if (!oldClients || oldClients.length === 0) return 0;
+
+  const existing = clients.get(newKey) || [];
+  clients.set(newKey, existing.concat(oldClients));
+  clients.delete(oldKey);
+  console.log(`[${ts()}] SSE ↔ rekey ${oldKey} → ${newKey} (${oldClients.length} clients)`);
+  return oldClients.length;
+}
+
+eventBus.on("rename-committed", (event: RenameCommittedEvent) => {
+  try {
+    rekeyClient(event.old_alias, event.new_alias, event.networkId);
+  } catch (e: any) {
+    console.log(`[${ts()}] SSE rekey failed: ${e?.message || e}`);
+  }
+});
+
 /** 推送事件给指定 session 的所有 SSE 连接 */
 export function pushEvent(sessionName: string, event: Record<string, unknown>, networkId?: string | null): void {
   const arr = clients.get(clientKey(sessionName, networkId ?? (event.network_id as string | null | undefined)));
@@ -95,6 +119,10 @@ export function pushEvent(sessionName: string, event: Record<string, unknown>, n
   if (arr.length === 0) clients.delete(clientKey(sessionName, networkId ?? (event.network_id as string | null | undefined)));
 }
 
+export function __resetSSEClientsForTest(): void {
+  clients.clear();
+}
+
 /** 获取当前 SSE 连接统计 */
 export function getSSEStats(): { total: number; sessions: Record<string, number> } {
   let total = 0;

package/src/rename.ts

@@ -16,11 +16,14 @@ import { randomUUID } from "crypto";
 import { db } from "./db";
 import { getUserNetworkRole, getNetworkMembers } from "./auth";
 import { pushEvent } from "./push";
+import { eventBus } from "./event_bus";
 
 export interface RenameResult {
   ok: boolean;
   txn_id?: string;
   error?: string;
+  code?: string;
+  suggested?: string;
 }
 
 export interface CanonicalAlias {
@@ -111,7 +114,14 @@ export function prepareRename(
   // old-alias must exist as a session in this network
   const oldSession = db.get<any>(
     "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2", networkId, oldAlias);
-  if (!oldSession) return { ok: false, error: `node "${oldAlias}" not found in this network` };
+  if (!oldSession) {
+    return {
+      ok: false,
+      code: "node_local_only",
+      error: `node "${oldAlias}" has no server session in this network`,
+      suggested: "rename locally",
+    };
+  }
 
   // new-alias must not be taken — in sessions OR reserved by another prepared txn
   const newInSessions = db.get<any>(
@@ -147,19 +157,32 @@ export function commitRename(userId: string, txnId: string): RenameResult {
     "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2", txn.network_id, txn.new_alias);
   if (conflict) return { ok: false, error: `alias "${txn.new_alias}" was taken since prepare` };
 
-  db.run(
-    "UPDATE sessions SET alias = ?1, updated_at = datetime('now') WHERE network_id = ?2 AND alias = ?3",
-    [txn.new_alias, txn.network_id, txn.old_alias]);
-  cleanupRenamedAliasSession(txn.network_id, txn.old_alias, txn.new_alias);
-  db.run(
-    "UPDATE nodes SET alias = ?1, updated_at = datetime('now') WHERE network_id = ?2 AND alias = ?3",
-    [txn.new_alias, txn.network_id, txn.old_alias]);
-  db.run(
-    "UPDATE api_tokens SET name = ?1 WHERE network_id = ?2 AND name = ?3",
-    [`node:${txn.new_alias}`, txn.network_id, `node:${txn.old_alias}`]);
-  db.run(
-    "UPDATE rename_txn SET status = 'committed', committed_at = datetime('now') WHERE txn_id = ?1",
-    [txnId]);
+  const renamedNode = db.transaction(() => {
+    db.run(
+      "UPDATE sessions SET alias = ?1, updated_at = datetime('now') WHERE network_id = ?2 AND alias = ?3",
+      [txn.new_alias, txn.network_id, txn.old_alias]);
+    cleanupRenamedAliasSession(txn.network_id, txn.old_alias, txn.new_alias);
+    db.run(
+      "UPDATE nodes SET alias = ?1, updated_at = datetime('now') WHERE network_id = ?2 AND alias = ?3",
+      [txn.new_alias, txn.network_id, txn.old_alias]);
+    db.run(
+      "UPDATE api_tokens SET name = ?1 WHERE network_id = ?2 AND name = ?3",
+      [`node:${txn.new_alias}`, txn.network_id, `node:${txn.old_alias}`]);
+    db.run(
+      "UPDATE rename_txn SET status = 'committed', committed_at = datetime('now') WHERE txn_id = ?1",
+      [txnId]);
+    const node = db.get<{ node_id: string | null }>(
+      "SELECT node_id FROM sessions WHERE network_id = ?1 AND alias = ?2",
+      [txn.network_id, txn.new_alias]
+    );
+    eventBus.emit("rename-committed", {
+      networkId: txn.network_id,
+      old_alias: txn.old_alias,
+      new_alias: txn.new_alias,
+      node_id: node?.node_id ?? null,
+    });
+    return node;
+  });
 
   // RFC-010 §4.2.1 C4 — broadcast node.renamed SSE. (#84 实施补漏: the Server
   // surface originally missed C4; N站马's dashboard slice needs this event.)
@@ -174,9 +197,11 @@ export function commitRename(userId: string, txnId: string): RenameResult {
     txn_id: txnId,
     alias: txn.new_alias,
     network_id: txn.network_id,
+    node_id: renamedNode?.node_id ?? null,
     data: {
       old_alias: txn.old_alias,
       new_alias: txn.new_alias,
+      node_id: renamedNode?.node_id ?? null,
       surfaces_updated: ["config", "tmux", "commhub", "dashboard", "batch_prefix", "session_resume"],
       history_policy: "preserve",
     },

package/src/tools.ts

@@ -119,11 +119,18 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
 
   const scopedSessionStatus = (alias: string, networkId?: string | null) => {
     const params: any[] = [alias];
-    let sql = "SELECT status, updated_at, last_seen_at FROM sessions WHERE alias = ?1";
+    let sql = "SELECT status, updated_at, last_seen_at, node_id FROM sessions WHERE alias = ?1";
     sql = addScope(sql, params, networkId);
     return db.get<any>(sql, ...params);
   };
 
+  const resolveNodeIdForAlias = (alias: string, networkId?: string | null): string | null => {
+    if (!alias || alias === "hub" || alias === "api") return null;
+    const canonical = resolveCanonicalAlias(networkId, alias);
+    const session = scopedSessionStatus(canonical.alias, networkId);
+    return session?.node_id ?? null;
+  };
+
   const resolveDeliveryTarget = (alias: string, networkId?: string | null): DeliveryTarget => {
     const session = scopedSessionStatus(alias, networkId);
     if (!session) {
@@ -746,20 +753,22 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
 
       console.log(`[${ts()}] ${from_session} → send_task → ${targetAlias}: ${task.slice(0, 60)}${priority === "high" ? " [HIGH]" : ""}${canonical.renamed ? ` [renamed from ${alias}]` : ""}`);
       const id = uuidv4();
+      const fromNodeId = resolveNodeIdForAlias(from_session, effectiveNetId);
+      const targetNodeId = target.session?.node_id ?? null;
       // 事务：inbox + tasks 双写 + 触碰目标 session 的 task/updated_at（让
       // dashboard 在派任务一刻就反映出"任务已下发"，不再等 agent 的
       // report_status 心跳；status 字段交给 agent，避免与 working/idle
       // 报告冲突）。
       db.transaction(() => {
         db.run(
-          `INSERT INTO inbox (id, session_name, type, priority, content, context, from_session, requires_response, network_id, meta_json)
-           VALUES (?1, ?2, 'task', ?3, ?4, ?5, ?6, 'reply', ?7, ?8)`,
-          [id, targetAlias, priority, task, context ?? null, from_session, effectiveNetId ?? null, metaJson]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, context, from_session, requires_response, network_id, meta_json)
+           VALUES (?1, ?2, ?3, 'task', ?4, ?5, ?6, ?7, 'reply', ?8, ?9)`,
+          [id, targetAlias, targetNodeId, priority, task, context ?? null, from_session, effectiveNetId ?? null, metaJson]
         );
         db.run(
-          `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response, created_at, delivered_at, expires_at, network_id, parent_task_id, meta_json)
-           VALUES (?1, ?2, ?3, ?4, 'delivered', ?5, 'reply', datetime('now'), datetime('now'), datetime('now', ?6), ?7, ?8, ?9)`,
-          [id, from_session, targetAlias, priority, task, `+${ttl_seconds || 3600} seconds`, effectiveNetId ?? null, parentTaskId, metaJson]
+          `INSERT INTO tasks (task_id, from_node_id, from_name, to_node_id, to_name, priority, status, content, requires_response, created_at, delivered_at, expires_at, network_id, parent_task_id, meta_json)
+           VALUES (?1, ?2, ?3, ?4, ?5, ?6, 'delivered', ?7, 'reply', datetime('now'), datetime('now'), datetime('now', ?8), ?9, ?10, ?11)`,
+          [id, fromNodeId, from_session, targetNodeId, targetAlias, priority, task, `+${ttl_seconds || 3600} seconds`, effectiveNetId ?? null, parentTaskId, metaJson]
         );
         const touchParams: any[] = [task.slice(0, 200), targetAlias];
         let touchSql = "UPDATE sessions SET task = ?1, updated_at = datetime('now') WHERE alias = ?2";
@@ -833,22 +842,31 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     async ({ alias, message, from_session: _fromIn }) => { const fromMismatch = fromIdentityMismatchReply(_fromIn); if (fromMismatch) return fromMismatch; const from_session = defaultFrom(_fromIn);
       const effectiveNetId = getNetworkId(null);
       if (!canWrite(effectiveNetId)) return writeDeniedReply(effectiveNetId);
-      const target = resolveDeliveryTarget(alias, effectiveNetId);
+      const canonical = resolveCanonicalAlias(effectiveNetId, alias);
+      const targetAlias = canonical.alias;
+      const target = resolveDeliveryTarget(targetAlias, effectiveNetId);
       if (target.state === "not_found") return deliveryTargetReply(target)!;
-      console.log(`[${ts()}] ${from_session} → send_message → ${alias}: ${message.slice(0, 60)}`);
+      console.log(`[${ts()}] ${from_session} → send_message → ${targetAlias}: ${message.slice(0, 60)}${canonical.renamed ? ` [renamed from ${alias}]` : ""}`);
       const id = uuidv4();
       db.run(
-        `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]
+        `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, network_id)
+         VALUES (?1, ?2, ?3, 'message', 'normal', ?4, ?5, ?6)`,
+        [id, targetAlias, target.session?.node_id ?? null, message, from_session, effectiveNetId ?? null]
       );
 
       if (target.state === "online") {
-        pushEvent(alias, { type: "new_message", from: from_session, message_id: id }, effectiveNetId);
+        pushEvent(targetAlias, { type: "new_message", from: from_session, message_id: id, ...(canonical.renamed ? { renamed_from: alias } : {}) }, effectiveNetId);
       }
 
       const offlineReply = deliveryTargetReply(target, { message_id: id });
-      if (offlineReply) return offlineReply;
+      if (offlineReply) {
+        const payload = JSON.parse(offlineReply.content[0].text);
+        offlineReply.content[0].text = JSON.stringify({
+          ...payload,
+          ...(canonical.renamed ? { renamed_from: alias, renamed_to: targetAlias } : {}),
+        });
+        return offlineReply;
+      }
 
       return {
         content: [
@@ -857,6 +875,7 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
             text: JSON.stringify({
               ok: true,
               message_id: id,
+              ...(canonical.renamed ? { renamed_from: alias, renamed_to: targetAlias } : {}),
               session_status: target.session?.status ?? "unknown",
             }),
           },
@@ -917,11 +936,12 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
           };
         }
       }
+      const replyTargetNodeId = resolveNodeIdForAlias(alias, effectiveNetId);
       const replyLogged = db.transaction(() => {
         db.run(
-          `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]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, in_reply_to, requires_response, network_id)
+           VALUES (?1, ?2, ?3, 'reply', 'normal', ?4, ?5, ?6, 'none', ?7)`,
+          [id, alias, replyTargetNodeId, text, from_session, in_reply_to ?? null, effectiveNetId ?? null]
         );
 
         // 更新 tasks 表
@@ -1053,9 +1073,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         // 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, 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]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, requires_response, network_id)
+           VALUES (?1, ?2, ?3, 'task', ?4, ?5, ?6, 'reply', ?7)`,
+          [retryInboxId, task.to_name, task.to_node_id ?? resolveNodeIdForAlias(task.to_name, effectiveNetId ?? task.network_id ?? null), task.priority, task.content, from_session, effectiveNetId ?? task.network_id ?? null]
         );
       });
       logTaskEvent(task_id, task.status, "delivered", from_session, "retry");
@@ -1098,18 +1118,20 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       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"),
+      from_node_id: z.string().max(200).optional().describe("Filter by immutable sender node_id"),
       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, network_id: netId, limit }) => {
+    async ({ alias, status, from_name, from_node_id, network_id: netId, limit }) => {
       const readScope = resolveReadScope(netId);
       if (readScope.denied) return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: readScope.denied }) }] };
-      let sql = "SELECT task_id, from_name, to_name, priority, status, content, result, created_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, 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); }
       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); }
+      if (from_node_id) { sql += ` AND from_node_id = ?${params.length + 1}`; params.push(from_node_id); }
       sql += ` ORDER BY created_at DESC LIMIT ?${params.length + 1}`;
       params.push(limit);
       const tasks = db.all(sql, ...params);
@@ -1184,6 +1206,10 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         return { content: [{ type: "text" as const, text: JSON.stringify({ ok: false, error: `task is terminal (${task.status})` }) }] };
       }
       const oldAlias = task.to_name;
+      const canonical = resolveCanonicalAlias(effectiveNetId ?? task.network_id ?? null, new_alias);
+      const reassignedAlias = canonical.alias;
+      const target = resolveDeliveryTarget(reassignedAlias, effectiveNetId ?? task.network_id ?? null);
+      const newNodeId = target.state === "not_found" ? null : (target.session?.node_id ?? null);
       db.transaction(() => {
         // Ack old inbox to prevent original agent from picking it up
         const inboxParams: any[] = [task_id];
@@ -1191,18 +1217,18 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
         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";
+        const updateParams: any[] = [reassignedAlias, newNodeId, task_id];
+        let updateSql = "UPDATE tasks SET to_name = ?1, to_node_id = ?2, status = 'delivered', started_at = NULL, delivered_at = datetime('now') WHERE task_id = ?3";
         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, 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]);
+        db.run("INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, requires_response, network_id) VALUES (?1, ?2, ?3, 'task', ?4, ?5, ?6, 'reply', ?7)",
+          [newInboxId, reassignedAlias, newNodeId, 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 }, effectiveNetId ?? task.network_id ?? null);
-      return { content: [{ type: "text" as const, text: JSON.stringify({ ok: true, task_id, reassigned_from: oldAlias, reassigned_to: new_alias }) }] };
+      logTaskEvent(task_id, task.status, "delivered", from_session, `reassign: ${oldAlias} → ${reassignedAlias}`);
+      pushEvent(reassignedAlias, { type: "new_task", inbox_count: 1, priority: task.priority, from: from_session, ...(canonical.renamed ? { renamed_from: new_alias } : {}) }, effectiveNetId ?? task.network_id ?? null);
+      return { content: [{ type: "text" as const, text: JSON.stringify({ ok: true, task_id, reassigned_from: oldAlias, reassigned_to: reassignedAlias, ...(canonical.renamed ? { renamed_from: new_alias, renamed_to: reassignedAlias } : {}) }) }] };
     }
   );
 
@@ -1219,21 +1245,21 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
       const effectiveNetId = getNetworkId(netId);
       if (!canWrite(effectiveNetId)) return writeDeniedReply(effectiveNetId);
       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";
+      let sql = "SELECT alias, node_id, 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.all<{ alias: string; network_id: string | null }>(sql, ...params);
+      const targets = db.all<{ alias: string; node_id: string | null; 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, network_id)
-           VALUES (?1, ?2, 'broadcast', 'normal', ?3, 'hub', ?4)`,
-          [id, t.alias, message, effectiveNetId ?? t.network_id ?? null]
+          `INSERT INTO inbox (id, session_name, node_id, type, priority, content, from_session, network_id)
+           VALUES (?1, ?2, ?3, 'broadcast', 'normal', ?4, 'hub', ?5)`,
+          [id, t.alias, t.node_id ?? null, message, effectiveNetId ?? t.network_id ?? null]
         );
         ids.push(id);
       }