@sleep2agi/commhub-server 0.9.0-preview.110 → 0.9.0-preview.112

package/src/node-daemon-bindings.test.ts

@@ -48,7 +48,7 @@ test("two-phase binding, daemon-bound pull, controllable map, adopted delete ref
   expect(await call(handlers("daemon").get_adopt_request, { request_id: r.request_id })).toMatchObject({ ok: true, node_id: CHILD, alias: "adoption-child", workdir: "/workspace/project" });
   expect(await call(handlers().get_adopt_request, { request_id: r.request_id })).toMatchObject({ ok: false });
   expect(await call(handlers("daemon").ack_adopt_request, { request_id: r.request_id, status: "adopted" })).toMatchObject({ ok: true });
-  expect((await call(handlers("daemon").list_my_children)).children).toContainEqual({ child_node_id: CHILD, alias: "adoption-child", lifecycle_state: "active", managed: "adopted" });
+  expect((await call(handlers("daemon").list_my_children)).children).toContainEqual({ child_node_id: CHILD, alias: "adoption-child", lifecycle_state: "active", managed: "adopted", binding_request_id: r.request_id });
   expect(buildControllableMap([], [{ node_id: CHILD, daemon_node_id: DAEMON }]).get(CHILD)).toBe(DAEMON);
   expect(await call(handlers().delete_node, { child_node_id: CHILD, confirm_alias: "adoption-child", network_id: NET })).toMatchObject({ ok: false, error: "adopted_node_delete_unsupported" });
   expect(db.get<any>("SELECT lifecycle_state FROM nodes WHERE node_id=?1", CHILD).lifecycle_state).toBe("active");

package/src/node-lifecycle-read-http.test.ts

@@ -59,8 +59,9 @@ test("public errors redact free text for granted viewers on every projection", a
       "not_my_child: daemon has no local record of fixture-node (fixture-id) — no children-map entry and no config at /private/fixture/fixture-node/config.json; refusing to signal processes by alias.",
       "bin: ENOENT: /private/fixture/bin/anet on fixture-host",
       "adopt_unknown_secret", "adopt_start_timeout: /private/fixture", "", "adopt_start_timeout", null,
+      "adopted_node_delete_unsupported", "adopt_codex_readopt_required", "adopt_stop_receipt_changed",
     ]) {
-      const expected = error === null || error === "adopt_start_timeout" ? error : "lifecycle_error";
+      const expected = error === null || ["adopt_start_timeout", "adopted_node_delete_unsupported", "adopt_codex_readopt_required", "adopt_stop_receipt_changed"].includes(error) ? error : "lifecycle_error";
       for (const [kind, table, request] of [
         ["adopt", "node_daemon_bindings", "adopt_read_active"],
         ["start", "node_start_requests", "start_read_failed"],

package/src/node-lifecycle-read.ts

@@ -3,6 +3,7 @@ import { addAgentNetworkScope, type RestNetworkScope } from "./network-scope.js"
 
 // Exact public codes only; daemon exception text must never reach node viewers.
 const publicLifecycleErrors = new Set([
+  "adopted_node_delete_unsupported", "adopt_codex_readopt_required", "adopt_stop_receipt_changed",
   "adopt_active_binding_required", "adopt_binding_unavailable",
   "adopt_binding_revoked_during_start", "adopt_explicit_private_socket_required",
   "adopt_start_evidence_missing", "adopt_stop_evidence_missing",

package/src/node-permissions.ts

@@ -16,6 +16,7 @@
 
 import { db } from "./db.js";
 import { canMessageAgent, type AgentRef } from "./agent-access.js";
+import { resolveNodeCaller } from "./create-node.js";
 
 export type NodePermissionMode = "normal" | "readonly" | "restricted";
 export const NODE_PERMISSION_MODES: readonly NodePermissionMode[] = ["normal", "readonly", "restricted"];
@@ -71,23 +72,55 @@ function normalizeMode(raw: unknown): NodePermissionMode {
 /** 节点令牌 → 节点身份(一次带索引的查询)。不是节点令牌 / 查不到 → null。 */
 export function nodeIdentity(tokenId: string | null | undefined, networkId: string | null | undefined): NodeIdentity | null {
   if (!tokenId || !networkId) return null;
-  const row = db.get<{ user_id: string | null; bound_node_id: string | null; name: string | null; owner_user_id: string | null; permission_mode: string | null; alias: string | null }>(
-    `SELECT t.user_id, t.bound_node_id, t.name, n.owner_user_id, n.permission_mode, n.alias
-       FROM api_tokens t LEFT JOIN nodes n ON n.node_id = t.bound_node_id
-      WHERE t.token_id = ?1 AND t.network_id = ?2`,
+  const row = db.get<{ user_id: string | null; name: string | null }>(
+    `SELECT user_id, name FROM api_tokens WHERE token_id = ?1 AND network_id = ?2`,
     tokenId, networkId,
   );
   if (!row) return null;
-  const aliases = new Set<string>();
-  if (row.alias) aliases.add(row.alias);
-  if (row.name?.startsWith("node:")) aliases.add(row.name.slice(5));
+  const resolved = resolveNodeCaller(tokenId);
+  // Revoked or not node-shaped: this lookup is not a second revocation gate.
+  if (!resolved.ok && resolved.reason === "not_a_node_token") {
+    const aliases = row.name?.startsWith("node:") ? [row.name.slice(5)] : [];
+    return {
+      networkId,
+      nodeId: null,
+      logKey: `token:${tokenId}`,
+      aliases,
+      ownerUserId: row.user_id,
+      mode: "normal",
+    };
+  }
+  if (!resolved.ok || resolved.networkId !== networkId) {
+    return {
+      networkId,
+      nodeId: null,
+      logKey: `token:${tokenId}`,
+      aliases: [],
+      ownerUserId: row.user_id,
+      mode: "normal",
+    };
+  }
+  if (resolved.kind === "unregistered") {
+    return {
+      networkId,
+      nodeId: null,
+      logKey: `token:${tokenId}`,
+      aliases: resolved.alias ? [resolved.alias] : [],
+      ownerUserId: row.user_id,
+      mode: "normal",
+    };
+  }
+  const node = db.get<{ owner_user_id: string | null; permission_mode: string | null }>(
+    `SELECT owner_user_id, permission_mode FROM nodes WHERE node_id = ?1 AND network_id = ?2`,
+    resolved.nodeId, networkId,
+  );
   return {
     networkId,
-    nodeId: row.bound_node_id,
-    logKey: row.bound_node_id ?? `token:${tokenId}`,
-    aliases: [...aliases],
-    ownerUserId: row.owner_user_id || row.user_id || null,
-    mode: normalizeMode(row.permission_mode),
+    nodeId: resolved.nodeId,
+    logKey: resolved.nodeId,
+    aliases: [resolved.alias],
+    ownerUserId: node?.owner_user_id || row.user_id || null,
+    mode: normalizeMode(node?.permission_mode),
   };
 }
 

package/src/node-token-ownership.ts

@@ -0,0 +1,36 @@
+import { db } from "./db.js";
+
+// Call inside the caller's transaction. Serialize registration and issuance for
+// this alias on PG; SQLite already serializes writes on its single connection.
+export function lockNodeAlias(network: string, alias: string, nodeId?: string): void {
+  if (db.dialect !== "postgres") return;
+  db.get("SELECT pg_advisory_xact_lock(hashtext(?1))", JSON.stringify([network, "alias", alias]));
+  if (nodeId) db.get("SELECT pg_advisory_xact_lock(hashtext(?1))", JSON.stringify([network, "id", nodeId]));
+}
+
+export function legacyNodeHolder(user: string, network: string, alias: string, nodeId: string): boolean {
+  return !!db.get(`SELECT token_id FROM api_tokens WHERE user_id=?1 AND network_id=?2
+    AND name=?3 AND revoked_at IS NULL AND (expires_at IS NULL OR expires_at > datetime('now'))
+    AND (bound_node_id=?4 OR (bound_node_id IS NULL AND node_identity_epoch=0)) LIMIT 1`,
+    user, network, `node:${alias}`, nodeId);
+}
+
+/** Resolve a name-only refresh to the existing identity, never claim its owner. */
+export function checkNodeTokenClaim(user: string, network: string, alias: string, nodeId?: string): string | undefined {
+  lockNodeAlias(network, alias, nodeId);
+  const rows = db.all<{node_id: string; owner_user_id: string | null}>(
+    "SELECT node_id, owner_user_id FROM nodes WHERE network_id=?1 AND alias=?2", network, alias);
+  if (rows.length > 1 || rows.some(row => nodeId && row.node_id !== nodeId)) throw Error("node_owner_mismatch");
+  const row = rows[0];
+  // Explicit-ID ownerless claims retain auth.ts's node_owner_unclaimed error;
+  // name-only requests need holder evidence before resolving to that ID.
+  if (row && (row.owner_user_id ? row.owner_user_id !== user : !nodeId && !legacyNodeHolder(user, network, alias, row.node_id))) {
+    throw Error("node_owner_mismatch");
+  }
+  if (!row && db.get(`SELECT token_id FROM api_tokens WHERE network_id=?1 AND name=?2
+    AND user_id<>?3 AND node_identity_epoch=2 AND revoked_at IS NULL
+    AND (expires_at IS NULL OR expires_at > datetime('now')) LIMIT 1`, network, `node:${alias}`, user)) {
+    throw Error("node_owner_mismatch");
+  }
+  return nodeId ?? row?.node_id;
+}

package/src/project-dir-warn-clear-http.test.ts

@@ -0,0 +1,132 @@
+// #667 — a restart from the right directory must clear the cwd warning the
+// previous process left on the same resume_id. Hub stores
+// `task = COALESCE(?11, sessions.task)`, so omitting task keeps the warning.
+// Register sends task: "" once. Later idle reports omit task, so the
+// description of a finished task stays. This boots a throwaway hub on
+// port 0 (never 9200).
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { reportedTask } from "../../agent-node/src/project-dir-mismatch.ts";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-667-clear-"));
+process.env.COMMHUB_DB = join(DIR, "hub.db");
+process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+process.env.HOST = "127.0.0.1";
+
+const PW = "ProjectDirWarn123!x";
+const stamp = Date.now();
+const ROOT = "/work";
+const NODE_DIR = "/work/.anet/nodes/demo-node";
+const CONFIG = `${NODE_DIR}/config.json`;
+
+let db: { get: (sql: string, ...params: unknown[]) => { task: string | null } | null };
+let hub: { port: number; stop: (close?: boolean) => void } | null = null;
+let BASE = "";
+let NET = "";
+let node: { alias: string; nodeId: string; token: string };
+
+async function tool(token: string, name: string, args: Record<string, unknown>) {
+  const res = await fetch(`${BASE}/mcp`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      "MCP-Protocol-Version": "2025-03-26",
+    },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }),
+  });
+  const raw = await res.text();
+  const data = raw.split("\n").filter((line) => line.startsWith("data:"));
+  const payload = data.length ? JSON.parse(data.at(-1)!.slice(5).trim()) : JSON.parse(raw);
+  return JSON.parse(payload.result.content[0].text);
+}
+
+function sessionTask(): string | null {
+  return db.get("SELECT task FROM sessions WHERE resume_id = ?1", `sdk-${node.nodeId}`)?.task ?? null;
+}
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { createNetworkTokenForNode, register } = await import("./auth.js");
+  const boss = register(`cwd_boss_${stamp}`, PW);
+  expect(boss.ok).toBe(true);
+  NET = boss.network_id!;
+  const alias = `demo-node-${stamp}`;
+  const nodeId = `n_cwd_${stamp}`;
+  const minted = createNetworkTokenForNode(boss.user!.user_id, NET, alias, nodeId);
+  expect(minted.ok).toBe(true);
+  node = { alias, nodeId, token: minted.token! };
+  const mod = await import("./server.js");
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  expect(hub.port).not.toBe(9200);
+  expect(hub.port).toBeGreaterThan(0);
+  BASE = `http://127.0.0.1:${hub.port}`;
+}, 30_000);
+
+afterAll(() => {
+  try { hub?.stop(true); } catch { /* already stopped */ }
+  try { rmSync(DIR, { recursive: true, force: true }); } catch { /* temp dir */ }
+});
+
+describe("#667 restart from the workspace root clears the cwd warning", () => {
+  test("wrong directory writes the warning; the right directory sends \"\" and the hub row is empty", async () => {
+    const resume = `sdk-${node.nodeId}`;
+    const wrong = reportedTask({ configPath: CONFIG, cwd: NODE_DIR, inFlight: 0, status: "idle" });
+    expect(wrong).toContain("目录不一致");
+    const started = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET, task: wrong,
+    });
+    expect(started.ok).toBe(true);
+    expect(sessionTask()).toBe(wrong);
+
+    const kept = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET,
+    });
+    expect(kept.ok).toBe(true);
+    expect(sessionTask()).toBe(wrong);
+
+    const idle = reportedTask({ configPath: CONFIG, cwd: ROOT, inFlight: 0, status: "idle" });
+    expect(idle).toBeUndefined();
+    const cleared = idle ?? "";
+    expect(cleared).toBe("");
+    const fixed = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET, task: cleared,
+    });
+    expect(fixed.ok).toBe(true);
+    expect(sessionTask()).toBe("");
+  });
+
+  test("after startup, a finished task's description stays on the hub", async () => {
+    const resume = `sdk-${node.nodeId}`;
+    const description = "BOARD667-FINISHED-TASK";
+    const startup = reportedTask({ configPath: CONFIG, cwd: ROOT, inFlight: 0, status: "idle" }) ?? "";
+    expect(startup).toBe("");
+    const registered = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET, task: startup,
+    });
+    expect(registered.ok).toBe(true);
+    expect(sessionTask()).toBe("");
+
+    const working = reportedTask({
+      configPath: CONFIG, cwd: ROOT, inFlight: 1, status: "working", task: description,
+    });
+    expect(working).toBe(description);
+    const ran = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "working", node_id: node.nodeId, network_id: NET, task: working,
+    });
+    expect(ran.ok).toBe(true);
+    expect(sessionTask()).toBe(description);
+
+    const finished = reportedTask({ configPath: CONFIG, cwd: ROOT, inFlight: 0, status: "idle" });
+    expect(finished).toBeUndefined();
+    const done = await tool(node.token, "report_status", {
+      resume_id: resume, alias: node.alias, status: "idle", node_id: node.nodeId, network_id: NET,
+    });
+    expect(done.ok).toBe(true);
+    expect(sessionTask()).toBe(description);
+  });
+});

