switchroom 0.13.10 → 0.13.12

package/telegram-plugin/model-unavailable.ts

@@ -326,7 +326,17 @@ export function resolveModelUnavailableFromOperatorEvent(
     return detectModelUnavailable(detail) ?? { kind: 'quota_exhausted', raw: detail }
   }
   if (ev.kind === 'rate-limited') {
-    return detectModelUnavailable(detail) ?? { kind: 'overload', raw: detail }
+    // A rate-limited / transient overload is NOT "model unavailable" —
+    // it is retryable and Claude Code retries it internally. Escalate
+    // to the model-unavailable card ONLY if the detail carries a
+    // genuine quota signal (a 4xx that slipped past the classifier
+    // with usage-limit wording in its body). A bare overload /
+    // rate-limit returns null → the caller renders the calm
+    // `rate-limited` card, never the scary "⚠️ Model unavailable" one.
+    // Returning `{kind:'overload'}` here is what fired a false
+    // model-unavailable card on every transient 529.
+    const detected = detectModelUnavailable(detail)
+    return detected?.kind === 'quota_exhausted' ? detected : null
   }
   if (ev.kind === 'unknown-5xx') {
     return detectModelUnavailable(detail) ?? { kind: 'overload', raw: detail }

package/telegram-plugin/operator-events.fixtures.json

@@ -1,6 +1,5 @@
 {
   "_comment": "Captured error shapes per OperatorEventKind. Real API keys/IDs have been scrubbed.",
-
   "credentials-expired": [
     {
       "_source": "Anthropic API — 401 with authentication_error + expired hint",
@@ -16,7 +15,6 @@
       "message": "OAuth token expired, please re-authenticate to continue"
     }
   ],
-
   "credentials-invalid": [
     {
       "_source": "Anthropic API — 401 with invalid_api_key",
@@ -40,7 +38,6 @@
       "message": "Invalid API key"
     }
   ],
-
   "credit-exhausted": [
     {
       "_source": "Anthropic API — 402 credit_balance_too_low",
@@ -56,23 +53,7 @@
       "message": "credit balance insufficient"
     }
   ],
-
-  "quota-exhausted": [
-    {
-      "_source": "Anthropic API — 529 overloaded_error (Claude Code converts to quota-exhausted)",
-      "status": 529,
-      "error": {
-        "type": "overloaded_error",
-        "message": "Overloaded"
-      }
-    },
-    {
-      "_source": "Synthetic — set by session-tail after repeated 429 + slot exhaustion",
-      "type": "overloaded_error",
-      "message": "Service overloaded, usage limits reached"
-    }
-  ],
-
+  "quota-exhausted": [],
   "rate-limited": [
     {
       "_source": "Anthropic API — 429 rate_limit_error",
@@ -86,9 +67,21 @@
       "_source": "Top-level rate_limit_error",
       "type": "rate_limit_error",
       "message": "rate limit exceeded"
+    },
+    {
+      "_source": "Anthropic API — 529 overloaded_error (transient server capacity → rate-limited, NOT quota)",
+      "status": 529,
+      "error": {
+        "type": "overloaded_error",
+        "message": "Overloaded"
+      }
+    },
+    {
+      "_source": "Synthetic — overloaded_error from session-tail (transient → rate-limited, NOT quota)",
+      "type": "overloaded_error",
+      "message": "Service overloaded, usage limits reached"
     }
   ],
-
   "agent-crashed": [
     {
       "_source": "Synthetic — emitted by IPC bridge when Claude child exits nonzero",
@@ -101,7 +94,6 @@
       "message": "IPC socket disconnected unexpectedly"
     }
   ],
-
   "agent-restarted-unexpectedly": [
     {
       "_source": "Synthetic — emitted by gateway boot-banner diff when uptime drops unexpectedly",
@@ -114,7 +106,6 @@
       "message": "systemd unit restarted outside of operator request"
     }
   ],
-
   "unknown-4xx": [
     {
       "_source": "Novel 4xx not matching any known Anthropic error type",
@@ -142,7 +133,6 @@
       "_value": "something went wrong"
     }
   ],
-
   "unknown-5xx": [
     {
       "_source": "500 with no recognised type",

package/telegram-plugin/operator-events.ts

@@ -139,8 +139,17 @@ function classifyInner(raw: unknown): OperatorEventKind {
     message.toLowerCase().includes('overloaded_error') ||
     message.toLowerCase().includes('overloaded')
   ) {
-    // Anthropic overloaded = quota exhausted / service rate-limiting
-    return 'quota-exhausted'
+    // Anthropic "overloaded" (HTTP 529) is transient SERVER-side
+    // capacity pressure — orthogonal to account quota. It is retryable
+    // (`x-should-retry: true`) and Claude Code retries it internally.
+    // Classifying it `quota-exhausted` fired a false "Model
+    // unavailable — quota exhausted" card AND a self-cancelling fleet
+    // auto-fallback on every 529 (the active account always probes
+    // healthy — nothing is actually exhausted — so the fallback no-ops
+    // with "probed healthy / Stale event?"). It is a rate-limit-family
+    // transient; failing over to another account does nothing because
+    // every account is equally affected.
+    return 'rate-limited'
   }
 
   // Synthetic kinds (non-Anthropic — set by session-tail or IPC bridge)

package/telegram-plugin/session-tail.ts

@@ -409,9 +409,37 @@ export function projectSubagentLine(
  * Returns null when no actionable error is detected (routine lines).
  * Never throws — delegates to classifyClaudeError's own safety guarantee.
  */
+/**
+ * Extract Claude Code's retry-state annotations from a transcript line.
+ * Claude Code writes top-level `retryAttempt` / `maxRetries` on a
+ * retried API error (e.g. a 529 it is internally retrying). Used to
+ * tell an in-flight retry from an exhausted (terminal) one. Both
+ * optional — non-retried errors and older Claude Code versions omit
+ * them.
+ */
+function extractRetryState(obj: Record<string, unknown>): {
+  retryAttempt: number | null
+  maxRetries: number | null
+} {
+  return {
+    retryAttempt: typeof obj.retryAttempt === 'number' ? obj.retryAttempt : null,
+    maxRetries: typeof obj.maxRetries === 'number' ? obj.maxRetries : null,
+  }
+}
+
 export function detectErrorInTranscriptLine(
   line: string,
-): { kind: OperatorEventKind; raw: unknown; detail: string } | null {
+): {
+  kind: OperatorEventKind
+  raw: unknown
+  detail: string
+  /** True for the rate-limit / transient-overload family. */
+  transient: boolean
+  /** True when the error is final — NOT an in-flight retry. A transient
+   *  error mid-retry is `transient:true, terminal:false`; the caller
+   *  suppresses it (no operator card until the failure is terminal). */
+  terminal: boolean
+} | null {
   if (!line || line.length > 2 * 1024 * 1024) return null
   let obj: Record<string, unknown>
   try {
@@ -447,7 +475,16 @@ export function detectErrorInTranscriptLine(
       status === 429
         ? 'quota-exhausted'
         : classifyClaudeError({ type: errStr, status, message: text })
-    return { kind, raw: obj, detail: text || errStr || 'api error' }
+    // An `isApiErrorMessage` line is Claude surfacing the failure to the
+    // user — terminal by construction (Claude writes this shape only
+    // after its own internal retries are exhausted).
+    return {
+      kind,
+      raw: obj,
+      detail: text || errStr || 'api error',
+      transient: kind === 'rate-limited',
+      terminal: true,
+    }
   }
 
   // Explicit error line types from Claude Code JSONL
@@ -472,7 +509,23 @@ export function detectErrorInTranscriptLine(
     extractDetailMessage(obj) ??
     String(type ?? '')
 
-  return { kind, raw, detail }
+  // Transient = the rate-limit / overload family. For a transient,
+  // decide `terminal` from Claude Code's retry annotations: below the
+  // cap → still retrying (in-flight); at/above → exhausted. With no
+  // retry state, an explicit `type:"api_error"`/`"error"` LINE means
+  // Claude surfaced the failure (terminal); an embedded-error object
+  // with no retry state is ambiguous → treat as in-flight and suppress
+  // (the silence-poke covers a genuinely stuck turn; a false card is
+  // the bug we are fixing, a missed ambiguous card costs nothing).
+  const transient = kind === 'rate-limited'
+  const retry = extractRetryState(obj)
+  const terminal = !transient
+    ? true
+    : retry.retryAttempt != null && retry.maxRetries != null
+      ? retry.retryAttempt >= retry.maxRetries
+      : isErrorLine
+
+  return { kind, raw, detail, transient, terminal }
 }
 
 function extractDetailMessage(obj: Record<string, unknown> | null): string | null {
@@ -514,6 +567,10 @@ export interface TailOperatorEvent {
   kind: OperatorEventKind
   detail: string
   raw: unknown
+  /** True for the rate-limit / transient-overload family. */
+  transient: boolean
+  /** True when the failure is final, not an in-flight retry. */
+  terminal: boolean
 }
 
 export interface SessionTailConfig {
@@ -665,7 +722,17 @@ export function startSessionTail(config: SessionTailConfig): SessionTailHandle {
           try {
             const errEvent = detectErrorInTranscriptLine(line)
             if (errEvent) {
-              onOperatorEvent(errEvent)
+              // Honest escalation: a transient overload Claude is still
+              // retrying (transient && !terminal) posts NO operator
+              // card — it almost always resolves on the next retry.
+              // Escalate only terminal failures + non-transient errors.
+              if (errEvent.terminal || !errEvent.transient) {
+                onOperatorEvent(errEvent)
+              } else {
+                log?.(
+                  `session-tail: transient overload suppressed (in-flight retry) kind=${errEvent.kind}`,
+                )
+              }
             }
           } catch (err) {
             log?.(`session-tail: onOperatorEvent threw: ${(err as Error).message}`)

package/telegram-plugin/subagent-watcher.ts

@@ -146,11 +146,6 @@ export interface SubagentWatcherConfig {
    * an agent's home pollutes the watcher with phantom registrations).
    */
   agentCwd?: string
-  /**
-   * Send a fresh (non-edit) Telegram message. For stall / completion
-   * state-transition notifications.
-   */
-  sendNotification: (text: string) => void
   /**
    * How often to re-scan for new subagent dirs (ms). Default 1000.
    */
@@ -862,21 +857,19 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
 
     if (entry.state === 'done' && !entry.completionNotified) {
       entry.completionNotified = true
-      const desc = escapeHtml(truncate(entry.description, 80))
-      const summary = entry.lastSummaryLine
-        ? ` — ${escapeHtml(truncate(entry.lastSummaryLine, 120))}`
-        : ''
-      const tools = entry.toolCount > 0 ? ` (${entry.toolCount} tools)` : ''
-      try {
-        config.sendNotification(`✓ Worker done: ${desc}${tools}${summary}`)
-      } catch (err) {
-        log?.(`subagent-watcher: completion notification error: ${(err as Error).message}`)
-      }
-      // Symmetric `sub_agent_finished` surface (#card-audit-log). Emit
-      // before the deferred cleanup runs so the callback always sees a
-      // live registry entry. Historical entries that already-completed at
-      // boot get their `completionNotified=true` shortcut in registerAgent
-      // and skip this path entirely — only post-boot transitions fire.
+      // Card retired (#1122): the watcher no longer sends a user-facing
+      // "✓ Worker done" message. A framework-authored status line is a
+      // conversational-pacing anti-pattern, and the heuristic that drove
+      // it (silent-stall synthesis) fired on a worker mid-`Bash` as
+      // readily as on a finished one. The user-facing handback is the
+      // model's own beat-4 reply, woken by Claude Code's native
+      // background-task notification. Completion is surfaced here only
+      // via the structured `onFinish` callback — emitted before the
+      // deferred cleanup runs so the callback always sees a live
+      // registry entry. Historical entries that already-completed at
+      // boot get their `completionNotified=true` shortcut in
+      // registerAgent and skip this path — only post-boot transitions
+      // fire.
       if (config.onFinish) {
         try {
           config.onFinish({

package/telegram-plugin/tests/fleet-state-watcher.test.ts

@@ -50,7 +50,6 @@ describe('subagent-watcher: WorkerEntry.lastTool', () => {
     const intervals: Array<{ fn: () => void }> = []
     const w = startSubagentWatcher({
       agentDir,
-      sendNotification: () => {},
       stallThresholdMs: 60_000,
       rescanMs: 500,
       now: () => Date.now(),

package/telegram-plugin/tests/model-unavailable.test.ts

@@ -247,9 +247,22 @@ describe('resolveModelUnavailableFromOperatorEvent — kind-driven mapping', ()
     expect(d?.kind).toBe('quota_exhausted')
   })
 
-  it('always treats kind=rate-limited as overload', () => {
+  it('treats a bare kind=rate-limited as NOT model-unavailable (transient → calm card)', () => {
+    // A transient overload / rate-limit is retryable — Claude Code
+    // retries it internally. resolveModelUnavailableFromOperatorEvent
+    // returns null so the gateway renders the calm `rate-limited` card,
+    // never the scary "⚠️ Model unavailable" one. Returning
+    // `{kind:'overload'}` here is what fired a false card on every 529.
     const d = resolveModelUnavailableFromOperatorEvent({ kind: 'rate-limited', detail: '' })
-    expect(d?.kind).toBe('overload')
+    expect(d).toBeNull()
+  })
+
+  it('escalates a kind=rate-limited that carries a genuine quota signal', () => {
+    const d = resolveModelUnavailableFromOperatorEvent({
+      kind: 'rate-limited',
+      detail: "You've hit your limit · resets 8:50am",
+    })
+    expect(d?.kind).toBe('quota_exhausted')
   })
 
   it('always treats kind=unknown-5xx as overload', () => {

package/telegram-plugin/tests/operator-events-session-tail.test.ts

@@ -56,13 +56,64 @@ describe('detectErrorInTranscriptLine — error detection', () => {
     expect(result!.kind).toBe('credit-exhausted')
   })
 
-  it('classifies overloaded_error as quota-exhausted', () => {
+  it('classifies overloaded_error as rate-limited (transient), NOT quota-exhausted', () => {
+    // A 529 "overloaded" is transient Anthropic server-capacity
+    // pressure — orthogonal to account quota. Classifying it
+    // quota-exhausted fired a false "Model unavailable" card + a
+    // self-cancelling fleet auto-fallback on every 529.
     const line = JSON.stringify({
       type: 'api_error',
       error: { type: 'overloaded_error', message: 'Overloaded' },
     })
     const result = detectErrorInTranscriptLine(line)
-    expect(result!.kind).toBe('quota-exhausted')
+    expect(result!.kind).toBe('rate-limited')
+    expect(result!.transient).toBe(true)
+    // An explicit `type:"api_error"` line (no retry state) = Claude
+    // surfaced the failure → terminal.
+    expect(result!.terminal).toBe(true)
+  })
+
+  it('marks an in-flight 529 retry transient + NOT terminal (suppressed)', () => {
+    // Real on-disk shape: a 529 Claude Code is internally retrying,
+    // annotated with retryAttempt < maxRetries.
+    const line = JSON.stringify({
+      type: 'system',
+      subtype: 'api_error',
+      error: { status: 529, type: 'overloaded_error', message: 'Overloaded' },
+      retryAttempt: 9,
+      maxRetries: 10,
+      retryInMs: 34479,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result!.kind).toBe('rate-limited')
+    expect(result!.transient).toBe(true)
+    // 9 < 10 — still retrying → in-flight → the caller suppresses it.
+    expect(result!.terminal).toBe(false)
+  })
+
+  it('marks an exhausted 529 retry terminal (escalates)', () => {
+    const line = JSON.stringify({
+      type: 'system',
+      subtype: 'api_error',
+      error: { status: 529, type: 'overloaded_error', message: 'Overloaded' },
+      retryAttempt: 10,
+      maxRetries: 10,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result!.kind).toBe('rate-limited')
+    expect(result!.transient).toBe(true)
+    // retries exhausted → terminal → escalates.
+    expect(result!.terminal).toBe(true)
+  })
+
+  it('marks non-transient errors terminal (always escalate)', () => {
+    const line = JSON.stringify({
+      type: 'api_error',
+      error: { type: 'authentication_error', message: 'expired' },
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result!.transient).toBe(false)
+    expect(result!.terminal).toBe(true)
   })
 
   it('returns null for lines without error field', () => {

package/telegram-plugin/tests/operator-events.test.ts

@@ -57,13 +57,20 @@ describe('classifyClaudeError — credit-exhausted fixtures', () => {
   }
 })
 
-describe('classifyClaudeError — quota-exhausted fixtures', () => {
-  for (const fixture of fixtures['quota-exhausted']) {
-    it(`classifies: ${fixture._source}`, () => {
-      const input = '_value' in fixture ? fixture._value : fixture
-      expect(classifyClaudeError(input)).toBe('quota-exhausted')
-    })
-  }
+describe('classifyClaudeError — quota-exhausted', () => {
+  // classifyClaudeError is type/code/status-based and intentionally
+  // does NOT self-classify quota-exhausted: a genuine subscription
+  // usage-limit hit has no reliable Anthropic error TYPE — it is
+  // detected from the response TEXT. session-tail's `isApiErrorMessage`
+  // 429 branch + the `detectModelUnavailable` text path own quota
+  // detection. (`overloaded_error` used to be mapped here — wrongly;
+  // a 529 overload is transient server capacity, now `rate-limited`.)
+  it('no error TYPE maps to quota-exhausted (the text path owns it)', () => {
+    expect(fixtures['quota-exhausted']).toHaveLength(0)
+    expect(
+      classifyClaudeError({ type: 'overloaded_error', message: 'Overloaded' }),
+    ).not.toBe('quota-exhausted')
+  })
 })
 
 describe('classifyClaudeError — rate-limited fixtures', () => {

package/telegram-plugin/tests/subagent-handback-decision.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Regression coverage for `decideSubagentHandback` — the gate the
+ * gateway's subagent-watcher `onFinish` callback runs to decide whether
+ * a finished sub-agent gets a handback turn injected.
+ *
+ * This is the highest-risk surface of the handback feature (#1650): it
+ * injects a fresh turn. Before this suite the decision lived inline in
+ * the gateway's `onFinish` closure with no automated test — a refactor
+ * that broke the `isBackground` gate would have fired handbacks for
+ * foreground sub-agents (double messages) with nothing to catch it.
+ * The decision is now a pure function; these cases pin every gate.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { decideSubagentHandback } from '../gateway/subagent-handback-inbound-builder.js'
+
+const FIXED_NOW = 1_700_000_000_000
+
+const base = {
+  handbackEnvValue: undefined as string | undefined,
+  outcome: 'completed' as 'completed' | 'failed' | 'orphan',
+  isBackground: true,
+  fleetChatId: '777',
+  ownerChatId: '999',
+  taskDescription: 'Do the thing',
+  resultText: 'Done.',
+  nowMs: FIXED_NOW,
+}
+
+describe('decideSubagentHandback', () => {
+  it('delivers for a background completed sub-agent', () => {
+    const d = decideSubagentHandback({ ...base })
+    expect(d.deliver).toBe(true)
+    if (d.deliver) {
+      expect(d.chatId).toBe('777')
+      expect(d.inbound.meta.source).toBe('subagent_handback')
+      expect(d.inbound.chatId).toBe('777')
+    }
+  })
+
+  it('delivers for a background FAILED sub-agent', () => {
+    const d = decideSubagentHandback({ ...base, outcome: 'failed' })
+    expect(d.deliver).toBe(true)
+    if (d.deliver) expect(d.inbound.meta.outcome).toBe('failed')
+  })
+
+  it('skips a foreground sub-agent (handed back natively in-turn)', () => {
+    const d = decideSubagentHandback({ ...base, isBackground: false })
+    expect(d).toEqual({ deliver: false, reason: 'foreground' })
+  })
+
+  it("skips an 'orphan' outcome (stale historical-at-boot row)", () => {
+    const d = decideSubagentHandback({ ...base, outcome: 'orphan' })
+    expect(d).toEqual({ deliver: false, reason: 'outcome-not-terminal' })
+  })
+
+  it('skips when the kill-switch is set (SWITCHROOM_SUBAGENT_HANDBACK=0)', () => {
+    const d = decideSubagentHandback({ ...base, handbackEnvValue: '0' })
+    expect(d).toEqual({ deliver: false, reason: 'env-disabled' })
+  })
+
+  it('treats any non-"0" env value (incl. undefined) as enabled', () => {
+    expect(decideSubagentHandback({ ...base, handbackEnvValue: undefined }).deliver).toBe(true)
+    expect(decideSubagentHandback({ ...base, handbackEnvValue: '1' }).deliver).toBe(true)
+    expect(decideSubagentHandback({ ...base, handbackEnvValue: '' }).deliver).toBe(true)
+  })
+
+  it('falls back to the owner chat when the fleet entry is gone', () => {
+    const d = decideSubagentHandback({ ...base, fleetChatId: '' })
+    expect(d.deliver).toBe(true)
+    if (d.deliver) {
+      expect(d.chatId).toBe('999')
+      expect(d.inbound.chatId).toBe('999')
+    }
+  })
+
+  it('prefers the fleet chat id over the owner chat when both are present', () => {
+    const d = decideSubagentHandback({ ...base, fleetChatId: '777', ownerChatId: '999' })
+    expect(d.deliver).toBe(true)
+    if (d.deliver) expect(d.chatId).toBe('777')
+  })
+
+  it('skips when no chat resolves at all', () => {
+    const d = decideSubagentHandback({ ...base, fleetChatId: '', ownerChatId: '' })
+    expect(d).toEqual({ deliver: false, reason: 'no-chat' })
+  })
+
+  it('gate order: kill-switch wins over every other condition', () => {
+    // env-disabled even though it is a deliverable background completion.
+    const d = decideSubagentHandback({ ...base, handbackEnvValue: '0', isBackground: true })
+    expect(d).toEqual({ deliver: false, reason: 'env-disabled' })
+  })
+
+  it('gate order: outcome filter applies before the foreground check', () => {
+    // orphan + foreground — outcome filter is checked first.
+    const d = decideSubagentHandback({ ...base, outcome: 'orphan', isBackground: false })
+    expect(d).toEqual({ deliver: false, reason: 'outcome-not-terminal' })
+  })
+
+  it('carries the task description and result text into the inbound', () => {
+    const d = decideSubagentHandback({
+      ...base,
+      taskDescription: 'Migrate the DB',
+      resultText: 'Applied 3 migrations, 0 rows dropped.',
+    })
+    expect(d.deliver).toBe(true)
+    if (d.deliver) {
+      expect(d.inbound.text).toContain('Migrate the DB')
+      expect(d.inbound.text).toContain('Applied 3 migrations')
+    }
+  })
+})

package/telegram-plugin/tests/subagent-registry-bugs.test.ts

@@ -148,7 +148,6 @@ function makeHarnessWithDb(opts: {
   } = opts
 
   let currentTime = 10_000
-  const notifications: string[] = []
   const logs: string[] = []
 
   const fileContents: Map<string, Buffer> = new Map()
@@ -217,7 +216,6 @@ function makeHarnessWithDb(opts: {
 
   const watcher = startSubagentWatcher({
     agentDir,
-    sendNotification: (text) => notifications.push(text),
     stallThresholdMs,
     // Mirror the active-loop threshold for fixtures with toolCount=0;
     // tests that need the silent-synthesis vs active-loop distinction
@@ -257,7 +255,7 @@ function makeHarnessWithDb(opts: {
     if (pollInterval) pollInterval.fn()
   }
 
-  return { notifications, logs, advance, poll, watcher, now: () => currentTime, mockFs, fileContents }
+  return { logs, advance, poll, watcher, now: () => currentTime, mockFs, fileContents }
 }
 
 // ─── Bug 1 — ID mismatch: watcher never bumps last_activity_at ───────────────

package/telegram-plugin/tests/subagent-watcher-env-thresholds.test.ts

@@ -84,7 +84,6 @@ function makeHarness(opts: {
     silentSynthesisStallThresholdMs: configStallThresholdMs,
     silentStallTerminalMs: configSilentStallTerminalMs,
     rescanMs: 500,
-    sendNotification: () => {},
     onStall: (_id, idleMs) => stallCalls.push({ idleMs }),
     onStallTerminal: (id) => stallTerminalCalls.push({ agentId: id }),
     onFinish: ({ outcome }) => finishCalls.push({ outcome }),

package/telegram-plugin/tests/subagent-watcher-parent-marker.test.ts

@@ -86,7 +86,6 @@ describe('subagent-watcher: parent turn-active marker refresh (#501)', () => {
     let nextRef = 1
     const watcher = startSubagentWatcher({
       agentDir: opts.agentDir,
-      sendNotification: () => { /* noop */ },
       stallThresholdMs: 60_000,
       rescanMs: 500,
       now: () => Date.now(),

package/telegram-plugin/tests/subagent-watcher-stall-notification.test.ts

@@ -26,7 +26,6 @@ function subAgentUserMsg(promptText: string) {
 // ─── Harness (mirrors subagent-watcher.test.ts pattern) ──────────────────────
 
 interface StallHarness {
-  notifications: string[]
   stallCalls: Array<{ agentId: string; idleMs: number; description: string }>
   unstallCalls: Array<{ agentId: string; description: string }>
   logs: string[]
@@ -55,7 +54,6 @@ function makeStallHarness(opts: {
   } = opts
 
   let currentTime = 1000
-  const notifications: string[] = []
   const stallCalls: Array<{ agentId: string; idleMs: number; description: string }> = []
   const unstallCalls: Array<{ agentId: string; description: string }> = []
   const logs: string[] = []
@@ -139,7 +137,6 @@ function makeStallHarness(opts: {
     // silent-synthesis vs active-loop split.
     silentSynthesisStallThresholdMs: silentSynthesisStallThresholdMs ?? stallThresholdMs,
     rescanMs,
-    sendNotification: (text) => notifications.push(text),
     onStall: (id, idle, desc) => stallCalls.push({ agentId: id, idleMs: idle, description: desc }),
     onUnstall: (id, desc) => unstallCalls.push({ agentId: id, description: desc }),
     now: () => currentTime,
@@ -168,7 +165,7 @@ function makeStallHarness(opts: {
     }
   }
 
-  return { notifications, stallCalls, unstallCalls, logs, advance, watcher, now: () => currentTime, fileContents, jsonlPath }
+  return { stallCalls, unstallCalls, logs, advance, watcher, now: () => currentTime, fileContents, jsonlPath }
 }
 
 // ─── Tests ────────────────────────────────────────────────────────────────────

package/telegram-plugin/tests/subagent-watcher-stall-terminal.test.ts

@@ -127,7 +127,6 @@ function makeHarness(opts: {
     silentSynthesisStallThresholdMs: stallThresholdMs,
     silentStallTerminalMs,
     rescanMs,
-    sendNotification: () => {},
     onStall: (id, idleMs) => stallCalls.push({ agentId: id, idleMs }),
     onUnstall: (id) => unstallCalls.push({ agentId: id }),
     onStallTerminal: (id, desc) => stallTerminalCalls.push({ agentId: id, description: desc }),