switchroom 0.18.6 → 0.18.7

package/telegram-plugin/silent-end.ts

@@ -60,6 +60,8 @@ export interface SilentEndDeps {
    * never suppress on doubt.
    */
   hasOutboundDeliveredSince?: (chatId: string, sinceMs: number, threadId?: number | null) => boolean
+  /** Wall-clock now, ms. Defaults to `Date.now`; injectable for tests. */
+  now?: () => number
 }
 
 /**
@@ -80,6 +82,31 @@ export interface SilentEndDeps {
  */
 export const SILENT_END_MAX_RETRIES = 2
 
+/**
+ * Fix #8 (adversarial-validation progress-card fix pass): `turnKey` is the
+ * STABLE `statusKey(chatId, threadId)` — it never changes across turns on
+ * the same chat/thread — so `writeSilentEndState`'s "inherit retryCount IFF
+ * turnKey matches" rule has no per-turn discriminator on its own. Normally
+ * that's fine because `clearSilentEndState` always fires the moment a reply
+ * lands, wiping the exhausted record before the next turn starts. But if the
+ * gateway's own exhaust-read-and-clear is bypassed (crash/interrupt mid-turn,
+ * `gateway.ts` ~turn_end handler never runs), an exhausted
+ * (`retryCount >= SILENT_END_MAX_RETRIES`) record can survive into a LATER,
+ * unrelated turn. That later turn's first silent-end would then misread the
+ * old record as "this turn already exhausted its ladder" and skip its own
+ * re-prompt entirely.
+ *
+ * A record legitimately re-written within one turn's own retry ladder is
+ * always fresh (each Stop-hook block re-writes `timestamp`), so bounding by
+ * age is a safe, cheap staleness signal that doesn't require a new identity
+ * field: any record older than a turn's plausible lifetime could not still
+ * be "this turn's" in-flight retry state, and is therefore stale-carryover,
+ * not an active ladder. 30 minutes comfortably exceeds any real single-turn
+ * Stop-hook retry cycle (seconds, not minutes) while staying well inside the
+ * fleet's other staleness bounds (e.g. the 3h boot-resume window).
+ */
+export const SILENT_END_STALE_RECORD_MAX_AGE_MS = 30 * 60_000
+
 /**
  * User-facing fallback text delivered when a user-message turn ends with no
  * final answer AND the deterministic Stop-hook re-prompt has already been
@@ -313,12 +340,30 @@ export function recordSilentTurnEnd(
     // If so, the record is satisfied-but-misdetected — drop it silently
     // and let this dark turn start its OWN fresh retry cycle instead of
     // inheriting someone else's spent budget.
-    if (deps?.hasOutboundDeliveredSince?.(args.chatId, prev.timestamp, args.threadId)) {
+    // Fix #8: age-based staleness bound. `turnKey` has no per-turn nonce
+    // (see SILENT_END_STALE_RECORD_MAX_AGE_MS doc), so a record whose
+    // `timestamp` is older than a turn's plausible lifetime cannot belong to
+    // THIS dark turn's own retry ladder even absent any delivery evidence —
+    // it's carryover from a prior turn whose gateway-side clear was
+    // bypassed (crash/interrupt). Check this before (and independent of)
+    // the delivery-based check below so a bypassed-clear record is caught
+    // even when no reply was ever delivered on the chat/thread at all.
+    const now = deps?.now?.() ?? Date.now()
+    const staleByAge = now - prev.timestamp > SILENT_END_STALE_RECORD_MAX_AGE_MS
+    if (
+      staleByAge ||
+      deps?.hasOutboundDeliveredSince?.(args.chatId, prev.timestamp, args.threadId)
+    ) {
       emitLog(
         deps,
-        `silent-end: stale exhausted record for turnKey=${args.turnKey} ` +
-          `(retryCount=${prev.retryCount}) but a reply was delivered since ` +
-          `${prev.timestamp} — treating as satisfied-but-misdetected, not exhausted\n`,
+        staleByAge
+          ? `silent-end: stale exhausted record for turnKey=${args.turnKey} ` +
+              `(retryCount=${prev.retryCount}, age=${now - prev.timestamp}ms > ` +
+              `${SILENT_END_STALE_RECORD_MAX_AGE_MS}ms) — treating as carryover ` +
+              `from a prior turn, not exhausted\n`
+          : `silent-end: stale exhausted record for turnKey=${args.turnKey} ` +
+              `(retryCount=${prev.retryCount}) but a reply was delivered since ` +
+              `${prev.timestamp} — treating as satisfied-but-misdetected, not exhausted\n`,
       )
       // MUST clear before writing (adversarial review of #2892):
       // writeSilentEndState re-inherits retryCount whenever the on-disk

package/telegram-plugin/subagent-watcher.ts

@@ -48,7 +48,7 @@ import { sanitiseToolArg } from './fleet-state.js'
 import { clipNarrative, describeToolUse } from './tool-activity-summary.js'
 import { REPLY_TOOLS, isDraftOfReply } from './narrative-dedup.js'
 import { truncate } from './card-format.js'
-import { bumpSubagentActivity, recordSubagentStall, recordSubagentResume, recordSubagentEnd, reapStuckRunningRows, countRunningBackgroundSubagents, recordNestedSubagentDispatch } from './registry/subagents-schema.js'
+import { bumpSubagentActivity, recordSubagentStall, recordSubagentResume, recordSubagentEnd, reapStuckRunningRows, countRunningBackgroundSubagents, recordNestedSubagentDispatch, recordSubagentModel } from './registry/subagents-schema.js'
 import { touchTurnActiveMarker } from './gateway/turn-active-marker.js'
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -193,6 +193,44 @@ export interface WorkerEntry {
    * Pre hook pending" window that froze nested cards on "starting…".
    */
   lastBackfillAttemptAt?: number
