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

package/src/task-diagnostic.test.ts

@@ -0,0 +1,115 @@
+import { describe, expect, test } from "bun:test";
+import { diagnoseTask, type TaskDiagnosticInput } from "./task-diagnostic";
+
+const base = (patch: Partial<TaskDiagnosticInput> = {}): TaskDiagnosticInput => ({
+  status: "delivered",
+  runtimeSubmittedAt: null,
+  consumedAt: null,
+  targetSessionStatus: "idle",
+  targetSessionExists: true,
+  liveSseConnections: 1,
+  ...patch,
+});
+
+describe("#166 evidence-only task diagnostics", () => {
+  test("terminal state wins over stale transport and runtime evidence", () => {
+    expect(diagnoseTask(base({
+      status: "replied",
+      runtimeSubmittedAt: "2026-08-10T00:00:00Z",
+      consumedAt: "2026-08-10T00:00:01Z",
+      targetSessionExists: false,
+      targetSessionStatus: null,
+      liveSseConnections: 0,
+    }))).toMatchObject({ code: "terminal", action_hint: "none" });
+  });
+
+  test("runtime evidence outranks current target connectivity", () => {
+    expect(diagnoseTask(base({ consumedAt: "2026-08-10T00:00:01Z", liveSseConnections: 0 }))).toMatchObject({
+      code: "runtime_consumed_nonterminal",
+      action_hint: "inspect_runtime",
+    });
+    expect(diagnoseTask(base({ runtimeSubmittedAt: "2026-08-10T00:00:00Z", targetSessionStatus: "offline" }))).toMatchObject({
+      code: "runtime_submitted_waiting_for_signal",
+      action_hint: "inspect_runtime",
+    });
+  });
+
+  test("distinguishes missing, offline, and no-SSE targets", () => {
+    expect(diagnoseTask(base({ targetSessionExists: false, targetSessionStatus: null }))).toMatchObject({
+      code: "target_session_missing",
+      action_hint: "check_target_registration",
+    });
+    expect(diagnoseTask(base({ targetSessionStatus: "offline" }))).toMatchObject({
+      code: "target_session_offline",
+      action_hint: "restore_target",
+    });
+    expect(diagnoseTask(base({ liveSseConnections: 0 }))).toMatchObject({
+      code: "target_no_live_sse",
+      action_hint: "restore_sse",
+    });
+  });
+
+  test("does not infer consumption from lifecycle status alone", () => {
+    const diagnostic = diagnoseTask(base({ status: "running" }));
+    expect(diagnostic).toMatchObject({
+      code: "lifecycle_progress_without_runtime_evidence",
+      action_hint: "inspect_runtime",
+      evidence: { runtime_submitted: false, runtime_consumed: false },
+    });
+  });
+
+  test("reports delivered waiting only when registration and SSE are present", () => {
+    expect(diagnoseTask(base())).toEqual({
+      schema_version: 1,
+      code: "delivered_waiting_for_agent",
+      action_hint: "inspect_agent_queue",
+      evidence: {
+        task_status: "delivered",
+        target_session_status: "idle",
+        live_sse_connections: 1,
+        runtime_submitted: false,
+        runtime_consumed: false,
+        // 🔴 #1083 新增。这里保持 toEqual（整形断言）而**不**退化成 toMatchObject ——
+        //    隔壁那条测试的名字就是 "without widening the evidence"，
+        //    这个严格性是故意的：它防的正是「有人往 evidence 里悄悄加字段」。
+        //    加宽了就把新字段写进来，不是把断言放松。
+        target_ever_reported_runtime_evidence: null,
+      },
+    });
+  });
+
+  // 🔴 #1083：【时序】与【能力】必须落在不同的 code 上。
+  //    实测背景：一个**确实回了长信**的任务与一个**毫无回音**的任务，
+  //    在旧实现下 diagnostic 逐字相同（都是 lifecycle_progress_without_runtime_evidence
+  //    + inspect_runtime）⇒ 鉴别力 = 0。
+  test("a target that never reported runtime evidence gets its own code, not inspect_runtime", () => {
+    const d = diagnoseTask(base({ status: "acked", targetEverReportedRuntimeEvidence: false }));
+    expect(d.code).toBe("runtime_evidence_channel_absent");
+    expect(d.action_hint).toBe("wire_runtime_evidence");
+    expect(d.evidence.target_ever_reported_runtime_evidence).toBe(false);
+  });
+
+  test("a target that HAS reported evidence before keeps the timing-flavoured code", () => {
+    const d = diagnoseTask(base({ status: "acked", targetEverReportedRuntimeEvidence: true }));
+    expect(d.code).toBe("lifecycle_progress_without_runtime_evidence");
+    expect(d.action_hint).toBe("inspect_runtime");
+  });
+
+  // 「Hub 没算这一项」不等于「没报过」—— 不知道就不改判。
+  test("an unknown capability (null / omitted) does not change the old verdict", () => {
+    const omitted = diagnoseTask(base({ status: "acked" }));
+    const explicitNull = diagnoseTask(base({ status: "acked", targetEverReportedRuntimeEvidence: null }));
+    for (const d of [omitted, explicitNull]) {
+      expect(d.code).toBe("lifecycle_progress_without_runtime_evidence");
+      expect(d.action_hint).toBe("inspect_runtime");
+      expect(d.evidence.target_ever_reported_runtime_evidence).toBeNull();
+    }
+  });
+
+  test("normalizes invalid SSE counts without widening the evidence", () => {
+    expect(diagnoseTask(base({ liveSseConnections: Number.NaN }))).toMatchObject({
+      code: "target_no_live_sse",
+      evidence: { live_sse_connections: 0 },
+    });
+  });
+});

