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

package/src/task-orphan-http.test.ts

@@ -0,0 +1,287 @@
+// #758 —— 孤儿任务:acked / running 超过阈值,接收节点在开工之后回到 idle / offline 却没回复。
+// HTTP 集成测试(真实 Bun.serve,私有端口,临时库);test2123 在真实 PostgreSQL 上原样再跑一遍。
+//
+// 任务经真入口 POST /api/task 派出,目标用自己的节点令牌经 /mcp ack_inbox / report_status 推进;
+// 只把任务的时间戳往前拨,然后调巡检(server.ts patrolOrphanTasks,5 分钟定时器调的就是它)。
+//
+// 钉住:
+//   1. 孤儿(agent 派的)→ 记一条 task.orphan_suspected、发一条 inbox reply 给派活节点,任务状态不变;第二次巡检不重发。
+//   2. 人派的孤儿 → user_inbox 一条。
+//   3. 节点 working → 不标。
+//   4. 不到阈值 → 不标;阈值可由 COMMHUB_ORPHAN_TASK_MINUTES 改,0 = 关。
+//   5. 节点开工之后没再报过状态 → 不标。
+//   6. scheduler 派的孤儿 → 标,但不通知。
+//   7. TTL 巡检(patrolExpiredTasks)不碰孤儿阶段:不写 orphan 事件。
+//
+// 跑法:cd server && bun test src/task-orphan-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-orphan-"));
+process.env.COMMHUB_DB ||= join(DIR, "hub.db");
+process.env.COMMHUB_UPLOADS_DIR = join(DIR, "uploads");
+process.env.HOST = "127.0.0.1";
+const ENV = "COMMHUB_ORPHAN_TASK_MINUTES";
+const LOOKBACK_ENV = "COMMHUB_ORPHAN_TASK_LOOKBACK_HOURS";
+delete process.env[ENV];
+delete process.env[LOOKBACK_ENV];
+const PW = "Orphan123!xyz";
+const stamp = Date.now();
+
+let db: any;
+let patrol: () => void;
+let ttlPatrol: () => void;
+let flag: (o?: { minutes?: number | null }) => Array<{ task_id: string; notified: string | null }>;
+let hub: any = null;
+let BASE = "";
+let NET = "";
+let umaToken = "", umaId = "";
+let EVENT = "";
+type Node = { alias: string; nodeId: string; token: string };
+const nodes: Record<"sender" | "target", 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);
+}
+
+let seq = 0;
+async function dispatch(token: string): Promise<{ id: string; content: string }> {
+  const content = `orphan case ${stamp} #${++seq}`;
+  const r = await send(token, "POST", "/api/task", { alias: nodes.target.alias, task: content, network_id: NET });
+  expect(r.status).toBe(200);
+  expect(r.body.ok).toBe(true);
+  return { id: r.body.task_id, content };
+}
+async function ack(taskId: string) {
+  const r = await tool(nodes.target.token, "ack_inbox", { alias: nodes.target.alias, message_id: taskId, network_id: NET });
+  expect(r.ok).toBe(true);
+  expect(taskRow(taskId).status).toBe("acked");
+}
+async function targetStatus(status: string, task?: string) {
+  const r = await tool(nodes.target.token, "report_status", { resume_id: `sdk-${nodes.target.nodeId}`, alias: nodes.target.alias, status, task, node_id: nodes.target.nodeId, network_id: NET });
+  expect(r.ok).toBe(true);
+}
+/** 任务的时间戳拨到 `minutes` 分钟前(节点的 last_seen_at 不动 = 「之后还报过状态」)。 */
+function age(taskId: string, minutes: number) {
+  const off = `-${minutes * 60} seconds`;
+  db.run(
+    `UPDATE tasks SET created_at = datetime('now', ?2),
+        delivered_at = CASE WHEN delivered_at IS NULL THEN NULL ELSE datetime('now', ?2) END,
+        started_at = CASE WHEN started_at IS NULL THEN NULL ELSE datetime('now', ?2) END,
+        consumed_at = CASE WHEN consumed_at IS NULL THEN NULL ELSE datetime('now', ?2) END
+      WHERE task_id = ?1`,
+    [taskId, off],
+  );
+}
+const taskRow = (taskId: string) => db.get("SELECT status, result, completed_at FROM tasks WHERE task_id = ?1", taskId) as { status: string; result: string | null; completed_at: string | null };
+const orphanEvents = (taskId: string) => db.all("SELECT from_status, to_status, event_type, event_key, actor, detail FROM task_events WHERE task_id = ?1 AND event_type = ?2", taskId, EVENT) as any[];
+const agentNotices = () => db.all("SELECT in_reply_to, type, requires_response, content FROM inbox WHERE network_id = ?1 AND session_name = ?2 AND from_session = 'hub'", NET, nodes.sender.alias) as any[];
+const userNotices = () => db.all("SELECT kind, from_session, content FROM user_inbox WHERE network_id = ?1 AND user_id = ?2", NET, umaId) as any[];
+
+function withMinutes<T>(value: string | undefined, fn: () => T): T {
+  const prev = process.env[ENV];
+  if (value === undefined) delete process.env[ENV]; else process.env[ENV] = value;
+  try { return fn(); } finally { if (prev === undefined) delete process.env[ENV]; else process.env[ENV] = prev; }
+}
+
+beforeAll(async () => {
+  ({ db } = await import("./db.js"));
+  const { addNetworkMember, createNetworkTokenForNode, register } = await import("./auth.js");
+  const orphan: any = await import("./task-orphan.js");
+  EVENT = orphan.ORPHAN_EVENT_TYPE;
+  flag = orphan.flagOrphanTasks;
+  const boss = register(`orphan_boss_${stamp}`, PW);
+  expect(boss.ok).toBe(true);
+  NET = boss.network_id!;
+  const bossId = boss.user!.user_id;
+  const uma = register(`orphan_uma_${stamp}`, PW);
+  umaToken = uma.token!; umaId = uma.user!.user_id;
+  expect(addNetworkMember(NET, umaId, "member", bossId, { agentAccess: "all" }).ok).toBe(true);
+  for (const key of ["sender", "target"] as const) {
+    const alias = `orphan-${key}-${stamp}`;
+    const nodeId = `n_orphan_${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.patrolOrphanTasks;
+  ttlPatrol = 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 from_session = 'hub'", [NET]);
+  db.run("DELETE FROM user_inbox WHERE network_id = ?1", [NET]);
+  // 上一条用例可能把目标留在 offline / working:派活前先让它回到 idle(否则 /api/task 回 202 排队)。
+  db.run("UPDATE sessions SET status = 'idle' WHERE alias = ?1 AND network_id = ?2", [nodes.target.alias, NET]);
+});
+
+afterAll(() => {
+  try { hub?.stop?.(true); } catch {}
+  try { rmSync(DIR, { recursive: true, force: true }); } catch {}
+});
+
+describe("#758 orphan detected", () => {
+  test("acked 2h, node idle since → one event + one inbox reply to the sending agent; status unchanged; second pass silent", async () => {
+    const t = await dispatch(nodes.sender.token);
+    await ack(t.id);
+    age(t.id, 120);
+    await targetStatus("idle");
+
+    withMinutes(undefined, () => patrol());
+
+    expect(taskRow(t.id)).toMatchObject({ status: "acked", result: null, completed_at: null });
+    const ev = orphanEvents(t.id);
+    expect(ev.length).toBe(1);
+    expect(ev[0]).toMatchObject({ from_status: "acked", to_status: "acked", event_key: EVENT, actor: "patrol" });
+    expect(ev[0].detail).toContain(`notify: agent ${nodes.sender.alias}`);
+    const n = agentNotices();
+    expect(n.length).toBe(1);
+    expect(n[0]).toMatchObject({ in_reply_to: t.id, type: "reply", requires_response: "none" });
+    expect(n[0].content).toContain(nodes.target.alias);
+    expect(n[0].content).toContain("没有改这条任务的状态");
+
+    // 第二、三次巡检:不重发、不重记。
+    withMinutes(undefined, () => { patrol(); patrol(); });
+    expect(orphanEvents(t.id).length).toBe(1);
+    expect(agentNotices().length).toBe(1);
+    expect(taskRow(t.id).status).toBe("acked");
+  });
+
+  test("running task, node went offline afterwards → flagged; a human sender gets one user_inbox notice", async () => {
+    const t = await dispatch(umaToken);
+    await ack(t.id);
+    await targetStatus("working", t.content);
+    expect(taskRow(t.id).status).toBe("running");
+    age(t.id, 90);
+    await targetStatus("idle");
+    db.run("UPDATE sessions SET status = 'offline' WHERE alias = ?1 AND network_id = ?2", [nodes.target.alias, NET]);
+
+    const out = withMinutes(undefined, () => flag());
+    expect(out).toEqual([{ task_id: t.id, notified: "user" }]);
+    expect(taskRow(t.id).status).toBe("running");
+    const u = userNotices();
+    expect(u.length).toBe(1);
+    expect(u[0]).toMatchObject({ kind: "task_orphan_suspected", from_session: nodes.target.alias });
+    expect(withMinutes(undefined, () => flag())).toEqual([]);
+    expect(userNotices().length).toBe(1);
+  });
+});
+
+describe("#758 not orphans", () => {
+  test("node is working (busy) → not flagged", async () => {
+    const t = await dispatch(nodes.sender.token);
+    await ack(t.id);
+    age(t.id, 120);
+    await targetStatus("working", "something else");
+    withMinutes(undefined, () => patrol());
+    expect(orphanEvents(t.id).length).toBe(0);
+    expect(agentNotices().length).toBe(0);
+  });
+
+  test("younger than the threshold → not flagged; env lowers it; 0 turns it off", async () => {
+    const t = await dispatch(nodes.sender.token);
+    await ack(t.id);
+    age(t.id, 45);
+    await targetStatus("idle");
+    withMinutes(undefined, () => patrol());
+    expect(orphanEvents(t.id).length).toBe(0);
+    withMinutes("0", () => patrol());
+    expect(orphanEvents(t.id).length).toBe(0);
+    withMinutes("30", () => patrol());
+    expect(orphanEvents(t.id).length).toBe(1);
+    expect(agentNotices().length).toBe(1);
+  });
+
+  test("node has not reported any status since the task started → not flagged", async () => {
+    const t = await dispatch(nodes.sender.token);
+    await ack(t.id);
+    age(t.id, 120);
+    await targetStatus("idle");
+    db.run("UPDATE sessions SET last_seen_at = datetime('now', '-180 minutes'), updated_at = datetime('now', '-180 minutes') WHERE alias = ?1 AND network_id = ?2", [nodes.target.alias, NET]);
+    withMinutes(undefined, () => patrol());
+    expect(orphanEvents(t.id).length).toBe(0);
+    expect(agentNotices().length).toBe(0);
+  });
+});
+
+describe("#758 lookback cap", () => {
+  test("a 10-day-old orphan is not flagged by default (72h cap) but is with lookback 0", async () => {
+    // 10 天前的那条直接写库(目标上已有开着的任务时 /api/task 回 202 排队,而这里要两条同时开着)。
+    const t = { id: `orphan_old_${stamp}` };
+    db.run(
+      `INSERT INTO tasks (task_id, from_name, from_node_id, to_name, to_node_id, priority, status, content, requires_response, created_at, delivered_at, network_id)
+       VALUES (?1, ?2, ?3, ?4, ?5, 'normal', 'acked', 'ten days old', 'reply', datetime('now', '-240 hours'), datetime('now', '-240 hours'), ?6)`,
+      [t.id, nodes.sender.alias, nodes.sender.nodeId, nodes.target.alias, nodes.target.nodeId, NET],
+    );
+    await targetStatus("idle");
+    withMinutes(undefined, () => patrol());
+    expect(orphanEvents(t.id).length).toBe(0);
+    expect(agentNotices().length).toBe(0);
+    // 71 小时的照常标出:上限只挡更老的。
+    const recent = await dispatch(nodes.sender.token);
+    await ack(recent.id);
+    age(recent.id, 71 * 60);
+    await targetStatus("idle");
+    withMinutes(undefined, () => patrol());
+    expect(orphanEvents(recent.id).length).toBe(1);
+    expect(orphanEvents(t.id).length).toBe(0);
+    process.env[LOOKBACK_ENV] = "0";
+    try { withMinutes(undefined, () => patrol()); } finally { delete process.env[LOOKBACK_ENV]; }
+    expect(orphanEvents(t.id).length).toBe(1);
+    expect(agentNotices().map((n) => n.in_reply_to).sort()).toEqual([recent.id, t.id].sort());
+  });
+});
+
+describe("#758 scheduler and regression", () => {
+  test("scheduler-sent orphan → flagged, sender not notified", async () => {
+    const id = `orphan_sched_${stamp}`;
+    db.run(
+      `INSERT INTO tasks (task_id, from_name, to_name, to_node_id, priority, status, content, requires_response, created_at, delivered_at, network_id)
+       VALUES (?1, 'scheduler', ?2, ?3, 'normal', 'acked', 'scheduled run', 'reply', datetime('now', '-120 minutes'), datetime('now', '-120 minutes'), ?4)`,
+      [id, nodes.target.alias, nodes.target.nodeId, NET],
+    );
+    await targetStatus("idle");
+    const out = withMinutes(undefined, () => flag());
+    expect(out).toEqual([{ task_id: id, notified: null }]);
+    expect(orphanEvents(id)[0].detail).toContain("notify: none (scheduler)");
+    expect(agentNotices().length).toBe(0);
+    expect(userNotices().length).toBe(0);
+  });
+
+  test("the TTL patrol alone does not run the orphan phase", async () => {
+    const t = await dispatch(nodes.sender.token);
+    await ack(t.id);
+    age(t.id, 120);
+    await targetStatus("idle");
+    withMinutes(undefined, () => ttlPatrol());
+    expect(orphanEvents(t.id).length).toBe(0);
+    expect(taskRow(t.id).status).toBe("acked");
+  });
+});

package/src/task-orphan.ts

@@ -0,0 +1,119 @@
+// #758 —— 「孤儿任务」:任务还停在 acked / running,接收节点却已经回到 idle(或 offline)、
+// 并且在任务开工之后还报过状态 —— 节点转去干别的了,没回这一条。
+//
+// 生产只读实测:17 条任务 acked / running 超过 1 小时,接收节点早已 idle;最长一条(admin 的 P0)挂了 15.7 小时。
+// 以前巡检只对 delivered 记警告(task-lifecycle-watcher.ts),acked / running 这一段谁都看不见。
+//
+// 规则(每次 5 分钟任务巡检跑一遍,server.ts runTaskPatrol):
+//   status ∈ {acked, running}
+//   ∧ 开工时刻 = COALESCE(started_at, delivered_at, created_at) 早于 COMMHUB_ORPHAN_TASK_MINUTES(默认 60;0 = 关)
+//   ∧ 开工时刻在最近 COMMHUB_ORPHAN_TASK_LOOKBACK_HOURS 内(默认 72;0 = 不设上限)—— 首次部署不爆发历史通知
+//   ∧ 接收节点(sessions 同网络同别名)当前 status ∈ {idle, offline}
+//   ∧ 节点最后一次报状态 COALESCE(last_seen_at, updated_at) 晚于开工时刻
+// 命中后对每条任务**只做一次**:
+//   - task_events 写一行 event_type = event_key = task.orphan_suspected(唯一索引 (task_id, event_key) 兜底,
+//     ON CONFLICT DO NOTHING;只有真插进去的那一次才往下走)。
+//   - 通知派活的一方,与过期通知同一条路(task-expiry-notice.ts 的 classifyExpirySender / deliver):
+//     agent → inbox reply + new_reply;人 → user_inbox;scheduler / hub / api → 不发。
+//   - **不改任务状态**:不 fail、不关、不碰过期语义。
+
+import { db } from "./db.js";
+import { parseDbTimestampMs } from "./db-timestamp.js";
+import { classifyExpirySender, deliver, type ExpiredTaskRow } from "./task-expiry-notice.js";
+
+export const ORPHAN_TASK_ENV = "COMMHUB_ORPHAN_TASK_MINUTES";
+export const ORPHAN_DEFAULT_MINUTES = 60;
+export const ORPHAN_LOOKBACK_ENV = "COMMHUB_ORPHAN_TASK_LOOKBACK_HOURS";
+export const ORPHAN_DEFAULT_LOOKBACK_HOURS = 72;
+export const ORPHAN_EVENT_TYPE = "task.orphan_suspected";
+export const ORPHAN_NOTICE_KIND = "task_orphan_suspected";
+const BATCH_LIMIT = 200;
+
+/** 未设 / 非数字 → 默认 60;0 或负数 → 关闭(null)。 */
+export function orphanTaskMinutes(env: Record<string, string | undefined> = process.env): number | null {
+  const raw = (env[ORPHAN_TASK_ENV] ?? "").trim();
+  if (!raw) return ORPHAN_DEFAULT_MINUTES;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return ORPHAN_DEFAULT_MINUTES;
+  return n > 0 ? n : null;
+}
+
+/** 只看开工时刻在最近 N 小时内的任务:未设 / 非数字 / 负数 → 默认 72;0 → 不设上限。
+ *  首次部署时不把几周前的历史 acked / running 一次性全标出来、给派活方(包括 owner)刷一屏通知。 */
+export function orphanLookbackHours(env: Record<string, string | undefined> = process.env): number | null {
+  const raw = (env[ORPHAN_LOOKBACK_ENV] ?? "").trim();
+  const n = raw ? Number(raw) : NaN;
+  if (!Number.isFinite(n) || n < 0) return ORPHAN_DEFAULT_LOOKBACK_HOURS;
+  return n === 0 ? null : n;
+}
+
+type OrphanRow = ExpiredTaskRow & { status: string; started: string; node_status: string; node_seen: string };
+
+export type OrphanFlagged = { task_id: string; notified: "agent" | "user" | null };
+
+export function orphanNoticeText(r: Pick<OrphanRow, "task_id" | "to_name" | "status" | "content" | "node_status">, openMin: number | null): { title: string; text: string } {
+  const preview = (r.content ?? "").replace(/\s+/g, " ").trim().slice(0, 60);
+  const m = openMin === null ? "?" : String(openMin);
+  return {
+    title: "任务可能没人收尾",
+    text: `[Hub] 任务可能没人收尾:你派给 ${r.to_name} 的任务 ${r.task_id} 停在 ${r.status} 已 ${m} 分钟,但 ${r.to_name} 之后已回到 ${r.node_status},一直没有回复。`
+      + `Hub 没有改这条任务的状态。\n内容:${preview}\n`
+      + `建议:问 ${r.to_name} 一句,或 cancel_task 后换个节点重派。\n`
+      + `Task ${r.task_id} to ${r.to_name} has been ${r.status} for ${m} min while ${r.to_name} went ${r.node_status} without replying. Its status was not changed.`,
+  };
+}
+
+/** 一次巡检的孤儿阶段。返回本次新标记的任务(测试 / 日志用)。调用方负责吞异常。 */
+export function flagOrphanTasks(opts: { minutes?: number | null; lookbackHours?: number | null; nowMs?: number } = {}): OrphanFlagged[] {
+  const minutes = opts.minutes === undefined ? orphanTaskMinutes() : opts.minutes;
+  if (!minutes || minutes <= 0) return [];
+  const cutoff = `datetime('now', '-${Math.max(1, Math.round(minutes * 60))} seconds')`;
+  const started = "COALESCE(t.started_at, t.delivered_at, t.created_at)";
+  const lookback = opts.lookbackHours === undefined ? orphanLookbackHours() : opts.lookbackHours;
+  const lookbackSql = lookback && lookback > 0
+    ? `AND ${started} >= datetime('now', '-${Math.max(1, Math.round(lookback * 3600))} seconds')`
+    : "";
+  const rows = db.all<OrphanRow>(
+    `SELECT t.task_id, t.network_id, t.from_name, t.from_node_id, t.to_name, t.content, t.created_at, t.expires_at,
+            t.parent_task_id, t.meta_json, t.status, ${started} AS started,
+            s.status AS node_status, COALESCE(s.last_seen_at, s.updated_at) AS node_seen
+       FROM tasks t
+       JOIN sessions s ON s.alias = t.to_name AND s.network_id = COALESCE(t.network_id, 'default')
+      WHERE t.status IN ('acked', 'running')
+        AND ${started} < ${cutoff}
+        ${lookbackSql}
+        AND s.status IN ('idle', 'offline')
+        AND COALESCE(s.last_seen_at, s.updated_at) > ${started}
+        AND NOT EXISTS (SELECT 1 FROM task_events e WHERE e.task_id = t.task_id AND e.event_key = '${ORPHAN_EVENT_TYPE}')
+      ORDER BY t.created_at ASC LIMIT ${BATCH_LIMIT}`,
+  );
+  const nowMs = opts.nowMs ?? Date.now();
+  const flagged: OrphanFlagged[] = [];
+  for (const r of rows) {
+    const route = classifyExpirySender(r);
+    const who = route.kind === "none" ? `none (${route.reason})` : `${route.kind} ${route.kind === "agent" ? route.alias : route.username}`;
+    const detail = `${r.to_name} is ${r.node_status} (last status ${r.node_seen}) since ${r.status} at ${r.started}; notify: ${who}`;
+    const res = db.run(
+      `INSERT INTO task_events (task_id, from_status, to_status, event_type, event_key, actor, detail, network_id)
+       VALUES (?1, ?2, ?2, '${ORPHAN_EVENT_TYPE}', '${ORPHAN_EVENT_TYPE}', 'patrol', ?3, ?4)
+       ON CONFLICT(task_id, event_key) DO NOTHING`,
+      [r.task_id, r.status, detail, r.network_id ?? null],
+    );
+    if (res.changes < 1) continue; // 只做一次:别的巡检 / 别的 Hub worker 已经标过了
+    let notified: OrphanFlagged["notified"] = null;
+    if (route.kind !== "none") {
+      try {
+        const startedMs = parseDbTimestampMs(r.started);
+        const openMin = Number.isFinite(startedMs) ? Math.max(0, Math.round((nowMs - startedMs) / 60_000)) : null;
+        const meta = { task_orphan_suspected: { task_id: r.task_id, target: r.to_name, status: r.status, node_status: r.node_status } };
+        const id = deliver(route, r.network_id, r.to_name, r.task_id, orphanNoticeText(r, openMin), meta,
+          { kind: ORPHAN_NOTICE_KIND, status: "orphan_suspected", agentPrefix: "orph_", userPrefix: "dm_orphan_" });
+        if (id) notified = route.kind;
+      } catch (e: any) {
+        console.error(`[patrol] orphan notice failed task=${r.task_id}: ${e?.message || e}`);
+      }
+    }
+    flagged.push({ task_id: r.task_id, notified });
+  }
+  return flagged;
+}