+  /**
+   * Fix #5: set on a boot-scan `running` file whose mtime passed the
+   * `inflightPromoteMaxAgeMs` freshness gate but has NOT yet shown any
+   * post-boot JSONL growth. mtime freshness alone can't distinguish a
+   * worker killed moments before the restart (indistinguishable file state)
+   * from a genuinely still-running one — so promotion is deferred until
+   * `checkBootPromotionGrowth` observes the file's size actually advance
+   * past its boot-time snapshot (real proof of life), or `deadlineAt`
+   * passes with no growth (treated as historical/orphan — never promoted).
+   * `undefined` once resolved either way.
+   */
+  bootPromotionPending?: { deadlineAt: number }
+  /**
+   * Fix #1(+#2): the `run_in_background` flag as last observed from the
+   * registry `subagents` row, carried on the entry itself rather than
+   * re-derived only at `onFinish` time. The registry row is the sole
+   * source of truth for this flag (the watcher never sees the dispatching
+   * tool_input directly), but the row is looked up by `jsonl_agent_id` —
+   * exactly the linkage that can be permanently missing (meta.json
+   * unreadable, or the fuzzy backfill found no unambiguous candidate).
+   * Once we DO observe the row (at registration or on any later liveness
+   * tick — the backfill retry can link it after the fact), we cache the
+   * flag here so a subsequent `onFinish` can fall back to it even if
+   * `getSubagentByJsonlId` fails again at finish time. `undefined` until
+   * the row has been observed at least once.
+   */
+  background?: boolean
+  /**
+   * Live model this worker is running, as a raw resolved model id (e.g.
+   * `claude-opus-4-8`). Set from the worker's OWN transcript `message.model`
+   * (`sub_agent_model` event) — the authoritative live source — and persisted to
+   * the registry row on change (recordSubagentModel) so boot-replay / handback
+   * cards can render it without a live entry. Threaded onto the onProgress
+   * payload so the worker card's metrics line shows the model. Undefined until
+   * the worker's first assistant line lands; before that the card falls back to
+   * the dispatch-time `tool_input.model` persisted on the registry row.
+   */
+  currentModel?: string
 }
 
 export interface SubagentWatcherConfig {
@@ -271,6 +309,13 @@ export interface SubagentWatcherConfig {
    * stale-handback replay regression.
    */
   inflightPromoteMaxAgeMs?: number
+  /**
+   * Fix #9a: override for `TERMINATED_AGENT_IDS_CAP` — the bound on the
+   * `terminatedAgentIds` re-discovery dedup guard. Exposed mainly so tests
+   * can exercise eviction without inserting thousands of entries. Defaults
+   * to `TERMINATED_AGENT_IDS_CAP` (a few thousand) in production.
+   */
+  terminatedAgentIdsCap?: number
   /**
    * Kill-switch for the boot-scan promotion path. When false, a
    * running-at-boot worker is never promoted — the watcher reverts to the
@@ -390,6 +435,15 @@ export interface SubagentWatcherConfig {
      *  no `sub_agent_text` line was ever observed. Feeds the
      *  `subagent_handback` inbound. */
     resultText: string
+    /**
+     * Fix #1(+#2): the entry's own cached `background` flag (see
+     * `WorkerEntry.background`), threaded through so the gateway can fall
+     * back to it when its own registry lookup at finish time also comes up
+     * empty (unlinked `jsonl_agent_id`). `undefined` when the row was never
+     * observed by the watcher either — the gateway degrades further from
+     * there (see the onFinish handler's non-empty-resultText fallback).
+     */
+    background: boolean | undefined
   }) => void
   /**
    * #1720: fires on every `sub_agent_text` event for a running
@@ -419,6 +473,12 @@ export interface SubagentWatcherConfig {
      *  feed. Undefined on `sub_agent_text` ticks — the gateway falls back
      *  to `latestSummary` (the narrative line), preserving prior behavior. */
     progressLine?: string
