@sleep2agi/commhub-server 0.9.0-preview.12 → 0.9.0-preview.121

package/src/status-read-cache.ts

@@ -0,0 +1,122 @@
+// #431(app「连接较慢」)—— GET /api/status 的序列化结果记忆化 + 强 ETag。
+//
+// 现场(2026-10-02 生产 /api/stats/routes,15 分钟窗口):GET /api/status 2000 次 ≈ 2.2 次/秒,全部来自 UA「node」
+// (旧版 agent-node 的别名解析器,.82 起给它 light+node_id 投影),线上平均 30 KB/次(已经是 gzip 后的字节:
+// node 的 fetch 发 `Accept-Encoding: gzip, deflate`)。两次读之间表多半没变(report_status 约 0.75 次/秒),
+// 但每次都重新 SELECT 300 行、拼对象、JSON.stringify、再 gzip 一遍。
+//
+// 这里只做「同一份正文不重复算」,**不改任何正文**:
+//   键 = 最终 SQL + 参数(里面已经编码了调用者能看到哪些节点)+ 投影开关;
+//   失效 = 任何写 sessions 表的语句(db.ts 里统一挂钩,SQLite / PG 同一处)、任何健康上报、
+//          任何一份健康报告过 TTL(那一刻 degraded / health 字段会变)。
+//   全量投影里 `health_observed_ms_ago` 随时间走:只要有一行带健康报告,这份正文就是时间的函数,不缓存。
+// 命中时正文和当场重算逐字节相同(status-read-cache-http.test.ts 用随机写序列钉住)。
+//
+// ETag:正文的哈希,`If-None-Match` 命中回 304 空体。🔴 旧 agent-node 不发 If-None-Match(fetch 没有 HTTP 缓存),
+// 所以 ETag 只帮得上会带它的客户端(app / dashboard 以后接上);隧道上省字节靠的是同一份 gzip 只压一次
+// 且用更高的压缩级别(http-gzip.ts:可复用的正文压一次、存起来,级别 9)。
+
+import type { DbAdapter } from "./db-adapter";
+import { nodeHealthNextExpiryAt, nodeHealthVersion } from "./node-health-store.js";
+
+let sessionsWriteGen = 0;
+// #500 step 2 —— 全量投影带 queue_depth(tasks 表的开着任务数):写 tasks 的语句也要让**全量**正文失效。
+// light / 别名解析器投影不读 tasks,不看这个代数(写任务不打掉它们的缓存)。
+let tasksWriteGen = 0;
+
+const WRITE_START = /^\s*(?:insert|update|delete|replace|upsert|merge|alter|drop|create|truncate|with)\b/i;
+const SESSIONS_WORD = /\bsessions\b/i;
+// `\b` 不在 `_` 与字母之间:scheduled_tasks / task_events 不命中,只有 tasks 表本身。
+const TASKS_WORD = /\btasks\b/i;
+
+/**
+ * 每条经过 db 的语句都过一遍。写语句(含带 RETURNING 的、DDL)里点名了 sessions → 代数 +1。读语句不动。
+ * 不会有「没点名 sessions 却改了它」的写:两种方言的 schema 里都没有指向 sessions 的外键 / 级联删除
+ * (status-read-cache.test.ts 钉住这一点)。
+ */
+export function noteStatement(sql: string): void {
+  if (!WRITE_START.test(sql)) return;
+  if (SESSIONS_WORD.test(sql)) sessionsWriteGen++;
+  if (TASKS_WORD.test(sql)) tasksWriteGen++;
+}
+
+/** 原生 exec(迁移 / DDL / 多语句):不逐句判断,一律失效。 */
+export function noteExec(): void { sessionsWriteGen++; tasksWriteGen++; }
+
+export function statusWriteGeneration(): number { return sessionsWriteGen; }
+export function statusTasksWriteGeneration(): number { return tasksWriteGen; }
+
+/**
+ * db.ts 用它包住唯一的那个适配器:每条语句先报给上面两个函数。挂在这一个出口上,SQLite / PG 一样,
+ * 不靠每个写 sessions 的地方各自记得。直接换掉实例上的四个方法(不用 Proxy):有测试按 `db.all = …`
+ * 临时打桩数查询次数,方法得是普通可写属性。
+ */
+export function withStatementHook(inner: DbAdapter): DbAdapter {
+  const run = inner.run.bind(inner), get = inner.get.bind(inner), all = inner.all.bind(inner), exec = inner.exec.bind(inner);
+  inner.run = (sql: string, params?: any[]) => { noteStatement(sql); return run(sql, params); };
+  inner.get = ((sql: string, ...params: any[]) => { noteStatement(sql); return get(sql, ...params); }) as DbAdapter["get"];
+  inner.all = ((sql: string, ...params: any[]) => { noteStatement(sql); return all(sql, ...params); }) as DbAdapter["all"];
+  inner.exec = (sql: string) => { noteExec(); return exec(sql); };
+  return inner;
+}
+
+type Entry = { gen: number; taskGen: number | null; healthVer: number; validUntil: number; body: string; etag: string };
+const MAX_ENTRIES = 64;
+const memo = new Map<string, Entry>();
+export const statusCacheStats = { hits: 0, misses: 0, uncacheable: 0 };
+
+function etagOf(body: string): string {
+  return `"s-${Bun.hash(body).toString(36)}-${body.length.toString(36)}"`;
+}
+
+/**
+ * 取或算。compute 返回正文和它能不能缓存(全量投影里有健康报告 = 正文随时间变 = 不能)。
+ * 返回的 etag 总是这份正文的哈希(不缓存的也给,便于 304)。
+ */
+let bypass = false;
+/** 测试用:临时绕过缓存(既不读也不写),拿「当场重算」的那一份来对比,而不清掉缓存里已有的条目。 */
+export function __setStatusCacheBypassForTest(on: boolean): void { bypass = on; }
+
+export function memoStatusBody(
+  key: string,
+  compute: () => { body: string; cacheable: boolean },
+  now = Date.now(),
+  opts: { dependsOnTasks?: boolean } = {},
+): { body: string; etag: string; hit: boolean } {
+  if (bypass) { const { body } = compute(); return { body, etag: etagOf(body), hit: false }; }
+  const gen = sessionsWriteGen;
+  const taskGen = opts.dependsOnTasks ? tasksWriteGen : null;
+  const healthVer = nodeHealthVersion();
+  const hit = memo.get(key);
+  if (hit && hit.gen === gen && hit.taskGen === taskGen && hit.healthVer === healthVer && now < hit.validUntil) {
+    statusCacheStats.hits++;
+    memo.delete(key);
+    memo.set(key, hit); // LRU
+    return { body: hit.body, etag: hit.etag, hit: true };
+  }
+  const { body, cacheable } = compute();
+  const etag = etagOf(body);
+  // 以算之前的代数入账:算的过程中若有写(改名清理之类),下一次比较就对不上、重算 —— 宁可多算一次也不发旧正文。
+  if (!cacheable) {
+    statusCacheStats.uncacheable++;
+    memo.delete(key);
+    return { body, etag, hit: false };
+  }
+  statusCacheStats.misses++;
+  memo.set(key, { gen, taskGen, healthVer, validUntil: nodeHealthNextExpiryAt(now), body, etag });
+  while (memo.size > MAX_ENTRIES) memo.delete(memo.keys().next().value as string);
+  return { body, etag, hit: false };
+}
+
+/** If-None-Match 里有这个 ETag(或 `*`)。弱比较:去掉 W/ 前缀。 */
+export function ifNoneMatchHits(header: string | null, etag: string): boolean {
+  if (!header) return false;
+  const bare = (t: string) => t.trim().replace(/^W\//, "");
+  return header.split(",").some((t) => t.trim() === "*" || bare(t) === bare(etag));
+}
+
+/** 测试用。 */
+export function __resetStatusCacheForTest(): void {
+  memo.clear();
+  statusCacheStats.hits = statusCacheStats.misses = statusCacheStats.uncacheable = 0;
+}

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

@@ -2,12 +2,13 @@ import { afterAll, beforeEach, describe, expect, test } from "bun:test";
 import { db } from "./db.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { registerTools } from "./tools.js";
+import { patrolExpiredTasks } from "./server.js";
 
 // RFC-027 PR1 — handler-driven tests for stop_node, delete_node,
 // get_stop_request, ack_stop_request. Drives the MCP handlers via
 // registerTools() so the wired auth context is real (not the
 // mirror-SQL pattern that PR2 v1 used and which let SEC-1 leak slip
-// through, per [[feedback_parallel_fork_review_catches_wired_wrong]]).
+// through — per team rule: independent fork-review catches wired-wrong even when unit tests pass).
 //
 // Covers RFC-027 P1 e2e plan §5.2 scenarios A/B/C/D/E/F at the
 // handler layer:
@@ -36,11 +37,15 @@ interface Reply { ok?: boolean; error?: string; [k: string]: unknown; }
 function cleanup() {
   for (const n of [NET_A, NET_B]) {
     try { db.run("DELETE FROM node_stop_requests WHERE network_id = ?1", [n]); } catch {}
+    try { db.run("DELETE FROM node_create_requests WHERE network_id = ?1", [n]); } catch {}
     try { db.run("DELETE FROM audit_log WHERE network_id = ?1", [n]); } catch {}
     try { db.run("DELETE FROM inbox WHERE network_id = ?1", [n]); } catch {}
     // PR1.2a restart_node tests leave node_config_updates rows; clear
     // so the next test's restart_node doesn't see them as in_flight.
     try { db.run("DELETE FROM node_config_updates WHERE network_id = ?1", [n]); } catch {}
+    // #2022 seeds tasks rows whose status drives the in-flight join; clear
+    // them by network or a later test inherits a stale terminal row.
+    try { db.run("DELETE FROM tasks WHERE network_id = ?1", [n]); } catch {}
     try { db.run("DELETE FROM nodes WHERE network_id = ?1", [n]); } catch {}
     try { db.run("DELETE FROM sessions WHERE network_id = ?1", [n]); } catch {}
     try { db.run("DELETE FROM api_tokens WHERE network_id = ?1", [n]); } catch {}
@@ -179,6 +184,12 @@ function setupAlphaNetwork() {
   seedMembership(USER_A_ID, NET_A, "admin");
   seedDaemon(NET_A, DAEMON_A_ID, DAEMON_A_ALIAS, USER_A_ID, DAEMON_A_TOK);
   seedChild(NET_A, CHILD_A_ID, CHILD_A_ALIAS, USER_A_ID, CHILD_TOK_A_ID);
+  // Board #625: happy paths must carry actual creation authority, not merely a node_ id.
+  db.run(
+    `INSERT INTO node_create_requests(request_id,daemon_node_id,child_name,network_id,runtime,model,flags_json,env_keys,status,created_at,created_by_token,child_node_id)
+     VALUES(?1,?2,?3,?4,'claude-agent-sdk','x','{}','[]','succeeded',1,'t',?5)`,
+    [`cr_${CHILD_A_ID.slice(5)}`, DAEMON_A_ID, CHILD_A_ALIAS, NET_A, CHILD_A_ID],
+  );
 }
 
 // ── stop_node ──────────────────────────────────────────────────────
@@ -408,6 +419,69 @@ describe("get_stop_request + ack_stop_request — daemon flow", () => {
     expect(JSON.parse(audits[0].detail).backup_path).toBe("/home/u/.anet/deleted/1719647200000-sd-child-a");
   });
 
+  // #1448 finding-4 — stop/delete 必须校验 daemon 是 child 的权威创建者(镜像 start)。
+  // 改前只校验 daemon 存在+同网 → 同网调用方传错 daemon_node_id,门铃路由到错 daemon。
+  // f3 合入后错 daemon 会 sweep 空 + ack stopped → hub 假收敛 stopped 而 child 仍在跑。
+  test("#1448 finding-4: stop/delete reject a wrong same-network daemon_node_id (daemon_child_mismatch)", async () => {
+    setupAlphaNetwork();
+    // setupAlphaNetwork carries the creation authority.
+    // 一个同网、存在、但没创建 CHILD_A 的 daemon
+    const DAEMON_B = "node_sd_daemon_b";
+    seedDaemon(NET_A, DAEMON_B, "sd-daemon-b", USER_A_ID, "tok_sd_daemon_b");
+    const u = buildHandlers(USER_A_ID);
+    // 错 daemon → mismatch(stop + delete 都拦)。改前会放行、路由到错 daemon。
+    expect((await call(u.stop_node, { child_node_id: CHILD_A_ID, daemon_node_id: DAEMON_B, network_id: NET_A })).error).toBe("daemon_child_mismatch");
+    expect((await call(u.delete_node, { child_node_id: CHILD_A_ID, daemon_node_id: DAEMON_B, confirm_alias: CHILD_A_ALIAS, network_id: NET_A })).error).toBe("daemon_child_mismatch");
+    // 正确 daemon → 放行(回归钉)
+    expect((await call(u.stop_node, { child_node_id: CHILD_A_ID, daemon_node_id: DAEMON_A_ID, network_id: NET_A })).ok).toBe(true);
+  });
+
+  // #571 — 手工起的节点(id `n_…`)没有任何 daemon 链接。改前:authority==null 时
+  // 放行调用方点名的任意同网 daemon → 门铃发过去,那台 daemon 本地无记录,按 alias
+  // 全机 pgrep+SIGTERM,误杀同 alias 的别的 agent-node。改后:不论传没传 daemon 一律拒。
+  test("#571: stop/delete of a hand-started node refuse even with an explicit same-network daemon", async () => {
+    setupAlphaNetwork();
+    const HAND_ID = "n_571abcde";
+    const HAND_ALIAS = "sd-hand-571";
+    seedChild(NET_A, HAND_ID, HAND_ALIAS, USER_A_ID, "tok_sd_hand_571");
+    const u = buildHandlers(USER_A_ID);
+    const s = await call(u.stop_node, { child_node_id: HAND_ID, daemon_node_id: DAEMON_A_ID, network_id: NET_A });
+    expect(s.ok).toBe(false);
+    expect(s.error).toBe("not_daemon_managed");
+    expect(String(s.message)).toContain("anet node stop");
+    const d = await call(u.delete_node, { child_node_id: HAND_ID, daemon_node_id: DAEMON_A_ID, confirm_alias: HAND_ALIAS, network_id: NET_A });
+    expect(d.error).toBe("not_daemon_managed");
+    // 没有任何副作用:状态没动、没写 stop 请求行
+    expect(readNode(HAND_ID)?.lifecycle_state).toBe("active");
+    const rows = db.get<{ n: number }>(`SELECT COUNT(*) AS n FROM node_stop_requests WHERE child_node_id = ?1`, HAND_ID);
+    expect(Number(rows?.n ?? 0)).toBe(0);
+    // 回归钉:setupAlphaNetwork 中有 create 记录的 child 照常可停。
+    expect((await call(u.stop_node, { child_node_id: CHILD_A_ID, network_id: NET_A })).ok).toBe(true);
+  });
+
+  // #1448 finding-5 — delete 完成时按派发时定住的 token_id 精确撤 ntok,而非按
+  // name='node:<alias>' 广撤。改前:同 alias 在 delete 未收敛窗口内被重建、拿到同名新
+  // token,ack 会把新 token 一并误撤(下面 REBUILT_TOK 断言 not revoked 会红)。
+  test("#1448 finding-5: delete revokes by token_id, spares a same-alias rebuilt token", async () => {
+    setupAlphaNetwork();
+    const userTools = buildHandlers(USER_A_ID);
+    const dispatch = await call(userTools.delete_node, {
+      child_node_id: CHILD_A_ID, daemon_node_id: DAEMON_A_ID, network_id: NET_A, confirm_alias: CHILD_A_ALIAS,
+    });
+    expect(dispatch.ok).toBe(true);
+    // 派发后、ack 前:同 alias 节点被重建,拿到**同名**新 ntok(不同 token_id,仍 active)。
+    const REBUILT_TOK = "tok_sd_child_a_rebuilt";
+    db.run(
+      `INSERT INTO api_tokens (token_id, user_id, network_id, scope, name, token_hash, expires_at, revoked_at)
+       VALUES (?1, ?2, ?3, 'network', ?4, ?5, NULL, NULL)`,
+      [REBUILT_TOK, USER_A_ID, NET_A, `node:${CHILD_A_ALIAS}`, `hash_${REBUILT_TOK}`],
+    );
+    const daemonTools = buildHandlers(USER_A_ID, true, DAEMON_A_TOK, NET_A);
+    await call(daemonTools.ack_stop_request, { request_id: dispatch.request_id as string, status: "stopped", exit_signal: "SIGTERM" });
+    expect(readToken(CHILD_TOK_A_ID)?.revoked_at).not.toBeNull();   // 原 token 撤销(精确命中)
+    expect(readToken(REBUILT_TOK)?.revoked_at).toBeNull();          // 重建的同名新 token 未被误撤(改前按 name 广撤会红)
+  });
+
   test("daemon ack 'stop_failed' → lifecycle_state=stop_failed, request error captured", async () => {
     setupAlphaNetwork();
     const userTools = buildHandlers(USER_A_ID);
@@ -676,6 +750,135 @@ describe("list_my_children HANDLER (RFC-027 PR1.1)", () => {
   });
 });
 
+describe("create_node audit wording (#1362)", () => {
+  test("create_node records a dispatch attempt, not guaranteed SSE delivery", async () => {
+    setupAlphaNetwork();
+    const tools = buildHandlers(USER_A_ID);
+    const r = await call(tools.create_node, {
+      daemon_node_id: DAEMON_A_ID,
+      node_spec: {
+        name: "sd-new-child",
+        runtime: "claude-agent-sdk",
+        model: "x",
+      },
+      network_id: NET_A,
+    });
+
+    expect(r.ok).toBe(true);
+    expect(typeof r.request_id).toBe("string");
+    expect(readAudit("create_node_dispatch_attempted", NET_A).length).toBe(1);
+    expect(readAudit("create_node_dispatched", NET_A).length).toBe(0);
+  });
+});
+
+describe("list_my_pending_create_requests HANDLER (#1362 SSE reconnect compensation)", () => {
+  test("daemon-bound caller gets only its own pending create requests", async () => {
+    setupAlphaNetwork();
+    const otherDaemonId = "node_sd_daemon_other";
+    seedDaemon(NET_A, otherDaemonId, "sd-daemon-other", USER_A_ID, "tok_sd_daemon_other");
+    db.run(
+      `INSERT INTO node_create_requests
+         (request_id, daemon_node_id, child_name, network_id, runtime, model, flags_json, env_keys, status, child_token_id, created_at, created_by_token)
+       VALUES
+         ('cr_pending_mine', ?1, 'child-pending-mine', ?2, 'claude-agent-sdk', 'x', '{}', '[]', 'pending', NULL, ?3, 'tok_test'),
+         ('cr_delivered_mine', ?1, 'child-delivered-mine', ?2, 'claude-agent-sdk', 'x', '{}', '[]', 'delivered', NULL, ?4, 'tok_test'),
+         ('cr_pending_other', ?5, 'child-pending-other', ?2, 'claude-agent-sdk', 'x', '{}', '[]', 'pending', NULL, ?6, 'tok_test')`,
+      [DAEMON_A_ID, NET_A, Date.now(), Date.now() + 1, otherDaemonId, Date.now() + 2],
+    );
+
+    const daemonTools = buildHandlers(USER_A_ID, true, DAEMON_A_TOK, NET_A);
+    const r = await call(daemonTools.list_my_pending_create_requests, {});
+
+    expect(r.ok).toBe(true);
+    expect(r.count).toBe(1);
+    expect(r.requests).toEqual([
+      expect.objectContaining({ request_id: "cr_pending_mine", child_name: "child-pending-mine" }),
+    ]);
+  });
+
+  test("non-daemon caller (utok) refused", async () => {
+    setupAlphaNetwork();
+    const userTools = buildHandlers(USER_A_ID);
+    const r = await call(userTools.list_my_pending_create_requests, {});
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe("list_my_pending_lifecycle_requests HANDLER (#1448 SSE reconnect compensation)", () => {
+  function seedStop(reqId: string, daemonId: string, status: string, action: string, ageMs: number) {
+    db.run(
+      `INSERT INTO node_stop_requests (request_id, network_id, daemon_node_id, child_node_id,
+         child_alias, action, delete_config, created_by_token, status, created_at)
+       VALUES (?1, ?2, ?3, ?4, ?5, ?6, 1, 'tok_test', ?7, ?8)`,
+      [reqId, NET_A, daemonId, CHILD_A_ID, CHILD_A_ALIAS, action, status, Date.now() - ageMs],
+    );
+  }
+  // child_node_id parameterized: node_start_requests has a partial-unique
+  // index on child_node_id WHERE status IN ('pending','delivered'), so the
+  // "mine" and "other" pending start rows must target different children.
+  function seedStart(reqId: string, daemonId: string, childId: string, status: string, ageMs: number) {
+    db.run(
+      `INSERT INTO node_start_requests (request_id, network_id, daemon_node_id, child_node_id,
+         child_alias, created_by_token, status, created_at)
+       VALUES (?1, ?2, ?3, ?4, ?5, 'tok_test', ?6, ?7)`,
+      [reqId, NET_A, daemonId, childId, CHILD_A_ALIAS, status, Date.now() - ageMs],
+    );
+  }
+
+  test("daemon-bound caller gets only its own PENDING stop/delete + start (excludes delivered + other daemon)", async () => {
+    setupAlphaNetwork();
+    const otherDaemonId = "node_sd_daemon_other";
+    seedDaemon(NET_A, otherDaemonId, "sd-daemon-other", USER_A_ID, "tok_sd_daemon_other");
+    // mine — should be returned (stop + delete, oldest first)
+    seedStop("sr_pending_stop", DAEMON_A_ID, "pending", "stop", 30);
+    seedStop("sr_pending_delete", DAEMON_A_ID, "pending", "delete", 20);
+    seedStart("str_pending_mine", DAEMON_A_ID, CHILD_A_ID, "pending", 25);
+    // excluded — delivered (already pulled) + other daemon's pending
+    seedStop("sr_delivered_mine", DAEMON_A_ID, "delivered", "stop", 40);
+    seedStop("sr_pending_other", otherDaemonId, "pending", "stop", 10);
+    seedStart("str_pending_other", otherDaemonId, "node_sd_child_other", "pending", 10);
+
+    const daemonTools = buildHandlers(USER_A_ID, true, DAEMON_A_TOK, NET_A);
+    const res = await call(daemonTools.list_my_pending_lifecycle_requests, {});
+    expect(res.ok).toBe(true);
+    expect(res.stop_count).toBe(2);
+    expect((res.stop_requests as Array<{ request_id: string }>).map(x => x.request_id))
+      .toEqual(["sr_pending_stop", "sr_pending_delete"]);   // oldest-first, action preserved
+    expect(res.start_count).toBe(1);
+    expect((res.start_requests as Array<{ request_id: string }>).map(x => x.request_id))
+      .toEqual(["str_pending_mine"]);
+  });
+
+  // Witnessed-red 的核心链：真实 stop_node 派发时 daemon 无 SSE 订阅者 →
+  // pushEvent 静默丢门铃 → 行卡 pending / 节点卡 stopping（缺陷态）。修复后这条
+  // pending 行会被 list_my_pending_lifecycle_requests 列出 → 重连 reconcile 能重放。
+  // 改前（无此工具）该行永远无人发现、节点永久卡 stopping。
+  test("stuck-pending after a dropped doorbell IS surfaced for reconnect replay", async () => {
+    setupAlphaNetwork();
+    const userTools = buildHandlers(USER_A_ID);
+    // 无 SSE 订阅者：dispatch 建 pending 行 + pushEvent 丢弃（测试进程里没有 client）
+    const disp = await call(userTools.stop_node, { child_node_id: CHILD_A_ID, daemon_node_id: DAEMON_A_ID, network_id: NET_A });
+    expect(disp.ok).toBe(true);
+    const reqId = disp.request_id as string;
+    // 缺陷态：行 pending、节点 stopping（门铃没送达，无人推进）
+    const row = db.get<{ status: string }>("SELECT status FROM node_stop_requests WHERE request_id = ?1", reqId);
+    expect(row?.status).toBe("pending");
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("stopping");
+    // 修复：pending 行经新工具对本 daemon 可见 → 重连补偿能拿到并重放
+    const daemonTools = buildHandlers(USER_A_ID, true, DAEMON_A_TOK, NET_A);
+    const r = await call(daemonTools.list_my_pending_lifecycle_requests, {});
+    expect(r.ok).toBe(true);
+    expect((r.stop_requests as Array<{ request_id: string }>).map(x => x.request_id)).toContain(reqId);
+  });
+
+  test("non-daemon caller (utok) refused", async () => {
+    setupAlphaNetwork();
+    const userTools = buildHandlers(USER_A_ID);
+    const r = await call(userTools.list_my_pending_lifecycle_requests, {});
+    expect(r.ok).toBe(false);
+  });
+});
+
 // ─── PR1.2a — restart_node resets lifecycle_state ──────────────────
 //
 // 通信龙 #346 ack latent: without this, a stopped node restart-ed via
@@ -718,3 +921,268 @@ describe("RFC-027 PR1.2a — restart_node resets lifecycle_state to 'active'", (
     expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("active");
   });
 });
+
+// ── #1286 stale-deleting 重派出口 ──────────────────────────────────
+//
+// 修复前 daemon 丢 ack 会让行永远停在 deleting：重发被挡、force 也一样。
+// 2026-08-28 实测两行卡死（acc-…-3373 / probe-tl2），API 层面无解。
+// 出口三条件缺一不放行：force=true + 最近 delete 请求非终态 + 晾超 5 分钟。
+describe("delete_node — stale-deleting redispatch exit (#1286)", () => {
+  function seedDeletingChild() {
+    setupAlphaNetwork();
+    db.run(`UPDATE nodes SET lifecycle_state = 'deleting' WHERE node_id = ?1`, [CHILD_A_ID]);
+  }
+  function seedStopRequest(status: string, ageMs: number) {
+    db.run(
+      `INSERT INTO node_stop_requests (request_id, network_id, daemon_node_id, child_node_id,
+         child_alias, action, delete_config, created_by_token, status, created_at)
+       VALUES (?1, ?2, ?3, ?4, ?5, 'delete', 1, 'tok_test', ?6, ?7)`,
+      [`sr_stale_${Date.now()}_${Math.floor(ageMs)}`, NET_A, DAEMON_A_ID, CHILD_A_ID,
+       CHILD_A_ALIAS, status, Date.now() - ageMs],
+    );
+  }
+  const base = { child_node_id: CHILD_A_ID, daemon_node_id: DAEMON_A_ID, network_id: NET_A, confirm_alias: CHILD_A_ALIAS };
+
+  test("无 force：仍拒，且带 hint 指出口（不是让人反复撞墙）", async () => {
+    seedDeletingChild(); seedStopRequest("pending", 10 * 60_000);
+    const r = await call(buildHandlers(USER_A_ID).delete_node, base);
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_already_deleting");
+    expect(typeof r.hint).toBe("string");
+  });
+
+  test("🔴 force 但请求还新鲜（1 分钟）：仍拒 —— force 不能变成竞态放大器", async () => {
+    seedDeletingChild(); seedStopRequest("pending", 60_000);
+    const r = await call(buildHandlers(USER_A_ID).delete_node, { ...base, force: true });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_already_deleting");
+  });
+
+  test("🔴 force 但上一条已终态（stopped）：仍拒 —— daemon 刚 ack 过，行马上会转移", async () => {
+    seedDeletingChild(); seedStopRequest("stopped", 10 * 60_000);
+    const r = await call(buildHandlers(USER_A_ID).delete_node, { ...base, force: true });
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_already_deleting");
+  });
+
+  test("force + pending 晾超 5 分钟：放行，生成新 request_id", async () => {
+    seedDeletingChild(); seedStopRequest("pending", 10 * 60_000);
+    const r = await call(buildHandlers(USER_A_ID).delete_node, { ...base, force: true });
+    expect(r.ok).toBe(true);
+    expect((r.request_id as string).startsWith("sr_")).toBe(true);
+  });
+
+  test("force + dispatched 晾超 5 分钟：同样放行", async () => {
+    seedDeletingChild(); seedStopRequest("dispatched", 10 * 60_000);
+    const r = await call(buildHandlers(USER_A_ID).delete_node, { ...base, force: true });
+    expect(r.ok).toBe(true);
+  });
+});
+
+// ── #2022 — in-flight gate: terminal / aged rows must not pin busy ──
+//
+// The old gate was COUNT(*) FROM inbox WHERE session_name=? AND acked=0:
+// no join to tasks, no age limit, and nothing acks an inbox row whose
+// task already died (retention sweeps only acked=1 rows), so a single
+// dead row pinned the node to node_busy_in_flight forever.
+//
+// Rule under test (#2029 review):
+//   1. type='task' rows that join to a tasks row are judged by status
+//      ALONE — terminal (replied / failed / cancelled / expired) is not
+//      counted, anything else is counted with NO age ceiling. agent-node
+//      acks the inbox row only when the task is done, so a 90-minute
+//      (or ttl_seconds>3600) run stays acked=0 the whole time and must
+//      keep the gate closed; expiry is patrolExpiredTasks' job.
+//      Join key is COALESCE(task_id, id), the logical id cancel_task
+//      uses.
+//   2. rows with no status of their own — task rows whose tasks row is
+//      gone, and non-task rows (reply / broadcast / message) — get the
+//      60-minute age ceiling; nothing else will ever retire them.
+//   3. patrolExpiredTasks acks the matching inbox rows in the same
+//      transaction that expires the task.
+
+function seedTaskWithInbox(
+  net: string,
+  alias: string,
+  opts: {
+    task_id: string;
+    status: string;
+    /** signed datetime offset for the tasks row, e.g. '-3 days' */
+    task_age?: string;
+    /** signed datetime offset for the inbox row, e.g. '-3 days' */
+    inbox_age?: string;
+    /** signed datetime offset for tasks.expires_at, e.g. '+1 hour' */
+    expires_in?: string;
+  },
+) {
+  db.run(
+    `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response,
+                        created_at, delivered_at, expires_at, network_id)
+     VALUES (?1, 'caller', ?2, 'normal', ?3, 'do the thing', 'reply',
+             datetime('now', ?4), datetime('now', ?4), datetime('now', ?5), ?6)`,
+    [opts.task_id, alias, opts.status, opts.task_age ?? "0 seconds", opts.expires_in ?? "+1 hour", net],
+  );
+  db.run(
+    `INSERT INTO inbox (id, task_id, session_name, type, priority, content, from_session, network_id, acked, created_at)
+     VALUES (?1, ?1, ?2, 'task', 'normal', 'do the thing', 'caller', ?3, 0, datetime('now', ?4))`,
+    [opts.task_id, alias, net, opts.inbox_age ?? "0 seconds"],
+  );
+}
+
+function stopArgs() {
+  return { child_node_id: CHILD_A_ID, daemon_node_id: DAEMON_A_ID, network_id: NET_A };
+}
+
+describe("#2022 stop gate — terminal task rows are not in flight", () => {
+  test("28-day-old expired + 3-day-old replied rows → stop dispatches, in_flight=0", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, {
+      task_id: "task_2022_expired", status: "expired",
+      task_age: "-28 days", inbox_age: "-28 days", expires_in: "-27 days",
+    });
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, {
+      task_id: "task_2022_replied", status: "replied",
+      task_age: "-3 days", inbox_age: "-3 days", expires_in: "-2 days",
+    });
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.ok).toBe(true);
+    expect(r.in_flight_at_dispatch).toBe(0);
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("stopping");
+  });
+
+  test("FRESH terminal row (replied, 0s old) also not counted — terminal filter alone is enough", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_2022_fresh_replied", status: "replied" });
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.ok).toBe(true);
+    expect(r.in_flight_at_dispatch).toBe(0);
+  });
+});
+
+describe("#2022 stop gate — genuinely in-flight rows still block", () => {
+  test("fresh non-terminal task row → node_busy_in_flight, count surfaced, state untouched", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, { task_id: "task_2022_live", status: "delivered" });
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(1);
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("active");
+    expect(readAudit("stop_node_dispatched", NET_A).length).toBe(0);
+  });
+
+  test("fresh non-task inbox row (type='reply') still counts — judged by age only", async () => {
+    setupAlphaNetwork();
+    db.run(
+      `INSERT INTO inbox (id, session_name, type, content, from_session, network_id, acked, created_at)
+       VALUES (?1, ?2, 'reply', 'fresh reply', 'caller', ?3, 0, datetime('now'))`,
+      [`inbox_2022_fresh_reply`, CHILD_A_ALIAS, NET_A],
+    );
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(1);
+  });
+});
+
+describe("#2022 stop gate — a live task is never aged out (status wins over age)", () => {
+  test("🔴 created 2 hours ago + task.status='running' → still node_busy_in_flight", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, {
+      task_id: "task_2022_running_90m", status: "running",
+      task_age: "-120 minutes", inbox_age: "-120 minutes", expires_in: "-60 minutes",
+    });
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.ok).toBe(false);
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(1);
+    expect(readNode(CHILD_A_ID)?.lifecycle_state).toBe("active");
+  });
+
+  test("task.status='acked' 2 hours old (patrol never expires it) → still blocked", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, {
+      task_id: "task_2022_acked_120m", status: "acked",
+      inbox_age: "-120 minutes", expires_in: "+12 hours",
+    });
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.error).toBe("node_busy_in_flight");
+    expect(r.in_flight_count).toBe(1);
+  });
+});
+
+describe("#2022 stop gate — age ceiling (60 min) for rows with no status", () => {
+  test("orphan task row (tasks row reaped) 8 days old → not counted", async () => {
+    setupAlphaNetwork();
+    db.run(
+      `INSERT INTO inbox (id, task_id, session_name, type, content, from_session, network_id, acked, created_at)
+       VALUES (?1, ?1, ?2, 'task', 'orphan task', 'caller', ?3, 0, datetime('now', '-8 days'))`,
+      [`task_2022_reaped`, CHILD_A_ALIAS, NET_A],
+    );
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.ok).toBe(true);
+    expect(r.in_flight_at_dispatch).toBe(0);
+  });
+
+  test("non-task row older than the ceiling → not counted (the production backlog shape)", async () => {
+    setupAlphaNetwork();
+    db.run(
+      `INSERT INTO inbox (id, session_name, type, content, from_session, network_id, acked, created_at)
+       VALUES (?1, ?2, 'broadcast', 'week-old broadcast', 'caller', ?3, 0, datetime('now', '-7 days'))`,
+      [`inbox_2022_old_broadcast`, CHILD_A_ALIAS, NET_A],
+    );
+    const r = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(r.ok).toBe(true);
+    expect(r.in_flight_at_dispatch).toBe(0);
+  });
+});
+
+describe("#2022 patrolExpiredTasks — expires the task AND acks its inbox rows", () => {
+  test("same transaction: tasks.status='expired' + inbox.acked=1 → gate unblocks", async () => {
+    setupAlphaNetwork();
+    seedTaskWithInbox(NET_A, CHILD_A_ALIAS, {
+      task_id: "task_2022_due", status: "delivered",
+      inbox_age: "-10 minutes", expires_in: "-1 minute",
+    });
+
+    // Before the patrol: fresh, non-terminal → the node is correctly busy.
+    const before = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(before.error).toBe("node_busy_in_flight");
+    expect(before.in_flight_count).toBe(1);
+
+    patrolExpiredTasks();
+
+    expect(db.get<{ status: string }>("SELECT status FROM tasks WHERE task_id = ?1", "task_2022_due")?.status).toBe("expired");
+    const inboxRow = db.get<{ acked: number }>(
+      "SELECT acked FROM inbox WHERE task_id = ?1 AND session_name = ?2", "task_2022_due", CHILD_A_ALIAS,
+    );
+    expect(inboxRow?.acked).toBe(1);
+
+    // And the gate that was blocked a moment ago now dispatches.
+    const after = await call(buildHandlers(USER_A_ID).stop_node, stopArgs());
+    expect(after.ok).toBe(true);
+    expect(after.in_flight_at_dispatch).toBe(0);
+  });
+
+  test("legacy inbox row keyed by id (task_id IS NULL) is acked too", async () => {
+    setupAlphaNetwork();
+    db.run(
+      `INSERT INTO tasks (task_id, from_name, to_name, priority, status, content, requires_response,
+                          created_at, expires_at, network_id)
+       VALUES ('task_2022_legacy', 'caller', ?1, 'normal', 'delivered', 'do the thing', 'reply',
+               datetime('now', '-10 minutes'), datetime('now', '-1 minute'), ?2)`,
+      [CHILD_A_ALIAS, NET_A],
+    );
+    // Pre-task_id shape: the transport row IS the logical id.
+    db.run(
+      `INSERT INTO inbox (id, session_name, type, content, from_session, network_id, acked, created_at)
+       VALUES ('task_2022_legacy', ?1, 'task', 'do the thing', 'caller', ?2, 0, datetime('now', '-10 minutes'))`,
+      [CHILD_A_ALIAS, NET_A],
+    );
+
+    patrolExpiredTasks();
+
+    expect(db.get<{ status: string }>("SELECT status FROM tasks WHERE task_id = 'task_2022_legacy'")?.status).toBe("expired");
+    expect(db.get<{ acked: number }>("SELECT acked FROM inbox WHERE id = 'task_2022_legacy'")?.acked).toBe(1);
+  });
+});