switchroom 0.18.17 → 0.18.18

package/telegram-plugin/tests/permission-title.test.ts

@@ -156,25 +156,188 @@ describe('formatPermissionCardBody', () => {
     expect(body).toContain('why: _listing temp files_')
   })
 
-  test('shows "not provided" when no caller reason is present (never the description)', () => {
+  // #3167: no caller reason → an honest synthesized `context:` line built
+  // from the tool's salient input, NEVER a bare "why: not provided" and never
+  // the static schema description. The distinct `context:` label keeps the
+  // agent's omission of a rationale visible.
+  test('synthesizes a context line when no caller reason is present (never "not provided" / the description)', () => {
     const body = formatPermissionCardBody({
       toolName: 'Bash',
       inputPreview: JSON.stringify({ command: 'ls /tmp' }),
       description: 'Run a shell command on the host.',
       agentName: 'gymbro',
     })
-    expect(body).toContain('why: _not provided_')
+    expect(body).not.toContain('not provided')
     expect(body).not.toContain('Run a shell command')
+    expect(body).toContain('context: _command: ls /tmp_')
   })
 
-  test('shows "not provided" when caller reason is whitespace only', () => {
+  test('synthesizes context when the caller reason is whitespace only', () => {
     const body = formatPermissionCardBody({
       toolName: 'Bash',
       inputPreview: JSON.stringify({ command: 'ls /tmp', reason: '   \n ' }),
       description: 'Run a shell command.',
       agentName: 'gymbro',
     })
-    expect(body).toContain('why: _not provided_')
+    expect(body).not.toContain('not provided')
+    expect(body).toContain('context: _command: ls /tmp_')
+  })
+
+  // #3167 root case: the `reply` tool (and react/edit_message/…) carries NO
+  // `reason` argument, so its cards used to render a contentless
+  // "🔐 Clerk wants to reply / why: not provided". Now the reply text is
+  // synthesized onto a `context:` line so the operator has something to judge.
+  test('reply (no reason arg) synthesizes the reply text as context, not "not provided"', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({
+        chat_id: '12345',
+        text: "On it — pulling yesterday's GitHub activity now.",
+        format: 'html',
+        disable_notification: true,
+      }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    const lines = body.split('\n')
+    expect(lines[0]).toBe('🔐 **Clerk** wants to reply')
+    expect(body).not.toContain('not provided')
+    // Salient field surfaced (truncated); id/routing/formatting noise stripped.
+    expect(body).toContain('context: _text: On it — pulling')
+    expect(body).toMatch(/context: _text: On it — pulling[^_]*…_/)
+    expect(body).not.toContain('chat_id')
+    expect(body).not.toContain('disable_notification')
+    expect(body).not.toContain('format')
+  })
+
+  test('a reason ON a reply card still renders as why:, not context: (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({
+        chat_id: '12345',
+        text: 'done',
+        reason: 'answering the operator’s status question',
+      }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).toContain('why: _answering the operator’s status question_')
+    expect(body).not.toContain('context:')
+  })
+
+  test('synthesized context redacts secrets in the salient input (#3167)', () => {
+    const fakeToken = 'sk-ant-' + 'api03-' + 'B'.repeat(48)
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({ chat_id: '1', text: `here is the key: ${fakeToken}` }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).toContain('context:')
+    expect(body).not.toContain(fakeToken)
+  })
+
+  test('falls back to the natural action when the input exposes nothing salient (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'ExitPlanMode',
+      inputPreview: undefined,
+      description: 'Exit plan mode.',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain('not provided')
+    expect(body).toContain('context: _exit plan mode_')
+  })
+
+  // #3167 review (HIGH/MEDIUM): the salient-value redactor must catch secrets
+  // the bare-value path missed. redact() excludes generic_high_entropy and the
+  // contextual kv detectors need a `key=value` shape — so a prefixless token
+  // under a credential-shaped key leaked verbatim. These FAIL pre-fix.
+  test('hard-masks a prefixless high-entropy value under a `token` key (#3167)', () => {
+    // No sk-/ghp-/JWT prefix — shape detection alone cannot catch it; only the
+    // key-name signal ("token") does.
+    const bare = 'Zx8Kq2Lm9Rn4Tv6Wb1Yc3Hd5Jf7Ug0Pe'
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__acme__do',
+      inputPreview: JSON.stringify({ token: bare, note: 'ping' }),
+      description: 'do a thing',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain(bare)
+    // `token` value is hard-masked; the benign `note` still surfaces.
+    expect(body).toContain('token:')
+    expect(body).toContain('REDACTED')
+    expect(body).toContain('note: ping')
+  })
+
+  test('hard-masks a 40-hex secret under a `secret`-shaped key (#3167)', () => {
+    const hex = 'a3f1'.repeat(10) // 40 hex chars, no prefix
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__acme__do',
+      inputPreview: JSON.stringify({ webhook_secret: hex }),
+      description: 'do a thing',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain(hex)
+    expect(body).toContain('REDACTED')
+  })
+
+  test('masks a non-http DSN credential embedded in free text (redactUrls misses it) (#3167)', () => {
+    // Under a benign key (`text`) so the hard-mask key path does NOT fire —
+    // this exercises the NON_HTTP_DSN_RE scheme coverage specifically.
+    const dsn = 'postgres://user:S3cretPass99@db.host:5432/app'
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({ chat_id: '1', text: `connect via ${dsn} then run` }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain('S3cretPass99')
+    expect(body).not.toContain(dsn)
+    expect(body).toContain('REDACTED')
+  })
+
+  test('hard-masks a DATABASE_URL under a url-shaped key (#3167)', () => {
+    const dsn = 'postgres://admin:hunter2pass@10.0.0.5/prod'
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__acme__migrate',
+      inputPreview: JSON.stringify({ database_url: dsn }),
+      description: 'run a migration',
+      agentName: 'clerk',
+    })
+    expect(body).not.toContain('hunter2pass')
+    expect(body).not.toContain(dsn)
+    expect(body).toContain('REDACTED')
+  })
+
+  // #3167 review (LOW-2): acceptance asks for "tool + summarized input +
+  // originating turn" — surface a compact origin-turn reference when present.
+  test('appends a compact originating-turn reference when origin_turn_id is present (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__switchroom-telegram__reply',
+      inputPreview: JSON.stringify({ chat_id: '1', text: 'hi', origin_turn_id: 'turn-abcdef123456' }),
+      description: 'Reply on Telegram.',
+      agentName: 'clerk',
+    })
+    expect(body).toContain('· turn …ef123456')
+    // The raw routing id is NOT dumped as its own kv pair.
+    expect(body).not.toContain('origin_turn_id:')
+  })
+
+  // #3167 review (LOW-3): raw commands/text now reach the context line, so a
+  // markdown metachar in the value must be escaped or it can spoof/break the
+  // card's own `_italic_` / `code` formatting.
+  test('escapes markdown metachars in the synthesized context value (#3167)', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'Bash',
+      inputPreview: JSON.stringify({ command: 'echo _a_ *b* `c`' }),
+      description: 'run a shell command',
+      agentName: 'clerk',
+    })
+    // The metachars are backslash-escaped so they can't open emphasis/code.
+    expect(body).toContain('\\_a\\_')
+    expect(body).toContain('\\*b\\*')
+    expect(body).toContain('\\`c\\`')
+    expect(body).not.toContain('echo _a_ *b* `c`')
   })
 
   test('drops the agent prefix when agentName is null (early-boot edge)', () => {

package/telegram-plugin/tests/premium-recovery-wiring.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Integration test for the premium-recovery ping GLUE
+ * (`runPremiumRecoveryPing`, premium-recovery-wiring.ts) — the never-storm
+ * orchestration the pure `decidePremiumRecovery` / `renderPremiumRecoveryPing`
+ * tests do NOT cover. This is the P0 at-most-once guarantee (claim-gate → clear-
+ * marker-before-send → per-chat fan-out) that was inline in the gateway and so
+ * had ZERO coverage; the same untested-glue gap the tier-downgrade extraction
+ * closed for the downgrade path.
+ *
+ * It drives the real runner with injected seams and PINS:
+ *   - clear-BEFORE-send ordering (never-storm) + exactly one send per chat;
+ *   - claim !granted → marker cleared, NO send;
+ *   - decision.fire === false → no clear, no claim, no send;
+ *   - no marker / no agent dir → no-op;
+ *   - the button `callback_data` is EXACTLY `mdl:alias:<premium>` (a future edit
+ *     can't silently break the session-scoped switch-back path).
+ * These are outcome assertions that FAIL if the guard logic is reordered/dropped.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  runPremiumRecoveryPing,
+  type PremiumRecoveryPingDeps,
+  type PremiumRecoveryMarkerView,
+  type PremiumRecoveryKeyboard,
+} from '../gateway/premium-recovery-wiring.js'
+import type { PremiumRecoveryPing } from '../premium-recovery.js'
+
+interface Recorder {
+  /** Ordered event log — pins clear-before-send. */
+  events: string[]
+  clears: number
+  claims: string[]
+  sends: Array<{ chatId: string; ping: PremiumRecoveryPing; keyboard: PremiumRecoveryKeyboard }>
+  decides: number
+  logs: string[]
+}
+
+function makeDeps(
+  over: {
+    agentDir?: string | null
+    marker?: PremiumRecoveryMarkerView | null
+    fire?: boolean
+    granted?: boolean
+    fallbackChats?: string[]
+  } = {},
+): { deps: PremiumRecoveryPingDeps; rec: Recorder } {
+  const rec: Recorder = { events: [], clears: 0, claims: [], sends: [], decides: 0, logs: [] }
+  const deps: PremiumRecoveryPingDeps = {
+    getAgentDir: () => (over.agentDir === undefined ? '/tmp/agent' : over.agentDir),
+    readMarker: () =>
+      over.marker === undefined
+        ? { premiumModel: 'fable', chats: ['111', '222'] }
+        : over.marker,
+    clearMarker: () => {
+      rec.clears += 1
+      rec.events.push('clear')
+    },
+    getAgent: () => 'klanker',
+    decide: () => {
+      rec.decides += 1
+      return over.fire === undefined ? true : over.fire
+    },
+    claimNotification: async (key) => {
+      rec.claims.push(key)
+      return over.granted === undefined ? true : over.granted
+    },
+    fallbackChats: () => over.fallbackChats ?? ['999'],
+    sendToChat: (chatId, ping, keyboard) => {
+      rec.sends.push({ chatId, ping, keyboard })
+      rec.events.push(`send:${chatId}`)
+    },
+    log: (msg) => rec.logs.push(msg),
+  }
+  return { deps, rec }
+}
+
+describe('runPremiumRecoveryPing — never-storm at-most-once ordering', () => {
+  it('fire + granted: marker cleared BEFORE any send, exactly one send per chat', async () => {
+    const { deps, rec } = makeDeps({ marker: { premiumModel: 'fable', chats: ['111', '222'] } })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.clears).toBe(1)
+    // One send per recorded chat, in order, no duplicates.
+    expect(rec.sends.map((s) => s.chatId)).toEqual(['111', '222'])
+    // The clear MUST precede the first send (a double-send is unrecoverable).
+    const clearIdx = rec.events.indexOf('clear')
+    const firstSendIdx = rec.events.findIndex((e) => e.startsWith('send:'))
+    expect(clearIdx).toBeGreaterThanOrEqual(0)
+    expect(firstSendIdx).toBeGreaterThanOrEqual(0)
+    expect(clearIdx).toBeLessThan(firstSendIdx)
+    // The fleet claim was keyed on agent + the dropped premium token.
+    expect(rec.claims).toEqual(['premium-recovery:klanker:fable'])
+    expect(rec.logs).toHaveLength(1)
+  })
+
+  it('claim NOT granted: marker cleared (no lingering re-attempt), NO send', async () => {
+    const { deps, rec } = makeDeps({ granted: false })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.claims).toEqual(['premium-recovery:klanker:fable'])
+    expect(rec.clears).toBe(1)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('decision.fire === false: NO clear, NO claim, NO send (marker survives for a later tick)', async () => {
+    const { deps, rec } = makeDeps({ fire: false })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.decides).toBe(1)
+    expect(rec.clears).toBe(0)
+    expect(rec.claims).toHaveLength(0)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('no marker present: no-op — no decide, no claim, no clear, no send', async () => {
+    const { deps, rec } = makeDeps({ marker: null })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.decides).toBe(0)
+    expect(rec.clears).toBe(0)
+    expect(rec.claims).toHaveLength(0)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('no agent dir: immediate no-op (marker is never even read)', async () => {
+    const { deps, rec } = makeDeps({ agentDir: null })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.decides).toBe(0)
+    expect(rec.clears).toBe(0)
+    expect(rec.sends).toHaveLength(0)
+  })
+
+  it('marker with no chats falls back to the access allowFrom chats', async () => {
+    const { deps, rec } = makeDeps({
+      marker: { premiumModel: 'fable', chats: [] },
+      fallbackChats: ['999'],
+    })
+    await runPremiumRecoveryPing(deps)
+    expect(rec.sends.map((s) => s.chatId)).toEqual(['999'])
+  })
+})
+
+describe('runPremiumRecoveryPing — session-scoped switch-back button', () => {
+  it('the button callback_data is EXACTLY mdl:alias:<premium> (routes the model-menu apply path)', async () => {
+    const { deps, rec } = makeDeps({ marker: { premiumModel: 'fable', chats: ['111'] } })
+    await runPremiumRecoveryPing(deps)
+    const button = rec.sends[0].keyboard.inline_keyboard[0][0]
+    // Pin the exact wire format — a change to MODEL_CALLBACK_ALIAS or the button
+    // construction that broke the session-scoped `/model` apply path must fail here.
+    expect(button.callback_data).toBe('mdl:alias:fable')
+    expect(button.text).toBe('Switch to fable')
+  })
+})

package/telegram-plugin/tests/premium-recovery.test.ts

@@ -0,0 +1,165 @@
+/**
+ * Unit tests for the "premium model recovered" ping.
+ *
+ *  - `decidePremiumRecovery` is the PURE recovery predicate: fires iff a marker
+ *    is pending AND the broker shows the premium tier servable again (at least
+ *    one account neither `exhausted` nor `premium_walled`) — the exact
+ *    complement of the `all-blocked` condition that fired the downgrade. This
+ *    IS the deterministic recovery signal: both fields are the broker's live-
+ *    authoritative verdicts, so the ping never depends on model judgement.
+ *  - `renderPremiumRecoveryPing` pins the honest, session-scoped wording +
+ *    button label.
+ *  - `premiumRecoveryClaimKey` keys the fleet-wide dedup on agent + token.
+ *  - the `.premium-recovery` carrier round-trips + is shape-gated (parity with
+ *    the `.session-model` / `.session-effort` carriers).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, writeFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  decidePremiumRecovery,
+  renderPremiumRecoveryPing,
+  premiumRecoveryClaimKey,
+} from '../premium-recovery.js'
+import {
+  writePremiumRecoveryFile,
+  readPremiumRecoveryFile,
+  clearPremiumRecoveryFile,
+  parsePremiumRecovery,
+  PREMIUM_RECOVERY_FILE,
+} from '../gateway/session-model-file.js'
+
+describe('decidePremiumRecovery — deterministic recovery predicate', () => {
+  it('no marker → never fires', () => {
+    expect(
+      decidePremiumRecovery({ hasMarker: false, accounts: [{ exhausted: false, premiumWalled: false }] }),
+    ).toEqual({ fire: false, reason: 'no-marker' })
+  })
+
+  it('marker pending but EVERY account still walled/exhausted → no fire (still-walled)', () => {
+    const d = decidePremiumRecovery({
+      hasMarker: true,
+      accounts: [
+        { exhausted: true, premiumWalled: false },
+        { exhausted: false, premiumWalled: true },
+        { exhausted: true, premiumWalled: true },
+      ],
+    })
+    expect(d).toEqual({ fire: false, reason: 'still-walled' })
+  })
+
+  it('marker pending AND one account can serve the premium tier again → fire', () => {
+    const d = decidePremiumRecovery({
+      hasMarker: true,
+      accounts: [
+        { exhausted: true, premiumWalled: true },
+        { exhausted: false, premiumWalled: false }, // recovered
+      ],
+    })
+    expect(d).toEqual({ fire: true, reason: 'recovered' })
+  })
+
+  it('an account that is exhausted-but-not-premium-walled does NOT count as recovered', () => {
+    // The premium tier is only servable on an account that is BOTH not
+    // exhausted AND not premium-walled.
+    const d = decidePremiumRecovery({
+      hasMarker: true,
+      accounts: [{ exhausted: true, premiumWalled: false }],
+    })
+    expect(d.fire).toBe(false)
+  })
+
+  it('an account that is premium-walled-but-not-exhausted does NOT count as recovered', () => {
+    const d = decidePremiumRecovery({
+      hasMarker: true,
+      accounts: [{ exhausted: false, premiumWalled: true }],
+    })
+    expect(d.fire).toBe(false)
+  })
+
+  it('empty account list with a pending marker → no fire (nothing servable)', () => {
+    expect(decidePremiumRecovery({ hasMarker: true, accounts: [] }).fire).toBe(false)
+  })
+})
+
+describe('renderPremiumRecoveryPing — honest wording', () => {
+  it('names the model, says available again, and offers a session-scoped switch', () => {
+    const p = renderPremiumRecoveryPing('fable')
+    expect(p.text).toContain('`fable`')
+    expect(p.text.toLowerCase()).toContain('available again')
+    expect(p.text.toLowerCase()).toContain('this session')
+    expect(p.buttonText).toBe('Switch to fable')
+    // Must NOT over-promise a durable pin.
+    expect(p.text.toLowerCase()).not.toContain('permanently')
+    expect(p.text.toLowerCase()).not.toContain('forever')
+  })
+})
+
+describe('premiumRecoveryClaimKey', () => {
+  it('keys the dedup on agent + token so different drops never collide', () => {
+    expect(premiumRecoveryClaimKey('klanker', 'fable')).toBe('premium-recovery:klanker:fable')
+    expect(premiumRecoveryClaimKey('klanker', 'fable')).not.toBe(
+      premiumRecoveryClaimKey('klanker', 'opus'),
+    )
+  })
+})
+
+describe('.premium-recovery carrier — round-trip + shape gate', () => {
+  let dir: string
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'premium-recovery-'))
+  })
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it('write → read round-trips model + chats (a VALID marker is NOT swept)', () => {
+    writePremiumRecoveryFile(dir, 'fable', ['12345', '67890'])
+    const rec = readPremiumRecoveryFile(dir)
+    expect(rec?.premiumModel).toBe('fable')
+    expect(rec?.chats).toEqual(['12345', '67890'])
+    expect(typeof rec?.ts).toBe('number')
+    // A well-formed marker must survive a read — only corrupt files are swept.
+    expect(existsSync(join(dir, PREMIUM_RECOVERY_FILE))).toBe(true)
+  })
+
+  it('clear removes the marker', () => {
+    writePremiumRecoveryFile(dir, 'fable', ['12345'])
+    expect(existsSync(join(dir, PREMIUM_RECOVERY_FILE))).toBe(true)
+    clearPremiumRecoveryFile(dir)
+    expect(existsSync(join(dir, PREMIUM_RECOVERY_FILE))).toBe(false)
+    expect(readPremiumRecoveryFile(dir)).toBeNull()
+  })
+
+  it('refuses a non-canonical model token (shell-injection shape)', () => {
+    expect(() => writePremiumRecoveryFile(dir, 'bad name; rm -rf /', ['12345'])).toThrow()
+  })
+
+  it('refuses an empty chat list (a marker with nowhere to ping is a bug)', () => {
+    expect(() => writePremiumRecoveryFile(dir, 'fable', [])).toThrow()
+  })
+
+  it('parse rejects corrupt JSON / bad shape / bad token / empty chats', () => {
+    expect(parsePremiumRecovery('{broken')).toBeNull()
+    expect(parsePremiumRecovery(JSON.stringify({ premiumModel: 'fable', chats: [], ts: 1 }))).toBeNull()
+    expect(
+      parsePremiumRecovery(JSON.stringify({ premiumModel: 'bad;name', chats: ['1'], ts: 1 })),
+    ).toBeNull()
+    expect(
+      parsePremiumRecovery(JSON.stringify({ premiumModel: 'fable', chats: [1, 2], ts: 1 })),
+    ).toBeNull()
+    expect(parsePremiumRecovery(JSON.stringify({ premiumModel: 'fable', chats: ['1'] }))).toBeNull()
+  })
+
+  it('read returns null on a corrupt on-disk marker AND sweeps the garbled file', () => {
+    writeFileSync(join(dir, PREMIUM_RECOVERY_FILE), '{not json\n')
+    expect(existsSync(join(dir, PREMIUM_RECOVERY_FILE))).toBe(true)
+    expect(readPremiumRecoveryFile(dir)).toBeNull()
+    // LOW-1: a corrupt marker is garbage-collected on read so it can't linger
+    // forever (neither the ping path nor the manual-switch clear could ever
+    // delete it — both read null first).
+    expect(existsSync(join(dir, PREMIUM_RECOVERY_FILE))).toBe(false)
+  })
+})

package/telegram-plugin/tests/reaction-gate-routing.test.ts

@@ -130,7 +130,12 @@ describe('#3155 reactions route through the send gate (cosmetic)', () => {
     // The reaction actually reached the API (was admitted, not shed)...
     expect(setMessageReaction).toHaveBeenCalled()
     // ...and its 429 was recorded by the breaker — the whole gap this closes.
-    expect(onFloodWait).toHaveBeenCalledWith(7)
+    // #3111: the retry policy now also passes the call's opts so the gateway can
+    // open a scope-precise window (a reaction 429 implies only that chat).
+    expect(onFloodWait).toHaveBeenCalledWith(
+      7,
+      expect.objectContaining({ chat_id: 'chatA', priorityClass: 'cosmetic' }),
+    )
   })
 })
 

package/telegram-plugin/tests/retry-api-call.test.ts

@@ -576,6 +576,27 @@ describe('#2923 — LOCAL resource exhaustion is NOT retried (avoids flood ban)'
     expect(out).toBe('ok')
     expect(seen).toEqual([42])
   })
+
+  it('passes the call opts to onFloodWait so the gateway can open a scope-precise window (#3111)', async () => {
+    const seen: { sec: number; chat_id?: string; chatType?: string }[] = []
+    const sleep = vi.fn(async () => {})
+    let n = 0
+    const retry = createRetryApiCall({
+      maxRetries: 3,
+      sleep,
+      onFloodWait: (sec, opts) => seen.push({ sec, chat_id: opts?.chat_id, chatType: opts?.chatType }),
+    })
+    const out = await retry(
+      async () => {
+        if (n++ === 0) throw errors.floodWait(7)
+        return 'ok'
+      },
+      { chat_id: '42', chatType: 'supergroup' },
+    )
+    expect(out).toBe('ok')
+    // The hook received the same chat scope the send carried — not a bare number.
+    expect(seen).toEqual([{ sec: 7, chat_id: '42', chatType: 'supergroup' }])
+  })
 })
 
 describe('#3084 — a long flood ban fails FAST instead of sleeping for hours', () => {