+    /** Live model this worker is running (raw resolved id, e.g.
+     *  `claude-opus-4-8`), from `WorkerEntry.currentModel`. Threaded onto the
+     *  worker/nested card's metrics line. Undefined before the worker's first
+     *  assistant line — the gateway then falls back to the registry's
+     *  dispatch-time model. */
+    model?: string
   }) => void
   /** `Date.now` override for tests. */
   now?: () => number
@@ -572,6 +632,18 @@ const TERMINAL_CLEANUP_GRACE_MS = 30_000
  */
 const BACKFILL_RETRY_INTERVAL_MS = 3000
 
+/**
+ * Fix #9a: cap on `terminatedAgentIds` (the re-discovery dedup guard in
+ * `cleanupTerminalAgent` / `scanSubagentsDir`). Pre-fix the Set only grew
+ * (added on every terminal cleanup, only ever cleared wholesale in
+ * `stop()`), so a long-lived gateway with sustained sub-agent throughput
+ * accumulated ids without bound. A `Set` preserves insertion order, so once
+ * the cap is hit the OLDEST id is evicted on each new insert (simple ring
+ * buffer semantics) — recently-terminated ids (the ones actually at risk of
+ * a re-discovery race) always stay covered.
+ */
+const TERMINATED_AGENT_IDS_CAP = 5000
+
 // ─── JSONL tail per sub-agent ─────────────────────────────────────────────
 
 interface SubTail {
@@ -662,20 +734,30 @@ export function backfillJsonlAgentId(
 
   // Fallback path: fuzzy (agentType, description) match for older Claude Code
   // versions whose meta.json predates the toolUseId field.
+  //
+  // Fix #3: with N unlinked rows sharing (agent_type, description), a bare
+  // `ORDER BY started_at DESC LIMIT 1` assigns by start-order, not true
+  // correspondence — a benign FIFO for interchangeable rows, but a genuine
+  // mislink for a cross-topic identical dispatch. Read up to 2 candidates
+  // (not just 1): if more than one row shares the key, the match is
+  // ambiguous — refuse to link (leave jsonl_agent_id NULL) and let the
+  // marker/window path attribute it instead, rather than guessing.
   if (candidateId == null && (meta.agentType || meta.description)) {
-    const fuzzy = db
+    const fuzzyCandidates = db
       .prepare(`
         SELECT id FROM subagents
         WHERE jsonl_agent_id IS NULL
           AND agent_type IS ?
           AND description IS ?
         ORDER BY started_at DESC
-        LIMIT 1
+        LIMIT 2
       `)
-      .get(meta.agentType ?? null, meta.description ?? null) as { id: string } | null
-    if (fuzzy != null) {
-      candidateId = fuzzy.id
+      .all(meta.agentType ?? null, meta.description ?? null) as { id: string }[]
+    if (fuzzyCandidates.length === 1) {
+      candidateId = fuzzyCandidates[0]!.id
       log?.(`subagent-watcher: backfill fuzzy match ${agentId} → ${candidateId} (type=${meta.agentType} desc=${meta.description})`)
+    } else if (fuzzyCandidates.length > 1) {
+      log?.(`subagent-watcher: backfill fuzzy match refused for ${agentId} — ${fuzzyCandidates.length} ambiguous candidates share (type=${meta.agentType} desc=${meta.description}); leaving unlinked`)
     }
   }
 
@@ -809,6 +891,8 @@ export function readSubTail(
     /** Friendly display line for THIS tick (set on tool ticks; see the
      *  SubagentWatcherConfig.onProgress doc). */
     progressLine?: string
+    /** Live model this worker is running (see SubagentWatcherConfig.onProgress). */
+    model?: string
   }) => void,
 ): void {
   try {
@@ -868,6 +952,12 @@ export function readSubTail(
         } else {
           bumpSubagentActivity(db, { id: existing.id, ts: now })
           isForeground = existing.background === 0
+          // Fix #1(+#2): keep the entry's cached background flag fresh —
+          // this is also how a NESTED worker (whose row links only via the
+          // throttled backfill retry above, after the one-shot attempt at
+          // registration lost the race) picks up its background flag before
+          // its own `onFinish` fires.
+          entry.background = existing.background === 1
         }
       } catch (dbErr) {
         log?.(`subagent-watcher: liveness write error ${entry.agentId}: ${(dbErr as Error).message}`)
@@ -932,6 +1022,7 @@ export function readSubTail(
             },
             lastTool: entry.lastTool,
             toolCount: entry.toolCount,
+            model: entry.currentModel,
           })
           return true
         } catch (cbErr) {
@@ -1015,6 +1106,31 @@ export function readSubTail(
           }
           log?.(`subagent-watcher: stall cleared for ${entry.agentId} (activity resumed after ${idleSecBeforeBump}s — re-arming detection)`)
         }
