switchroom 0.15.45 → 0.16.5

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

@@ -151,6 +151,124 @@ describe('detectModelUnavailable — reset-time extraction', () => {
   })
 })
 
+// ─── SESSION-cap (time-only) reset parsing — auth-failover-stall Fix 2 ─────────
+//
+// A session cap surfaces as "resets <time>" with NO month/day. Pre-fix this
+// was unparseable → resetAt undefined → the 429 inference path applied the +7d
+// weekly floor, benching the account for a WEEK. The new branch resolves it to
+// the NEXT occurrence of that wall-clock time (hours away), tz-aware.
+describe('detectModelUnavailable — time-only session-cap reset (Fix 2)', () => {
+  const HOUR = 3600_000
+  const WEEK = 7 * 24 * HOUR
+
+  // Next occurrence of a wall-clock time in a tz must be ≤24h away — and
+  // crucially NOT the +7d weekly floor.
+  function expectHoursAway(d: Date | undefined): void {
+    expect(d).toBeInstanceOf(Date)
+    const deltaMs = (d as Date).getTime() - Date.now()
+    expect(deltaMs).toBeGreaterThan(0)
+    expect(deltaMs).toBeLessThanOrEqual(24 * HOUR + 60_000)
+    // The whole point: never the weekly floor.
+    expect(deltaMs).toBeLessThan(WEEK - HOUR)
+  }
+
+  // The next wall-clock occurrence of `hour:minute` in `tz` should land on
+  // that exact minute (sanity that we resolved the time, not a fudge).
+  function expectWallClock(d: Date | undefined, tz: string, hour: number, minute = 0): void {
+    expect(d).toBeInstanceOf(Date)
+    const parts = Object.fromEntries(
+      new Intl.DateTimeFormat('en-US', {
+        timeZone: tz, hour: '2-digit', minute: '2-digit', hour12: false,
+      })
+        .formatToParts(d as Date)
+        .filter((p) => p.type !== 'literal')
+        .map((p) => [p.type, p.value]),
+    )
+    expect(Number(parts.hour) % 24).toBe(hour)
+    expect(Number(parts.minute)).toBe(minute)
+  }
+
+  it('parses "resets 5pm (Australia/Melbourne)" to the next 17:00 there, hours away (NOT +7d)', () => {
+    const d = detectModelUnavailable(
+      "You've hit your session limit · resets 5pm (Australia/Melbourne)",
+    )
+    expect(d?.kind).toBe('quota_exhausted')
+    expectHoursAway(d?.resetAt)
+    expectWallClock(d?.resetAt, 'Australia/Melbourne', 17, 0)
+  })
+
+  it('parses the "at"-prefixed form — "resets at 5pm (Australia/Melbourne)" (parity with wedge-watchdog parseWeeklyReset)', () => {
+    // wedge-watchdog's parseWeeklyReset time-only regex accepts an optional
+    // "(?:at\s+)?" token; this parser must accept the IDENTICAL grammar or the
+    // "at"-prefixed string falls through to the +7d weekly floor — the
+    // week-long-bench bug this PR exists to kill.
+    const d = detectModelUnavailable(
+      "You've hit your session limit · resets at 5pm (Australia/Melbourne)",
+    )
+    expect(d?.kind).toBe('quota_exhausted')
+    expectHoursAway(d?.resetAt)
+    expectWallClock(d?.resetAt, 'Australia/Melbourne', 17, 0)
+  })
+
+  it('parses am times — "resets 8:50am (Australia/Melbourne)"', () => {
+    const d = detectModelUnavailable("You've hit your limit · resets 8:50am (Australia/Melbourne)")
+    expect(d?.kind).toBe('quota_exhausted')
+    expectHoursAway(d?.resetAt)
+    expectWallClock(d?.resetAt, 'Australia/Melbourne', 8, 50)
+  })
+
+  it('parses a time WITHOUT minutes — "resets 9am (UTC)"', () => {
+    const d = detectModelUnavailable('hit your limit · resets 9am (UTC)')
+    expect(d?.kind).toBe('quota_exhausted')
+    expectHoursAway(d?.resetAt)
+    expectWallClock(d?.resetAt, 'UTC', 9, 0)
+  })
+
+  it('parses a time WITHOUT a tz label (best-effort UTC) — "resets 11pm"', () => {
+    const d = detectModelUnavailable('usage limit hit · resets 11pm')
+    expect(d?.kind).toBe('quota_exhausted')
+    expectHoursAway(d?.resetAt)
+    expectWallClock(d?.resetAt, 'UTC', 23, 0)
+  })
+
+  it('parses 24-hour clock times — "resets 17:00 (UTC)"', () => {
+    const d = detectModelUnavailable('hit your limit · resets 17:00 (UTC)')
+    expect(d?.kind).toBe('quota_exhausted')
+    expectHoursAway(d?.resetAt)
+    expectWallClock(d?.resetAt, 'UTC', 17, 0)
+  })
+
+  it('STILL parses a bare ISO-8601 reset (calendar-path regression guard)', () => {
+    const d = detectModelUnavailable('quota exhausted, retry at 2026-05-03T11:00:00Z')
+    expect(d?.resetAt?.toISOString()).toBe('2026-05-03T11:00:00.000Z')
+  })
+
+  it('a month/day "resets" string is NOT hijacked into the time-only branch', () => {
+    // The negative lookahead must reject "May"/"Jun" so a date-bearing string
+    // never resolves to "tomorrow at HH:MM". (The month/day+time calendar form
+    // itself does not currently resolve to a Date — that is pre-existing
+    // behaviour; the load-bearing guard is that the time-only branch leaves it
+    // alone rather than producing a WRONG hours-away time.)
+    const may = detectModelUnavailable("You're out of extra usage · resets May 3, 11am")
+    expect(may?.kind).toBe('quota_exhausted')
+    // If the time-only branch had wrongly fired, resetAt would be ≤24h away.
+    if (may?.resetAt) {
+      const deltaMs = may.resetAt.getTime() - Date.now()
+      // A genuine May-3 resolution is many days away (or in the past); never the
+      // bare next-11am-tomorrow the time-only branch would have produced.
+      expect(Math.abs(deltaMs)).toBeGreaterThan(2 * 24 * HOUR)
+    }
+    const jun = detectModelUnavailable(
+      "hit your limit · resets Jun 9, 5am (Australia/Melbourne)",
+    )
+    expect(jun?.kind).toBe('quota_exhausted')
+    if (jun?.resetAt) {
+      const deltaMs = jun.resetAt.getTime() - Date.now()
+      expect(Math.abs(deltaMs)).toBeGreaterThan(2 * 24 * HOUR)
+    }
+  })
+})
+
 // ─── formatModelUnavailableCard ──────────────────────────────────────────────
 
 describe('formatModelUnavailableCard — actionable card', () => {

package/telegram-plugin/tests/narrative-dedup.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from 'vitest'
+import {
+  normalizeNarrative,
+  prefixSimilarity,
+  isDraftOfReply,
+  DRAFT_SUPPRESS_THRESHOLD,
+  REPLY_TOOLS,
+} from '../narrative-dedup.js'
+
+describe('narrative-dedup', () => {
+  it('pins the threshold so a silent retune breaks the test', () => {
+    expect(DRAFT_SUPPRESS_THRESHOLD).toBe(0.8)
+  })
+
+  it('REPLY_TOOLS holds exactly reply + stream_reply', () => {
+    expect(REPLY_TOOLS.has('reply')).toBe(true)
+    expect(REPLY_TOOLS.has('stream_reply')).toBe(true)
+    expect(REPLY_TOOLS.has('Bash')).toBe(false)
+  })
+
+  describe('normalizeNarrative', () => {
+    it('strips markdown emphasis/heading/quote marks, collapses whitespace, lowercases', () => {
+      expect(normalizeNarrative('**Bold**  _italic_   `code`')).toBe('bold italic code')
+      expect(normalizeNarrative('> # Heading\n  text')).toBe('heading text')
+    })
+  })
+
+  describe('prefixSimilarity', () => {
+    it('returns 1 for identical strings', () => {
+      expect(prefixSimilarity('hello there', 'hello there')).toBe(1)
+    })
+
+    it('returns 0 when either side is empty (no divide-by-zero)', () => {
+      expect(prefixSimilarity('', 'something')).toBe(0)
+      expect(prefixSimilarity('something', '')).toBe(0)
+      expect(prefixSimilarity('', '')).toBe(0)
+    })
+
+    it('ratio is over the SHORTER normalized string', () => {
+      // "abc" vs "abcdef": shared prefix 3 of shorter length 3 = 1.0
+      expect(prefixSimilarity('abc', 'abcdef')).toBe(1)
+      // "abx" vs "abcdef": shared prefix 2 of shorter length 3 ≈ 0.667
+      expect(prefixSimilarity('abx', 'abcdef')).toBeCloseTo(2 / 3, 5)
+    })
+  })
+
+  describe('isDraftOfReply', () => {
+    it('SUPPRESS: identical draft and reply', () => {
+      const t = 'The repo is at /home/user/code/switchroom.'
+      expect(isDraftOfReply(t, t)).toBe(true)
+    })
+
+    it('SUPPRESS: draft whose trailing sentence was trimmed before sending (~0.85 prefix)', () => {
+      const draft = 'The repo is at /home/user/code/switchroom. I will start now.'
+      const reply = 'The repo is at /home/user/code/switchroom.'
+      // reply is the shorter string and is a full prefix of the draft → 1.0
+      expect(prefixSimilarity(draft, reply)).toBe(1)
+      expect(isDraftOfReply(draft, reply)).toBe(true)
+      // And the symmetric framing (draft slightly longer head, reply trimmed):
+      const draft2 = 'Found both repos and confirmed the remote is correct here.'
+      const reply2 = 'Found both repos and confirmed the remote is correct.'
+      expect(prefixSimilarity(draft2, reply2)).toBeGreaterThanOrEqual(0.85)
+      expect(isDraftOfReply(draft2, reply2)).toBe(true)
+    })
+
+    it('SHOW: post-action narration that merely precedes a different reply', () => {
+      // "Sent. Waiting on the build…" vs an unrelated reply payload — short
+      // string, near-zero shared prefix → below threshold → SHOW.
+      const narration = 'Sent. Waiting on the build…'
+      const reply = "Here's the result of the build: all green."
+      expect(prefixSimilarity(narration, reply)).toBeLessThan(DRAFT_SUPPRESS_THRESHOLD)
+      expect(isDraftOfReply(narration, reply)).toBe(false)
+    })
+
+    it('SHOW: empty reply text never suppresses (no divide-by-zero)', () => {
+      expect(isDraftOfReply('On it. Let me find the repo…', '')).toBe(false)
+    })
+
+    it('SUPPRESS: draft differs from reply only by markdown decoration', () => {
+      const draft = 'Here is the **plan**: do A then B.'
+      const reply = 'Here is the plan: do A then B.'
+      // After normalization the markdown stars vanish → identical → suppress.
+      expect(normalizeNarrative(draft)).toBe(normalizeNarrative(reply))
+      expect(isDraftOfReply(draft, reply)).toBe(true)
+    })
+
+    it('NIT 2: the doubled-capturedText proxy mis-suppresses; the actual reply text does not', () => {
+      // The bug: flushPendingNarrativeAtTurnEnd used to compare a trailing
+      // narration against capturedText.join(''). When the model emits the same
+      // short string twice in a turn — e.g. "Done." as working narration and
+      // then "Done." as the reply — that proxy becomes the CONCATENATION
+      // "Done.Done.", whose prefix the trailing narration still matches above
+      // threshold → genuine trailing narration WRONGLY suppressed.
+      const trailing = 'Done.'
+      const doubledProxy = 'Done.' + 'Done.' // capturedText.join('') of two "Done." blocks
+      const actualReply = 'Done.'
+
+      // Old (broken) comparison: trailing vs the doubled proxy → wrongly suppresses.
+      expect(isDraftOfReply(trailing, doubledProxy)).toBe(true)
+
+      // New comparison: trailing vs the ACTUAL reply text. Here the reply text
+      // really IS "Done.", so a trailing "Done." is a genuine duplicate and is
+      // correctly suppressed — the fix preserves the common-case suppression.
+      expect(isDraftOfReply(trailing, actualReply)).toBe(true)
+    })
+
+    it('NIT 2: genuine trailing narration is preserved when the reply text differs', () => {
+      // The case the proxy hurt most: the turn's reply is a SHORT distinct
+      // string and the trailing narration is genuine liveness. Comparing
+      // against the actual reply text (not a concatenation that happens to
+      // share a prefix) keeps the trailing narration SHOWN.
+      const trailingNarration = 'Done — all green, pushing now.'
+      const actualReply = 'Here is the summary you asked for: 3 files changed.'
+      // Below threshold against the real reply → SHOW (not suppressed).
+      expect(isDraftOfReply(trailingNarration, actualReply)).toBe(false)
+    })
+  })
+})

package/telegram-plugin/tests/orphaned-reply-rearm.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Unit tests for the activity-feed-teardown fix (orphaned-reply backstop).
+ *
+ * Root cause: the orphaned-reply backstop fired a synthetic turn_end
+ * (`durationMs: -1`) after 30 s of silence, even mid-tool-call. That nulled
+ * `currentTurn` and dropped every subsequent `tool_label`, darkening the live
+ * activity feed for the rest of the turn.
+ *
+ * Fix: three layers described in the PR.
+ *   PRIMARY   — fuse fires mid-tool → re-arm instead (bounded by ORPHANED_REPLY_MAX_REARMS).
+ *   SECONDARY — tool_label re-arms the fuse so active label streams keep it fresh.
+ *   DEFENSIVE — turn_end entry rejects the synthetic event if tools are in flight.
+ *
+ * These tests cover the pure / unit-testable surfaces:
+ *   - shouldArmOrphanedReplyTimeout (existing, now with midToolCall param)
+ *   - ORPHANED_REPLY_MAX_REARMS constant math
+ *   - The re-arm guard logic (pure decision extracted from the closure)
+ *   - The defensive turn_end discriminator (durationMs === -1 + in-flight check)
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  shouldArmOrphanedReplyTimeout,
+  ORPHANED_REPLY_TIMEOUT_MS,
+  ORPHANED_REPLY_MAX_REARMS,
+} from '../context-exhaustion.js'
+import { ToolFlightTracker } from '../gateway/interrupt-defer.js'
+
+// ---------------------------------------------------------------------------
+// Helpers — pure decision functions mirroring the gateway closure logic.
+// These extract the discriminable parts of the fix so they are unit-testable
+// without instantiating the full gateway.
+// ---------------------------------------------------------------------------
+
+/**
+ * Mirrors the PRIMARY fix decision inside the setTimeout callback:
+ * should the backstop re-arm (true) or fire turn_end (false)?
+ */
+function shouldRearmInsteadOfFire(opts: {
+  midToolCall: boolean
+  rearmCount: number
+  maxRearms: number
+}): boolean {
+  return opts.midToolCall && opts.rearmCount < opts.maxRearms
+}
+
+/**
+ * Mirrors the DEFENSIVE fix at turn_end entry:
+ * should a synthetic turn_end (durationMs === -1) be suppressed?
+ */
+function shouldSuppressSyntheticTurnEnd(opts: {
+  durationMs: number
+  midToolCall: boolean
+}): boolean {
+  return opts.durationMs === -1 && opts.midToolCall
+}
+
+// ---------------------------------------------------------------------------
+// Tests: ORPHANED_REPLY_MAX_REARMS constant
+// ---------------------------------------------------------------------------
+
+describe('ORPHANED_REPLY_MAX_REARMS', () => {
+  it('is 20 (20 × 30 s = 10 min cap)', () => {
+    expect(ORPHANED_REPLY_MAX_REARMS).toBe(20)
+  })
+
+  it('combined with ORPHANED_REPLY_TIMEOUT_MS covers at least 10 min of tool activity', () => {
+    const coverageMs = ORPHANED_REPLY_MAX_REARMS * ORPHANED_REPLY_TIMEOUT_MS
+    // 20 × 30 000 ms = 600 000 ms = 10 min
+    expect(coverageMs).toBeGreaterThanOrEqual(10 * 60 * 1000)
+  })
+
+  it('fuse duration is still 30 s', () => {
+    expect(ORPHANED_REPLY_TIMEOUT_MS).toBe(30_000)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Tests: PRIMARY fix — re-arm guard
+// ---------------------------------------------------------------------------
+
+describe('PRIMARY fix: re-arm guard (shouldRearmInsteadOfFire)', () => {
+  it('re-arms when a tool is in flight and rearm count is under the cap', () => {
+    expect(shouldRearmInsteadOfFire({ midToolCall: true, rearmCount: 0, maxRearms: 20 })).toBe(true)
+    expect(shouldRearmInsteadOfFire({ midToolCall: true, rearmCount: 19, maxRearms: 20 })).toBe(true)
+  })
+
+  it('fires once rearm count reaches the cap, even mid-tool-call', () => {
+    expect(shouldRearmInsteadOfFire({ midToolCall: true, rearmCount: 20, maxRearms: 20 })).toBe(false)
+    expect(shouldRearmInsteadOfFire({ midToolCall: true, rearmCount: 21, maxRearms: 20 })).toBe(false)
+  })
+
+  it('fires immediately when no tool is in flight, regardless of rearm count', () => {
+    expect(shouldRearmInsteadOfFire({ midToolCall: false, rearmCount: 0, maxRearms: 20 })).toBe(false)
+    expect(shouldRearmInsteadOfFire({ midToolCall: false, rearmCount: 5, maxRearms: 20 })).toBe(false)
+  })
+
+  it('rearm count transitions: 0 → cap-1 → cap fires', () => {
+    const max = ORPHANED_REPLY_MAX_REARMS
+    for (let i = 0; i < max; i++) {
+      expect(shouldRearmInsteadOfFire({ midToolCall: true, rearmCount: i, maxRearms: max })).toBe(true)
+    }
+    // At exactly the cap: fire
+    expect(shouldRearmInsteadOfFire({ midToolCall: true, rearmCount: max, maxRearms: max })).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Tests: DEFENSIVE fix — synthetic turn_end suppressor
+// ---------------------------------------------------------------------------
+
+describe('DEFENSIVE fix: synthetic turn_end suppressor', () => {
+  it('suppresses a synthetic turn_end (durationMs === -1) when tools are in flight', () => {
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: -1, midToolCall: true })).toBe(true)
+  })
+
+  it('does NOT suppress a synthetic turn_end when no tools are in flight', () => {
+    // No tools → the backstop should fire normally (turn is genuinely orphaned)
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: -1, midToolCall: false })).toBe(false)
+  })
+
+  it('does NOT suppress an authoritative turn_end (durationMs >= 0)', () => {
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: 0, midToolCall: true })).toBe(false)
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: 1, midToolCall: true })).toBe(false)
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: 12345, midToolCall: true })).toBe(false)
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: 0, midToolCall: false })).toBe(false)
+  })
+
+  it('only durationMs === -1 is the synthetic discriminator', () => {
+    // Values near -1 must not accidentally trigger suppression
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: -2, midToolCall: true })).toBe(false)
+    expect(shouldSuppressSyntheticTurnEnd({ durationMs: -0.5, midToolCall: true })).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Tests: ToolFlightTracker integration with the guard logic
+// ---------------------------------------------------------------------------
+
+describe('ToolFlightTracker + guard integration', () => {
+  it('re-arm fires when a Bash tool is in flight', () => {
+    const tracker = new ToolFlightTracker()
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'bash_1' })
+
+    expect(shouldRearmInsteadOfFire({
+      midToolCall: tracker.isMidToolCall(),
+      rearmCount: 0,
+      maxRearms: ORPHANED_REPLY_MAX_REARMS,
+    })).toBe(true)
+  })
+
+  it('fires normally after tool_result completes the tool', () => {
+    const tracker = new ToolFlightTracker()
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'bash_1' })
+    tracker.onEvent({ kind: 'tool_result', toolUseId: 'bash_1' })
+
+    expect(shouldRearmInsteadOfFire({
+      midToolCall: tracker.isMidToolCall(),
+      rearmCount: 0,
+      maxRearms: ORPHANED_REPLY_MAX_REARMS,
+    })).toBe(false)
+  })
+
+  it('defensive guard suppresses synthetic turn_end mid-Bash', () => {
+    const tracker = new ToolFlightTracker()
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'bash_2' })
+
+    expect(shouldSuppressSyntheticTurnEnd({
+      durationMs: -1,
+      midToolCall: tracker.isMidToolCall(),
+    })).toBe(true)
+  })
+
+  it('defensive guard allows synthetic turn_end after all tools complete', () => {
+    const tracker = new ToolFlightTracker()
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'bash_2' })
+    tracker.onEvent({ kind: 'tool_result', toolUseId: 'bash_2' })
+
+    expect(shouldSuppressSyntheticTurnEnd({
+      durationMs: -1,
+      midToolCall: tracker.isMidToolCall(),
+    })).toBe(false)
+  })
+
+  it('parallel tools: re-arm persists while ANY tool is in flight', () => {
+    const tracker = new ToolFlightTracker()
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'read_1' })
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'read_2' })
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'edit_1' })
+
+    // Still re-arming: 3 tools open
+    expect(shouldRearmInsteadOfFire({
+      midToolCall: tracker.isMidToolCall(),
+      rearmCount: 0,
+      maxRearms: ORPHANED_REPLY_MAX_REARMS,
+    })).toBe(true)
+
+    // Two complete
+    tracker.onEvent({ kind: 'tool_result', toolUseId: 'read_1' })
+    tracker.onEvent({ kind: 'tool_result', toolUseId: 'read_2' })
+
+    // Still re-arming: edit_1 open
+    expect(shouldRearmInsteadOfFire({
+      midToolCall: tracker.isMidToolCall(),
+      rearmCount: 1,
+      maxRearms: ORPHANED_REPLY_MAX_REARMS,
+    })).toBe(true)
+
+    // All complete
+    tracker.onEvent({ kind: 'tool_result', toolUseId: 'edit_1' })
+
+    expect(shouldRearmInsteadOfFire({
+      midToolCall: tracker.isMidToolCall(),
+      rearmCount: 2,
+      maxRearms: ORPHANED_REPLY_MAX_REARMS,
+    })).toBe(false)
+  })
+
+  it('cap fires even mid-tool after 20 re-arms (wedged tool surfaces)', () => {
+    const tracker = new ToolFlightTracker()
+    tracker.onEvent({ kind: 'tool_use', toolUseId: 'hung_bash' })
+
+    // First 20 re-arms proceed
+    for (let i = 0; i < ORPHANED_REPLY_MAX_REARMS; i++) {
+      expect(shouldRearmInsteadOfFire({
+        midToolCall: tracker.isMidToolCall(),
+        rearmCount: i,
+        maxRearms: ORPHANED_REPLY_MAX_REARMS,
+      })).toBe(true)
+    }
+
+    // 21st: cap exceeded — fire despite in-flight
+    expect(shouldRearmInsteadOfFire({
+      midToolCall: tracker.isMidToolCall(),
+      rearmCount: ORPHANED_REPLY_MAX_REARMS,
+      maxRearms: ORPHANED_REPLY_MAX_REARMS,
+    })).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Tests: shouldArmOrphanedReplyTimeout (existing surface, unchanged)
+// ---------------------------------------------------------------------------
+
+describe('shouldArmOrphanedReplyTimeout (existing — unchanged by this fix)', () => {
+  it('arms when conditions are met', () => {
+    expect(
+      shouldArmOrphanedReplyTimeout({
+        currentSessionChatId: '123',
+        capturedTextCount: 1,
+        replyCalled: false,
+      }),
+    ).toBe(true)
+  })
+
+  it('does not arm after reply has been called', () => {
+    expect(
+      shouldArmOrphanedReplyTimeout({
+        currentSessionChatId: '123',
+        capturedTextCount: 5,
+        replyCalled: true,
+      }),
+    ).toBe(false)
+  })
+
+  it('does not arm when no chat is active', () => {
+    expect(
+      shouldArmOrphanedReplyTimeout({
+        currentSessionChatId: null,
+        capturedTextCount: 1,
+        replyCalled: false,
+      }),
+    ).toBe(false)
+  })
+
+  it('does not arm when no text captured yet', () => {
+    expect(
+      shouldArmOrphanedReplyTimeout({
+        currentSessionChatId: '123',
+        capturedTextCount: 0,
+        replyCalled: false,
+      }),
+    ).toBe(false)
+  })
+})