package/src/requirement-events-http.test.ts

@@ -73,10 +73,21 @@ beforeAll(async () => {
   // 看全部任务,但一个 Agent 都没授权:所有节点对他隐去
   db.run("UPDATE network_members SET task_access = 'all', agent_access = 'granted' WHERE network_id = ?1 AND user_id = ?2", [NET, restricted.id]);
   NODE = `n_ev_${stamp}`;
-  db.run("INSERT INTO nodes (node_id, node_name, alias, network_id) VALUES (?1, ?2, ?3, ?4)", [NODE, "ev-node", "ev-node", NET]);
   const ntok = createNetworkTokenForNode(admin.id, NET, "ev-node");
   expect(ntok.ok).toBe(true);
   nodeToken = ntok.token!;
+  // Real legacy-client order: mint by name, then register; never fill owner.
+  const registration = await fetch(`${BASE}/mcp`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${nodeToken}`, "Content-Type": "application/json", Accept: "application/json, text/event-stream" },
+    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name: "report_status", arguments: {
+      resume_id: `ev-session-${stamp}`, alias: "ev-node", status: "idle", node_id: NODE,
+    } } }),
+  });
+  expect(registration.status).toBe(200);
+  await registration.text();
+  expect(db.get<{owner_user_id: string | null}>("SELECT owner_user_id FROM nodes WHERE node_id=?1", NODE)?.owner_user_id).toBeNull();
+  expect(db.get<{bound_node_id: string | null}>("SELECT bound_node_id FROM api_tokens WHERE token_id=?1", ntok.token_id!)?.bound_node_id).toBe(NODE);
 }, 30_000);
 
 afterAll(() => {

package/src/requirements-last-event-http.test.ts

@@ -92,10 +92,15 @@ beforeAll(async () => {
   // 看全部任务,但一个 Agent 都没授权:所有节点对他隐去
   db.run("UPDATE network_members SET task_access = 'all', agent_access = 'granted' WHERE network_id = ?1 AND user_id = ?2", [NET, restricted.id]);
   NODE = `n_le_${stamp}`;
-  db.run("INSERT INTO nodes (node_id, node_name, alias, network_id) VALUES (?1, ?2, ?3, ?4)", [NODE, "le-node", "le-node", NET]);
   const ntok = createNetworkTokenForNode(admin.id, NET, "le-node");
   expect(ntok.ok).toBe(true);
   nodeToken = ntok.token!;
+  // Real legacy-client order, with no owner backfill or administrator claim.
+  expect((await mcp(nodeToken, "report_status", {
+    resume_id: `le-session-${stamp}`, alias: "le-node", status: "idle", node_id: NODE,
+  })).data.ok).toBe(true);
+  expect(db.get("SELECT owner_user_id FROM nodes WHERE node_id=?1", NODE).owner_user_id).toBeNull();
+  expect(db.get("SELECT bound_node_id FROM api_tokens WHERE token_id=?1", ntok.token_id).bound_node_id).toBe(NODE);
 }, 30_000);
 
 afterAll(() => {

package/src/requirements.ts

@@ -5,6 +5,7 @@ import { createHash } from "node:crypto";
 import { parsePeopleQuery, peopleDirectory, resolvePersonName } from "./requirements-people.js";
 import { encodeCursor, matchesTaskId, matchesTerms, parseListQuery, type ListQuery, type NameMaps } from "./requirements-search.js";
 import { db, logAudit } from "./db.js";
+import { resolveNodeCaller } from "./create-node.js";
 import { markGzipReusable } from "./http-gzip.js";
 import { applyTagOp, normalizeTags, parseTagOp, storedTags, type TagOp } from "./requirement-tags.js";
 import { aggregateStats, parseStatsQuery, type StatsRow } from "./requirements-stats.js";
@@ -795,13 +796,8 @@ function actorOf(ctx: RequirementsRequestContext): Actor | null {
   if (!ctx.auth) return null;
   if (!ctx.isNodeToken) return { kind: "user", id: ctx.auth.userId };
   const tokenId = ctx.auth.tokenId ?? null;
-  const bound = tokenId ? db.get<{ bound_node_id: string | null }>("SELECT bound_node_id FROM api_tokens WHERE token_id = ?1", tokenId)?.bound_node_id : null;
-  if (bound) return { kind: "node", id: bound };
-  const alias = ctx.auth.tokenName?.startsWith("node:") ? ctx.auth.tokenName.slice(5) : null;
-  if (alias && ctx.auth.networkId) {
-    const node = db.get<{ node_id: string }>("SELECT node_id FROM nodes WHERE network_id = ?1 AND alias = ?2", ctx.auth.networkId, alias);
-    if (node) return { kind: "node", id: node.node_id };
-  }
+  const resolved = tokenId ? resolveNodeCaller(tokenId) : null;
+  if (resolved?.ok && resolved.kind === "node") return { kind: "node", id: resolved.nodeId };
   return { kind: "node", id: `token:${tokenId ?? "unknown"}` };
 }
 

package/src/rest-identity.ts

@@ -12,15 +12,20 @@
 // task row and, once sender labels reach the copresence TUIs, rendered to a
 // human as an attribution.
 //
-// This is the same decision expressed as a pure function so every credential
-// kind is a directly constructible test input rather than a hand-assembled
-// Request (the #503 convention in this codebase).
+// Production network tokens pass tokenId and resolve through resolveNodeCaller.
+// A token whose name is not `node:` (not_a_node_token, the registration token
+// before report_status) falls back to nodeAliasForToken, same as main.
+// tokenId omitted keeps the name-only shape used by the unit cases below.
+
+import { resolveNodeCaller } from "./create-node.js";
 
 export interface RestIdentityInput {
   /** Raw bearer token, only its prefix matters (`ntok_` = network-bound). */
   token: string;
   /** `api_tokens.name`; for node tokens it is `node:<alias>`. */
   tokenName: string | null | undefined;
+  /** Set on the production path. Network tokens then ignore tokenName as authority. */
+  tokenId?: string | null;
   /** Username resolved from the authenticated token. */
   authenticatedUsername?: string | null;
   /** Caller-supplied `body.from`. */
@@ -46,8 +51,28 @@ export function nodeAliasForToken(token: string, tokenName: string | null | unde
 }
 
 export function resolveRestFromSession(input: RestIdentityInput): RestIdentityResult {
-  const alias = nodeAliasForToken(input.token, input.tokenName);
   const requested = typeof input.requestedFrom === "string" ? input.requestedFrom.trim() : "";
+  let alias: string | null;
+  if (input.token.startsWith("ntok_") && input.tokenId) {
+    const resolved = resolveNodeCaller(input.tokenId);
+    if (resolved.ok) {
+      alias = resolved.alias;
+    } 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.
+      alias = nodeAliasForToken(input.token, input.tokenName);
+    } else {
+      return {
+        ok: false,
+        error: "from_session_identity_mismatch",
+        message: "network token from_session does not match token-bound node alias",
+        tokenAlias: "",
+        requestedFromSession: requested,
+      };
+    }
+  } else {
+    alias = nodeAliasForToken(input.token, input.tokenName);
+  }
 
   // A network-bound token whose name we cannot resolve to an alias (`node:`,
   // `node:   `, or a name that was never node-scoped) is the degenerate case.

package/src/scheduled-tasks.ts

@@ -1,4 +1,6 @@
 import { db, logTaskEvent } from "./db.js";
+import { sessionTaskOnDispatch } from "./session-task-on-dispatch.js";
+import { TASK_CONTENT_MAX, sessionTaskPreview } from "./shared/task-content-limit.js";
 import { assertNodeActive } from "./lifecycle-guard.js";
 import { assertNodeHealthy } from "./node-health-guard.js";
 import { addNetworkScope, canRestWriteNetwork, singleNetworkId, type RestNetworkScope } from "./network-scope.js";
@@ -366,7 +368,7 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
     // Dispatch is not completion. Keep the run open until the exact bound
     // task reaches replied/failed/cancelled/expired; db.ts owns that mirror.
     db.run("UPDATE scheduled_task_runs SET task_id = ?1, status = ?2, completed_at = NULL WHERE run_id = ?3", [taskId, deliveryState, runId]);
-    db.run("UPDATE sessions SET task = ?1, updated_at = datetime('now') WHERE node_id = ?2 AND network_id = ?3", [row.task_content.slice(0, 200), node.node_id, row.network_id]);
+    db.run(`UPDATE sessions SET task = ${sessionTaskOnDispatch("?1")}, updated_at = datetime('now') WHERE node_id = ?2 AND network_id = ?3`, [sessionTaskPreview(row.task_content), node.node_id, row.network_id]);
     db.run("UPDATE scheduled_tasks SET target_alias = ?1, last_run_at = ?2, updated_at = datetime('now') WHERE schedule_id = ?3", [node.alias, scheduledFor, row.schedule_id]);
     if (advanceSchedule) advance({ ...row, target_alias: node.alias }, scheduledFor, advanceAfter);
     createdTaskId = taskId;
@@ -517,7 +519,7 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
       const name = typeof body.name === "string" ? body.name.trim() : "";
       const content = typeof body.task === "string" ? body.task.trim() : "";
       if (!name || name.length > 120) throw new Error("invalid_name");
-      if (!content || content.length > 10_000) throw new Error("invalid_task");
+      if (!content || content.length > TASK_CONTENT_MAX) throw new Error("invalid_task");
       const priority = typeof body.priority === "string" ? body.priority : "normal";
       if (!PRIORITIES.has(priority)) throw new Error("invalid_priority");
       const misfirePolicy = parseMisfirePolicy(body.misfire_policy);
@@ -604,7 +606,7 @@ export async function handleScheduledTaskRequest(ctx: ScheduledRequestContext):
       const content = body.task === undefined ? row.task_content : String(body.task).trim();
       const priority = body.priority === undefined ? row.priority : String(body.priority);
       if (!name || name.length > 120) throw new Error("invalid_name");
-      if (!content || content.length > 10_000) throw new Error("invalid_task");
+      if (!content || content.length > TASK_CONTENT_MAX) throw new Error("invalid_task");
       if (!PRIORITIES.has(priority)) throw new Error("invalid_priority");
       const target = body.target_node_id === undefined ? { node_id: row.target_node_id, alias: row.target_alias } : validateTarget(row.network_id, body.target_node_id);
       const parsed = body.schedule === undefined

package/src/server.ts

@@ -3,6 +3,8 @@ import { sanitizeRuntimeReadiness } from "./runtime-readiness.js";
 import { markGzipReusable, maybeGzipResponse, trimLightTask } from "./http-gzip";
 import { ifNoneMatchHits, memoStatusBody } from "./status-read-cache";
 import { dispatchQueueInfo, queueDepthByNode, queueDepthKey } from "./task-queue-ahead.js";
+import { sessionTaskOnDispatch } from "./session-task-on-dispatch.js";
+import { TASK_CONTENT_MAX, sessionTaskPreview } from "./shared/task-content-limit.js";
 import { statusAliasResolverRead } from "./status-alias-resolver.js";
 import { readNodeHealth } from "./node-health-store.js";
 import { wantsAllTools } from "./tool-audience.js";
@@ -73,6 +75,7 @@ import {
   TASK_REST_SELECT,
 } from "./rest-projections.js";
 import { resolveRestFromSession } from "./rest-identity.js";
+import { resolveNodeCaller } from "./create-node.js";
 import { stampTaskAuthOrigin, type TaskAuthOrigin } from "./task-auth-origin.js";
 import { diagnoseTask } from "./task-diagnostic.js";
 import { assertScheduledTaskBackendSupported, handleScheduledTaskRequest, startScheduledTaskScheduler } from "./scheduled-tasks.js";
@@ -195,12 +198,12 @@ function sweepStaleRateLimits(): void {
 }
 
 // ── Factory: 每个请求创建新的 McpServer（stateless 模式）──
-function createServer(clientIP?: string, enforceNetworkId?: string | null, enforceUserId?: string | null, callerAlias?: string | null, callerTokenIsNetwork = false, callerTokenId?: string | null, includeProtocolTools = false): McpServer {
+function createServer(clientIP?: string, enforceNetworkId?: string | null, enforceUserId?: string | null, callerAlias?: string | null, callerTokenIsNetwork = false, callerTokenId?: string | null, includeProtocolTools = false, callerIdentityRejected = false): McpServer {
   const server = new McpServer({
     name: "commhub",
     version: "0.5.0",
   });
-  registerTools(server, clientIP, enforceNetworkId, enforceUserId, callerAlias, callerTokenIsNetwork, callerTokenId, { includeProtocol: includeProtocolTools });
+  registerTools(server, clientIP, enforceNetworkId, enforceUserId, callerAlias, callerTokenIsNetwork, callerTokenId, { includeProtocol: includeProtocolTools }, callerIdentityRejected);
   return server;
 }
 
@@ -270,6 +273,16 @@ function nodeSubscriberInfo(req: Request, server: any, tokenId: string | null, a
   return { nodeId, instanceId, remote, userAgent: req.headers.get("user-agent")?.slice(0, 200) ?? null };
 }
 
+// The stream belongs to a node id, not a name. A session that never stored
+// node_id still owns its stream when this network has exactly one nodes row
+// for the alias. Null does not match null.
+function streamOwnerNodeId(alias: string, networkId: string): string | null {
+  const fromSession = db.get<{ node_id: string | null }>("SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2", alias, networkId)?.node_id ?? null;
+  if (fromSession) return fromSession;
+  const rows = db.all<{ node_id: string }>("SELECT node_id FROM nodes WHERE alias = ?1 AND network_id = ?2", alias, networkId);
+  return rows.length === 1 ? rows[0].node_id : null;
+}
+
 function isLocalhostIP(ip: string): boolean {
   return ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1" || ip === "localhost";
 }
@@ -308,17 +321,24 @@ function isHubAdminCredential(resolved: { networkId: string | null; user: { role
 function nodeTokenAlias(resolved: { tokenName: string | null }): string | null {
   return resolved.tokenName?.startsWith("node:") ? resolved.tokenName.slice("node:".length) : null;
 }
-function nodeMayRename(resolved: { networkId: string | null; tokenName: string | null }, networkId: unknown, oldAlias: unknown): boolean {
+function resolvedNodeAlias(resolved: { networkId: string | null; tokenName: string | null; tokenId?: string | null }): string | null {
+  if (!resolved.tokenId) return nodeTokenAlias(resolved);
+  const caller = resolveNodeCaller(resolved.tokenId);
+  if (!caller.ok) return null;
+  if (resolved.networkId && caller.networkId !== resolved.networkId) return null;
+  return caller.alias;
+}
+function nodeMayRename(resolved: { networkId: string | null; tokenName: string | null; tokenId?: string | null }, networkId: unknown, oldAlias: unknown): boolean {
   if (!resolved.networkId) return true;
-  return networkId === resolved.networkId && typeof oldAlias === "string" && oldAlias === nodeTokenAlias(resolved);
+  return networkId === resolved.networkId && typeof oldAlias === "string" && oldAlias === resolvedNodeAlias(resolved);
 }
-function nodeMayRenameTxn(resolved: { networkId: string | null; tokenName: string | null }, txnId: unknown): boolean {
+function nodeMayRenameTxn(resolved: { networkId: string | null; tokenName: string | null; tokenId?: string | null }, txnId: unknown): boolean {
   if (!resolved.networkId) return true;
   if (typeof txnId !== "string") return false;
   const txn = db.get<{ network_id: string; old_alias: string; new_alias: string }>("SELECT network_id, old_alias, new_alias FROM rename_txn WHERE txn_id = ?1", txnId);
   if (!txn || txn.network_id !== resolved.networkId) return false;
   // commit 前后令牌名可能已被改成新 alias(api_tokens.name 跟随改名),两个都算它自己。
-  const self = nodeTokenAlias(resolved);
+  const self = resolvedNodeAlias(resolved);
   return self === txn.old_alias || self === txn.new_alias;
 }
 
@@ -793,7 +813,7 @@ function withNetworkNameAlias<T extends { network_name?: unknown }>(row: T): T &
 // ── REST input schema ───────────────────────────────
 const TaskSchema = z.object({
   alias: z.string().min(1).max(200),
-  task: z.string().min(1).max(10000),
+  task: z.string().min(1).max(TASK_CONTENT_MAX),
   priority: z.enum(["high", "normal", "low"]).default("normal"),
   from: z.string().max(200).optional(),
   network_id: z.string().max(200).optional(),
@@ -1028,11 +1048,20 @@ return Bun.serve({
       const token = requestToken(req);
       const authCtx = resolveRequestAuth(req);
       const enforceNetId = authCtx?.networkId || null;
-      // Derive the calling alias from the token name (e.g., 'node:视频审查')
-      // so peer agents see the real sender instead of 'hub' on send_task.
-      const callerAlias = authCtx?.tokenName?.startsWith("node:")
-        ? authCtx.tokenName.slice("node:".length)
-        : (authCtx?.username || null);
+      // A resolved node token speaks as that node. A token whose name is not
+      // `node:` (the registration network token) keeps the username. Only a
+      // `node:` token refused as not_owner / bound_node_missing / ambiguous
+      // is impersonation, and must not fall through to a client-supplied from.
+      let callerAlias: string | null = authCtx?.username || null;
+      let callerIdentityRejected = false;
+      if (token?.startsWith("ntok_")) {
+        const resolvedCaller = authCtx?.tokenId ? resolveNodeCaller(authCtx.tokenId) : null;
+        if (resolvedCaller?.ok) callerAlias = resolvedCaller.alias;
+        else if (resolvedCaller && resolvedCaller.reason !== "not_a_node_token") { // board679-plain-ntok
+          callerAlias = null;
+          callerIdentityRejected = true;
+        }
+      }
       const transport = new WebStandardStreamableHTTPServerTransport({
         sessionIdGenerator: undefined,
       });
@@ -1050,7 +1079,7 @@ return Bun.serve({
         labelRoute(req, mcpParsedBody === undefined ? "?" : mcpRouteLabel(mcpParsedBody));
       }
       // #478:tools/list 按调用者过滤;X-Anet-Tools: all / ?tools=all 时节点令牌也列出协议工具。
-      const mcpServer = createServer(clientIP, enforceNetId, authCtx?.userId || null, callerAlias, !!token?.startsWith("ntok_"), authCtx?.tokenId || null, wantsAllTools(req, url));
+      const mcpServer = createServer(clientIP, enforceNetId, authCtx?.userId || null, callerAlias, !!token?.startsWith("ntok_"), authCtx?.tokenId || null, wantsAllTools(req, url), callerIdentityRejected);
       await mcpServer.connect(transport);
       const response = await transport.handleRequest(req, mcpParsedBody === undefined ? undefined : { parsedBody: mcpParsedBody });
       // Disconnect after response to prevent McpServer leak
@@ -1204,11 +1233,22 @@ return Bun.serve({
           nodeId: db.get<{ node_id: string | null }>("SELECT node_id FROM sessions WHERE alias = ?1 AND network_id = ?2", sessionName, scopedNetId)?.node_id ?? null,
         }));
         if (streamDenied) return streamDenied;
-        // #507 — the node's OWN stream (token bound to this alias) is node-scoped:
-        // at most one per (network, alias), newest wins. A node token watching some
-        // other alias stays a plain monitor and can never supersede that node.
-        if (authCtx.tokenName === `node:${sessionName}` && authCtx.networkId === scopedNetId) {
-          return createSSEStream(sessionName, scopedNetId, { node: nodeSubscriberInfo(req, server, authCtx.tokenId, sessionName, scopedNetId) });
+        // #507 — the node's OWN stream is node-scoped: at most one per (network,
+        // alias), newest wins. Own means the resolved node id equals this stream's
+        // node id. A matching token name is not enough, and a monitor never supersedes.
+        const resolvedCaller = authCtx.tokenId ? resolveNodeCaller(authCtx.tokenId) : null;
+        const streamNodeId = streamOwnerNodeId(sessionName, scopedNetId);
+        if (
+          resolvedCaller?.ok
+          && resolvedCaller.kind === "node"
+          && resolvedCaller.nodeId
+          && streamNodeId
+          && resolvedCaller.nodeId === streamNodeId
+          && resolvedCaller.networkId === scopedNetId
+        ) {
+          const info = nodeSubscriberInfo(req, server, authCtx.tokenId, sessionName, scopedNetId);
+          if (!info.nodeId) info.nodeId = resolvedCaller.nodeId;
+          return createSSEStream(sessionName, scopedNetId, { node: info });
         }
         return createSSEStream(sessionName, scopedNetId);
       }
@@ -1393,8 +1433,9 @@ return Bun.serve({
       // RFC-040:managed_department_ids = 我负责的部门 + 全部下级(空 = 不是负责人;viewer 恒空;节点令牌不是人,恒空)。
       const networks = (resolved.networkId ? allNetworks.filter((n: any) => n.network_id === resolved.networkId) : allNetworks)
         .map((n: any) => ({ ...n, managed_department_ids: resolved.networkId ? [] : managedDepartmentIds(n.network_id, resolved.user.user_id) }));
+      const nodeCaller = resolved.networkId && resolved.tokenId ? resolveNodeCaller(resolved.tokenId) : null;
       const credential = resolved.networkId
-        ? { kind: "node", network_id: resolved.networkId, node_alias: resolved.tokenName?.startsWith("node:") ? resolved.tokenName.slice(5) : null, acts_as_owner: false }
+        ? { kind: "node", network_id: resolved.networkId, node_alias: nodeCaller?.ok ? nodeCaller.alias : null, acts_as_owner: false }
         : { kind: "user" };
       return withCors(req, Response.json({ ok: true, user: resolved.user, networks, current_network: resolved.networkId, credential }));
     }
@@ -3544,6 +3585,7 @@ return Bun.serve({
       const identity = resolveRestFromSession({
         token: requestToken(req),
         tokenName: restAuth?.tokenName,
+        tokenId: restAuth?.tokenId,
         authenticatedUsername: restAuth?.username,
         requestedFrom: body.from,
       });
@@ -3688,8 +3730,8 @@ return Bun.serve({
         // immediately, without waiting for the agent's report_status to
         // arrive. Updating both `task` and `updated_at` is enough — we
         // leave `status` to the agent (idle → working → idle).
-        const touchParams: any[] = [body.task.slice(0, 200), targetAlias];
-        let touchSql = "UPDATE sessions SET task = ?1, updated_at = datetime('now') WHERE alias = ?2";
+        const touchParams: any[] = [sessionTaskPreview(body.task), targetAlias];
+        let touchSql = `UPDATE sessions SET task = ${sessionTaskOnDispatch("?1")}, updated_at = datetime('now') WHERE alias = ?2`;
         if (taskNetId) { touchSql += " AND network_id = ?3"; touchParams.push(taskNetId); }
         db.run(touchSql, touchParams);
       });

package/src/session-task-on-dispatch.ts

@@ -0,0 +1,14 @@
+// Board #668. A dispatch preview is what the hub shows before the node
+// reports. Once the session is already working, that text is the task in
+// flight — a newer message waits in the inbox and must not replace it.
+// Idle and every other status still take the preview.
+
+const PLACEHOLDER = /^\?\d+$/;
+
+/** SQL expression for `sessions.task` on dispatch. `placeholder` is a `?N` bind. */
+export function sessionTaskOnDispatch(placeholder: string): string {
+  if (!PLACEHOLDER.test(placeholder)) {
+    throw new Error("sessionTaskOnDispatch placeholder must be a ?N bind");
+  }
+  return `CASE WHEN status = 'working' THEN task ELSE ${placeholder} END`;
+}