package/src/task-diagnostic.ts

@@ -0,0 +1,118 @@
+const TERMINAL_STATUSES = new Set(["replied", "failed", "cancelled", "expired"]);
+
+export type TaskDiagnosticCode =
+  | "terminal"
+  | "runtime_consumed_nonterminal"
+  | "runtime_submitted_waiting_for_signal"
+  | "target_session_missing"
+  | "target_session_offline"
+  | "target_no_live_sse"
+  | "lifecycle_progress_without_runtime_evidence"
+  // 🔴 #1083：与上一条的区别是【时序】vs【能力】。上一条说的是「还没走到那一步」，
+  //    这一条说的是「这个目标从来没有报过任何一次运行时证据」——它不会走到。
+  //    两者处置相反：前者【等】，后者【别等，去接线】。
+  | "runtime_evidence_channel_absent"
+  | "delivered_waiting_for_agent";
+
+export type TaskDiagnosticAction =
+  | "none"
+  | "inspect_runtime"
+  | "check_target_registration"
+  | "restore_target"
+  | "restore_sse"
+  | "inspect_agent_queue"
+  | "wire_runtime_evidence";
+
+export interface TaskDiagnosticInput {
+  status: string;
+  runtimeSubmittedAt: string | null;
+  consumedAt: string | null;
+  targetSessionStatus: string | null;
+  targetSessionExists: boolean;
+  liveSseConnections: number;
+  /**
+   * 🔴 #1083：这个目标节点【历史上是否报过任何一次】运行时证据。
+   * `false` = 从来没报过 ⇒ `runtime_submitted_at`/`consumed_at` 为空**推不出**「没消费」，
+   *           它只说明这条证据通道不存在。
+   * `null`/省略 = Hub 没算这一项 ⇒ 保持旧行为（不因为「不知道」就改判）。
+   *
+   * 背景：RFC-035 §75 要求 agent-node 接线上报，但 agent 侧至今没有实现
+   * （`grep -rn runtime_evidence agent-node/src/ agent-network/src/` = 0 命中），
+   * 于是这两列对所有任务恒为 NULL。实测后果：一个**确实回了长信**的任务
+   * 与一个**毫无回音**的任务，diagnostic 读数逐字相同 ⇒ 鉴别力 = 0。
+   */
+  targetEverReportedRuntimeEvidence?: boolean | null;
+}
+
+export interface TaskDiagnostic {
+  schema_version: 1;
+  code: TaskDiagnosticCode;
+  action_hint: TaskDiagnosticAction;
+  evidence: {
+    task_status: string;
+    target_session_status: string | null;
+    live_sse_connections: number;
+    runtime_submitted: boolean;
+    runtime_consumed: boolean;
+    /** `null` = Hub 没算这一项；`false` = 该目标从来没报过运行时证据。 */
+    target_ever_reported_runtime_evidence: boolean | null;
+  };
+}
+
+/**
+ * Classify only facts the Hub can prove. This deliberately does not claim
+ * that a model session has (or lacks) MCP tools: that capability lives in an
+ * external runtime and is not observable from the Hub wire.
+ */
+export function diagnoseTask(input: TaskDiagnosticInput): TaskDiagnostic {
+  const liveSseConnections = Number.isSafeInteger(input.liveSseConnections) && input.liveSseConnections > 0
+    ? input.liveSseConnections
+    : 0;
+  const evidence: TaskDiagnostic["evidence"] = {
+    task_status: input.status,
+    target_session_status: input.targetSessionStatus,
+    live_sse_connections: liveSseConnections,
+    runtime_submitted: Boolean(input.runtimeSubmittedAt),
+    runtime_consumed: Boolean(input.consumedAt),
+    target_ever_reported_runtime_evidence:
+      input.targetEverReportedRuntimeEvidence ?? null,
+  };
+
+  let code: TaskDiagnosticCode;
+  let action_hint: TaskDiagnosticAction;
+  if (TERMINAL_STATUSES.has(input.status)) {
+    code = "terminal";
+    action_hint = "none";
+  } else if (input.consumedAt) {
+    code = "runtime_consumed_nonterminal";
+    action_hint = "inspect_runtime";
+  } else if (input.runtimeSubmittedAt) {
+    code = "runtime_submitted_waiting_for_signal";
+    action_hint = "inspect_runtime";
+  } else if (!input.targetSessionExists) {
+    code = "target_session_missing";
+    action_hint = "check_target_registration";
+  } else if (input.targetSessionStatus === "offline") {
+    code = "target_session_offline";
+    action_hint = "restore_target";
+  } else if (liveSseConnections === 0) {
+    code = "target_no_live_sse";
+    action_hint = "restore_sse";
+  } else if (input.status === "acked" || input.status === "running") {
+    // 🔴 #1083：这里原本只有一档，于是【还没走到】和【不会走到】共用同一个 code
+    //    和同一个 action_hint(`inspect_runtime`)。后者被支去查一个没坏的东西。
+    //    只有在 Hub **确知**该目标从未报过证据时才改判；`null`(没算) 保持旧行为。
+    if (input.targetEverReportedRuntimeEvidence === false) {
+      code = "runtime_evidence_channel_absent";
+      action_hint = "wire_runtime_evidence";
+    } else {
+      code = "lifecycle_progress_without_runtime_evidence";
+      action_hint = "inspect_runtime";
+    }
+  } else {
+    code = "delivered_waiting_for_agent";
+    action_hint = "inspect_agent_queue";
+  }
+
+  return { schema_version: 1, code, action_hint, evidence };
+}

