@sleep2agi/commhub-server 0.9.0-preview.132 → 0.9.0-preview.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sleep2agi/commhub-server",
-  "version": "0.9.0-preview.132",
+  "version": "0.9.0-preview.134",
   "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",

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

@@ -288,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;
@@ -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>(
@@ -167,6 +171,10 @@ 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 both registries (prepare already CAS'd,
   // but a parallel direct registration could have raced in).
@@ -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/scheduled-stuck-http.test.ts

@@ -16,7 +16,7 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { addNetworkMember, createNetworkTokenForNode, register } from "./auth.js";
 import { db } from "./db.js";
 import { dispatchScheduledOccurrence, handleScheduledTaskRequest } from "./scheduled-tasks.js";
-import { SCHEDULE_STUCK_NOTICE_KIND, stuckTimeoutMs } from "./scheduled-stuck.js";
+import { blockerTimedOut, SCHEDULE_STUCK_NOTICE_KIND, stuckTimeoutMs } from "./scheduled-stuck.js";
 import { registerTools } from "./tools.js";
 
 const activeDbPath = process.env.COMMHUB_DB ?? (process.env.COMMHUB_TEST_PG_URL ? "postgres" : undefined);
@@ -236,3 +236,53 @@ describe("#464 history clarity", () => {
     expect(skipped.blocked_by_state).toBe("not_received");
   });
 });
+
+
+describe("#1112 execution clock", () => {
+  const ts = (now: Date, minutes: number) => new Date(now.getTime() - minutes * 60_000).toISOString();
+  test("queue budget: creation over one hour but consumption under one hour keeps the exact run open", () => {
+    const s = seedSchedule();
+    const first = fire(s);
+    const now = new Date();
+    db.run("UPDATE tasks SET status = 'running', created_at = ?1, consumed_at = ?2 WHERE task_id = ?3", [ts(now, 61), ts(now, 49), first.taskId]);
+    expect(fire(s, now).status).toBe("skipped");
+    expect(taskRow(first.taskId!).status).toBe("running");
+    expect(runRow(first.runId).status).toBe("delivered");
+    expect(db.get<any>("SELECT COUNT(*) AS n FROM task_events WHERE task_id = ?1 AND to_status = 'expired'", first.taskId).n).toBe(0);
+    db.run("UPDATE tasks SET created_at = ?1, consumed_at = ?2 WHERE task_id = ?3", [ts(now, 73), ts(now, 61), first.taskId]);
+    const later = fire(s, now);
+    expect(later.status).toBe("delivered");
+    expect(taskRow(first.taskId!).status).toBe("expired");
+    expect(runRow(first.runId).error_message).toContain("since consumed_at");
+  });
+  test("queue budget: legacy execution start protects the queued task, consumption takes precedence", () => {
+    const s = seedSchedule(); const first = fire(s); const now = new Date();
+    db.run("UPDATE tasks SET status = 'running', created_at = ?1, started_at = ?2 WHERE task_id = ?3", [ts(now, 75), ts(now, 40), first.taskId]);
+    expect(fire(s, now).status).toBe("skipped");
+    db.run("UPDATE tasks SET started_at = ?1, consumed_at = ?2 WHERE task_id = ?3", [ts(now, 70), ts(now, 40), first.taskId]);
+    expect(fire(s, now).status).toBe("skipped");
+  });
+  test("submission and ACK alone do not renew queue time", () => {
+    const s = seedSchedule(); const first = fire(s); const now = new Date();
+    db.run("UPDATE tasks SET status = 'acked', created_at = ?1, runtime_submitted_at = ?2 WHERE task_id = ?3", [ts(now, 61), ts(now, 1), first.taskId]);
+    expect(fire(s, now).status).toBe("delivered");
+    expect(runRow(first.runId).error_message).toContain("since created_at");
+  });
+  test("total cap: a very late consumption cannot keep an occurrence open beyond 24 hours", () => {
+    const s = seedSchedule(); const first = fire(s); const now = new Date();
+    db.run("UPDATE tasks SET status = 'running', created_at = ?1, consumed_at = ?2 WHERE task_id = ?3", [ts(now, 1441), ts(now, 1), first.taskId]);
+    expect(fire(s, now).status).toBe("delivered");
+    expect(runRow(first.runId).status).toBe("expired");
+    expect(runRow(first.runId).error_message).toContain("created_at (total cap)");
+    expect(runRow(first.runId).error_message).toContain("limit 1440 min");
+  });
+  test("invalid, future and pre-creation evidence falls back; UTC and exact execution boundary remain stable", () => {
+    const now = new Date("2026-10-13T03:00:00Z");
+    const schedule = JSON.stringify({ type: "interval", every_seconds: 60 });
+    for (const consumed_at of [null, "invalid", "2026-10-14T00:00:00Z", "2026-10-12T00:00:00Z"]) {
+      expect(blockerTimedOut({ created_at: "2026-10-13 01:00:00", consumed_at }, schedule, now)).toBe(true);
+    }
+    expect(blockerTimedOut({ created_at: "2026-10-13 01:00:00", consumed_at: "2026-10-13 02:00:01" }, schedule, now)).toBe(false);
+    expect(blockerTimedOut({ created_at: "2026-10-13 01:00:00", consumed_at: "2026-10-13 02:00:00" }, schedule, now)).toBe(true);
+  });
+});

