@sleep2agi/commhub-server 0.9.0-preview.13 → 0.9.0-preview.130

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,109 @@ 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");
   });
 
+  // Daemon-mediated delete used to drop only the nodes row. The child's sessions
+  // row stayed behind as "offline", so /api/status — and every client list built
+  // on it — kept showing the deleted node forever (desktop: the node stays put
+  // under 「删除请求已提交」). REST DELETE /api/nodes/:id already drops both.
+  test("daemon ack 'stopped' on delete branch → the child's session row is gone too", async () => {
+    setupAlphaNetwork();
+    db.run(
+      "INSERT INTO sessions (resume_id, alias, node_id, network_id, status) VALUES (?1, ?2, ?3, ?4, 'idle')",
+      ["resume-sd-child-a", CHILD_A_ALIAS, CHILD_A_ID, NET_A],
+    );
+    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);
+    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" });
+    const left = db.get<{ n: number }>("SELECT COUNT(*) AS n FROM sessions WHERE node_id = ?1", CHILD_A_ID);
+    expect(Number(left?.n ?? 0)).toBe(0);
+  });
+
+  test("delete finalize drops the session by node_id, sparing a same-alias rebuilt node", 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);
+    // Before the ack lands, a new node takes the same alias and registers.
+    const REBUILT_ID = "node_sd_child_a_rebuilt";
+    db.run(
+      "INSERT INTO sessions (resume_id, alias, node_id, network_id, status) VALUES (?1, ?2, ?3, ?4, 'idle')",
+      ["resume-sd-child-a-rebuilt", CHILD_A_ALIAS, REBUILT_ID, NET_A],
+    );
+    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" });
+    const rebuilt = db.get<{ status: string }>("SELECT status FROM sessions WHERE node_id = ?1", REBUILT_ID);
+    expect(rebuilt?.status).toBe("idle");
+  });
+
+  // #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 +790,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 +961,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);
+  });
+});