switchroom 0.18.7 → 0.18.9

package/telegram-plugin/tests/mental-model-name-entity-corruption.test.ts

@@ -0,0 +1,119 @@
+/**
+ * Regression coverage for #2976 — HTML-entity corruption in mental-model
+ * fields, config-write-boundary layer.
+ *
+ * Reachability (stated plainly so these tests don't over-claim):
+ *   - `source_query` decode is the REACHABLE/load-bearing half: a proposal's
+ *     free-form query can carry escaped entities the model copied out of its
+ *     Telegram-HTML context, and undecoded it steers recall on `R&D`
+ *     instead of `R&D`.
+ *   - `name` decode is REDUNDANT with the gateway slug gate
+ *     (/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/ rejects an entity-bearing name before
+ *     `buildMentalModelAppendDiff` ever runs). It's belt-and-suspenders; the
+ *     name-path tests here exercise the boundary directly (bypassing the gate)
+ *     to prove the normalization, NOT to imply the propose path could carry the
+ *     bug.
+ *   - The observed in-NAME corruption (`Nutrition Protocol & Deficit
+ *     Status`, klanker 2026-07-06) actually arrived via the DIRECT
+ *     `create_mental_model` Hindsight tool, which this PR does not touch — that
+ *     vector is out of scope (steering.ts / Dockerfile.hindsight follow-ups).
+ *
+ * These tests pin the switchroom-owned WRITE-BOUNDARY normalization: name +
+ * source_query are decoded to their literal characters BEFORE synthesis into
+ * the config diff. Each assertion below FAILS against the pre-fix code (which
+ * serialized `spec.name` / `spec.source_query` verbatim) and passes after.
+ */
+
+import { describe, it, expect } from "vitest";
+import { parseDocument } from "yaml";
+import {
+  buildMentalModelAppendDiff,
+  readDeclaredMentalModelNames,
+  decodeCanonicalEntities,
+} from "../gateway/mental-model-propose-diff.js";
+
+const BASE_CONFIG = `agents:
+  klanker:
+    memory:
+      backend: hindsight
+`;
+
+/** Pull the appended model node out of the synthesized `after` config. */
+function appendedModel(after: string, agent = "klanker"): { name?: unknown; source_query?: unknown } {
+  const js = parseDocument(after).toJS() as {
+    agents: Record<string, { memory: { mental_models: Array<Record<string, unknown>> } }>;
+  };
+  const models = js.agents[agent]!.memory.mental_models;
+  return models[models.length - 1]!;
+}
+
+describe("decodeCanonicalEntities — single-pass, canonical six only", () => {
+  it("decodes each canonical entity to its literal character", () => {
+    expect(decodeCanonicalEntities("R&amp;D")).toBe("R&D");
+    expect(decodeCanonicalEntities("a&lt;b&gt;c")).toBe("a<b>c");
+    expect(decodeCanonicalEntities("say &quot;hi&quot;")).toBe('say "hi"');
+    expect(decodeCanonicalEntities("Ken&apos;s")).toBe("Ken's");
+    expect(decodeCanonicalEntities("Ken&#39;s")).toBe("Ken's");
+  });
+
+  it("undoes exactly ONE layer of escaping (double-escaped → single-escaped)", () => {
+    // We only reverse the escaping switchroom applied when rendering the model's
+    // own prior output — never the user's literal intent.
+    expect(decodeCanonicalEntities("R&amp;amp;D")).toBe("R&amp;D");
+    expect(decodeCanonicalEntities("&amp;lt;")).toBe("&lt;");
+  });
+
+  it("leaves entity-free text untouched (idempotent on clean input)", () => {
+    expect(decodeCanonicalEntities("Nutrition Protocol & Deficit")).toBe("Nutrition Protocol & Deficit");
+  });
+});
+
+describe("#2976 — propose write-boundary normalizes the mental-model name", () => {
+  it("stores the LITERAL '&' name, not the escaped '&amp;' the model emitted", () => {
+    const built = buildMentalModelAppendDiff({
+      configText: BASE_CONFIG,
+      agentName: "klanker",
+      spec: { name: "Nutrition Protocol &amp; Deficit Status", source_query: "how is the deficit?" },
+    });
+    expect(built.ok).toBe(true);
+    if (!built.ok) return;
+    expect(appendedModel(built.after).name).toBe("Nutrition Protocol & Deficit Status");
+    // And there is no residual entity anywhere in the persisted config.
+    expect(built.after).not.toContain("&amp;");
+    // Reading the declared names back yields the decoded literal.
+    expect(readDeclaredMentalModelNames(built.after, "klanker")).toContain(
+      "Nutrition Protocol & Deficit Status",
+    );
+  });
+
+  it("normalizes the recall-steering source_query too (not just the name)", () => {
+    const built = buildMentalModelAppendDiff({
+      configText: BASE_CONFIG,
+      agentName: "klanker",
+      spec: { name: "rd-budget", source_query: "what is the user&apos;s R&amp;D budget?" },
+    });
+    expect(built.ok).toBe(true);
+    if (!built.ok) return;
+    expect(appendedModel(built.after).source_query).toBe("what is the user's R&D budget?");
+  });
+
+  it("rejects an entity-escaped re-propose of an already-declared literal name (dup guard on decoded name)", () => {
+    const configWithModel = `agents:
+  klanker:
+    memory:
+      backend: hindsight
+      mental_models:
+        - name: Q3 R&D Plan
+          source_query: what is the plan?
+`;
+    const built = buildMentalModelAppendDiff({
+      configText: configWithModel,
+      agentName: "klanker",
+      // Escaped variant of the same logical name — must collide, not create a twin.
+      spec: { name: "Q3 R&amp;D Plan", source_query: "different query" },
+    });
+    expect(built.ok).toBe(false);
+    if (built.ok) return;
+    expect(built.error).toBe("duplicate");
+  });
+});