package/src/scheduled-stuck.ts

@@ -14,6 +14,8 @@
 //    恰好一条通知。
 //
 // 默认值(PR 里有推导):N=3;超时 = clamp(6 × 间隔, 下限 1 小时, 上限 24 小时)。
+// #1112:从 consumed_at 起算,旧节点回落 started_at,未执行回落 created_at;
+//       自创建时间的总保护上限仍为 cap,节点心跳/提交/ACK 不刷新执行时钟。
 //   下限 1 小时:一轮 agent 任务正常要跑几十分钟,不能因为排程间隔短就把还在干活的任务掐掉。
 //   上限 24 小时:Hub 本来就给定时任务 24 小时的 expires_at(没被取走时由巡检过期),开着超过一天的
 //   定时任务不是「还在做」。6 × 间隔:间隔长的排程(每小时一次)给它 6 小时,而不是 1 小时。
@@ -54,20 +56,44 @@ export function stuckTimeoutMs(scheduleJson: string): number {
   return Math.min(cap, Math.max(floor, factor * nominalIntervalSeconds(scheduleJson))) * 1000;
 }
 
-type Blocker = { task_id: string; created_at: string; status: string };
+export type StuckBlockerClock = {
+  created_at: string;
+  consumed_at?: string | null;
+  started_at?: string | null;
+};
+
+/** #1105: queue time is not execution time. Submission/ACK/node heartbeat are not consumption. */
+export function blockerTimeoutClock(blocker: StuckBlockerClock, scheduleJson: string, now: Date): { ageMs: number; limitMs: number; source: string } {
+  const created = parseDbTimestampMs(blocker.created_at);
+  const nowMs = now.getTime();
+  const floor = envNumber("COMMHUB_SCHEDULE_STUCK_TIMEOUT_FLOOR_SEC", 3_600, 1);
+  const capMs = Math.max(floor, envNumber("COMMHUB_SCHEDULE_STUCK_TIMEOUT_CAP_SEC", 86_400, 1)) * 1000;
+  // Even a very late consumption cannot hold this occurrence beyond the total cap.
+  if (Number.isFinite(created) && nowMs - created >= capMs) {
+    return { ageMs: nowMs - created, limitMs: capMs, source: "created_at (total cap)" };
+  }
+  for (const source of ["consumed_at", "started_at"] as const) {
+    const value = blocker[source];
+    if (!value) continue;
+    const at = parseDbTimestampMs(value);
+    if (Number.isFinite(at) && at <= nowMs && (!Number.isFinite(created) || at >= created)) {
+      return { ageMs: nowMs - at, limitMs: stuckTimeoutMs(scheduleJson), source };
+    }
+  }
+  return { ageMs: nowMs - created, limitMs: stuckTimeoutMs(scheduleJson), source: "created_at" };
+}
 
 /** 挡路的任务开了多久已经到超时 → true。读不出时间 = 不超时(宁可多挡一次,不错杀)。 */
