@sleep2agi/commhub-server 0.9.0-preview.131 → 0.9.0-preview.133

package/package.json

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

package/src/dashboard-slash-routing-http.test.ts

@@ -14,6 +14,7 @@ const TARGET_RESUME_ID = `resume_dashboard_slash_target_${process.pid}`;
 let server: any;
 let base = "";
 let userToken = "";
+let userName = "";
 let nodeToken = "";
 let networkId = "";
 let requestSequence = 0;
@@ -25,6 +26,7 @@ let requestSequence = 0;
 beforeAll(async () => {
   process.env.COMMHUB_DB = process.env.COMMHUB_DB || join(PRIVATE_DB_DIR, "hub.db");
   const username = `dashboard_slash_${Date.now()}`;
+  userName = username;
   const registered = register(username, "DashboardSlash123!", undefined, "seed");
   expect(registered.ok).toBe(true);
   userToken = registered.token!;
@@ -81,7 +83,7 @@ async function postAndRead(token: string, from: string, task: string) {
 describe("real Hub → authenticated Dashboard slash routing", () => {
   test("Dashboard /goal and /loop remain exact native payloads for every runtime", async () => {
     for (const command of ["/goal 更新一下文档", "/loop 5m native loop"] as const) {
-      const row = await postAndRead(userToken, "dashboard-user", command);
+      const row = await postAndRead(userToken, userName, command);
       expect(row.content).toBe(command);
       expect(isInteractiveDashboardTask(row)).toBe(true);
       for (const runtime of ["codex-app-server", "codex", "claude", "grok", "opencode"] as const) {
@@ -92,7 +94,7 @@ describe("real Hub → authenticated Dashboard slash routing", () => {
 
   test("Dashboard /agoal and /aloop use the Agent Network scheduler", async () => {
     for (const command of ["/agoal 5m update docs", "/aloop 5m update docs"] as const) {
-      const row = await postAndRead(userToken, "dashboard-user", command);
+      const row = await postAndRead(userToken, userName, command);
       expect(isInteractiveDashboardTask(row)).toBe(true);
       expect(shouldCreateScheduledGoal(row.content, "codex-app-server", true)).toBe(true);
     }

package/src/node-caller-identity-http.test.ts

@@ -75,6 +75,92 @@ let p10Owner: Tok;
 type Sub = { events: any[]; done: boolean; abort: () => void; ready: Promise<void> };
 const openSubs: Sub[] = [];
 
+for (const transport of ["mcp", "rest"] as const) {
+  for (const shape of ["bound duplicate", "unbound duplicate", "no session", "other network"] as const) {
+    test(`node attribution: ${transport} ${shape} retains the credential's node ID`, async () => {
+      const key = `${transport}-${shape.replaceAll(" ", "-")}-${stamp}`;
+      const alias = `idvsender-${key}`;
+      const mine = `n_idv_sender_${key}`;
+      const member = register(`idvmem-${key}`, "CallerMember123!", undefined, "seed");
+      if (!member.ok || !member.user) throw new Error("member fixture failed");
+      const memberId = member.user.user_id;
+      const joined = addNetworkMember(NET, memberId, "member", ownerId, { agentAccess: "all" });
+      if (!joined.ok) throw new Error(joined.error);
+      seedNode(mine, alias, NET, memberId);
+      if (shape.includes("duplicate")) {
+        const ownerNode = `n_idv_owner_${key}`;
+        seedNode(ownerNode, alias, NET, ownerId);
+        seedSession(ownerNode, alias, NET); // the active session belongs to a different row
+      }
+      if (shape === "other network") {
+        const foreignNode = `n_idv_foreign_${key}`;
+        seedNode(foreignNode, alias, NET2, outsiderId);
+        seedSession(foreignNode, alias, NET2);
+      }
+      const tok = mint(memberId, NET, shape === "bound duplicate" ? victimAlias : alias,
+        shape === "unbound duplicate" ? 0 : 2, shape === "unbound duplicate" ? null : mine);
+      const content = `sender identity ${key}`;
+      const sent = transport === "mcp"
+        ? await mcpSend(tok.token, content, undefined)
+        : (await api(tok.token, "POST", "/api/task", { alias: sinkAlias, task: content, network_id: NET })).body;
+      expect(sent.ok).toBe(true);
+      const row = db.get("SELECT from_name, from_node_id, network_id FROM tasks WHERE content = ?1", content);
+      expect(row).toEqual({ from_name: alias, from_node_id: mine, network_id: NET });
+    });
+  }
+}
+
+for (const owner of ["own", "another"] as const) {
+  test(`rename registry: prepare rejects ${owner} node without a session`, async () => {
+    const target = `idvreserved-${owner}-${stamp}`;
+    seedNode(`n_idv_reserved_${owner}_${stamp}`, target, NET, owner === "own" ? ownerId : outsiderId);
+    const before = db.get("SELECT COUNT(*) AS n FROM rename_txn");
+    const result = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: victimAlias, new_alias: target });
+    expect(result.status).toBe(400);
+    expect(result.body.ok).toBe(false);
+    expect(db.get("SELECT COUNT(*) AS n FROM rename_txn")).toEqual(before);
+    expect(sessionSnap(victimAlias, NET)?.node_id).toBe(victimId);
+  });
+}
+
+test("rename registry: commit rejects a node created after prepare", async () => {
+  const target = `idvrace-${stamp}`;
+  const prepared = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: victimAlias, new_alias: target });
+  expect(prepared.body.ok).toBe(true);
+  const nodeId = `n_idv_race_${stamp}`;
+  seedNode(nodeId, target, NET, outsiderId);
+  const result = await api(ownerToken, "POST", "/api/node-rename/commit", { txn_id: prepared.body.txn_id });
+  expect(result.status).toBe(400);
+  expect(result.body.ok).toBe(false);
+  expect(sessionSnap(victimAlias, NET)?.node_id).toBe(victimId);
+  expect(db.get("SELECT alias FROM nodes WHERE node_id = ?1", nodeId)).toEqual({ alias: target });
+  expect(db.get("SELECT status FROM rename_txn WHERE txn_id = ?1", prepared.body.txn_id)).toEqual({ status: "prepared" });
+  await api(ownerToken, "POST", "/api/node-rename/abort", { txn_id: prepared.body.txn_id });
+});
+
+test("rename registry: another network's node does not reserve the local alias", async () => {
+  const target = `idvforeign-target-${stamp}`;
+  seedNode(`n_idv_foreign_target_${stamp}`, target, NET2, outsiderId);
+  const prepared = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: victimAlias, new_alias: target });
+  expect(prepared.body.ok).toBe(true);
+  expect((await api(ownerToken, "POST", "/api/node-rename/abort", { txn_id: prepared.body.txn_id })).body.ok).toBe(true);
+});
+
+test("rename registry: a free alias commits and preserves node identity", async () => {
+  const alias = `idvrename-old-${stamp}`;
+  const target = `idvrename-new-${stamp}`;
+  const nodeId = `n_idv_rename_${stamp}`;
+  seedNode(nodeId, alias, NET, ownerId);
+  seedSession(nodeId, alias, NET);
+  const prepared = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: alias, new_alias: target });
+  expect(prepared.body.ok).toBe(true);
+  const committed = await api(ownerToken, "POST", "/api/node-rename/commit", { txn_id: prepared.body.txn_id });
+  expect(committed.body.ok).toBe(true);
+  expect(sessionSnap(target, NET)?.node_id).toBe(nodeId);
+  expect(sessionSnap(alias, NET)).toBeNull();
+  expect(db.get("SELECT alias FROM nodes WHERE node_id = ?1", nodeId)).toEqual({ alias: target });
+});
+
 function subscribe(path: string, token: string, headers: Record<string, string> = {}): Sub {
   const ctrl = new AbortController();
   const sub: Sub = { events: [], done: false, abort: () => ctrl.abort(), ready: Promise.resolve() };
@@ -165,6 +251,16 @@ function minted(userId: string, networkId: string, alias: string, nodeId: string
   return { token: row.token, tokenId: row.token_id };
 }
 
+function seedNode(nodeId: string, alias: string, networkId: string, userId: string) {
+  db.run(`INSERT INTO nodes (node_id, node_name, alias, network_id, owner_user_id)
+          VALUES (?1, ?2, ?2, ?3, ?4)`, [nodeId, alias, networkId, userId]);
+}
+
+function seedSession(nodeId: string, alias: string, networkId: string) {
+  db.run(`INSERT INTO sessions (resume_id, alias, node_id, network_id, status)
+          VALUES (?1, ?2, ?3, ?4, 'idle')`, [`sdk-${nodeId}`, alias, nodeId, networkId]);
+}
+
 function taskCount(content: string): number {
   return Number(db.get<{ n: number | string }>("SELECT COUNT(*) AS n FROM tasks WHERE content = ?1", content)?.n ?? 0);
 }
@@ -192,6 +288,115 @@ const report = (tok: Tok, alias: string, nodeId: string, networkId: string, extr
     ...extra,
   });
 
+function lifecycleFixture(key: string) {
+  const daemonId = `node_life_daemon_${key}_${stamp}`, daemonAlias = `life-daemon-${key}-${stamp}`;
+  const childId = `node_life_${key}_${stamp}`, childAlias = `life-child-${key}-${stamp}`;
+  seedNode(daemonId, daemonAlias, NET, ownerId); seedNode(childId, childAlias, NET, ownerId);
+  seedSession(daemonId, daemonAlias, NET);
+  db.run("UPDATE nodes SET hostname='lifecycle-host',config_snapshot=?1 WHERE node_id=?2",
+    [JSON.stringify({ role: "host_supervisor", daemon_capabilities: { adopt_capable: true } }), daemonId]);
+  db.run("UPDATE nodes SET hostname='lifecycle-host',config_snapshot='{}' WHERE node_id=?1", [childId]);
+  db.run("UPDATE sessions SET last_seen_at=datetime('now') WHERE node_id=?1", [daemonId]);
+  return { daemonId, daemonAlias, childId, childAlias };
+}
+
+test("token lifecycle: adoption rejects a different node's same-name credential", async () => {
+  const f = lifecycleFixture("adopt-denied");
+  const otherNode = `n_life_other_${stamp}`;
+  seedNode(otherNode, `life-other-${stamp}`, NET, outsiderId);
+  mint(outsiderId, NET, f.daemonAlias, 2, otherNode);
+  mint(outsiderId, NET, f.daemonAlias, 0, null);
+  const result = await tool(ownerToken, "request_adopt_node", { node_id: f.childId, daemon_node_id: f.daemonId, workdir: "/workspace/fixture" });
+  expect(result.error).toBe("daemon_offline");
+  expect(db.get("SELECT request_id FROM node_daemon_bindings WHERE node_id=?1", f.childId)).toBeNull();
+});
+
+for (const shape of ["bound", "unbound"] as const) {
+  test(`token lifecycle: adoption accepts verified ${shape} credentials`, async () => {
+    const f = lifecycleFixture(`adopt-${shape}`);
+    mint(ownerId, NET, shape === "bound" ? victimAlias : f.daemonAlias, shape === "bound" ? 2 : 0, shape === "bound" ? f.daemonId : null);
+    const result = await tool(ownerToken, "request_adopt_node", { node_id: f.childId, daemon_node_id: f.daemonId, workdir: "/workspace/fixture" });
+    expect(result.ok).toBe(true);
+  });
+}
+
+test("token lifecycle: another node's heartbeat cannot make the daemon ready", async () => {
+  const f=lifecycleFixture("heartbeat-denied");
+  mint(ownerId,NET,f.daemonAlias,2,f.daemonId);
+  const other=`node_life_heartbeat_other_${stamp}`;
+  seedNode(other,f.daemonAlias,NET,outsiderId);
+  db.run("DELETE FROM sessions WHERE node_id=?1",[f.daemonId]);
+  seedSession(other,f.daemonAlias,NET);
+  db.run("UPDATE sessions SET last_seen_at=datetime('now') WHERE node_id=?1",[other]);
+  const result=await tool(ownerToken,"request_adopt_node",{node_id:f.childId,daemon_node_id:f.daemonId,workdir:"/workspace/fixture"});
+  expect(result.error).toBe("daemon_offline");
+});
+
+test("token lifecycle: a unique legacy null-ID heartbeat remains supported", async () => {
+  const f=lifecycleFixture("heartbeat-legacy");
+  mint(ownerId,NET,f.daemonAlias,0,null);
+  db.run("UPDATE sessions SET node_id=NULL WHERE node_id=?1",[f.daemonId]);
+  expect((await tool(ownerToken,"request_adopt_node",{node_id:f.childId,daemon_node_id:f.daemonId,workdir:"/workspace/fixture"})).ok).toBe(true);
+});
+
+for (const shape of ["frozen", "legacy null", "wrong frozen", "same alias rebuild"] as const) {
+  test(`token lifecycle: delete ${shape} revokes only the target credential`, async () => {
+    const key = shape.replaceAll(" ", "-"); const f = lifecycleFixture(key);
+    const daemonTok = mint(ownerId, NET, f.daemonAlias, 2, f.daemonId);
+    const wrong = mint(outsiderId, NET, f.childAlias, 0, null);
+    const childTok = mint(ownerId, NET, shape === "frozen" ? victimAlias : f.childAlias, 2, f.childId);
+    db.run(`INSERT INTO node_create_requests(request_id,daemon_node_id,child_name,child_node_id,network_id,runtime,flags_json,env_keys,status,child_token_id,created_at,created_by_token)
+            VALUES(?1,?2,?3,?4,?5,'fixture','{}','[]','started',?6,?7,'fixture')`,
+      [`cr_${f.childId.slice(5)}`, f.daemonId, f.childAlias, f.childId, NET, childTok.tokenId, Date.now()]);
+    const dispatched = await tool(ownerToken, "delete_node", { child_node_id: f.childId, daemon_node_id: f.daemonId, network_id: NET, confirm_alias: f.childAlias });
+    expect(dispatched.ok).toBe(true);
+    expect(db.get<{ child_token_id: string }>("SELECT child_token_id FROM node_stop_requests WHERE request_id=?1", dispatched.request_id)?.child_token_id).toBe(childTok.tokenId);
+    if (shape === "legacy null" || shape === "wrong frozen") db.run("UPDATE node_stop_requests SET child_token_id=?1 WHERE request_id=?2", [shape === "wrong frozen" ? wrong.tokenId : null, dispatched.request_id]);
+    let rebuilt: Tok | null = null;
+    if (shape === "same alias rebuild") {
+      db.run("DELETE FROM nodes WHERE node_id=?1", [f.childId]);
+      const newId = `n_life_rebuilt_${stamp}`;seedNode(newId, f.childAlias, NET, ownerId);
+      rebuilt = mint(ownerId, NET, f.childAlias, 2, newId);
+    }
+    const ack = await tool(daemonTok.token, "ack_stop_request", { request_id: dispatched.request_id, status: "stopped" });
+    expect(ack.ok).toBe(true);
+    const revoked = (id: string) => db.get<{ revoked_at: string | null }>("SELECT revoked_at FROM api_tokens WHERE token_id=?1", id)?.revoked_at;
+    expect(revoked(childTok.tokenId)).not.toBeNull();
+    expect(revoked(wrong.tokenId)).toBeNull();
+    if (rebuilt) expect(revoked(rebuilt.tokenId)).toBeNull();
+    expect(db.get("SELECT node_id FROM nodes WHERE node_id=?1", f.childId)).toBeNull();
+  });
+}
+
+test("token lifecycle: rename updates verified labels and preserves unrelated credentials", async () => {
+  const alias = `life-rename-${stamp}`, nodeId = `n_life_rename_${stamp}`, target = `life-renamed-${stamp}`;
+  seedNode(nodeId, alias, NET, ownerId);seedSession(nodeId, alias, NET);
+  const unrelated = mint(outsiderId, NET, alias, 0, null);
+  const bound = mint(ownerId, NET, victimAlias, 2, nodeId);
+  const legacy = mint(ownerId, NET, alias, 0, null);
+  const foreign = mint(outsiderId, NET2, alias, 0, null);
+  const before = [unrelated,foreign].map(t => tokenName(t.tokenId));
+  const prepare = await api(ownerToken, "POST", "/api/node-rename/prepare", { network_id: NET, old_alias: alias, new_alias: target });
+  expect(prepare.body.ok).toBe(true);
+  expect((await api(ownerToken, "POST", "/api/node-rename/commit", { txn_id: prepare.body.txn_id })).body.ok).toBe(true);
+  expect(tokenName(bound.tokenId)).toBe(`node:${target}`);
+  expect(tokenName(legacy.tokenId)).toBe(`node:${target}`);
+  expect([unrelated,foreign].map(t => tokenName(t.tokenId))).toEqual(before);
+});
+
+test("token lifecycle: rename refuses ambiguous node rows before and after prepare", async () => {
+  const alias=`life-dup-rename-${stamp}`, nodeId=`n_life_dupr_${stamp}`, target=`life-dup-target-${stamp}`;
+  seedNode(nodeId,alias,NET,ownerId);seedSession(nodeId,alias,NET);
+  const mine=mint(ownerId,NET,alias,2,nodeId);
+  const prepared=await api(ownerToken,"POST","/api/node-rename/prepare",{network_id:NET,old_alias:alias,new_alias:target});expect(prepared.body.ok).toBe(true);
+  seedNode(`n_life_dupo_${stamp}`,alias,NET,outsiderId);
+  expect((await api(ownerToken,"POST","/api/node-rename/commit",{txn_id:prepared.body.txn_id})).body.error).toBe("node_alias_ambiguous");
+  expect((await api(ownerToken,"POST","/api/node-rename/prepare",{network_id:NET,old_alias:alias,new_alias:target})).body.error).toBe("node_alias_ambiguous");
+  expect(tokenName(mine.tokenId)).toBe(`node:${alias}`);
+  expect(db.get("SELECT status FROM rename_txn WHERE txn_id=?1",prepared.body.txn_id)).toEqual({status:"prepared"});
+  await api(ownerToken,"POST","/api/node-rename/abort",{txn_id:prepared.body.txn_id});
+});
+
 beforeAll(async () => {
   process.env.COMMHUB_UPLOADS_DIR = join(dir, "uploads");
   process.env.HOST = "127.0.0.1";

package/src/node-daemon-bindings.ts

@@ -3,6 +3,7 @@ import { getUserNetworkRole } from "./auth.js";
 import { pushEvent } from "./push.js";
 import { canRestWriteNetwork } from "./network-scope.js";
 import { parseDbTimestampMs } from "./db-timestamp.js";
+import { activeNodeTokenIds } from "./node-token-identity.js";
 
 type Node = { node_id: string; alias: string; network_id: string; owner_user_id: string | null; hostname: string | null; config_snapshot: string | null };
 type Binding = { request_id: string; network_id: string; node_id: string; daemon_node_id: string; workdir: string; requested_by: string; status: string; error: string | null };
@@ -41,11 +42,15 @@ function daemonReady(daemon: Node | null, node: Node): string | null {
   const snap = snapshot(daemon);
   if (snap.role !== "host_supervisor" || snap.daemon_capabilities?.adopt_capable !== true) return "daemon_not_adopt_capable";
   if (!node.hostname || daemon.hostname !== node.hostname) return "hostname_mismatch";
-  const session = db.get<{ last_seen_at: string }>(`SELECT last_seen_at FROM sessions WHERE alias=?1 AND network_id=?2`, daemon.alias, daemon.network_id);
+  const session = db.get<{ last_seen_at: string }>(
+    `SELECT last_seen_at FROM sessions WHERE alias=?1 AND network_id=?2
+       AND (node_id=?3 OR (node_id IS NULL AND NOT EXISTS (
+         SELECT 1 FROM nodes n WHERE n.network_id=?2 AND n.alias=?1 AND n.node_id!=?3)))`,
+    daemon.alias, daemon.network_id, daemon.node_id,
+  );
   const seen = parseDbTimestampMs(session?.last_seen_at ?? "");
   if (!Number.isFinite(seen) || Date.now() - seen > 300_000) return "daemon_offline";
-  const token = db.get(`SELECT token_id FROM api_tokens WHERE name=?1 AND network_id=?2 AND revoked_at IS NULL`, `node:${daemon.alias}`, daemon.network_id);
-  return token ? null : "daemon_offline";
+  return activeNodeTokenIds(daemon.node_id, daemon.network_id).length ? null : "daemon_offline";
 }
 
 export function requestAdopt(ctx: Human, args: { node_id: string; daemon_node_id: string; workdir: string }) {

package/src/node-token-identity.ts

@@ -0,0 +1,35 @@
+import { db } from "./db.js";
+import { resolveNodeCaller } from "./create-node.js";
+
+/** Active credentials belonging to an immutable node, including verified legacy unbound tokens. */
+export function activeNodeTokenIds(nodeId: string, networkId: string): string[] {
+  const node = db.get<{ alias: string }>("SELECT alias FROM nodes WHERE node_id=?1 AND network_id=?2", nodeId, networkId);
+  if (!node) return [];
+  const tokens = db.all<{ token_id: string }>(
+    `SELECT token_id FROM api_tokens WHERE network_id=?1 AND scope='network' AND revoked_at IS NULL
+       AND (bound_node_id=?2 OR (bound_node_id IS NULL AND name=?3)) ORDER BY token_id`,
+    networkId, nodeId, `node:${node.alias}`,
+  );
+  return tokens.filter(token => {
+    const caller = resolveNodeCaller(token.token_id);
+    return caller.ok && caller.kind === "node" && caller.nodeId === nodeId && caller.networkId === networkId;
+  }).map(token => token.token_id);
+}
+
+/** Preserve the dispatch-time freeze; old requests without it use verified node identity. */
+export function revokeNodeTokens(nodeId: string, networkId: string, frozenTokenId: string | null): void {
+  let ids: string[];
+  if (frozenTokenId) {
+    const token = db.get<{ bound_node_id: string | null }>(
+      "SELECT bound_node_id FROM api_tokens WHERE token_id=?1 AND network_id=?2 AND scope='network' AND revoked_at IS NULL",
+      frozenTokenId, networkId,
+    );
+    // An immutable binding remains sufficient for revocation even after its node row was removed.
+    const caller = token && !token.bound_node_id ? resolveNodeCaller(frozenTokenId) : null;
+    ids = token?.bound_node_id === nodeId || (caller?.ok && caller.kind === "node" && caller.nodeId === nodeId && caller.networkId === networkId)
+      ? [frozenTokenId] : activeNodeTokenIds(nodeId, networkId);
+  } else {
+    ids = activeNodeTokenIds(nodeId, networkId);
+  }
+  for (const id of ids) db.run("UPDATE api_tokens SET revoked_at=datetime('now') WHERE token_id=?1 AND network_id=?2 AND revoked_at IS NULL", [id, networkId]);
+}

package/src/rename.ts

@@ -19,6 +19,7 @@ import { canSeeAgent, isAgentRestricted } from "./agent-access";
 import { pushEvent } from "./push";
 import { eventBus } from "./event_bus";
 import { aliasControlCharacter, describeAliasControlCharacter } from "./node-alias-control";
+import { activeNodeTokenIds } from "./node-token-identity.js";
 
 export interface RenameResult {
   ok: boolean;
@@ -109,7 +110,7 @@ export function cleanupCommittedRenameSessions(networkIds: string[] | null = nul
 
 // PHASE 1 P3 — create a prepared rename_txn row reserving new_alias.
 // CAS guard (RFC §4 risk #3 TOCTOU): new_alias must be free both in the
-// sessions registry AND among in-flight prepared rename_txn rows.
+// sessions/nodes registries AND among in-flight prepared rename_txn rows.
 export function prepareRename(
   userId: string, networkId: string, oldAlias: string, newAlias: string,
 ): RenameResult {
@@ -127,6 +128,9 @@ export function prepareRename(
     };
   }
   if (oldAlias === newAlias) return { ok: false, error: "old and new alias are identical" };
+  if (db.all("SELECT node_id FROM nodes WHERE network_id=?1 AND alias=?2", networkId, oldAlias).length > 1) {
+    return { ok: false, error: "node_alias_ambiguous" };
+  }
 
   // old-alias must exist as a session in this network
   const oldSession = db.get<any>(
@@ -140,9 +144,9 @@ export function prepareRename(
     };
   }
 
-  // new-alias must not be taken — in sessions OR reserved by another prepared txn
+  // A node can reserve its alias before it has ever reported a session.
   const newInSessions = db.get<any>(
-    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2", networkId, newAlias);
+    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2 UNION ALL SELECT 1 FROM nodes WHERE network_id = ?1 AND alias = ?2", networkId, newAlias);
   if (newInSessions) return { ok: false, error: `alias "${newAlias}" already in use` };
   const newPrepared = db.get<any>(
     "SELECT txn_id FROM rename_txn WHERE network_id = ?1 AND new_alias = ?2 AND status = 'prepared'",
@@ -167,11 +171,15 @@ export function commitRename(userId: string, txnId: string): RenameResult {
   if (txn.status === "committed") return { ok: true, txn_id: txnId }; // idempotent
   if (txn.status === "aborted") return { ok: false, error: "rename transaction was aborted" };
   if (!hasWriteAccess(userId, txn.network_id)) return { ok: false, error: "no write access to this network" };
+  const nodes = db.all<{ node_id: string }>("SELECT node_id FROM nodes WHERE network_id=?1 AND alias=?2", txn.network_id, txn.old_alias);
+  if (nodes.length > 1) return { ok: false, error: "node_alias_ambiguous" };
+  // Resolve labels before changing the node alias, so legacy unbound ownership remains verifiable.
+  const tokenIds = nodes[0] ? activeNodeTokenIds(nodes[0].node_id, txn.network_id) : [];
 
-  // Defense-in-depth: new-alias still free in sessions (prepare already CAS'd,
+  // Defense-in-depth: new-alias still free in both registries (prepare already CAS'd,
   // but a parallel direct registration could have raced in).
   const conflict = db.get<any>(
-    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2", txn.network_id, txn.new_alias);
+    "SELECT 1 FROM sessions WHERE network_id = ?1 AND alias = ?2 UNION ALL SELECT 1 FROM nodes 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` };
 
   const renamedNode = db.transaction(() => {
@@ -182,9 +190,9 @@ export function commitRename(userId: string, txnId: string): RenameResult {
     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}`]);
+    for (const tokenId of tokenIds) db.run(
+      "UPDATE api_tokens SET name = ?1 WHERE token_id = ?2 AND network_id = ?3",
+      [`node:${txn.new_alias}`, tokenId, txn.network_id]);
     db.run(
       "UPDATE rename_txn SET status = 'committed', committed_at = datetime('now') WHERE txn_id = ?1",
       [txnId]);

package/src/rest-identity.ts

@@ -33,7 +33,7 @@ export interface RestIdentityInput {
 }
 
 export type RestIdentityResult =
-  | { ok: true; fromSession: string }
+  | { ok: true; fromSession: string; nodeId?: string | null }
   | {
       ok: false;
       error: "from_session_identity_mismatch";
@@ -69,10 +69,12 @@ export function resolveUserTaskFromSession(username: string | null | undefined,
 export function resolveRestFromSession(input: RestIdentityInput): RestIdentityResult {
   const requested = typeof input.requestedFrom === "string" ? input.requestedFrom.trim() : "";
   let alias: string | null;
+  let nodeId: string | null = null;
   if (input.token.startsWith("ntok_") && input.tokenId) {
     const resolved = resolveNodeCaller(input.tokenId);
     if (resolved.ok) {
       alias = resolved.alias;
+      nodeId = resolved.kind === "node" ? resolved.nodeId : null;
     } else if (resolved.reason === "not_a_node_token") { // board679-plain-ntok-rest
       // Name is not `node:` yet. Main signs that as api, and refuses a claim.
       // not_owner / bound_node_missing / ambiguous stay the hard reject.
@@ -135,5 +137,5 @@ export function resolveRestFromSession(input: RestIdentityInput): RestIdentityRe
   }
 
   // Node token, no claim or a matching one: bind to the token's own alias.
-  return { ok: true, fromSession: alias };
+  return { ok: true, fromSession: alias, ...(input.tokenId ? { nodeId } : {}) };
 }

package/src/server.ts

@@ -3695,7 +3695,9 @@ return Bun.serve({
       const ttlSeconds = (body as any).ttl_seconds || 3600;
       const fromNodeId = restAuth && !requestToken(req).startsWith("ntok_")
         ? null
-        : resolveRestNodeIdForAlias(fromSession, taskNetId);
+        : requestToken(req).startsWith("ntok_")
+          ? (identity.nodeId ?? null)
+          : resolveRestNodeIdForAlias(fromSession, taskNetId);
       const targetNodeId = target.session?.node_id ?? null;
       const actualTo = restActualTo(target, taskNetId);
       // #221 — fold top-level `attachments` into `meta.attachments` so

package/src/stop-delete-node.test.ts

@@ -742,7 +742,6 @@ describe("inbox-enqueue lifecycle_state guard (RFC-027 §2.3 race-free)", () =>
     const r = await call(tools.send_task, {
       alias: CHILD_A_ALIAS,
       task: "racey post-SIGTERM task",
-      from_session: "sender-x",
       network_id: NET_A,
     });
     expect(r.ok).toBe(false);

package/src/tools.ts

@@ -15,6 +15,7 @@ import { assertNodeHealthy } from "./node-health-guard.js";
 import { noteModelAuthHealth } from "./model-auth-notify.js";
 import { numberedAliasInClause, parseAliasFilter } from "./alias-filter.js";
 import { createHash } from "node:crypto";
+import { activeNodeTokenIds, revokeNodeTokens } from "./node-token-identity.js";
 import { db, uuidv4, logTaskEvent, chainReplyToParent, hashToken, generateId, generateNetworkToken, syncScheduledRunForTask } from "./db.js";
 import { sessionTaskOnDispatch } from "./session-task-on-dispatch.js";
 import { TASK_CONTENT_MAX, sessionTaskPreview } from "./shared/task-content-limit.js";
@@ -58,6 +59,7 @@ import {
   auditCreateNode,
   auditCreateNodeStrict,
   resolveCallerDaemonTokenBound as _resolveCallerDaemonTokenBound,
+  resolveNodeCaller,
 } from "./create-node.js";
 import { decideClone, factsFromRows, parseWorkdirPolicy } from "./clone-node.js";
 import {
@@ -2007,7 +2009,10 @@ 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 fromNodeId = humanSender ? null : resolveNodeIdForAlias(from_session, effectiveNetId);
+      const senderIdentity = callerTokenIsNetwork ? resolveNodeCaller(callerTokenId) : null;
+      const fromNodeId = humanSender ? null : callerTokenIsNetwork
+        ? (senderIdentity?.ok && senderIdentity.kind === "node" && senderIdentity.networkId === effectiveNetId ? senderIdentity.nodeId : null)
+        : resolveNodeIdForAlias(from_session, effectiveNetId);
       const targetNodeId = target.session?.node_id ?? null;
       const resolvedActualTo = actualTo(target, effectiveNetId);
       // #500 step 2 — what is already queued on the target, read BEFORE this task is written (advice only, never blocks).
@@ -5396,12 +5401,8 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
     // #1448 finding-5 — 记下该 child **当前活着的** ntok 的 token_id,让 ack 精确按
     // token_id 撤销,而非按 name='node:<alias>' 广撤。后者会在「同 alias 节点在这次
     // delete 未收敛的窗口内被重建(拿到同名新 token)」时,把新 token 一并误撤。这里
-    // 在派发时刻定住身份;若此刻没有活 token(异常),存 null,ack 退回按 name 撤(旧语义)。
-    const childTokenRow = db.get<{ token_id: string }>(
-      `SELECT token_id FROM api_tokens WHERE network_id = ?1 AND name = ?2 AND revoked_at IS NULL`,
-      node.network_id, `node:${node.alias}`,
-    );
-    const childTokenId = childTokenRow?.token_id ?? null;
+    // 在派发时刻定住经解析器验证的节点身份；旧请求也不按名字广撤。
+    const childTokenId = activeNodeTokenIds(node.node_id, node.network_id)[0] ?? null;
 
     // §4.5 D8 — lifecycle UPDATE + audit INSERTs + request INSERT atomic.
     // PR1.1: use db.transaction() (SQLiteAdapter wraps better-sqlite3's
@@ -5639,24 +5640,9 @@ export function registerTools(server: McpServer, clientIP?: string, enforceNetwo
             });
           } else if (status === "stopped" && row.action === "delete") {
             // Revoke the child's ntok, then DELETE the nodes row.
-            // #1448 finding-5 — 精确按派发时定住的 child_token_id 撤(镜像
-            // ack_create_request 的 token_id 精撤)。旧行(升级前派发,child_token_id
-            // 为 NULL)fallback 回按 name='node:<alias>' 撤——旧语义,不引入回归。
-            // 按 token_id 撤避免了「同 alias 在本次 delete 窗口内被重建、拿到同名新
-            // token」时把新 token 一并误撤。
-            if (row.child_token_id) {
-              db.run(
-                `UPDATE api_tokens SET revoked_at = datetime('now')
-                   WHERE token_id = ?1 AND revoked_at IS NULL`,
-                [row.child_token_id],
-              );
-            } else {
-              db.run(
-                `UPDATE api_tokens SET revoked_at = datetime('now')
-                   WHERE network_id = ?1 AND name = ?2 AND revoked_at IS NULL`,
-                [row.network_id, `node:${row.child_alias}`],
-              );
-            }
+            // Validate the frozen token's immutable identity; legacy requests
+            // resolve only credentials belonging to this node before deleting it.
+            revokeNodeTokens(row.child_node_id, row.network_id, row.child_token_id);
             db.run(`DELETE FROM nodes WHERE node_id = ?1`, [row.child_node_id]);
             // Same as REST DELETE /api/nodes/:id: without this the sessions row
             // stays "offline" and /api/status lists the deleted node forever.