+        if (ev.kind === 'sub_agent_model') {
+          // Live model capture for this worker. The projection already filtered
+          // sentinels, so `ev.model` is a real resolved id. Record it on the
+          // entry (transcript wins over the dispatch-time tool_input.model) and
+          // persist to the registry row on CHANGE — update-on-change like
+          // last_activity_at — so a boot-replay / handback card can render the
+          // model without a live entry. No card render here: the model rides the
+          // next onProgress tick's payload (below).
+          if (entry.currentModel !== ev.model) {
+            entry.currentModel = ev.model
+            if (db != null) {
+              try {
+                const rowRef = db
+                  .prepare('SELECT id FROM subagents WHERE jsonl_agent_id = ?')
+                  .get(entry.agentId) as { id: string } | null
+                if (rowRef != null) {
+                  recordSubagentModel(db, { id: rowRef.id, model: ev.model })
+                }
+              } catch (dbErr) {
+                log?.(`subagent-watcher: model DB write error ${entry.agentId}: ${(dbErr as Error).message}`)
+              }
+            }
+          }
+          continue
+        }
         if (ev.kind === 'sub_agent_tool_use') {
           // Narrative-dedup gate step 2: a sub_agent_text block was pending;
           // this tool is the lookahead that decides it (SHOW unless it drafts
@@ -1073,6 +1189,7 @@ export function readSubTail(
                   lastTool: entry.lastTool,
                   toolCount: entry.toolCount,
                   progressLine: toolLine,
+                  model: entry.currentModel,
                 })
               } catch (cbErr) {
                 log?.(`subagent-watcher: onProgress (tool) callback error ${entry.agentId}: ${(cbErr as Error).message}`)
@@ -1233,6 +1350,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
     config.inflightPromoteMaxAgeMs
     ?? parseEnvMs('SWITCHROOM_SUBAGENT_INFLIGHT_MAX_AGE_MS')
     ?? DEFAULT_INFLIGHT_PROMOTE_MAX_AGE_MS
+  const terminatedAgentIdsCap = config.terminatedAgentIdsCap ?? TERMINATED_AGENT_IDS_CAP
   // Kill-switch: not parseEnvMs (which rejects `0`) — an explicit `=0`
   // here MUST disable promotion (revert to pre-v0.14.23 suppression).
   const bootPromoteEnabled =
@@ -1361,6 +1479,17 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       } catch (err) {
         log?.(`subagent-watcher: backfill error for ${agentId}: ${(err as Error).message}`)
       }
