switchroom 0.13.4 → 0.13.7

package/telegram-plugin/gateway/gateway.ts

@@ -264,7 +264,7 @@ import { createInboundSpool } from './inbound-spool.js'
 import { purgeStaleTurnsForChat } from './turn-state-purge.js'
 import { decideInboundDelivery } from './inbound-delivery-gate.js'
 import { createPendingPermissionBuffer } from './pending-permission-decisions.js'
-import { chatKey, chatKeyWithSuffix } from './chat-key.js'
+import { chatKey, chatKeyWithSuffix, chatIdOfChatKey } from './chat-key.js'
 // Phase 2b PR 2 — shadow mode. Each event-site below calls shadowEmit()
 // to record what the InboundDeliveryStateMachine PREDICTS the gateway
 // should do. Behavior unchanged in this PR — the imperative code below
@@ -1310,6 +1310,13 @@ function purgeReactionTracking(key: string, endingTurn?: CurrentTurn): void {
   activeStatusReactions.delete(key)
   activeReactionMsgIds.delete(key)
   activeTurnStartedAt.delete(key)
+  // Human-feel UX: stop the turn-long `typing…` indicator started in
+  // the turn-start block. `purgeReactionTracking` is the canonical
+  // turn-end, so this is the single owner of the stop. (If an abnormal
+  // abort skips purge, the stray loop self-heals: the next turn on this
+  // chat calls `startTurnTypingLoop`, which stops the old interval
+  // first.)
+  stopTurnTypingLoop(chatIdOfChatKey(key as _ChatKey))
   if (msgInfo) {
     const agentDir = resolveAgentDirFromEnv()
     if (agentDir != null) removeActiveReaction(agentDir, msgInfo.chatId, msgInfo.messageId)
@@ -1781,6 +1788,32 @@ function stopTypingLoop(chat_id: string): void {
   if (retry) { clearTimeout(retry); typingRetryTimers.delete(chat_id) }
 }
 
+// Turn-level `typing…` indicator. Deliberately a SEPARATE interval map
+// from `typingIntervals` (which the reply handler and the tool-use
+// typing wrapper share and freely stop). If the turn loop lived in the
+// shared map, a mid-turn reply's `finally { stopTypingLoop }` would
+// kill it and the chat would go dark for the rest of the turn — the
+// exact black-box gap this is here to close. A dedicated map makes the
+// turn loop structurally immune to those stops: only `stopTurnTypingLoop`
+// (called at the canonical turn-end) clears it. The redundant `typing`
+// pings while a reply is mid-flight are harmless — same action, and
+// sendChatAction is cheap.
+const turnTypingIntervals = new Map<string, ReturnType<typeof setInterval>>()
+
+function startTurnTypingLoop(chat_id: string): void {
+  stopTurnTypingLoop(chat_id)
+  const send = () => {
+    void bot.api.sendChatAction(chat_id, 'typing').catch(() => {})
+  }
+  send()
+  turnTypingIntervals.set(chat_id, setInterval(send, 4000))
+}
+
+function stopTurnTypingLoop(chat_id: string): void {
+  const iv = turnTypingIntervals.get(chat_id)
+  if (iv) { clearInterval(iv); turnTypingIntervals.delete(chat_id) }
+}
+
 const typingWrapper = createTypingWrapper({
   startTypingLoop,
   stopTypingLoop,
@@ -7563,6 +7596,16 @@ async function handleInbound(
         // the framework can nudge the model if it goes quiet past the
         // soft / firm thresholds.
         silencePoke.startTurn(statusKey(chat_id, messageThreadId), Date.now())
+        // Human-feel UX: hold a continuous `typing…` indicator for the
+        // WHOLE turn, not just the split-second a reply is transmitted.
+        // A person you message shows as typing the entire time they
+        // compose; switchroom used to fire only one-shot ~5s pings, so
+        // any turn that read a file or thought for a moment went dark
+        // after 5s. Self-renews every 4s; stopped at the canonical
+        // turn-end (`purgeReactionTracking → stopTurnTypingLoop`).
+        // Deterministic, framework-owned, no prose — the mechanical
+        // ambient layer of the pacing contract.
+        startTurnTypingLoop(chat_id)
         // #1122 KPI: emit turn_started so dashboards can compute funnel
         // start counts + correlate to turn_ended for duration / TTFO.
         emitRuntimeMetric({
@@ -14111,6 +14154,8 @@ async function shutdown(signal: string): Promise<void> {
 
   for (const iv of [...typingIntervals.values()]) clearInterval(iv)
   typingIntervals.clear()
+  for (const iv of [...turnTypingIntervals.values()]) clearInterval(iv)
+  turnTypingIntervals.clear()
   for (const t of [...typingRetryTimers.values()]) clearTimeout(t)
   typingRetryTimers.clear()
 

package/telegram-plugin/model-unavailable.ts

@@ -80,6 +80,10 @@ export function detectModelUnavailable(
     'quota_exhausted',
     'plan limit',
     'subscription limit',
+    // Claude Code v2.1.x usage-limit wording: "You've hit your limit ·
+    // resets 8:50am (Australia/Melbourne)".
+    'hit your limit',
+    'hit the limit',
   ]
   if (quotaSignals.some(s => lower.includes(s))) {
     const resetAt = parseResetTime(sample)

package/telegram-plugin/runtime-metrics.ts

@@ -19,6 +19,7 @@
 import { existsSync, mkdirSync, appendFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { captureEvent } from './analytics-posthog.js'
+import type { PokeLevel } from './silence-poke.js'
 
 export type RuntimeMetricEvent =
   /**
@@ -62,28 +63,33 @@ export type RuntimeMetricEvent =
       ended_via: 'reply' | 'stream_reply_done' | 'silent' | 'forced' | 'framework_fallback'
     }
   /**
-   * Framework safety-net: a silence-poke was armed at 75s (soft) or
-   * 180s (firm). The system-reminder appended to the next tool result
-   * nudges the model to send an update. Doubles as a design-health
-   * signal — if these fire frequently, the conversational-pacing
-   * prompt isn't doing its job.
+   * Framework safety-net: a silence-poke was armed. `ack` is the early
+   * (~10s) ack-budget poke — the model has sent NOTHING this turn and is
+   * leaving the user on a silent chat. `soft` (75s) / `firm` (180s) are
+   * the silence-since-last-outbound ladder. The system-reminder appended
+   * to the next tool result nudges the model to send an update. Doubles
+   * as a design-health signal — if these fire frequently, the
+   * conversational-pacing prompt isn't doing its job.
    */
   | {
       kind: 'silence_poke_fired'
       key: string
-      level: 'soft' | 'firm'
+      level: PokeLevel
       silence_ms: number
       subagent_wait: boolean
     }
   /**
    * The model sent an outbound message within the success window
    * (default 15s) after a poke fired. Pair with `silence_poke_fired`
-   * to compute success rate — the design target is >80%.
+   * to compute success rate — the design target is >80%. (`ack`-level
+   * success is not currently emitted — the ack poke sits outside the
+   * `pokesFired` ladder noteOutbound measures against; the type admits
+   * `ack` only so the silence-poke metric union stays assignable.)
    */
   | {
       kind: 'silence_poke_succeeded'
       key: string
-      level: 'soft' | 'firm'
+      level: PokeLevel
       latency_ms: number
     }
   /**

package/telegram-plugin/session-tail.ts

@@ -423,6 +423,33 @@ export function detectErrorInTranscriptLine(
 
   const type = obj.type as string | undefined
 
+  // Claude Code (v2.1.x) records a usage-limit / API error as a
+  // SYNTHETIC ASSISTANT MESSAGE, not an api_error / error line:
+  //   { type: "assistant",
+  //     message: { role: "assistant",
+  //       content: [{ type: "text", text: "You've hit your limit · resets …" }] },
+  //     error: "rate_limit", isApiErrorMessage: true, apiErrorStatus: 429 }
+  // It has no `api_error`/`error` top-type and no nested error OBJECT
+  // (`error` is a bare string), so the structured checks below miss it
+  // entirely. That silent miss is what kept fleet auto-fallback from
+  // ever firing on a quota hit — the exhaustion signal never reached
+  // the operator-event path. Detect this shape explicitly.
+  if (obj.isApiErrorMessage === true) {
+    const status =
+      typeof obj.apiErrorStatus === 'number' ? obj.apiErrorStatus : null
+    const errStr = typeof obj.error === 'string' ? obj.error : ''
+    const text = extractAssistantText(obj)
+    // A 429 in this shape is a subscription usage-limit hit (it carries
+    // a reset time) — classify it quota-exhausted so the operator event
+    // resolves to an auto-fallback-eligible kind. Other statuses fall
+    // through to the shared classifier.
+    const kind: OperatorEventKind =
+      status === 429
+        ? 'quota-exhausted'
+        : classifyClaudeError({ type: errStr, status, message: text })
+    return { kind, raw: obj, detail: text || errStr || 'api error' }
+  }
+
   // Explicit error line types from Claude Code JSONL
   const isErrorLine = type === 'api_error' || type === 'error'
 
@@ -454,6 +481,32 @@ function extractDetailMessage(obj: Record<string, unknown> | null): string | nul
   return typeof msg === 'string' && msg.length > 0 ? msg : null
 }
 
+/**
+ * Pull the human-readable text out of a synthetic assistant message
+ * (`message.content[].text`, joined). Used for the v2.1.x
+ * `isApiErrorMessage` shape, where the user-facing error string lives
+ * inside the assistant message rather than in an `error` object.
+ * Returns '' for any non-conforming shape — never throws.
+ */
+function extractAssistantText(obj: Record<string, unknown>): string {
+  const message = obj.message
+  if (typeof message !== 'object' || message == null) return ''
+  const content = (message as Record<string, unknown>).content
+  if (!Array.isArray(content)) return ''
+  const parts: string[] = []
+  for (const block of content) {
+    if (
+      typeof block === 'object'
+      && block != null
+      && (block as Record<string, unknown>).type === 'text'
+    ) {
+      const t = (block as Record<string, unknown>).text
+      if (typeof t === 'string') parts.push(t)
+    }
+  }
+  return parts.join(' ').trim()
+}
+
 // ─── The tail watcher ─────────────────────────────────────────────────────
 
 /** Emitted to onOperatorEvent when the tail detects a Claude API error. */

package/telegram-plugin/silence-poke.ts

@@ -43,7 +43,7 @@
  * pacing prompt still applies; only the framework safety net is off.
  */
 
-export type PokeLevel = 'soft' | 'firm'
+export type PokeLevel = 'ack' | 'soft' | 'firm'
 
 /** #1292: snapshot of an in-flight tool call, surfaced in the 300s
  * framework-fallback message so the user sees the actual observable
@@ -76,6 +76,10 @@ export interface SilencePokeState {
   lastThinkingAt: number | null
   /** True once the 300s framework fallback has fired this turn. */
   fallbackFired: boolean
+  /** True once the early ack-budget poke has fired this turn. One-shot:
+   *  the ack nudge is specifically about the *first* outbound, so it
+   *  never re-arms even after the model later goes quiet again. */
+  ackPokeFired: boolean
   /** Wall-clock ms of last poke fire — used for poke-success latency. */
   lastPokeFiredAt: number | null
   /** #1292: in-flight tool calls keyed by toolUseId. Populated by
@@ -91,6 +95,12 @@ export interface SilencePokeState {
 }
 
 export interface ThresholdsMs {
+  /** Ack budget: if NO outbound at all has landed this many ms after
+   *  turn start, arm an 'ack' poke. This is the framework enforcing the
+   *  human-baseline "acknowledge within a beat" — far tighter than the
+   *  75s `soft` threshold, which measures silence-since-last-outbound
+   *  and is the wrong instrument for "you never said hello." */
+  ack: number
   soft: number
   firm: number
   fallback: number
@@ -101,6 +111,7 @@ export interface ThresholdsMs {
 }
 
 export const DEFAULT_THRESHOLDS: ThresholdsMs = {
+  ack: 10_000,
   soft: 75_000,
   firm: 180_000,
   fallback: 300_000,
@@ -176,6 +187,7 @@ export function startTurn(key: string, now: number): void {
     subagentDispatchActive: false,
     lastThinkingAt: null,
     fallbackFired: false,
+    ackPokeFired: false,
     lastPokeFiredAt: null,
     inFlightTools: new Map(),
   })
@@ -340,6 +352,16 @@ export function endTurn(key: string): void {
 
 /** Verbatim poke text. Wording is load-bearing — see issue #1122 design. */
 export function formatPokeText(level: PokeLevel): string {
+  if (level === 'ack') {
+    return (
+      "[silence-poke] You haven't sent the user anything yet this turn — "
+      + 'they are looking at a silent chat. Send a short, human one-line '
+      + 'acknowledgement now via `reply` (e.g. "on it — checking"), in your '
+      + "persona's voice, before you do any more work. A good colleague "
+      + "answers in a beat; don't leave the message hanging while you think. "
+      + 'If the full answer is genuinely seconds away, send that instead.'
+    )
+  }
   if (level === 'soft') {
     return (
       "[silence-poke] You've been silent to the user for 75s. If you're "
@@ -437,6 +459,32 @@ function tick(now: number): void {
       ? thresholds.subagentSoft
       : thresholds.soft
 
+    // Ack budget — the framework enforcing the human-baseline "answer
+    // in a beat." Fires once, only when NOTHING has been sent this turn
+    // (`lastOutboundAt == null`), well before the 75s `soft` threshold.
+    // `soft` measures silence-since-last-outbound and is the wrong
+    // instrument for "you never acknowledged me." Independent of the
+    // soft/firm/fallback ladder: if the model never acks, it still
+    // escalates soft → firm → fallback on schedule after this.
+    if (
+      !s.ackPokeFired
+      && s.lastOutboundAt == null
+      && s.pokesFired === 0
+      && silence >= thresholds.ack
+    ) {
+      s.pokeArmed = { level: 'ack' }
+      s.ackPokeFired = true
+      s.lastPokeFiredAt = now
+      activeDeps.emitMetric({
+        kind: 'silence_poke_fired',
+        key,
+        level: 'ack',
+        silence_ms: silence,
+        subagent_wait: s.subagentDispatchActive,
+      })
+      continue
+    }
+
     if (s.pokesFired === 0 && silence >= softThreshold) {
       s.pokeArmed = { level: 'soft' }
       s.pokesFired = 1

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

@@ -42,6 +42,15 @@ describe('detectModelUnavailable — quota / billing strings', () => {
   it('classifies "quota exhausted" verbatim', () => {
     expect(detectModelUnavailable('quota exhausted on slot main')?.kind).toBe('quota_exhausted')
   })
+
+  it("classifies Claude Code v2.1.x 'You've hit your limit' wording", () => {
+    // The exact text claude writes inside the synthetic
+    // isApiErrorMessage assistant message on a subscription quota hit.
+    const d = detectModelUnavailable(
+      "You've hit your limit · resets 8:50am (Australia/Melbourne)",
+    )
+    expect(d?.kind).toBe('quota_exhausted')
+  })
 })
 
 describe('detectModelUnavailable — overload / 429 / 5xx strings', () => {

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

@@ -70,6 +70,49 @@ describe('detectErrorInTranscriptLine — error detection', () => {
     expect(detectErrorInTranscriptLine(line)).toBeNull()
   })
 
+  // Regression — the fleet-auto-failover dead-zone. Claude Code v2.1.x
+  // records a usage-limit hit as a synthetic assistant message with
+  // isApiErrorMessage:true (no api_error type, no nested error OBJECT).
+  // Pre-fix, detectErrorInTranscriptLine missed it entirely → the
+  // operator-event path never ran → fleet auto-fallback never fired.
+  it('detects the v2.1.x synthetic-assistant-message usage-limit shape', () => {
+    // The exact on-disk line shape, verbatim from a real quota hit.
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        role: 'assistant',
+        model: '<synthetic>',
+        content: [
+          {
+            type: 'text',
+            text: "You've hit your limit · resets 8:50am (Australia/Melbourne)",
+          },
+        ],
+      },
+      error: 'rate_limit',
+      isApiErrorMessage: true,
+      apiErrorStatus: 429,
+    })
+    const result = detectErrorInTranscriptLine(line)
+    expect(result).not.toBeNull()
+    // A 429 in this shape is a subscription usage-limit hit → must
+    // classify quota-exhausted so the operator event resolves to an
+    // auto-fallback-eligible kind.
+    expect(result!.kind).toBe('quota-exhausted')
+    // The user-facing text must survive into `detail` (the model-
+    // unavailable card + the text-pattern path both rely on it).
+    expect(result!.detail).toContain('hit your limit')
+  })
+
+  it('still returns null for a normal (non-error) assistant message', () => {
+    // No isApiErrorMessage flag → must NOT be treated as an error.
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: { role: 'assistant', content: [{ type: 'text', text: 'Done.' }] },
+    })
+    expect(detectErrorInTranscriptLine(line)).toBeNull()
+  })
+
   it('returns null for lines with null error field', () => {
     const line = JSON.stringify({ type: 'assistant', error: null })
     expect(detectErrorInTranscriptLine(line)).toBeNull()

package/telegram-plugin/tests/silence-poke.test.ts

@@ -33,7 +33,15 @@ function setupDeps(opts?: { thresholds?: Partial<typeof DEFAULT_THRESHOLDS> }):
   __setDepsForTests({
     emitMetric: (e) => fixtures.emitted.push(e),
     onFrameworkFallback: (ctx) => { fixtures.fallbacks.push(ctx) },
-    thresholdsMs: { ...DEFAULT_THRESHOLDS, ...(opts?.thresholds ?? {}) },
+    // The ack budget (a new poke that fires *earlier* than `soft`) is
+    // disabled by default in this fixture so the soft/firm/fallback
+    // ladder tests stay isolated from it. The 'ack budget' describe
+    // block opts back in with a real value.
+    thresholdsMs: {
+      ...DEFAULT_THRESHOLDS,
+      ack: Number.MAX_SAFE_INTEGER,
+      ...(opts?.thresholds ?? {}),
+    },
   })
   return fixtures
 }
@@ -139,6 +147,127 @@ describe('silence-poke — escalation ladder', () => {
   })
 })
 
+// PR1 (human-feel UX epic): the ack budget. A person you message
+// answers in a beat — the framework enforces that baseline by arming an
+// 'ack' poke if NOTHING has been sent within `thresholds.ack` of turn
+// start. It is a one-shot nudge (the model still authors every word),
+// deliberately OUTSIDE the soft/firm/fallback `pokesFired` ladder: if
+// the model never acks, the ladder still escalates on its own schedule.
+// See `reference/conversational-pacing.md` and the "Open with an
+// acknowledgement" bullet in `profiles/_shared/telegram-style.md.hbs`.
+//
+// NB: `setupDeps` disables the ack budget by default (ack = MAX_SAFE);
+// every test here opts back in with a real `ack` threshold.
+describe('silence-poke — ack budget (PR1 human-feel UX)', () => {
+  it('arms an ack poke at the ack threshold when nothing has been sent', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+
+    __tickForTests(9_000) // before the ack budget
+    expect(consumeArmedPoke()).toBeNull()
+    expect(fx.emitted).toHaveLength(0)
+
+    __tickForTests(10_000) // at the ack budget
+    expect(fx.emitted).toEqual([
+      expect.objectContaining({ kind: 'silence_poke_fired', level: 'ack' }),
+    ])
+    const text = consumeArmedPoke()
+    expect(text).toContain('[silence-poke]')
+    expect(text).toContain('reply')
+  })
+
+  it('does NOT arm an ack poke if an outbound landed before the budget', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    noteOutbound('chat:0', 3_000) // model acked fast — inside the budget
+    __tickForTests(10_000)
+    __tickForTests(20_000)
+    expect(consumeArmedPoke()).toBeNull()
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'ack'),
+    ).toHaveLength(0)
+  })
+
+  it('is one-shot — never re-arms even if the model goes quiet again', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    __tickForTests(10_000)         // ack fires
+    consumeArmedPoke()             // drain it
+    noteOutbound('chat:0', 12_000) // model finally acks
+    // The model goes quiet again. The ack poke is specifically about the
+    // FIRST outbound — it must not fire twice. A later silence is the
+    // soft poke's job, not the ack budget's.
+    __tickForTests(40_000)
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'ack'),
+    ).toHaveLength(1)
+  })
+
+  it('ackPokeFired resets across turns even when endTurn was skipped (CC-5 invariant)', () => {
+    // Mirrors the subagentDispatchActive CC-5 guard: `ackPokeFired` is a
+    // turn-scoped one-shot flag, and the only thing that keeps it from
+    // leaking into the next turn (when an abnormal abort skips endTurn)
+    // is startTurn's unconditional state overwrite. Pin that here so a
+    // future read-modify-write refactor of startTurn fails loud.
+    setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('k', 0)
+    __tickForTests(10_000) // ack fires
+    expect(__getStateForTests('k')?.ackPokeFired).toBe(true)
+    // Turn 2 in the same key, no endTurn — startTurn MUST clear the flag.
+    startTurn('k', 1_000_000)
+    expect(__getStateForTests('k')?.ackPokeFired).toBe(false)
+  })
+
+  it('does not advance the ladder — soft still requires a full 75s of silence', () => {
+    // The ack poke is deliberately outside `pokesFired`. After it fires,
+    // a soft poke must still wait the normal 75s.
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    __tickForTests(10_000) // ack
+    consumeArmedPoke()
+    __tickForTests(70_000) // 70s total — under the 75s soft threshold
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'soft'),
+    ).toHaveLength(0)
+    __tickForTests(75_000)
+    expect(
+      fx.emitted.filter((e) => e.kind === 'silence_poke_fired' && e.level === 'soft'),
+    ).toHaveLength(1)
+  })
+
+  it('still escalates ack -> soft -> firm -> fallback on a turn that never acks', () => {
+    const fx = setupDeps({ thresholds: { ack: 10_000 } })
+    startTurn('chat:0', 0)
+    __tickForTests(10_000)  // ack
+    consumeArmedPoke()
+    __tickForTests(75_000)  // soft
+    consumeArmedPoke()
+    __tickForTests(180_000) // firm
+    consumeArmedPoke()
+    __tickForTests(300_000) // fallback
+    const trail = fx.emitted.map((e) =>
+      e.kind === 'silence_poke_fired'
+        ? `poke:${e.level}`
+        : e.kind === 'silence_fallback_sent'
+          ? `fallback:${e.fallback_kind}`
+          : e.kind,
+    )
+    expect(trail).toEqual([
+      'poke:ack',
+      'poke:soft',
+      'poke:firm',
+      'fallback:working',
+    ])
+  })
+
+  it('formatPokeText("ack") nudges for a human acknowledgement via reply', () => {
+    const text = formatPokeText('ack')
+    expect(text).toContain('[silence-poke]')
+    expect(text.toLowerCase()).toContain('acknowledg')
+    expect(text).toContain('reply')
+  })
+})
+
 describe('silence-poke — outbound resets clock + success measurement', () => {
   it('noteOutbound resets the silence clock', () => {
     setupDeps()
@@ -608,7 +737,9 @@ describe('silence-poke — fallback handler errors do not break timer', () => {
     __setDepsForTests({
       emitMetric: (e) => fx.emitted.push(e),
       onFrameworkFallback: () => { throw new Error('oh no') },
-      thresholdsMs: DEFAULT_THRESHOLDS,
+      // ack budget out of the way — this test exercises the
+      // soft/firm/fallback ladder under a throwing fallback handler.
+      thresholdsMs: { ...DEFAULT_THRESHOLDS, ack: Number.MAX_SAFE_INTEGER },
     })
     startTurn('k', 0)
     expect(() => {
@@ -625,7 +756,8 @@ describe('silence-poke — fallback handler errors do not break timer', () => {
     __setDepsForTests({
       emitMetric: (e) => fx.emitted.push(e),
       onFrameworkFallback: () => Promise.reject(new Error('async fail')),
-      thresholdsMs: DEFAULT_THRESHOLDS,
+      // ack budget out of the way — see the throwing-handler test above.
+      thresholdsMs: { ...DEFAULT_THRESHOLDS, ack: Number.MAX_SAFE_INTEGER },
     })
     startTurn('k', 0)
     __tickForTests(75_000)