package/src/task-expiry-notice-http.test.ts

@@ -0,0 +1,287 @@
+// #500 —— 任务过期时告诉派活的人;节点已经取走的任务不再被过期。HTTP 集成测试(真实 Bun.serve,私有端口,临时库)。
+// test2123 在真实 PostgreSQL 上原样再跑一遍(COMMHUB_TEST_PG_URL)。
+//
+// 任务一律经真入口 POST /api/task 派出(节点令牌 / 用户令牌),只把 created_at / expires_at 往前拨,
+// 然后调 TTL 巡检(server.ts patrolExpiredTasks,定时器调的就是它)。收件一侧也走真入口:
+// agent 用自己的节点令牌订阅 /events/<alias> 并经 /mcp get_inbox 取;人订阅 /events/users/me。
+//
+// 钉住:
+//   1. consumed_at 早于期限 → 不过期、不通知;consumed_at 晚于期限(迟到的回执)→ 照样过期。
+//   2. agent 派的任务过期 → 它收到恰好一条 type=reply / from=hub / requires_response=none 的通知 + SSE new_reply;
+//      正文带目标别名、等了几分钟、前面还有几个、retry_task、「不要原样重发」。
+//   3. 人派的 → user_inbox kind=task_expired 一条,from_session = 目标节点(出现在与它的会话里)+ SSE desktop_message。
+//   4. scheduler 派的 → 谁都不通知。
+//   5. 子任务过期 → 父任务的发送方收到一条「子任务已过期」,父任务状态 / result 不变。
+//   6. 同一次巡检里同一 (发送方, 目标) 5 条过期 → 只发一条,列出 5 个 id。
+//
+// 跑法:cd server && COMMHUB_DB=/tmp/x.db bun test src/task-expiry-notice-http.test.ts
+
+import { afterAll, beforeAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const DIR = mkdtempSync(join(tmpdir(), "anet-expiry-notice-"));
+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 = "ExpiryNotice123!x";
+const stamp = Date.now();
+
+let db: any;
+let patrol: () => void;
+let KIND = "";
+let hub: any = null;
+let BASE = "";
+let NET = "";
+let bossToken = "", umaToken = "", umaId = "", umaName = "";
+type Node = { alias: string; nodeId: string; token: string };
+const nodes: Record<"sender" | "target" | "other", Node> = {} as any;
+
+async function send(token: string, method: string, path: string, payload?: unknown) {
+  const res = await fetch(`${BASE}${path}`, {
+    method,
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: payload === undefined ? undefined : JSON.stringify(payload),
+  });
+  return { status: res.status, body: await res.json().catch(() => null) as any };
+}
+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((x) => x.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);
+}
+
+type Sub = { events: any[]; close: () => void };
+async function subscribe(path: string, token: string): Promise<Sub> {
+  const ctrl = new AbortController();
+  const res = await fetch(`${BASE}${path}`, { headers: { Authorization: `Bearer ${token}` }, signal: ctrl.signal });
+  expect(res.status).toBe(200);
+  const events: any[] = [];
+  const reader = res.body!.getReader();
+  const dec = new TextDecoder();
+  let buf = "";
+  void (async () => {
+    try {
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += dec.decode(value);
+        let i: number;
+        while ((i = buf.indexOf("\n\n")) >= 0) {
+          const frame = buf.slice(0, i); buf = buf.slice(i + 2);
+          for (const line of frame.split("\n")) if (line.startsWith("data: ")) { try { events.push(JSON.parse(line.slice(6))); } catch {} }
+        }
+      }
+    } catch {}
+  })();
+  await until(() => events.some((e) => e.type === "connected"));
+  return { events, close: () => ctrl.abort() };
+}
+const until = async (cond: () => boolean, tries = 150) => { for (let k = 0; k < tries && !cond(); k++) await new Promise((r) => setTimeout(r, 20)); };
+
+let seq = 0;
+/** 经 POST /api/task 派一条;返回 task_id。 */
+async function dispatch(token: string, to: string, extra: Record<string, unknown> = {}): Promise<string> {
+  const r = await send(token, "POST", "/api/task", { alias: to, task: `expiry case ${stamp} #${++seq}`, network_id: NET, ...extra });
+  expect(r.status).toBe(200);
+  expect(r.body.ok).toBe(true);
+  return r.body.task_id;
+}
+/** 把这条任务拨成「61 分钟前派出、1 分钟前到期」。 */
+const backdate = (taskId: string) => db.run(
+  "UPDATE tasks SET created_at = datetime('now', '-61 minutes'), delivered_at = datetime('now', '-61 minutes'), expires_at = datetime('now', '-1 minutes') WHERE task_id = ?1",
+  [taskId],
+);
+const taskRow = (taskId: string) => db.get("SELECT status, result FROM tasks WHERE task_id = ?1", taskId) as { status: string; result: string | null };
+const agentNotices = (alias: string) => db.all(
+  "SELECT id, type, content, from_session, in_reply_to, requires_response, meta_json, acked FROM inbox WHERE session_name = ?1 AND network_id = ?2 AND from_session = 'hub' AND id LIKE 'exp_%' ORDER BY created_at, id",
+  alias, NET,
+) as Array<{ id: string; type: string; content: string; from_session: string; in_reply_to: string; requires_response: string; meta_json: string; acked: number }>;
+const userNotices = (userId: string) => db.all(
+  "SELECT message_id, from_session, title, content, meta_json FROM user_inbox WHERE user_id = ?1 AND network_id = ?2 AND kind = ?3 ORDER BY created_at, message_id",
+  userId, NET, KIND,
+) as Array<{ message_id: string; from_session: string; title: string; content: string; meta_json: string }>;
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { addNetworkMember, createNetworkTokenForNode, register } = await import("./auth.js");
+  ({ TASK_EXPIRED_NOTICE_KIND: KIND } = await import("./task-expiry-notice.js"));
+  const boss = register(`exp_boss_${stamp}`, PW);
+  expect(boss.ok).toBe(true);
+  bossToken = boss.token!; NET = boss.network_id!;
+  const bossId = boss.user!.user_id;
+  const uma = register(`exp_uma_${stamp}`, PW);
+  umaToken = uma.token!; umaId = uma.user!.user_id; umaName = uma.user!.username;
+  expect(addNetworkMember(NET, umaId, "member", bossId, { agentAccess: "all" }).ok).toBe(true);
+  for (const key of ["sender", "target", "other"] as const) {
+    const alias = `exp-${key}-${stamp}`;
+    const nodeId = `n_exp_${key}_${stamp}`;
+    const minted = createNetworkTokenForNode(bossId, NET, alias, nodeId);
+    expect(minted.ok).toBe(true);
+    nodes[key] = { alias, nodeId, token: minted.token! };
+  }
+  const mod: any = await import("./server.js");
+  patrol = mod.patrolExpiredTasks;
+  hub = mod.bootServer({ port: 0, hostname: "127.0.0.1" });
+  BASE = `http://127.0.0.1:${hub.port}`;
+  for (const n of Object.values(nodes)) {
+    const r = await tool(n.token, "report_status", { resume_id: `sdk-${n.nodeId}`, alias: n.alias, status: "idle", node_id: n.nodeId, network_id: NET });
+    expect(r.ok).toBe(true);
+  }
+}, 30_000);
+
+beforeEach(() => {
+  // 每条用例自己的数据:上一条留下的开着的任务不许算进「前面还有几个」,也不许被这一次巡检过期。
+  db.run("UPDATE tasks SET status = 'replied', completed_at = datetime('now') WHERE network_id = ?1 AND status IN ('created', 'delivered', 'acked', 'running')", [NET]);
+  db.run("DELETE FROM inbox WHERE network_id = ?1 AND id LIKE 'exp_%'", [NET]);
+  db.run("DELETE FROM user_inbox WHERE network_id = ?1 AND kind = ?2", [NET, KIND]);
+});
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("#500 consumed before the deadline → not expired", () => {
+  test("consumed_at < expires_at keeps the task; a late consumed_at (after the deadline) does not", async () => {
+    const taken = await dispatch(nodes.sender.token, nodes.target.alias);
+    const late = await dispatch(nodes.sender.token, nodes.target.alias);
+    backdate(taken); backdate(late);
+    db.run("UPDATE tasks SET consumed_at = datetime('now', '-30 minutes') WHERE task_id = ?1", [taken]);
+    db.run("UPDATE tasks SET consumed_at = datetime('now') WHERE task_id = ?1", [late]);
+    patrol();
+    expect(taskRow(taken).status).toBe("delivered");
+    expect(taskRow(late).status).toBe("expired");
+    // 通知只说过期的那一条。
+    const n = agentNotices(nodes.sender.alias);
+    expect(n.length).toBe(1);
+    expect(n[0].content).toContain(late);
+    expect(n[0].content).not.toContain(taken);
+  });
+});
+
+describe("#500 sender is an agent node", () => {
+  test("exactly one terminal reply-row notice + new_reply push; get_inbox returns it", async () => {
+    const sub = await subscribe(`/events/${encodeURIComponent(nodes.sender.alias)}?network_id=${NET}`, nodes.sender.token);
+    try {
+      // 目标上有一条比它早、还开着的任务(别人派的,没到期)→ 「前面还有 1 个」。
+      const ahead = await dispatch(bossToken, nodes.target.alias);
+      db.run("UPDATE tasks SET created_at = datetime('now', '-90 minutes') WHERE task_id = ?1", [ahead]);
+      const id = await dispatch(nodes.sender.token, nodes.target.alias);
+      backdate(id);
+      patrol();
+      expect(taskRow(id).status).toBe("expired");
+      expect(taskRow(ahead).status).toBe("delivered");
+
+      const n = agentNotices(nodes.sender.alias);
+      expect(n.length).toBe(1);
+      expect(n[0].type).toBe("reply");
+      expect(n[0].from_session).toBe("hub");
+      expect(n[0].requires_response).toBe("none");
+      expect(n[0].in_reply_to).toBe(id);
+      for (const frag of ["[Hub] 任务已过期", nodes.target.alias, id, "等了 61 分钟", "期限 60 分钟", "还有 1 个", "retry_task", "不要原样重发", "do not blindly resend"]) {
+        expect(n[0].content).toContain(frag);
+      }
+      expect(JSON.parse(n[0].meta_json).task_expired).toEqual({ target: nodes.target.alias, task_ids: [id], queued_ahead: 1 });
+
+      await until(() => sub.events.some((e) => e.type === "new_reply" && e.message_id === n[0].id));
+      const push = sub.events.find((e) => e.type === "new_reply" && e.message_id === n[0].id);
+      expect(push).toMatchObject({ from: "hub", in_reply_to: id, status: "expired" });
+
+      const inbox = await tool(nodes.sender.token, "get_inbox", { alias: nodes.sender.alias, limit: 50 });
+      const got = JSON.stringify(inbox);
+      expect(got).toContain(n[0].id);
+      // 目标节点自己什么都没多收(过期的任务行已 acked,通知只给发送方)。
+      expect(agentNotices(nodes.target.alias).length).toBe(0);
+
+      // 再巡检一次:不重复发。
+      patrol();
+      expect(agentNotices(nodes.sender.alias).length).toBe(1);
+    } finally { sub.close(); }
+  });
+});
+
+describe("#500 sender is a person (Dashboard / App)", () => {
+  test("user_inbox task_expired from the target node + desktop_message push; no agent inbox row", async () => {
+    const sub = await subscribe(`/events/users/me?network_id=${NET}`, umaToken);
+    try {
+      const id = await dispatch(umaToken, nodes.target.alias);
+      backdate(id);
+      patrol();
+      expect(taskRow(id).status).toBe("expired");
+      const n = userNotices(umaId);
+      expect(n.length).toBe(1);
+      expect(n[0].from_session).toBe(nodes.target.alias);
+      expect(n[0].title).toBe("任务已过期");
+      for (const frag of [nodes.target.alias, id, "等了 61 分钟", "retry_task", "不要原样重发"]) expect(n[0].content).toContain(frag);
+      await until(() => sub.events.some((e) => e.type === "desktop_message" && e.message_id === n[0].message_id));
+      expect(sub.events.find((e) => e.type === "desktop_message" && e.message_id === n[0].message_id)).toMatchObject({ kind: KIND, from: nodes.target.alias });
+      // 没有往「用户名」那个 alias 的 agent inbox 里塞东西。
+      expect(agentNotices(umaName).length).toBe(0);
+    } finally { sub.close(); }
+  });
+});
+
+describe("#500 sender is the scheduler", () => {
+  test("no notice to anyone; the task still expires", async () => {
+    const id = `sched_task_${stamp}`;
+    db.run(
+      `INSERT INTO tasks (task_id, from_name, to_name, to_node_id, priority, status, content, requires_response, created_at, delivered_at, expires_at, network_id, meta_json)
+       VALUES (?1, 'scheduler', ?2, ?3, 'normal', 'delivered', 'scheduled', 'reply', datetime('now', '-61 minutes'), datetime('now', '-61 minutes'), datetime('now', '-1 minutes'), ?4, ?5)`,
+      [id, nodes.target.alias, nodes.target.nodeId, NET, JSON.stringify({ auth_origin: "hub_scheduler" })],
+    );
+    patrol();
+    expect(taskRow(id).status).toBe("expired");
+    const anyAgent = db.get("SELECT COUNT(*) AS n FROM inbox WHERE network_id = ?1 AND id LIKE 'exp_%'", NET) as { n: number };
+    expect(Number(anyAgent.n)).toBe(0);
+    const anyUser = db.get("SELECT COUNT(*) AS n FROM user_inbox WHERE network_id = ?1 AND kind = ?2", NET, KIND) as { n: number };
+    expect(Number(anyUser.n)).toBe(0);
+  });
+});
+
+describe("#500 child task expires", () => {
+  test("parent sender is told; parent stays open with its result untouched", async () => {
+    const parent = await dispatch(umaToken, nodes.sender.alias);
+    const child = await dispatch(nodes.sender.token, nodes.target.alias, { parent_task_id: parent });
+    backdate(child);
+    patrol();
+    expect(taskRow(child).status).toBe("expired");
+    expect(taskRow(parent)).toEqual({ status: "delivered", result: null });
+    // 子任务的发送方(父任务的执行者)照常收到过期通知。
+    expect(agentNotices(nodes.sender.alias).length).toBe(1);
+    // 父任务的发送方(人)收到一条「子任务已过期」,出现在与父任务执行者的会话里。
+    const n = userNotices(umaId);
+    expect(n.length).toBe(1);
+    expect(n[0].title).toBe("子任务已过期");
+    expect(n[0].from_session).toBe(nodes.sender.alias);
+    for (const frag of [parent, child, nodes.target.alias, "父任务没有被结束"]) expect(n[0].content).toContain(frag);
+  });
+});
+
+describe("#500 one notice per (sender, target) per patrol pass", () => {
+  test("5 expiring to the same target → one summarized notice listing all 5", async () => {
+    const ids: string[] = [];
+    for (let i = 0; i < 5; i++) ids.push(await dispatch(nodes.sender.token, nodes.target.alias));
+    // 再来一条派给另一个目标:那是另一组,单独一条。
+    const elsewhere = await dispatch(nodes.sender.token, nodes.other.alias);
+    for (const id of [...ids, elsewhere]) backdate(id);
+    patrol();
+    for (const id of ids) expect(taskRow(id).status).toBe("expired");
+    const n = agentNotices(nodes.sender.alias);
+    expect(n.length).toBe(2);
+    const batch = n.find((x) => x.content.includes(nodes.target.alias))!;
+    expect(batch.content).toContain("[Hub] 5 个任务已过期");
+    for (const id of ids) expect(batch.content).toContain(id);
+    expect(batch.content).not.toContain(elsewhere);
+    expect(JSON.parse(batch.meta_json).task_expired.task_ids.sort()).toEqual([...ids].sort());
+    const single = n.find((x) => x.content.includes(nodes.other.alias))!;
+    expect(single.content).toContain(elsewhere);
+  });
+});