+      // Fix #1(+#2): if the backfill above (or an already-linked row from a
+      // prior registration attempt) resolved jsonl_agent_id, cache the
+      // row's `background` flag on the entry NOW — the earliest point it
+      // can ever be known — so it survives even if a later `onFinish`
+      // can't re-resolve the row (see `WorkerEntry.background` doc).
+      try {
+        const row = db
+          .prepare('SELECT background FROM subagents WHERE jsonl_agent_id = ?')
+          .get(agentId) as { background: number } | null
+        if (row != null) entry.background = row.background === 1
+      } catch { /* best-effort — entry.background stays undefined */ }
     }
 
     const tail: SubTail = {
@@ -1409,37 +1538,16 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       } else if (fileAgeMs > inflightPromoteMaxAgeMs) {
         log?.(`subagent-watcher: ${agentId} running at boot but stale (last write ${Math.round(fileAgeMs / 1000)}s ago > ${Math.round(inflightPromoteMaxAgeMs / 1000)}s) — leaving historical (dead prior-session worker, not in-flight)`)
       } else {
-        entry.historical = false
-        log?.(`subagent-watcher: ${agentId} was in-flight at boot — promoting to live (last write ${Math.round(fileAgeMs / 1000)}s ago; user still awaiting handback)`)
-        // The prior gateway life's registration normally linked
-        // jsonl_agent_id already, but re-run the backfill idempotently in
-        // case that life crashed before the link persisted — the handback's
-        // isBackground lookup is keyed on jsonl_agent_id, and an unlinked row
-        // would mis-resolve the worker as foreground and drop the handback.
-        if (db != null) {
-          try {
-            backfillJsonlAgentId(db, filePath, agentId, log)
-          } catch (err) {
-            log?.(`subagent-watcher: backfill error for ${agentId}: ${(err as Error).message}`)
-          }
-        }
-        // Historical/onProgress gate-ordering fix: the initial read above ran
-        // while `entry.historical` was still TRUE, so every onProgress cue it
-        // would have fired was suppressed by the `!entry.historical` guard —
-        // and the tail cursor is now at EOF, so for a quiet worker no later
-        // tick ever re-fires them. The card painted as a bare stub and froze
-        // on "starting…" forever. Re-read from the start now that the entry
-        // is live: the replayed events rebuild toolCount/lastTool/narrative
-        // AND fire onProgress so the worker's card reaches real activity.
-        entry.toolCount = 0
-        entry.lastTool = null
-        entry.pendingNarrative = null
-        tail.cursor = 0
-        tail.pendingPartial = ''
-        tail.hasEmittedStart = false
-        readSubTail(entry, tail, n, (desc) => {
-          log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
-        }, fs, log, db, parentStateDir, config.onUnstall, undefined, config.onProgress)
+        // Fix #5: a fresh mtime alone does NOT confirm liveness — a worker
+        // killed seconds before this restart looks byte-for-byte identical
+        // to a genuinely still-running one. Defer promotion until
+        // `checkBootPromotionGrowth` observes the file actually grow AFTER
+        // this boot (real proof of life), bounded by the same
+        // `inflightPromoteMaxAgeMs` window as an outer timeout. Until then
+        // the entry stays `historical` (no stall detection, no completion
+        // synthesis) — see checkBootPromotionGrowth / promoteBootEntry.
+        entry.bootPromotionPending = { deadlineAt: n + inflightPromoteMaxAgeMs }
+        log?.(`subagent-watcher: ${agentId} running at boot (last write ${Math.round(fileAgeMs / 1000)}s ago) — awaiting post-boot JSONL growth before promoting to live (mtime freshness alone can't rule out a just-killed worker)`)
       }
     }
 
@@ -1470,6 +1578,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
         const entry = registry.get(agentId)
         const t = tails.get(agentId)
         if (!entry || !t) return
+        checkBootPromotionGrowth(entry, t, nowFn())
         readSubTail(entry, t, nowFn(), (desc) => {
           log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
         }, fs, log, db, parentStateDir, config.onUnstall, cleanupTerminalAgent, config.onProgress)
@@ -1480,6 +1589,68 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
     }
   }
 