-export function blockerTimedOut(blocker: Pick<Blocker, "created_at">, scheduleJson: string, now: Date): boolean {
-  const started = parseDbTimestampMs(blocker.created_at);
-  if (!Number.isFinite(started)) return false;
-  return now.getTime() - started >= stuckTimeoutMs(scheduleJson);
+export function blockerTimedOut(blocker: StuckBlockerClock, scheduleJson: string, now: Date): boolean {
+  const clock = blockerTimeoutClock(blocker, scheduleJson, now);
+  return Number.isFinite(clock.ageMs) && clock.ageMs >= clock.limitMs;
 }
 
 /**
  * 在调用方的事务里按超时结束挡路的任务。只动还开着的任务(条件写),返回是否真的结束了它。
  * 与 TTL 巡检(server.ts patrolExpiredTasks)同一套写法:status=expired、收件箱行置 acked、镜像到 run。
  */
-export function expireStuckBlocker(taskId: string, networkId: string, ageMs: number, limitMs: number): boolean {
+export function expireStuckBlocker(taskId: string, networkId: string, ageMs: number, limitMs: number, source = "created_at"): boolean {
   const changed = db.run(
     `UPDATE tasks SET status = 'expired', completed_at = datetime('now')
       WHERE task_id = ?1 AND network_id = ?2 AND status IN ('created', 'delivered', 'acked', 'running')`,
@@ -78,7 +104,7 @@ export function expireStuckBlocker(taskId: string, networkId: string, ageMs: num
   syncScheduledRunForTask(taskId, networkId);
   db.run(
     "UPDATE scheduled_task_runs SET error_message = ?1 WHERE task_id = ?2 AND network_id = ?3",
-    [`timed out by the scheduler: open for ${Math.round(ageMs / 60_000)} min (limit ${Math.round(limitMs / 60_000)} min); the next occurrence was dispatched`, taskId, networkId],
+    [`timed out by the scheduler: ${Math.round(ageMs / 60_000)} min since ${source} (limit ${Math.round(limitMs / 60_000)} min); the next occurrence was dispatched`, taskId, networkId],
   );
   return true;
 }
@@ -127,12 +153,12 @@ export function stuckNoticeText(n: StuckNotice): { title: string; text: string }
     return {
       title: "定时任务被卡住",
       text: `定时任务「${n.scheduleName}」被上一次的执行卡住了:任务 ${n.taskId} 于 ${started} 派给节点 ${n.alias},到现在还没有完成,之后的 ${n.skips} 次执行都被跳过。\n\n`
-        + `它开着超过 ${fmtDuration(n.timeoutMs)} 后会被自动按超时结束,下一次照常派发。等不及可以在任务列表里取消这条任务。`,
+        + `从实际开始执行起超过 ${fmtDuration(n.timeoutMs)} 后会被自动按超时结束;尚未开始的任务从派发起计时,所有执行仍受总时限保护。下一次照常派发。等不及可以在任务列表里取消这条任务。`,
     };
   }
   return {
     title: "定时任务已超时放行",
-    text: `定时任务「${n.scheduleName}」上一次的任务 ${n.taskId}(${started} 派给节点 ${n.alias})开着超过 ${fmtDuration(n.timeoutMs)} 还没有完成,已按超时结束,不再挡后面的执行。`,
+    text: `定时任务「${n.scheduleName}」上一次的任务 ${n.taskId}(${started} 派给节点 ${n.alias})超过 ${fmtDuration(n.timeoutMs)} 的执行或总保护时限还没有完成,已按超时结束,不再挡后面的执行。`,
   };
 }
 

package/src/scheduled-tasks.ts

@@ -8,8 +8,7 @@ import { canMessageAgent, type AgentRef } from "./agent-access.js";
 import { dispatchVerdict } from "./node-permissions.js";
 import { hasSubscribers, pushEvent, pushNetworkObserverEvent } from "./push.js";
 import { SCHEDULED_TASK_STORAGE_SELECT } from "./rest-projections.js";
-import { parseDbTimestampMs } from "./db-timestamp.js";
-import { blockerTimedOut, expireStuckBlocker, sendStuckNotice, skipsBlockedBy, stuckNoticeSkips, stuckTimeoutMs, type StuckNotice } from "./scheduled-stuck.js";
+import { blockerTimedOut, blockerTimeoutClock, expireStuckBlocker, sendStuckNotice, skipsBlockedBy, stuckNoticeSkips, stuckTimeoutMs, type StuckNotice } from "./scheduled-stuck.js";
 import { evaluateScheduleFailures, failureSummary } from "./scheduled-failures.js";
 import { scheduledTargetOffline, sendOfflineNotice, type OfflineNotice } from "./scheduled-offline.js";
 
@@ -413,8 +412,8 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       // received:节点那边有没有把这条任务取走过(inbox 行被 ack,或任务已进 acked/running)。
       // 跳过记录带上它,客户端才分得清「节点还没收到」和「节点在处理」—— 前者是投递故障,
       // 后者才是真的上一次还没做完。
-      const findOpen = () => db.get<{ task_id: string; received: number; created_at: string; status: string }>(
-        `SELECT r.task_id, t.created_at, t.status,
+      const findOpen = () => db.get<{ task_id: string; received: number; created_at: string; consumed_at: string | null; started_at: string | null; status: string }>(
+        `SELECT r.task_id, t.created_at, t.consumed_at, t.started_at, t.status,
                 CASE WHEN t.status IN ('acked', 'running')
                        OR EXISTS (SELECT 1 FROM inbox i WHERE (i.task_id = r.task_id OR i.id = r.task_id) AND i.acked = 1)
                      THEN 1 ELSE 0 END AS received
@@ -428,9 +427,8 @@ export function dispatchScheduledOccurrence(row: ScheduledRow, scheduledFor: str
       // #464 — a blocker open past the stuck timeout is ended as `expired` (the existing terminal state) and
       // this occurrence dispatches normally. Bounded: each pass ends one exact open task or stops.
       for (let guard = 0; open && guard < 20 && blockerTimedOut(open, row.schedule_json, advanceAfter); guard++) {
-        const limitMs = stuckTimeoutMs(row.schedule_json);
-        const ageMs = advanceAfter.getTime() - parseDbTimestampMs(open.created_at);
-        if (!expireStuckBlocker(open.task_id, row.network_id, ageMs, limitMs)) break;
+        const { ageMs, limitMs, source } = blockerTimeoutClock(open, row.schedule_json, advanceAfter);
+        if (!expireStuckBlocker(open.task_id, row.network_id, ageMs, limitMs, source)) break;
         timedOut.push({ taskId: open.task_id, fromStatus: open.status });
         // Each stuck episode gets exactly one notice: if the stuck notice already went out (N skips), stay quiet.
         if (skipsBlockedBy(row.schedule_id, open.task_id) < stuckNoticeSkips()) {

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";
@@ -5400,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
@@ -5643,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.