package/telegram-plugin/tests/mental-model-propose-callback-gate.test.ts

@@ -19,7 +19,14 @@ import { describe, expect, it } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 
-const gatewaySrc = readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8')
+// #2996 Phase 5: the callback-query handler families moved verbatim to
+// gateway/callback-query-handlers.ts; these pins read the gateway source
+// COMBINED with that module so the wiring assertions keep covering the
+// same runtime source text.
+const gatewaySrc =
+  readFileSync(resolve(__dirname, '..', 'gateway', 'gateway.ts'), 'utf-8') +
+  '\n' +
+  readFileSync(resolve(__dirname, '..', 'gateway', 'callback-query-handlers.ts'), 'utf-8')
 
 function proposeCallbackBlock(): string {
   return (

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

@@ -201,7 +201,7 @@ describe("handleModelCommand — set", () => {
     const reply = await handleModelCommand({ kind: "set", model: "opus" }, deps);
     expect(calls).toEqual([{ agent: "klanker", command: "/model opus" }]);
     expect(reply.text).toContain("<pre>⏺ Set model to sonnet</pre>");
-    expect(reply.text).toContain("Session-only");
+    expect(reply.text).toContain("Sticky across switchroom-managed relaunches");
     expect(reply.html).toBe(true);
     // A verified confirmation records the live model so /status stays honest
     // (bug 1: the typed path never recorded the switch before).
@@ -444,7 +444,7 @@ describe("handleModelCommand — busy gate + honest unverified reporting", () =>
     const reply = await handleModelCommand({ kind: "set", model: "claude-bogus" }, deps);
     expect(reply.text).toContain("did not take");
     expect(reply.text).toContain("Model not found");
-    expect(reply.text).not.toContain("Session-only");
+    expect(reply.text).not.toContain("Sticky across switchroom-managed relaunches");
     expect(reply.selectedModel).toBeUndefined();
   });
 

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

@@ -76,6 +76,47 @@ describe('detectModelUnavailable — overload / 429 / 5xx strings', () => {
   })
 })
 
+describe('detectModelUnavailable — transient upstream 429 vs account quota (#2922)', () => {
+  // The load-bearing regression: a server-side transient 429 whose message
+  // explicitly negates the account-quota reading ("not your usage limit")
+  // was misclassified as `quota_exhausted` by the negation-blind "usage limit"
+  // substring, firing a phantom fleet failover + dead turn. It must classify
+  // as `overload` (the calm rate-limit path Claude Code retries internally).
+  it("classifies the live-incident 'not your usage limit' 429 as overload, NOT quota_exhausted", () => {
+    const raw =
+      "API Error: Server is temporarily limiting requests (not your usage limit) · " +
+      'b\'{"type":"error","error":{"type":"rate_limit_error","message":' +
+      '"This request would exceed your account\'s rate limit. Please try again later."}}\''
+    const d = detectModelUnavailable(raw)
+    expect(d?.kind).toBe('overload')
+    expect(d?.kind).not.toBe('quota_exhausted')
+  })
+
+  it("classifies bare 'temporarily limiting requests' as overload", () => {
+    expect(
+      detectModelUnavailable('Server is temporarily limiting requests')?.kind,
+    ).toBe('overload')
+  })
+
+  it("classifies \"would exceed your account's rate limit\" as overload", () => {
+    expect(
+      detectModelUnavailable(
+        "This request would exceed your account's rate limit. Please try again later.",
+      )?.kind,
+    ).toBe('overload')
+  })
+
+  it('still classifies a genuine account usage-limit hit as quota_exhausted', () => {
+    // Guard against over-correction: real quota exhaustion must stay quota.
+    expect(
+      detectModelUnavailable("You've hit your limit · resets 8:50am (Australia/Melbourne)")?.kind,
+    ).toBe('quota_exhausted')
+    expect(detectModelUnavailable('Reached usage limit for the 5h window')?.kind).toBe(
+      'quota_exhausted',
+    )
+  })
+})
+
 describe('detectModelUnavailable — network failures', () => {
   it('classifies ECONNREFUSED', () => {
     expect(detectModelUnavailable('connect ECONNREFUSED 1.2.3.4:443')?.kind).toBe('network')

package/telegram-plugin/tests/outbound-send-chunks.test.ts

@@ -0,0 +1,304 @@
+/**
+ * Invocable send-loop harness (#2996 step 1).
+ *
+ * PR 3007 extracted the deterministic text/chunk CORE of the outbound path but
+ * noted the side-effecting send ORCHESTRATION could not be moved (or tested)
+ * without an "invocable-executeReply harness" — because gateway.ts is not
+ * importable in any test runner: it runs boot logic (acquires the PID lock,
+ * `process.exit(1)` when another gateway is live) and calls `Bun.listen` at
+ * import time, so `executeReply` can never be driven from vitest/bun in-place.
+ *
+ * This harness closes that gap for the highest-bug-density mechanic of the send
+ * path — the chunk-send loop with its THREAD_NOT_FOUND / oversize re-split /
+ * parse-reject fallback ladder and partial-failure contract (exactly where the
+ * recent oversize / wire-cap fixes landed). `sendReplyChunks` was relocated
+ * VERBATIM from executeReply and is now driven here against a FAKE bot API,
+ * asserting: multi-chunk send order, partial-failure contract (which chunks
+ * report sent), oversize re-send, HTML parse-reject plaintext fallback,
+ * THREAD_NOT_FOUND thread-drop + retry, keyboard-on-last-chunk passthrough,
+ * preview edit-in-place, and voice-only text suppression.
+ *
+ * The gateway keeps the raw `bot.api.*` calls as thin injected adapters; the
+ * module is bot-agnostic, so a fake is a plain record of function calls. The
+ * cross-surface `outboundDedup` singleton contract is covered by the sibling
+ * `outbound-send-path.test.ts` (a stream-path `record` suppresses a reply-path
+ * `check` on the same instance) — dedup lives in executeReply, not in this
+ * relocated loop, so it is intentionally out of scope here.
+ */
+import { describe, it, expect } from 'vitest'
+import { GrammyError } from 'grammy'
+import {
+  sendReplyChunks,
+  type ReplyChunkSendDeps,
+  type ReplyChunkSendState,
+} from '../gateway/outbound-send-path.js'
+
+// Build a GrammyError with a given 400 description (grammy 1.44 ctor shape).
+function grammy400(description: string, method = 'sendRichMessage'): GrammyError {
+  return new GrammyError(
+    `Call to '${method}' failed! (400: ${description})`,
+    { ok: false, error_code: 400, description },
+    method,
+    {},
+  )
+}
+
+interface RecordedCall {
+  kind: 'sendRich' | 'sendLiteral' | 'sendLiteralRaw' | 'sendRichRaw' | 'editPreview'
+  opts: Record<string, unknown>
+  body: unknown
+  threadId?: number | undefined
+  messageId?: number
+}
+
+/**
+ * Fake bot surface. `sendRich`/`sendLiteral` are the retry-wrapped adapters;
+ * `*Raw` are the unwrapped last-resort adapters; `editPreview` is the
+ * preview edit-in-place. Each records its call; per-kind `failers` inject
+ * one-shot errors (keyed by chunk-body identity or call index) so we can
+ * script the fallback ladder deterministically.
+ */
+function makeFake(opts?: {
+  failNext?: Partial<Record<RecordedCall['kind'], Array<unknown>>>
+  richMessage?: (s: string) => unknown
+}): {
+  deps: ReplyChunkSendDeps
+  calls: RecordedCall[]
+  stderr: string[]
+  logs: Array<{ id: number; chars: number; extra?: string }>
+  deleted: number[]
+} {
+  const calls: RecordedCall[] = []
+  const stderr: string[] = []
+  const logs: Array<{ id: number; chars: number; extra?: string }> = []
+  const deleted: number[] = []
+  let nextId = 1000
+  const queues = opts?.failNext ?? {}
+
+  const maybeFail = (kind: RecordedCall['kind']): void => {
+    const q = queues[kind]
+    if (q && q.length > 0) {
+      const e = q.shift()
+      if (e != null) throw e
+    }
+  }
+  const send = (
+    kind: RecordedCall['kind'],
+    o: Record<string, unknown>,
+    body: unknown,
+    threadId?: number | undefined,
+  ): Promise<{ message_id: number }> => {
+    // Evaluate the failure queue synchronously so a thrown GrammyError
+    // rejects the returned promise exactly as the real adapter would.
+    return (async () => {
+      maybeFail(kind)
+      const id = ++nextId
+      calls.push({ kind, opts: o, body, threadId, messageId: id })
+      return { message_id: id }
+    })()
+  }
+
+  const deps: ReplyChunkSendDeps = {
+    sendRich: (o, body, tid) => send('sendRich', o, body, tid),
+    sendLiteral: (o, txt, tid) => send('sendLiteral', o, txt, tid),
+    sendLiteralRaw: (o, txt) => send('sendLiteralRaw', o, txt),
+    sendRichRaw: (o, body) => send('sendRichRaw', o, body),
+    editPreview: async (mid, body, o, tid) => {
+      maybeFail('editPreview')
+      calls.push({ kind: 'editPreview', opts: o, body, threadId: tid, messageId: mid })
+      return {}
+    },
+    richMessage: opts?.richMessage ?? ((s: string) => ({ rich: s })),
+    logOutbound: (_path, _chat, id, chars, extra) => { logs.push({ id, chars, extra }) },
+    deleteStalePreview: async (id) => { deleted.push(id) },
+    stderr: (s) => { stderr.push(s) },
+  }
+  return { deps, calls, stderr, logs, deleted }
+}
+
+function baseState(over: Partial<ReplyChunkSendState> & { chunks: string[] }): ReplyChunkSendState {
+  return {
+    chatId: '555',
+    literalText: false,
+    suppressText: false,
+    threadId: undefined,
+    previewMessageId: null,
+    sentIds: [],
+    buildSendOpts: (i, isLastChunk, tid) => ({
+      ...(tid != null ? { message_thread_id: tid } : {}),
+      ...(isLastChunk ? { _last: true } : {}),
+      _chunkIndex: i,
+    }),
+    buildPreviewEditOpts: () => ({}),
+    ...over,
+  }
+}
+
+describe('sendReplyChunks — multi-chunk send order', () => {
+  it('sends every chunk in order and appends ids to the shared sentIds array', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['a', 'b', 'c'] })
+    const res = await sendReplyChunks(deps, state)
+    expect(calls.map((c) => c.kind)).toEqual(['sendRich', 'sendRich', 'sendRich'])
+    expect(calls.map((c) => c.body)).toEqual([{ rich: 'a' }, { rich: 'b' }, { rich: 'c' }])
+    // ids appended in order, one per chunk
+    expect(state.sentIds).toHaveLength(3)
+    expect(state.sentIds).toEqual([...state.sentIds].sort((x, y) => x - y))
+    expect(res.threadId).toBeUndefined()
+  })
+
+  it('literal (format:text) chunks route through sendLiteral, never rich', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['x', 'y'], literalText: true })
+    await sendReplyChunks(deps, state)
+    expect(calls.map((c) => c.kind)).toEqual(['sendLiteral', 'sendLiteral'])
+    expect(calls.map((c) => c.body)).toEqual(['x', 'y'])
+  })
+
+  it('voice-only suppressText sends NOTHING (voice note IS the reply)', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['a', 'b'], suppressText: true })
+    await sendReplyChunks(deps, state)
+    expect(calls).toHaveLength(0)
+    expect(state.sentIds).toHaveLength(0)
+  })
+})
+
+describe('sendReplyChunks — keyboard/opts passthrough', () => {
+  it('reply_markup rides ONLY on the last chunk (isLastChunk gate)', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({
+      chunks: ['one', 'two', 'three'],
+      buildSendOpts: (i, isLastChunk, tid) => ({
+        ...(tid != null ? { message_thread_id: tid } : {}),
+        ...(isLastChunk ? { reply_markup: { inline_keyboard: [[{ text: 'Go', callback_data: 'x' }]] } } : {}),
+      }),
+    })
+    await sendReplyChunks(deps, state)
+    expect(calls[0].opts.reply_markup).toBeUndefined()
+    expect(calls[1].opts.reply_markup).toBeUndefined()
+    expect(calls[2].opts.reply_markup).toBeDefined()
+  })
+
+  it('rich path strips link_preview_options before sending (rich entity previews)', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({
+      chunks: ['only'],
+      buildSendOpts: () => ({ link_preview_options: { is_disabled: true }, keepme: 1 }),
+    })
+    await sendReplyChunks(deps, state)
+    expect(calls[0].opts.link_preview_options).toBeUndefined()
+    expect(calls[0].opts.keepme).toBe(1)
+  })
+})
+
+describe('sendReplyChunks — partial-failure contract', () => {
+  it('an unrecoverable error midway propagates, and sentIds holds ONLY the chunks already sent', async () => {
+    // chunk 0 ok, chunk 1 throws a non-400 (not length, not parse) → rethrow.
+    const boom = new Error('network exploded')
+    const { deps, calls } = makeFake({ failNext: { sendRich: [undefined, boom] } })
+    const state = baseState({ chunks: ['first', 'second', 'third'] })
+    await expect(sendReplyChunks(deps, state)).rejects.toThrow('network exploded')
+    // first chunk reported sent; second/third never appended.
+    expect(state.sentIds).toHaveLength(1)
+    // exactly one send succeeded (chunk 1 threw before being recorded).
+    expect(calls.filter((c) => c.kind === 'sendRich')).toHaveLength(1)
+  })
+})
+
+describe('sendReplyChunks — oversize re-send', () => {
+  it('a RICH_MESSAGE_TEXT_TOO_LONG on the wrapped send re-splits via the raw rich adapter', async () => {
+    // A chunk far past the wire cap so resplitOversizeChunk yields >1 piece.
+    const huge = 'x'.repeat(70_000)
+    const { deps, calls } = makeFake({ failNext: { sendRich: [grammy400('RICH_MESSAGE_TEXT_TOO_LONG')] } })
+    const state = baseState({ chunks: [huge] })
+    await sendReplyChunks(deps, state)
+    const raws = calls.filter((c) => c.kind === 'sendRichRaw')
+    expect(raws.length).toBeGreaterThan(1)
+    // every re-split piece landed a message id
+    expect(state.sentIds.length).toBe(raws.length)
+  })
+})
+
+describe('sendReplyChunks — parse-reject plaintext fallback', () => {
+  it("a can't-parse-entities 400 resends the chunk as plain text via sendLiteralRaw", async () => {
+    const { deps, calls } = makeFake({ failNext: { sendRich: [grammy400("can't parse entities: bad offset")] } })
+    const state = baseState({ chunks: ['**bad markdown'] })
+    await sendReplyChunks(deps, state)
+    expect(calls.map((c) => c.kind)).toEqual(['sendLiteralRaw'])
+    expect(calls[0].body).toBe('**bad markdown')
+    expect(state.sentIds).toHaveLength(1)
+  })
+
+  it('an empty chunk parse-reject falls back to the placeholder glyph', async () => {
+    const { deps, calls } = makeFake({ failNext: { sendRich: [grammy400("can't parse entities")] } })
+    const state = baseState({ chunks: [''] })
+    await sendReplyChunks(deps, state)
+    expect(calls[0].kind).toBe('sendLiteralRaw')
+    expect(String(calls[0].body)).toContain('could not be rendered')
+  })
+})
+
+describe('sendReplyChunks — THREAD_NOT_FOUND fallback', () => {
+  it('drops the thread and retries UNWRAPPED, and returns threadId undefined', async () => {
+    // wrapped send throws THREAD_NOT_FOUND; retry (raw) succeeds.
+    const tnf = new Error('THREAD_NOT_FOUND')
+    const { deps, calls } = makeFake({ failNext: { sendRich: [tnf] } })
+    const state = baseState({ chunks: ['hi'], threadId: 42 })
+    const res = await sendReplyChunks(deps, state)
+    // The first (wrapped) attempt threw before recording; the retry uses
+    // sendChunk(_, false) → the UNWRAPPED raw adapter, deliberately not
+    // re-entering the retry policy after a dropped thread.
+    expect(calls[0].kind).toBe('sendRichRaw')
+    // retry re-built opts WITHOUT the thread id.
+    expect(res.threadId).toBeUndefined()
+    expect(calls[0].opts.message_thread_id).toBeUndefined()
+    expect(state.sentIds).toHaveLength(1)
+  })
+
+  it('THREAD_NOT_FOUND then a length error on retry re-splits', async () => {
+    const tnf = new Error('THREAD_NOT_FOUND')
+    const huge = 'y'.repeat(70_000)
+    const { deps, calls } = makeFake({
+      failNext: { sendRich: [tnf], sendRichRaw: [grammy400('MESSAGE_TOO_LONG')] },
+    })
+    const state = baseState({ chunks: [huge], threadId: 7 })
+    await sendReplyChunks(deps, state)
+    // retry (raw) threw length → resplit sent multiple raw pieces
+    const raws = calls.filter((c) => c.kind === 'sendRichRaw')
+    expect(raws.length).toBeGreaterThan(1)
+  })
+})
+
+describe('sendReplyChunks — preview edit-in-place', () => {
+  it('edits the stale preview on the first chunk, consumes it, then sends the rest fresh', async () => {
+    const { deps, calls } = makeFake()
+    const state = baseState({ chunks: ['a', 'b'], previewMessageId: 900 })
+    const res = await sendReplyChunks(deps, state)
+    expect(calls[0].kind).toBe('editPreview')
+    expect(calls[0].messageId).toBe(900)
+    // preview id consumed → subsequent chunk is a fresh send
+    expect(calls[1].kind).toBe('sendRich')
+    expect(res.previewMessageId).toBeNull()
+    // first sentId is the reused preview id
+    expect(state.sentIds[0]).toBe(900)
+  })
+
+  it('a failed preview edit deletes the stale preview and sends fresh', async () => {
+    const { deps, calls, deleted } = makeFake({ failNext: { editPreview: [new Error('message to edit not found')] } })
+    const state = baseState({ chunks: ['a'], previewMessageId: 901 })
+    const res = await sendReplyChunks(deps, state)
+    expect(deleted).toEqual([901])
+    expect(calls.some((c) => c.kind === 'sendRich')).toBe(true)
+    expect(res.previewMessageId).toBeNull()
+  })
+
+  it('a "not modified" preview edit is treated as success (id reused, no fresh send)', async () => {
+    const { deps, calls, deleted } = makeFake({ failNext: { editPreview: [new Error('Bad Request: message is not modified')] } })
+    const state = baseState({ chunks: ['a'], previewMessageId: 902 })
+    await sendReplyChunks(deps, state)
+    expect(deleted).toEqual([])
+    expect(state.sentIds).toEqual([902])
+    expect(calls.filter((c) => c.kind === 'sendRich')).toHaveLength(0)
+  })
+})