switchroom 0.13.51 → 0.13.53

package/telegram-plugin/gateway/inbound-coalesce.ts

@@ -137,11 +137,24 @@ export function createInboundCoalescer<T>(opts: InboundCoalescerOptions<T>): Inb
 }
 
 /**
- * Build a coalesce key from `(chatId, userId)`. Identity-stable across
- * messages from the same sender in the same chat, distinct across
- * different senders so a user-driven reply isn't merged with a sibling
- * message from someone else in a group chat.
+ * Build a coalesce key from `(chatId, threadId, userId)`. Identity-stable
+ * across messages from the same sender in the same chat and topic,
+ * distinct across:
+ *   - different senders (so one user's typing isn't merged with another's)
+ *   - different topics (so a user typing in #planning isn't merged with
+ *     the same user's message in #admin — supergroup-mode invariant,
+ *     CPO decision #9 ratified 2026-05-27)
+ *
+ * `threadId` collapses `null`/`undefined`/`0` to `_` via the same
+ * convention as `chatKey()`. The 1.5s coalesce window is per-topic
+ * intent ("user sends 3 sentences as one thought") — applying it
+ * cross-topic merges genuinely separate conversations.
  */
-export function inboundCoalesceKey(chatId: string, userId: string): string {
-  return `${chatId}:${userId}`
+export function inboundCoalesceKey(
+  chatId: string,
+  threadId: number | null | undefined,
+  userId: string,
+): string {
+  const t = threadId == null || threadId === 0 ? '_' : String(threadId)
+  return `${chatId}:${t}:${userId}`
 }

package/telegram-plugin/stream-reply-handler.ts

@@ -23,6 +23,7 @@ import {
   type RetryPolicy,
 } from './stream-controller.js'
 import { sanitizeTelegramHtml } from './html-sanitize.js'
+import { chatKey, chatKeyWithSuffix } from './gateway/chat-key.js'
 
 /**
  * Builds the inline status-accent header line for `reply` / `stream_reply`.
@@ -311,14 +312,15 @@ function streamKey(
   lane?: string,
   turnKey?: string,
 ): string {
-  // Canonical chat-key derivation lives in gateway/chat-key.ts — keep this
-  // expression in lockstep with that helper (treats 0/null/undefined the
-  // same), but inline here so this file doesn't introduce a cross-package
-  // import for one expression. See #1564 for the sibling-key bug class.
-  const t = threadId == null || threadId === 0 ? '_' : String(threadId)
-  const base = `${chatId}:${t}`
-  const withLane = lane != null && lane.length > 0 ? `${base}:${lane}` : base
-  return turnKey != null && turnKey.length > 0 ? `${withLane}:${turnKey}` : withLane
+  // Adopt the canonical chatKey() / chatKeyWithSuffix() primitives from
+  // gateway/chat-key.ts (PR2 of supergroup mode — kills the previously
+  // inlined copy of the key expression). The brand erases to string at
+  // runtime, so callers using `streamKey` as a `Map<string, T>` key
+  // continue to work unchanged.
+  const base = lane != null && lane.length > 0
+    ? chatKeyWithSuffix(chatId, threadId ?? null, lane)
+    : chatKey(chatId, threadId ?? null)
+  return turnKey != null && turnKey.length > 0 ? `${base}:${turnKey}` : base
 }
 
 export async function handleStreamReply(

package/telegram-plugin/tests/gateway-disconnect-flush.test.ts

@@ -50,6 +50,14 @@ function makeDeps(agentName: string | null) {
     ['chat1:thr1:msg1', 100],
     ['chat2:thr2:msg2', 200],
   ])
+  // PR3b: claudeBusyKeys tracks turns actually handed to claude. In a
+  // healthy registered-disconnect scenario both maps would carry the
+  // same keys (delivery succeeded); the dangling-sweep tests below
+  // override individual deps to exercise the orphaned-key path.
+  const claudeBusyKeys = new Set<string>([
+    'chat1:thr1:msg1',
+    'chat2:thr2:msg2',
+  ])
   const activeDraftStreams = new Map<string, FakeStream>([
     ['chat1:thr1:r1', { isFinal: () => false, finalize: finalizeA }],
     ['chat2:thr2:r2', { isFinal: () => true, finalize: finalizeB }],
@@ -66,6 +74,7 @@ function makeDeps(agentName: string | null) {
       activeStatusReactions,
       activeReactionMsgIds,
       activeTurnStartedAt,
+      claudeBusyKeys,
       activeDraftStreams,
       activeDraftParseModes,
       clearActiveReactions,
@@ -169,6 +178,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
         ['ghost:thr:msg', { chatId: 'ghost', messageId: 42 }],
       ]),
       activeTurnStartedAt: new Map<string, number>([['ghost:thr:msg', 100]]),
+      claudeBusyKeys: new Set<string>(['ghost:thr:msg']),
       activeDraftStreams: new Map<string, FakeStream>(),
       activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
       clearActiveReactions,
@@ -179,6 +189,10 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
 
     flushOnAgentDisconnect(deps)
 
+    // PR3b: claudeBusyKeys swept alongside the activeTurnStartedAt
+    // dangling entry — both maps mirror each other on registered
+    // disconnects, so a key in one is always a key in the other.
+    expect(deps.claudeBusyKeys.size).toBe(0)
     // The sweep fired and cleared the dangling entry.
     expect(deps.activeTurnStartedAt.size).toBe(0)
     expect(deps.activeReactionMsgIds.size).toBe(0)
@@ -222,6 +236,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeStatusReactions: new Map<string, FakeCtrl>(),
       activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
       activeTurnStartedAt: new Map<string, number>([['real-turn:thr:msg', 100]]),
+      claudeBusyKeys: new Set<string>(['real-turn:thr:msg']),
       activeDraftStreams: new Map<string, FakeStream>(),
       activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
       clearActiveReactions: vi.fn(),
@@ -237,6 +252,106 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
     expect(onDanglingTurnsSwept).not.toHaveBeenCalled()
   })
 
+  // PR3b orphan-sweep regression: synthetic-inbound deliveries
+  // (cron, reactions, vault, button-callback) bypass handleInbound's
+  // fresh-turn branch and so never stamp activeTurnStartedAt. They
+  // DO mark claudeBusyKeys. If their turn dies without turn_end, the
+  // activeTurnStartedAt-keyed dangling sweep misses them — orphan
+  // persists in claudeBusyKeys → fleet gate wedges. This test pins
+  // the post-sweep claudeBusyKeys.clear() fix.
+  it('sweeps claudeBusyKeys orphans that have NO activeTurnStartedAt entry (PR3b follow-up)', () => {
+    const onDanglingTurnsSwept = vi.fn()
+    const log = vi.fn()
+    const deps = {
+      agentName: 'clerk',
+      activeStatusReactions: new Map<string, FakeCtrl>(),
+      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
+      activeTurnStartedAt: new Map<string, number>(),
+      // The orphan scenario: claude was handed a turn (e.g. cron
+      // synthetic delivered), so claudeBusyKeys has it, but
+      // activeTurnStartedAt was never set because cron bypasses
+      // handleInbound's fresh-turn branch.
+      claudeBusyKeys: new Set<string>(['cron-only-key:_']),
+      activeDraftStreams: new Map<string, FakeStream>(),
+      activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+      clearActiveReactions: vi.fn(),
+      disposeProgressDriver: vi.fn(),
+      onDanglingTurnsSwept,
+      log,
+    }
+
+    flushOnAgentDisconnect(deps)
+
+    // The orphan is cleared even though it never had an
+    // activeTurnStartedAt entry.
+    expect(deps.claudeBusyKeys.size).toBe(0)
+    // The activeTurnStartedAt-keyed sweep wasn't fired (nothing in
+    // that map to sweep) — so onDanglingTurnsSwept shouldn't fire
+    // either. The orphan sweep is a separate observation.
+    expect(onDanglingTurnsSwept).not.toHaveBeenCalled()
+    // But it logs the orphan-clear so operators can see it.
+    expect(
+      log.mock.calls.some((c: unknown[]) =>
+        typeof c[0] === 'string' && /orphan claudeBusyKeys/.test(c[0]),
+      ),
+    ).toBe(true)
+  })
+
+  it('orphan-sweep singular vs plural log message agrees with count', () => {
+    // Tiny grammar regression: "1 entry" vs "2 entries".
+    const log = vi.fn()
+    const baseDeps = {
+      agentName: 'clerk',
+      activeStatusReactions: new Map<string, FakeCtrl>(),
+      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
+      activeTurnStartedAt: new Map<string, number>(),
+      activeDraftStreams: new Map<string, FakeStream>(),
+      activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+      clearActiveReactions: vi.fn(),
+      disposeProgressDriver: vi.fn(),
+    }
+    // Singular form.
+    flushOnAgentDisconnect({
+      ...baseDeps,
+      claudeBusyKeys: new Set<string>(['k1:_']),
+      log,
+    })
+    expect(log.mock.calls.some((c: unknown[]) =>
+      typeof c[0] === 'string' && / 1 orphan claudeBusyKeys entry /.test(c[0]),
+    )).toBe(true)
+    // Plural form.
+    log.mockClear()
+    flushOnAgentDisconnect({
+      ...baseDeps,
+      claudeBusyKeys: new Set<string>(['k1:_', 'k2:1']),
+      log,
+    })
+    expect(log.mock.calls.some((c: unknown[]) =>
+      typeof c[0] === 'string' && / 2 orphan claudeBusyKeys entries /.test(c[0]),
+    )).toBe(true)
+  })
+
+  it('does NOT fire orphan-sweep log when claudeBusyKeys is empty', () => {
+    // Zero-noise discipline: every disconnect for a healthy idle
+    // agent shouldn't produce a "0 orphan claudeBusyKeys" line.
+    const log = vi.fn()
+    flushOnAgentDisconnect({
+      agentName: 'clerk',
+      activeStatusReactions: new Map<string, FakeCtrl>(),
+      activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
+      activeTurnStartedAt: new Map<string, number>(),
+      claudeBusyKeys: new Set<string>(),
+      activeDraftStreams: new Map<string, FakeStream>(),
+      activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
+      clearActiveReactions: vi.fn(),
+      disposeProgressDriver: vi.fn(),
+      log,
+    })
+    expect(log.mock.calls.some((c: unknown[]) =>
+      typeof c[0] === 'string' && /orphan claudeBusyKeys/.test(c[0]),
+    )).toBe(false)
+  })
+
   it('omitting onDanglingTurnsSwept is safe (optional callback)', () => {
     // Backward-compat guard — existing callers that don't pass the new
     // callback still work without runtime error.
@@ -245,6 +360,7 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       activeStatusReactions: new Map<string, FakeCtrl>(),
       activeReactionMsgIds: new Map<string, { chatId: string; messageId: number }>(),
       activeTurnStartedAt: new Map<string, number>([['ghost:thr:msg', 100]]),
+      claudeBusyKeys: new Set<string>(['ghost:thr:msg']),
       activeDraftStreams: new Map<string, FakeStream>(),
       activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
       clearActiveReactions: vi.fn(),

package/telegram-plugin/tests/inbound-coalesce.test.ts

@@ -21,10 +21,26 @@ beforeEach(() => { vi.useFakeTimers() })
 afterEach(() => { vi.useRealTimers() })
 
 describe('inboundCoalesceKey', () => {
-  it('combines chatId and userId so distinct senders never collide', () => {
-    expect(inboundCoalesceKey('c1', 'u1')).not.toBe(inboundCoalesceKey('c1', 'u2'))
-    expect(inboundCoalesceKey('c1', 'u1')).not.toBe(inboundCoalesceKey('c2', 'u1'))
-    expect(inboundCoalesceKey('c1', 'u1')).toBe(inboundCoalesceKey('c1', 'u1'))
+  it('combines chatId, threadId, and userId so distinct senders never collide', () => {
+    expect(inboundCoalesceKey('c1', null, 'u1')).not.toBe(inboundCoalesceKey('c1', null, 'u2'))
+    expect(inboundCoalesceKey('c1', null, 'u1')).not.toBe(inboundCoalesceKey('c2', null, 'u1'))
+    expect(inboundCoalesceKey('c1', null, 'u1')).toBe(inboundCoalesceKey('c1', null, 'u1'))
+  })
+
+  it('keeps the same user\'s messages in DIFFERENT topics in distinct buckets (supergroup-mode)', () => {
+    // CPO decision #9 ratified 2026-05-27: per-topic coalesce intent.
+    // The 1.5s window is "user sends 3 sentences as one thought" —
+    // applying it cross-topic merges genuinely separate conversations.
+    expect(inboundCoalesceKey('c1', 17, 'u1')).not.toBe(inboundCoalesceKey('c1', 23, 'u1'))
+    expect(inboundCoalesceKey('c1', 17, 'u1')).not.toBe(inboundCoalesceKey('c1', null, 'u1'))
+  })
+
+  it('collapses null / undefined / 0 thread IDs to the same key (chatKey convention)', () => {
+    const k1 = inboundCoalesceKey('c1', null, 'u1')
+    const k2 = inboundCoalesceKey('c1', undefined, 'u1')
+    const k3 = inboundCoalesceKey('c1', 0, 'u1')
+    expect(k1).toBe(k2)
+    expect(k1).toBe(k3)
   })
 })
 

package/telegram-plugin/tests/outbound-ordering.test.ts

@@ -170,6 +170,234 @@ describe('wrapBot — bot.api.* calls auto-lock by first-arg chat id', () => {
     expect(rb.message_id).toBe(20)
   })
 
+  it('SAME chat + DIFFERENT thread sendMessage calls dispatch concurrently (supergroup-mode unblock)', async () => {
+    // PR2 of supergroup-mode: chat-lock moved from chatId-only keying
+    // to (chat, thread) keying. Two topics in the same supergroup must
+    // not artificially serialize at the bot.api layer.
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dTopicA = deferred<{ message_id: number }>()
+    const dTopicB = deferred<{ message_id: number }>()
+    const started: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      started.push(`A:${t}`)
+      return dTopicA.promise
+    })
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      started.push(`B:${t}`)
+      return dTopicB.promise
+    })
+
+    // Same chatId "supergrp" but different message_thread_id.
+    const pA = wrapped.api.sendMessage('supergrp', 'planning msg', { message_thread_id: 17 })
+    const pB = wrapped.api.sendMessage('supergrp', 'cron digest', { message_thread_id: 23 })
+    await Promise.resolve(); await Promise.resolve()
+    // BOTH should have started — supergroup-mode parallelism guarantee.
+    expect(started).toEqual(['A:planning msg', 'B:cron digest'])
+
+    // Resolve B first; A's resolution must not delay B's return.
+    dTopicB.resolve({ message_id: 200 })
+    const rB = await pB
+    expect(rB.message_id).toBe(200)
+
+    dTopicA.resolve({ message_id: 100 })
+    const rA = await pA
+    expect(rA.message_id).toBe(100)
+  })
+
+  it('SAME chat + SAME thread sendMessage calls STILL serialize (per-topic ordering preserved)', async () => {
+    // Per-topic message order matters (a reply tied to a message_id
+    // must see that message exist first). The lock must still serialize
+    // within a topic.
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dSlow = deferred<{ message_id: number }>()
+    const startOrder: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      startOrder.push(`first:${t}`)
+      const r = await dSlow.promise
+      startOrder.push(`first:end:${t}`)
+      return r
+    })
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      startOrder.push(`second:${t}`)
+      return { message_id: 2 }
+    })
+
+    const p1 = wrapped.api.sendMessage('supergrp', 'first', { message_thread_id: 17 })
+    const p2 = wrapped.api.sendMessage('supergrp', 'second', { message_thread_id: 17 })
+
+    await Promise.resolve(); await Promise.resolve()
+    // Same thread → second waits for first.
+    expect(startOrder).toEqual(['first:first'])
+
+    dSlow.resolve({ message_id: 1 })
+    await Promise.all([p1, p2])
+    expect(startOrder).toEqual(['first:first', 'first:end:first', 'second:second'])
+  })
+
+  it('a 429 from one topic does NOT stall sends to a different topic in the same chat', async () => {
+    // CPO #8=B guardrail: when grammY's autoRetry transformer backs off
+    // on a 429 in topic A, topic B's sends must keep flowing. This test
+    // pins the contract by simulating a slow/rejecting first call (proxy
+    // for a 429+backoff path) on topic A and asserting topic B doesn't
+    // wait on it.
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    // Topic A's send hangs (proxy for an in-flight 429-backoff path);
+    // topic B's send must NOT wait on it.
+    const dTopicA = deferred<{ message_id: number }>()
+    const started: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async () => {
+      started.push('topicA:start')
+      return dTopicA.promise
+    })
+    bot.api.sendMessage.mockImplementationOnce(async () => {
+      started.push('topicB:start')
+      return { message_id: 2 }
+    })
+
+    const pA = wrapped.api.sendMessage('supergrp', 'overloaded', { message_thread_id: 17 })
+    const pB = wrapped.api.sendMessage('supergrp', 'unaffected', { message_thread_id: 23 })
+
+    // Topic B should complete WITHOUT waiting on topic A's hang.
+    const rB = await pB
+    expect(rB.message_id).toBe(2)
+    expect(started).toContain('topicB:start')
+
+    // Resolve A so the lock chain drains cleanly.
+    dTopicA.resolve({ message_id: 1 })
+    const rA = await pA
+    expect(rA.message_id).toBe(1)
+  })
+
+  it('strips message_thread_id=1 from sendMessage opts (General-topic Bot API quirk)', async () => {
+    // Telegram's General topic has id=1 at MTProto but the Bot API
+    // REJECTS message_thread_id=1 on send with HTTP 400 "message thread
+    // not found" (tdlib/telegram-bot-api#447). The wrapper strips id=1
+    // from the opts bag before the underlying API call.
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    bot.api.sendMessage.mockImplementationOnce(async () => ({ message_id: 1 }))
+
+    await wrapped.api.sendMessage('supergrp', 'hello General', { message_thread_id: 1 })
+
+    const callOpts = bot.api.sendMessage.mock.calls[0]![2]
+    expect(callOpts).toBeDefined()
+    expect((callOpts as Record<string, unknown>).message_thread_id).toBeUndefined()
+  })
+
+  it('preserves other opts when stripping message_thread_id=1', async () => {
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+    bot.api.sendMessage.mockImplementationOnce(async () => ({ message_id: 1 }))
+
+    await wrapped.api.sendMessage('supergrp', 'hello', {
+      message_thread_id: 1,
+      parse_mode: 'HTML',
+      reply_to_message_id: 42,
+    })
+
+    const callOpts = bot.api.sendMessage.mock.calls[0]![2] as Record<string, unknown>
+    expect(callOpts.message_thread_id).toBeUndefined()
+    expect(callOpts.parse_mode).toBe('HTML')
+    expect(callOpts.reply_to_message_id).toBe(42)
+  })
+
+  it('does NOT mutate the caller\'s opts object (strip uses a copy)', async () => {
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+    bot.api.sendMessage.mockImplementationOnce(async () => ({ message_id: 1 }))
+
+    const callerOpts = { message_thread_id: 1, parse_mode: 'HTML' as const }
+    await wrapped.api.sendMessage('supergrp', 'hello', callerOpts)
+
+    expect(callerOpts.message_thread_id).toBe(1)  // caller's object untouched
+  })
+
+  it('does NOT strip non-1 thread IDs', async () => {
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+    bot.api.sendMessage.mockImplementationOnce(async () => ({ message_id: 1 }))
+
+    await wrapped.api.sendMessage('supergrp', 'planning msg', { message_thread_id: 17 })
+
+    const callOpts = bot.api.sendMessage.mock.calls[0]![2] as Record<string, unknown>
+    expect(callOpts.message_thread_id).toBe(17)  // non-General threads untouched
+  })
+
+  it('two SAME-chat General-topic sends still serialize (id=1 normalized to chat-root lane)', async () => {
+    // After stripping id=1, the lock key normalizes to chatKey(chatId, null)
+    // = `chatId:_`. Two General-topic sends queue through the same
+    // chat-root lane preserving order (Telegram per-chat order matters).
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dSlow = deferred<{ message_id: number }>()
+    const order: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      order.push(`first:${t}`)
+      const r = await dSlow.promise
+      order.push(`first:end:${t}`)
+      return r
+    })
+    bot.api.sendMessage.mockImplementationOnce(async (_c: string, t: string) => {
+      order.push(`second:${t}`)
+      return { message_id: 2 }
+    })
+
+    const p1 = wrapped.api.sendMessage('supergrp', 'general msg 1', { message_thread_id: 1 })
+    const p2 = wrapped.api.sendMessage('supergrp', 'general msg 2', { message_thread_id: 1 })
+
+    await Promise.resolve(); await Promise.resolve()
+    expect(order).toEqual(['first:general msg 1'])  // second waits
+
+    dSlow.resolve({ message_id: 1 })
+    await Promise.all([p1, p2])
+    expect(order).toEqual(['first:general msg 1', 'first:end:general msg 1', 'second:general msg 2'])
+  })
+
+  it('General-topic strip does NOT serialize against non-General sends in the same chat', async () => {
+    // id=1 → chat-root lane. id=17 → its own lane. Independent dispatch.
+    const lock = createChatLock()
+    const bot = createMockBot()
+    const wrapped = lock.wrapBot({ api: bot.api as unknown as Record<string, unknown> }) as unknown as typeof bot
+
+    const dGeneral = deferred<{ message_id: number }>()
+    const dPlanning = deferred<{ message_id: number }>()
+    const started: string[] = []
+    bot.api.sendMessage.mockImplementationOnce(async () => {
+      started.push('general')
+      return dGeneral.promise
+    })
+    bot.api.sendMessage.mockImplementationOnce(async () => {
+      started.push('planning')
+      return dPlanning.promise
+    })
+
+    const pGeneral = wrapped.api.sendMessage('supergrp', 'g', { message_thread_id: 1 })
+    const pPlanning = wrapped.api.sendMessage('supergrp', 'p', { message_thread_id: 17 })
+
+    await Promise.resolve(); await Promise.resolve()
+    expect(started).toEqual(['general', 'planning'])  // both started concurrently
+
+    dPlanning.resolve({ message_id: 17 })
+    dGeneral.resolve({ message_id: 1 })
+    await Promise.all([pGeneral, pPlanning])
+  })
+
   it('react (setMessageReaction) queues behind an in-flight reply (sendMessage) to the same chat', async () => {
     const lock = createChatLock()
     const bot = createMockBot()