+  /**
+   * Fix #5: the growth-confirmation half of boot promotion. Called on every
+   * tick (poll + fs.watch) for an entry that's still awaiting confirmation
+   * (`entry.bootPromotionPending` set — see the freshness-gate branch in
+   * `registerAgent`). Promotes to live the moment the file's size advances
+   * past `tail.cursor` (the boot-time snapshot — the initial full read in
+   * `registerAgent` already parked the cursor at EOF-at-boot, so ANY further
+   * growth is unambiguously post-boot). If the bounded window elapses with
+   * no growth, gives up permanently — the entry stays `historical`, so it
+   * can never synthesise a stale `completed` handback from pre-restart bytes
+   * (checkStalls / onFinish both gate on `!entry.historical`).
+   */
+  function checkBootPromotionGrowth(entry: WorkerEntry, tail: SubTail, n: number): void {
+    const pending = entry.bootPromotionPending
+    if (!pending) return
+    let size: number | null = null
+    try {
+      size = fs.statSync(entry.filePath).size
+    } catch {
+      /* unreadable — fall through to the deadline check below */
+    }
+    if (size != null && size > tail.cursor) {
+      entry.bootPromotionPending = undefined
+      entry.historical = false
+      log?.(`subagent-watcher: ${entry.agentId} confirmed live — observed post-boot JSONL growth (${tail.cursor} → ${size} bytes); promoting`)
+      // The prior gateway life's registration normally linked
+      // jsonl_agent_id already, but re-run the backfill idempotently in
+      // case that life crashed before the link persisted — the handback's
+      // isBackground lookup is keyed on jsonl_agent_id, and an unlinked row
+      // would mis-resolve the worker as foreground and drop the handback.
+      if (db != null) {
+        try {
+          backfillJsonlAgentId(db, entry.filePath, entry.agentId, log)
+        } catch (err) {
+          log?.(`subagent-watcher: backfill error for ${entry.agentId}: ${(err as Error).message}`)
+        }
+      }
+      // Historical/onProgress gate-ordering fix (carried over from the old
+      // synchronous promotion path): the initial read in registerAgent ran
+      // while `entry.historical` was still TRUE, so any onProgress cue it
+      // would have fired was suppressed, and the cursor is at EOF-at-boot —
+      // for a quiet worker no later tick would ever re-fire them. Re-read
+      // from the start now that the entry is live: the replayed events
+      // rebuild toolCount/lastTool/narrative AND fire onProgress so the
+      // worker's card reaches real activity instead of a frozen stub.
+      entry.toolCount = 0
+      entry.lastTool = null
+      entry.pendingNarrative = null
+      tail.cursor = 0
+      tail.pendingPartial = ''
+      tail.hasEmittedStart = false
+      readSubTail(entry, tail, n, (desc) => {
+        log?.(`subagent-watcher: description updated for ${entry.agentId}: ${desc}`)
+      }, fs, log, db, parentStateDir, config.onUnstall, undefined, config.onProgress)
+      return
+    }
+    if (n >= pending.deadlineAt) {
+      entry.bootPromotionPending = undefined
+      log?.(`subagent-watcher: ${entry.agentId} never observed post-boot JSONL growth within the window — leaving historical/orphan (not promoting; avoids synthesising a stale 'completed' handback from a worker killed before this restart)`)
+    }
+  }
+
   // ─── State-transition notifications ─────────────────────────────────────
 
   function maybySendStateTransition(agentId: string): void {
@@ -1522,6 +1693,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
             resultText: entry.errored
               ? entry.lastResultText || entry.errorDetail || ''
               : entry.lastResultText,
+            background: entry.background,
           })
         } catch (cbErr) {
           log?.(`subagent-watcher: onFinish callback error ${agentId}: ${(cbErr as Error).message}`)
@@ -1543,6 +1715,7 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
             durationMs: nowFn() - entry.dispatchedAt,
             description: entry.description,
             resultText: entry.lastResultText,
+            background: entry.background,
           })
         } catch (cbErr) {
           log?.(`subagent-watcher: onFinish callback error ${agentId}: ${(cbErr as Error).message}`)
@@ -1593,6 +1766,14 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
     // Issue #1116 (Bug B): record that this agent has been fully
     // processed so a rescan that rediscovers the still-present JSONL
     // doesn't re-register and re-notify.
+    //
+    // Fix #9a: bound the Set so it can't grow unboundedly over a long-lived
+    // gateway — evict the oldest id once the cap is hit (Set iteration
+    // order is insertion order, so `.values().next().value` is the oldest).
+    if (!terminatedAgentIds.has(agentId) && terminatedAgentIds.size >= terminatedAgentIdsCap) {
+      const oldest = terminatedAgentIds.values().next().value
+      if (oldest != null) terminatedAgentIds.delete(oldest)
+    }
     terminatedAgentIds.add(agentId)
     log?.(`subagent-watcher: cleaned up terminal agent ${agentId}`)
   }
@@ -1894,6 +2075,10 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
       if (entry.state !== 'running') continue
       const tail = tails.get(agentId)
       if (!tail) continue
+      // Fix #5: defensive poll-loop fallback for the same growth check the
+      // fs.watch callback runs — covers the case where fs.watch missed the
+      // event that would otherwise have confirmed liveness.
+      checkBootPromotionGrowth(entry, tail, n)
       readSubTail(entry, tail, n, (desc) => {
         log?.(`subagent-watcher: description updated for ${agentId}: ${desc}`)
       }, fs, log, db, parentStateDir, config.onUnstall, cleanupTerminalAgent, config.onProgress)