talon-agent 5.18.1 → 5.19.0

package/src/core/engine/turn-health.ts

@@ -0,0 +1,222 @@
+/**
+ * Turn health — turns the per-turn outcomes the dispatcher sees into
+ * operator alerts.
+ *
+ * Every chat turn on every backend settles through `execute`, so this is
+ * the one place that can tell "one bad turn" from "this chat is broken"
+ * or "this backend is down":
+ *
+ *   - `backend.auth.<backend>` / `backend.quota.<backend>` — the backend
+ *     lost its login or ran out of quota. Raised on the first such
+ *     failure: nothing but a human (a re-login, a plan change, waiting
+ *     out a window the operator should know about) clears it.
+ *   - `turn.failing.<chatId>` — the chat's last 3 turns failed.
+ *   - `backend.failing.<backend>` — the backend failed turns in 3
+ *     different chats within 10 minutes.
+ *   - `dispatcher.stuck` — the watchdog saw work arrive and nothing
+ *     finish or make progress for 10 minutes (see util/watchdog.ts).
+ *
+ * Auth and quota failures carry their own alert, so they do not also
+ * count toward the two failure streaks. Every alert resolves on the next
+ * successful turn on the same chat / backend. A stopped turn is neither.
+ */
+
+import { AgentRunError } from "../agent-runtime/events.js";
+import { TalonError } from "../errors.js";
+import { raiseAlert, resolveAlert } from "../frontend-runtime/alerts.js";
+import { taskTable } from "../tasks/index.js";
+import { log, logWarn } from "../../util/log.js";
+import type { StuckLoopListener } from "../../util/watchdog.js";
+import { faultText } from "./fault-text.js";
+
+const CHAT_STREAK_THRESHOLD = 3;
+const BACKEND_CHAT_THRESHOLD = 3;
+const BACKEND_WINDOW_MS = 10 * 60_000;
+
+/**
+ * Login / credential failures across backends: Claude Code's "Not logged
+ * in · Please run /login", an expired OAuth token, Codex's refresh-token
+ * 401, Antigravity's "not authenticated", a bare 401/403.
+ */
+const AUTH_RE =
+  /not logged in|please run \/login|not (?:yet )?authenticated|authentication (?:required|failed|error)|unauthori[sz]ed|invalid (?:api[ _-]?key|x-api-key|bearer|token|credentials)|(?:oauth |access )?token (?:has )?expired|login expired|refresh_token_invalidated|failed to refresh token|permission_error|\b40[13]\b/i;
+
+/** Subscription / credit exhaustion — a limit a short retry won't clear. */
+const QUOTA_RE =
+  /usage limit|usage exhausted|you['’]ve hit your .{0,40}limit|out of (?:extra usage|credits)|insufficient_quota|quota (?:exceeded|exhausted)|exceeded your current quota|credit balance is too low|no remaining credits/i;
+
+type TurnFault = "auth" | "quota" | "error";
+
+export type TurnBinding = {
+  chatId: string;
+  backendId: string;
+  model?: string;
+  source?: string;
+  durationMs: number;
+};
+
+/** chatId → consecutive failed turns. */
+const chatStreaks = new Map<string, number>();
+/** backend → chatId → time of that chat's latest failure. */
+const backendFailures = new Map<string, Map<string, number>>();
+
+/** What kind of failure `err` is — null when it is not a fault at all. */
+function classifyTurnFault(err: unknown): TurnFault | null {
+  if (err instanceof TalonError) {
+    if (err.reason === "stopped") return null;
+    if (err.reason === "auth") return "auth";
+    if (err.reason === "usage_limit") return "quota";
+  }
+  if (err instanceof AgentRunError) {
+    if (err.kind === "aborted") return null;
+    if (err.kind === "auth") return "auth";
+  }
+  if (err instanceof Error && err.name === "AbortError") return null;
+  const text =
+    err instanceof AgentRunError
+      ? `${err.message} ${err.raw ?? ""}`
+      : err instanceof Error
+        ? err.message
+        : String(err);
+  if (QUOTA_RE.test(text)) return "quota";
+  if (AUTH_RE.test(text)) return "auth";
+  if (err instanceof AgentRunError && err.kind === "rate_limit") {
+    // A non-retryable rate-limit event is a usage limit, not a 429.
+    return err.retryable ? "error" : "quota";
+  }
+  return "error";
+}
+
+function describe(b: TurnBinding): string {
+  return b.model ? `${b.backendId}/${b.model}` : b.backendId;
+}
+
+/** Record a turn that completed. Clears every alert it can vouch for. */
+export function noteTurnSucceeded(b: TurnBinding): void {
+  const streak = chatStreaks.get(b.chatId);
+  if (streak) {
+    chatStreaks.delete(b.chatId);
+    log(
+      "dispatcher",
+      `turn.recovered chat=${b.chatId} backend=${b.backendId} after_failures=${streak} ms=${b.durationMs}`,
+    );
+    resolveAlert(
+      `turn.failing.${b.chatId}`,
+      `Chat ${b.chatId} is answering again (${describe(b)}).`,
+    );
+  }
+  if (backendFailures.delete(b.backendId)) {
+    resolveAlert(
+      `backend.failing.${b.backendId}`,
+      `The ${b.backendId} backend is completing turns again.`,
+    );
+  }
+  resolveAlert(
+    `backend.auth.${b.backendId}`,
+    `The ${b.backendId} backend is signed in again.`,
+  );
+  resolveAlert(
+    `backend.quota.${b.backendId}`,
+    `The ${b.backendId} backend has quota again.`,
+  );
+}
+
+/** Record a turn that threw. Raises once a threshold is crossed. */
+export function noteTurnFailed(b: TurnBinding, err: unknown): void {
+  const fault = classifyTurnFault(err);
+  if (fault === null) return;
+  const detail = faultText(err);
+  const prior = chatStreaks.get(b.chatId) ?? 0;
+  const count = fault === "error" ? prior + 1 : prior;
+  logWarn(
+    "dispatcher",
+    `turn.fail chat=${b.chatId} backend=${b.backendId} model=${b.model ?? "?"} ` +
+      `source=${b.source ?? "?"} cause=${fault} streak=${count} ` +
+      `ms=${b.durationMs} error="${detail}"`,
+  );
+  if (fault === "auth") {
+    raiseAlert(
+      `backend.auth.${b.backendId}`,
+      `The ${b.backendId} backend is not signed in: ${detail}. Every chat on it fails until it is re-authenticated.`,
+      { severity: "critical" },
+    );
+    return;
+  }
+  if (fault === "quota") {
+    raiseAlert(
+      `backend.quota.${b.backendId}`,
+      `The ${b.backendId} backend is out of quota: ${detail}. Chats on it fail until the limit resets.`,
+    );
+    return;
+  }
+  chatStreaks.set(b.chatId, count);
+  if (count >= CHAT_STREAK_THRESHOLD) {
+    raiseAlert(
+      `turn.failing.${b.chatId}`,
+      `Chat ${b.chatId} has failed its last ${count} turns on ${describe(b)}: ${detail}`,
+    );
+  }
+  noteBackendFailure(b, detail);
+}
+
+function noteBackendFailure(b: TurnBinding, detail: string): void {
+  const now = Date.now();
+  let chats = backendFailures.get(b.backendId);
+  if (!chats) {
+    chats = new Map();
+    backendFailures.set(b.backendId, chats);
+  }
+  chats.set(b.chatId, now);
+  for (const [chatId, at] of chats) {
+    if (now - at > BACKEND_WINDOW_MS) chats.delete(chatId);
+  }
+  if (chats.size >= BACKEND_CHAT_THRESHOLD) {
+    raiseAlert(
+      `backend.failing.${b.backendId}`,
+      `The ${b.backendId} backend failed turns in ${chats.size} chats in the last 10 min. Last error: ${detail}`,
+    );
+  }
+}
+
+/** The turns in flight, for the stuck-loop alert: what is wedged where. */
+function describeTurnQueue(now = Date.now()): string {
+  const turns = taskTable
+    .list()
+    .filter(
+      (t) =>
+        t.kind === "turn" && (t.state === "running" || t.state === "queued"),
+    );
+  if (turns.length === 0) return "No turn is running or queued.";
+  const running = turns
+    .filter((t) => t.state === "running")
+    .map((t) => {
+      const mins = Math.round((now - (t.startedAt ?? t.queuedAt)) / 60_000);
+      const on = t.backendId
+        ? ` on ${t.backendId}${t.model ? `/${t.model}` : ""}`
+        : "";
+      return `chat ${t.chatId ?? "?"}${on} (${mins} min)`;
+    });
+  const queued = turns.length - running.length;
+  const parts = [
+    running.length ? `Running: ${running.join(", ")}.` : "Nothing is running.",
+  ];
+  if (queued) parts.push(`${queued} turn(s) queued.`);
+  return parts.join(" ");
+}
+
+/** Watchdog hook: the stuck message loop as an operator alert. */
+export const stuckLoopAlert: StuckLoopListener = {
+  onStuck: ({ pendingMins, silentMins }) =>
+    raiseAlert(
+      "dispatcher.stuck",
+      `The message loop looks stuck: a message received ${pendingMins} min ago is unprocessed and no turn has made progress for ${silentMins} min. ${describeTurnQueue()}`,
+    ),
+  onRecovered: () =>
+    resolveAlert("dispatcher.stuck", "The message loop is processing again."),
+};
+
+/** Test seam: forget every streak. */
+export function resetTurnHealthForTest(): void {
+  chatStreaks.clear();
+  backendFailures.clear();
+}

package/src/core/errors.ts

@@ -247,8 +247,8 @@ export function classify(err: unknown): TalonError {
   }
 
   // 408 Request Timeout — a transient deadline like any other, but it
-  // is neither 4xx-terminal nor 5xx, so it used to fall through to
-  // `unknown`/non-retryable and strand the request.
+  // is neither 4xx-terminal nor 5xx, so without this branch it falls
+  // through to `unknown`/non-retryable and strands the request.
   if (status === 408) {
     return new TalonError(msg, {
       reason: "network",

package/src/core/frontend-runtime/admin-notify.ts

@@ -10,7 +10,7 @@
  *
  * First consumer: WhatsApp pairing. When WhatsApp unlinks the device,
  * recovery needs a human to type a pairing code into the phone — a code
- * that previously only ever appeared in the daemon log, which nobody
+ * that would otherwise only appear in the daemon log, which nobody
  * watches. Alerts about a dead frontend must travel over a LIVE one.
  */
 

package/src/core/frontend-runtime/alerts.ts

@@ -0,0 +1,130 @@
+/**
+ * Operator alerts — "something is wrong" (and "it's fine again") on the
+ * admin's chat, deduplicated so a flapping fault can't flood it.
+ *
+ * Every alert has a stable key naming the fault ("telegram.polling",
+ * "backend.auth", "disk.low"). The first raise delivers; repeats inside
+ * the cooldown only count, and the next delivery after it says how many
+ * were folded in. `resolveAlert` sends one recovery notice for a key that
+ * was delivered, and nothing for one that never was. Delivery rides
+ * `notifyAdmin`, so alerts degrade to a log line when no frontend is up.
+ *
+ * Two exceptions to the cooldown: an escalation (warn → error → critical)
+ * always delivers, and a delivery that failed (no notifier wired, the
+ * admin's frontend down) doesn't count, so the next raise tries again.
+ */
+
+import { log, logWarn } from "../../util/log.js";
+import { notifyAdmin } from "./admin-notify.js";
+
+export type AlertSeverity = "warn" | "error" | "critical";
+
+type ActiveAlert = {
+  severity: AlertSeverity;
+  message: string;
+  firstAt: number;
+  lastSentAt: number;
+  /** Raises folded into the cooldown since the last delivery. */
+  suppressed: number;
+};
+
+const DEFAULT_COOLDOWN_MS = 30 * 60_000;
+const ICON: Record<AlertSeverity, string> = {
+  warn: "⚠️",
+  error: "🔴",
+  critical: "🚨",
+};
+const RANK: Record<AlertSeverity, number> = { warn: 0, error: 1, critical: 2 };
+
+const active = new Map<string, ActiveAlert>();
+let cooldownMs = DEFAULT_COOLDOWN_MS;
+let enabled = true;
+let send: (text: string) => Promise<unknown> = notifyAdmin;
+
+/** Apply operator settings (config `alerts`). */
+export function configureAlerts(opts: {
+  enabled?: boolean;
+  cooldownMs?: number;
+}): void {
+  if (opts.enabled !== undefined) enabled = opts.enabled;
+  if (opts.cooldownMs !== undefined && opts.cooldownMs >= 0)
+    cooldownMs = opts.cooldownMs;
+}
+
+/**
+ * Report a fault. Always logged; delivered to the admin unless the same
+ * key was delivered within the cooldown. Never throws.
+ */
+export function raiseAlert(
+  key: string,
+  message: string,
+  opts: { severity?: AlertSeverity } = {},
+): void {
+  const severity = opts.severity ?? "error";
+  const now = Date.now();
+  logWarn("alert", `[${severity}] ${key}: ${message}`);
+  const prior = active.get(key);
+  const escalated =
+    prior !== undefined && RANK[severity] > RANK[prior.severity];
+  if (prior && !escalated && now - prior.lastSentAt < cooldownMs) {
+    prior.suppressed++;
+    prior.message = message;
+    return;
+  }
+  const folded = prior?.suppressed ?? 0;
+  const entry: ActiveAlert = {
+    severity,
+    message,
+    firstAt: prior?.firstAt ?? now,
+    lastSentAt: now,
+    suppressed: 0,
+  };
+  active.set(key, entry);
+  if (!enabled) return;
+  const repeat = folded > 0 ? `\n(+${folded} more since the last alert)` : "";
+  const undelivered = (): void => {
+    // Nobody heard it: don't let the cooldown swallow the next raise.
+    if (active.get(key) === entry) entry.lastSentAt = 0;
+  };
+  void send(`${ICON[severity]} ${message}${repeat}`).then((ok) => {
+    if (ok === false) undelivered();
+  }, undelivered);
+}
+
+/** Clear a fault; announces recovery only if its alert was delivered. */
+export function resolveAlert(key: string, message?: string): void {
+  const prior = active.get(key);
+  if (!prior) return;
+  active.delete(key);
+  const mins = Math.max(1, Math.round((Date.now() - prior.firstAt) / 60_000));
+  log("alert", `resolved ${key} after ${mins} min`);
+  if (!enabled) return;
+  void send(`✅ ${message ?? `Recovered: ${key}`} (after ${mins} min)`).catch(
+    () => {},
+  );
+}
+
+/** Keys currently raised — for status surfaces and doctor. */
+export function activeAlerts(): ReadonlyArray<{
+  key: string;
+  severity: AlertSeverity;
+  message: string;
+  since: number;
+}> {
+  return [...active].map(([key, a]) => ({
+    key,
+    severity: a.severity,
+    message: a.message,
+    since: a.firstAt,
+  }));
+}
+
+/** Test seam: reset state and swap the delivery function. */
+export function resetAlertsForTest(
+  deliver: (text: string) => Promise<unknown> = notifyAdmin,
+): void {
+  active.clear();
+  cooldownMs = DEFAULT_COOLDOWN_MS;
+  enabled = true;
+  send = deliver;
+}

package/src/core/mcp-hub/children.ts

@@ -2,11 +2,8 @@
  * Hub child manager — the single owner of external MCP server
  * subprocesses (plugins, brave-search).
  *
- * Before the hub, every chat turn (claude-sdk, codex) or every chat
- * lifetime (openai-agents, kilo/opencode) spawned its own copy of every
- * plugin MCP server — memory grew linearly with chats. The hub instead
- * keeps one child per key and reaps it after an idle TTL, so resident
- * cost tracks *recently active* keys, not every chat ever seen.
+ * One child per key, reaped after an idle TTL, so resident cost tracks
+ * *recently active* keys, not every chat ever seen.
  *
  * Keys: chat-scoped plugins get `name + chatId` (they read
  * `TALON_CHAT_ID` at boot, so instances cannot be shared across chats
@@ -14,8 +11,8 @@
  * use a shared key. Either way the spec factory decides — this module
  * only manages lifecycles.
  *
- * Each child is spawned through the same supervisor wrap as before
- * (stdout JSON filtering + orphan cleanup if the daemon is SIGKILLed),
+ * Each child is spawned through the supervisor wrap (stdout JSON
+ * filtering + orphan cleanup if the daemon is SIGKILLed),
  * connected once over stdio, and shared by every hub session that
  * proxies to it. The tools list is cached per child lifetime — plugin
  * reload restarts children, which naturally invalidates the cache.
@@ -30,6 +27,8 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { CallToolResult, Tool } from "@modelcontextprotocol/sdk/types.js";
 import { log, logError, logWarn } from "../../util/log.js";
 import { HubChildTransport, type ChildExit } from "./child-transport.js";
+import { raiseAlert, resolveAlert } from "../frontend-runtime/alerts.js";
+import { faultText } from "../engine/fault-text.js";
 
 export type ChildSpec = {
   command: string;
@@ -40,13 +39,15 @@ export type ChildSpec = {
 export type ChildHandle = {
   /** Cached tools/list result — fetched once per child lifetime. */
   listTools(): Promise<Tool[]>;
-  /** Forward one tool call; tracked so retirement can drain in-flight work. */
+  /**
+   * Forward one tool call; tracked so retirement can drain in-flight work.
+   * Aborting `signal` cancels the call on the child too.
+   */
   callTool(
     name: string,
     args: Record<string, unknown>,
+    signal?: AbortSignal,
   ): Promise<CallToolResult>;
-  /** Mark activity so the idle reaper skips this child. */
-  touch(): void;
 };
 
 type ChildEntry = {
@@ -151,6 +152,8 @@ type SpawnFailure = { at: number; count: number; error: unknown };
 const spawnFailures = new Map<string, SpawnFailure>();
 const FAILURE_BACKOFF_BASE_MS = 30_000;
 const FAILURE_BACKOFF_MAX_MS = 10 * 60_000;
+/** Consecutive spawn failures of one child before the operator hears. */
+const SPAWN_FAILURE_ALERT_THRESHOLD = 3;
 
 function failureBackoffMs(count: number): number {
   return Math.min(
@@ -159,6 +162,42 @@ function failureBackoffMs(count: number): number {
   );
 }
 
+/** The MCP server name of a child key (keys are `server\0chat`). */
+function serverOf(key: string): string {
+  const nul = key.indexOf("\u0000");
+  return nul === -1 ? key : key.slice(0, nul);
+}
+
+/**
+ * Count a failed spawn into the negative cache, log it with the child's
+ * last words, and alert once the same child has failed
+ * SPAWN_FAILURE_ALERT_THRESHOLD times running — its tools are gone for
+ * every turn until whatever backs it comes back.
+ */
+function noteSpawnFailure(key: string, err: unknown): void {
+  const count = (spawnFailures.get(key)?.count ?? 0) + 1;
+  spawnFailures.set(key, { at: Date.now(), count, error: err });
+  const backoffMs = failureBackoffMs(count);
+  // The exit record is this attempt's only when it is fresh — an older
+  // one belongs to a child that ran and was reaped long ago.
+  const exit = lastExits.get(key);
+  const stderr =
+    exit && Date.now() - exit.at < 60_000 ? exit.stderr.at(-1) : undefined;
+  const detail = faultText(err);
+  logWarn(
+    "gateway",
+    `hub child spawn failed ${describeKey(key)} attempt=${count} backoff_ms=${backoffMs} ` +
+      `error="${detail}"${stderr ? ` stderr="${faultText(stderr)}"` : ""}`,
+  );
+  if (count < SPAWN_FAILURE_ALERT_THRESHOLD) return;
+  const server = serverOf(key);
+  raiseAlert(
+    `mcp.child.${server}`,
+    `MCP server "${server}" has failed to start ${count} times in a row: ${detail}` +
+      `${stderr ? ` (stderr: ${faultText(stderr, 120)})` : ""}. Its tools are unavailable until it starts.`,
+  );
+}
+
 /** Idle TTL for hub children; tunable for tests / tight deployments. */
 function idleTtlMs(): number {
   const raw = Number(process.env.TALON_MCP_HUB_IDLE_MS);
@@ -166,6 +205,14 @@ function idleTtlMs(): number {
 }
 
 const REAP_INTERVAL_MS = 60_000;
+
+/**
+ * Backstop for one forwarded tool call. The SDK's default (60s) would cut
+ * any longer plugin call, though the upstream client allows far more —
+ * its own timeout or cancel reaches the child through the forwarded
+ * signal. This only bounds a call nobody is waiting on any more.
+ */
+const CHILD_CALL_TIMEOUT_MS = 65 * 60_000;
 let reaper: ReturnType<typeof setInterval> | null = null;
 
 async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
@@ -217,9 +264,6 @@ async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
         })());
     })(),
     handle: {
-      touch: () => {
-        entry.lastActivity = Date.now();
-      },
       listTools: () =>
         track(async () => {
           if (toolsCache) return toolsCache;
@@ -227,12 +271,12 @@ async function spawnChild(key: string, spec: ChildSpec): Promise<ChildHandle> {
           toolsCache = result.tools;
           return toolsCache;
         }),
-      callTool: (name, args) =>
+      callTool: (name, args, signal) =>
         track(
           () =>
-            client.callTool({
-              name,
-              arguments: args,
+            client.callTool({ name, arguments: args }, undefined, {
+              signal,
+              timeout: CHILD_CALL_TIMEOUT_MS,
             }) as Promise<CallToolResult>,
         ),
     },
@@ -272,23 +316,26 @@ export function acquireChild(
     );
   }
 
-  const promise = (async () => {
+  const spawn = async (): Promise<ChildHandle> => {
     try {
       const handle = await spawnChild(key, spec());
-      spawnFailures.delete(key);
+      if (spawnFailures.delete(key)) {
+        const server = serverOf(key);
+        resolveAlert(
+          `mcp.child.${server}`,
+          `MCP server "${server}" is starting normally again.`,
+        );
+      }
       return handle;
     } catch (err) {
-      const prior = spawnFailures.get(key);
-      spawnFailures.set(key, {
-        at: Date.now(),
-        count: (prior?.count ?? 0) + 1,
-        error: err,
-      });
+      noteSpawnFailure(key, err);
       throw err;
-    } finally {
-      inflight.delete(key);
     }
-  })();
+  };
+  // `.finally` always runs after the `set` below. A `finally` block inside
+  // `spawn` would not: when `spec()` throws synchronously it runs before
+  // the set, leaving the rejected promise in `inflight` for good.
+  const promise = spawn().finally(() => inflight.delete(key));
   inflight.set(key, promise);
   return promise;
 }
@@ -340,7 +387,9 @@ export function retireAllChildren(): void {
 function reapIdle(): void {
   const cutoff = Date.now() - idleTtlMs();
   for (const [key, entry] of children) {
-    if (entry.lastActivity >= cutoff) continue;
+    // A call outliving the TTL is work, not idleness — closing the child
+    // would fail it mid-flight. The first sweep after it drains reaps.
+    if (entry.lastActivity >= cutoff || entry.pending > 0) continue;
     children.delete(key);
     entry.close().catch((err) => {
       logError("gateway", `hub reap of ${describeKey(key)} failed`, err);

package/src/core/mcp-hub/index.ts

@@ -1,12 +1,6 @@
 /**
  * MCP hub — daemon-hosted MCP over streamable HTTP, one endpoint for
- * every backend.
- *
- * Motivation: every backend used to spawn its own stdio copy of every
- * MCP server per chat (claude-sdk/codex per turn; openai-agents and
- * kilo/opencode per chat, held indefinitely) — two processes per server
- * per chat once the supervisor wrap is counted. Memory grew linearly
- * with chats. The hub inverts the ownership: the daemon hosts
+ * every backend. The daemon hosts
  *
  *   /mcp/talon/<frontend>/<chatId>   Talon's own tools, IN-PROCESS
  *                                    (zero subprocesses; chat binding
@@ -20,13 +14,13 @@
  * (claude-sdk `type:"http"`, openai-agents `MCPServerStreamableHttp`,
  * codex `mcp_servers.<name>.url`, kilo/opencode `type:"remote"`).
  *
- * What stays exactly as before:
+ * Invariants:
  *   - per-chat tool isolation (binding is per-session from the URL)
- *   - plugin semantics (chat-scoped children keep TALON_CHAT_ID env)
+ *   - chat-scoped plugin children keep TALON_CHAT_ID in their env
  *   - tool-surface trimming (disabledTools / disabledToolTags)
- *   - plugin reloading (reload closes children; next request respawns
- *     from the current registry — see reloadHubChildren)
- *   - orphan cleanup (children still run under the supervisor wrap)
+ *   - plugin reload retires children; the next request respawns from
+ *     the current registry (see reloadHubChildren)
+ *   - children run under the supervisor wrap (orphan cleanup)
  *
  * Endpoints live on the gateway HTTP server (127.0.0.1-bound, behind the
  * same token and Host/Origin guard as /action — see engine/gateway-auth.ts;
@@ -112,8 +106,7 @@ export function pluginHubUrl(
  * Names of every hub-served plugin server — what backends enumerate to
  * build their per-chat URL maps. Registry-backed, so it reflects plugin
  * reloads immediately. (brave-search is served by the hub too, but each
- * backend adds it explicitly alongside its frontend tools, matching the
- * pre-hub structure.)
+ * backend adds it explicitly alongside its frontend tools.)
  */
 export function hubPluginServerNames(only?: string[]): string[] {
   // Specs are built with placeholder identity — only the names matter.
@@ -134,7 +127,6 @@ export async function listHubPluginToolNames(
   const child = await acquireChild(childKey(serverName, chatId), () =>
     pluginSpec(serverName, chatId, bridgeUrl),
   );
-  child.touch();
   return (await child.listTools()).map((tool) => tool.name);
 }
 
@@ -253,6 +245,8 @@ function guestPluginDenied(target: { serverName: string; chatId: string }) {
 type SessionEntry = {
   transport: StreamableHTTPServerTransport;
   lastSeen: number;
+  /** Requests still open on this session, SSE streams included. */
+  open: number;
 };
 
 const sessions = new Map<string, SessionEntry>();
@@ -260,7 +254,11 @@ const sessions = new Map<string, SessionEntry>();
 /**
  * Sessions whose client vanished without a DELETE (crashed subprocess,
  * kill -9) are closed after this idle window. Every well-behaved client
- * terminates explicitly, so this only catches stragglers.
+ * terminates explicitly, so this only catches stragglers. A session with
+ * a request still open is never idle: a client that holds its event
+ * stream between turns (openai-agents keeps one per chat for good) is
+ * alive however quiet the chat, and it does not re-initialize on a 404.
+ * The idle clock restarts when its last open request ends.
  */
 const SESSION_IDLE_MS = 30 * 60_000;
 const SESSION_REAP_INTERVAL_MS = 5 * 60_000;
@@ -271,7 +269,7 @@ function startSessionReaper(): void {
   sessionReaper = setInterval(() => {
     const cutoff = Date.now() - SESSION_IDLE_MS;
     for (const [id, entry] of sessions) {
-      if (entry.lastSeen >= cutoff) continue;
+      if (entry.open > 0 || entry.lastSeen >= cutoff) continue;
       sessions.delete(id);
       entry.transport.close().catch(() => {});
       log("gateway", `hub session reaped (idle): ${id.slice(0, 8)}…`);
@@ -330,6 +328,11 @@ export async function handleHubRequest(
         return;
       }
       entry.lastSeen = Date.now();
+      entry.open++;
+      res.once("close", () => {
+        entry.open--;
+        entry.lastSeen = Date.now();
+      });
       await entry.transport.handleRequest(req, res);
       return;
     }
@@ -369,7 +372,7 @@ export async function handleHubRequest(
       enableDnsRebindingProtection: true,
       allowedHosts: loopbackHosts(bridgeUrl),
       onsessioninitialized: (id) => {
-        sessions.set(id, { transport, lastSeen: Date.now() });
+        sessions.set(id, { transport, lastSeen: Date.now(), open: 0 });
       },
     });
     transport.onclose = () => {