switchroom 0.19.38 → 0.19.40

package/telegram-plugin/session-tail.ts

@@ -158,6 +158,12 @@ export type SessionEvent =
    * ~300s wedge recovery once the launching bash is no longer running.
    */
   | { kind: 'task_notification'; taskId: string; status: string }
+  // #4058 — system compact_boundary: the CLI finished compacting the session
+  // mid-turn (the record is written at compaction END — it embeds the
+  // compaction's own durationMs). Consumed by silence-poke wiring to clear
+  // the PreCompact "compaction in flight" marker and count the boundary as
+  // production so the resumed turn gets a fresh silence window.
+  | { kind: 'compact_boundary'; trigger: string | null; compactDurationMs: number | null }
   // `reason` is set ONLY by an internal gateway-synthesized turn_end (never by
   // the JSONL projection). `answer-ready-quiescence` (PR A) marks the positive
   // deterministic quiescence-flush signal, which — unlike the orphaned-reply
@@ -702,6 +708,20 @@ export function projectTranscriptLine(line: string): SessionEvent[] {
     ]
   }
 
+  // #4058 — system compact_boundary: written when a mid-turn (auto or manual)
+  // compaction FINISHES. Real shape observed in live transcripts:
+  //   { type:"system", subtype:"compact_boundary", content:"Conversation
+  //     compacted", compactMetadata:{ trigger:"auto", preTokens, postTokens,
+  //     durationMs, ... } }
+  if (type === 'system' && obj.subtype === 'compact_boundary') {
+    const meta = obj.compactMetadata as { trigger?: unknown; durationMs?: unknown } | undefined
+    return [{
+      kind: 'compact_boundary',
+      trigger: typeof meta?.trigger === 'string' ? meta.trigger : null,
+      compactDurationMs: typeof meta?.durationMs === 'number' ? meta.durationMs : null,
+    }]
+  }
+
   return []
 }
 

package/telegram-plugin/silence-poke.ts

@@ -265,6 +265,25 @@ export interface SilencePokeDeps {
    * exactly as before.
    */
   isTurnLive?: (key: string) => boolean
+  /**
+   * #4058 — mid-turn auto-compaction defer predicate. Returns true while the
+   * Claude CLI is compacting the session for `key`'s turn (the PreCompact hook
+   * wrote the compaction marker and the `compact_boundary` transcript record
+   * hasn't landed / the marker isn't stale — see gateway/compaction-marker.ts).
+   *
+   * Why: during compaction the model emits ZERO output and runs ZERO tools
+   * for minutes, so every other work signal (`isLegitimatelyWorking`,
+   * in-flight tools, alive shells) is false and the 300s fallback fired on a
+   * healthy turn — a spurious "framework ended that stalled turn" card + a
+   * harmless re-ask, recurring on any session near the context ceiling.
+   *
+   * Semantics mirror the #1292/#3519 defers exactly: the silence CLOCK is
+   * never reset here; the terminal unwedge is DEFERRED (`continue` without
+   * setting fallbackFired) and remains bounded by `fallbackHardCeiling`, so
+   * a genuinely-wedged compaction still unwedges at the ceiling. Optional:
+   * absent (legacy fixtures) ⇒ behaviour unchanged.
+   */
+  isCompactionInFlight?: (key: string) => boolean
 }
 
 const state = new Map<string, SilencePokeState>()
@@ -773,6 +792,15 @@ function tick(now: number): void {
       const ceiling = thresholds.fallbackHardCeiling ?? Number.POSITIVE_INFINITY
       const underCeiling = silence < ceiling
       if (underCeiling) {
+        // #4058 — mid-turn auto-compaction: the CLI is summarizing the
+        // session, so the model provably CANNOT produce output or tool
+        // events; the silence is healthy, not a wedge. Defer exactly like
+        // the in-flight-tool paths below (clock untouched, fallbackFired
+        // unset, re-checked next tick) and stay bounded by the same hard
+        // ceiling via the enclosing `underCeiling` guard. Deliberately NOT
+        // gated by SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS=0 — that flag
+        // scopes the TOOL defers; compaction has no tool in flight.
+        if (activeDeps.isCompactionInFlight?.(key) === true) continue
         const forceDisable = process.env.SWITCHROOM_SILENCE_DEFER_INFLIGHT_TOOLS === '0'
         if (!forceDisable && activeDeps.isLegitimatelyWorking != null) {
           if (activeDeps.isLegitimatelyWorking(key)) continue

package/telegram-plugin/tests/activity-ever-opened-sticky.test.ts

@@ -11,13 +11,17 @@
  *
  * Load-bearing constraints:
  *   1. `activityEverOpened = true` is set only at legitimate feed-OPEN signal
- *      sites in gateway.ts — the send-message success site in
- *      drainActivitySummary, AND the sub-agent-handback pre-turn ADOPTION site
- *      (#3268): an adopted turn inherits an already-open pre-turn card via a
- *      seeded `activityMessageId`, so it only ever EDITs the feed (never hits
- *      the open branch), and must stamp the flag itself so the turn-end
- *      DEGRADED check doesn't false-flag it as "feed never opened". Both are
- *      set-TRUE (never a reset), preserving the sticky-true invariant.
+ *      sites — the send-message success site in drainActivitySummary, the
+ *      sub-agent-handback pre-turn ADOPTION site (#3268), AND the queued-card
+ *      ADOPTION site (#3927 Part B). The two adoption sites are the same shape:
+ *      an adopted turn inherits an ALREADY-OPEN, user-visible card via a seeded
+ *      `activityMessageId`, so it only ever EDITs the feed (never hits the open
+ *      branch), and must stamp the flag itself so the turn-end DEGRADED check
+ *      doesn't false-flag it as "feed never opened". A parked message's "⏳
+ *      Queued" card is a real message the user already sees before the turn
+ *      mints, so adopting it on dequeue IS a feed-open — same rationale as the
+ *      handback adoption. All three are set-TRUE (never a reset), preserving the
+ *      sticky-true invariant.
  *   2. `turn.activityEverOpened = false` NEVER appears in gateway.ts (it is only
  *      initialised to `false` in the turn-initialiser object literal, never reset
  *      via a standalone assignment).
@@ -49,13 +53,16 @@ const laneSrc = readFileSync(
 const gatewayAndStreamSrc = gatewaySrc + '\n' + streamSrc + '\n' + laneSrc
 
 describe('M-2: activityEverOpened sticky-true invariant', () => {
-  it('activityEverOpened = true appears only at the two feed-OPEN signal sites', () => {
+  it('activityEverOpened = true appears only at the three feed-OPEN signal sites', () => {
     // Site 1: drainActivitySummary send-message success. Site 2: the #3268
-    // handback pre-turn ADOPTION seed (an adopted turn only edits, so it stamps
-    // the flag itself). Both are set-TRUE; the sticky invariant (no reset to
-    // false) is enforced by the next test.
+    // handback pre-turn ADOPTION seed. Site 3: the #3927 Part B queued-card
+    // ADOPTION seed (stream-render.ts) — a parked message's "⏳ Queued" card is
+    // an already-open, user-visible card the dequeued turn adopts and only
+    // EDITs, so it stamps the flag itself, exactly like the handback adoption.
+    // All three are set-TRUE; the sticky invariant (no reset to false) is
+    // enforced by the next test.
     const setTrueMatches = [...gatewayAndStreamSrc.matchAll(/activityEverOpened\s*=\s*true/g)]
-    expect(setTrueMatches).toHaveLength(2)
+    expect(setTrueMatches).toHaveLength(3)
   })
 
   it('turn.activityEverOpened = false never appears (no standalone reset)', () => {

package/telegram-plugin/tests/fixtures/pretool-main-2.1.219.json

@@ -0,0 +1,15 @@
+{
+  "session_id": "e2c9a4f0-1b3d-4c8a-9f21-parent000000",
+  "transcript_path": "/home/agent/.claude/projects/-home-agent-work/e2c9a4f0-1b3d-4c8a-9f21-parent000000.jsonl",
+  "cwd": "/home/agent/work",
+  "permission_mode": "default",
+  "agent_id": "e2c9a4f0-1b3d-4c8a-9f21-parent000000",
+  "agent_type": "main",
+  "effort": "medium",
+  "hook_event_name": "PreToolUse",
+  "tool_name": "Read",
+  "tool_input": {
+    "file_path": "/home/agent/work/src/index.ts"
+  },
+  "tool_use_id": "toolu_01MainReadCall4z"
+}

package/telegram-plugin/tests/fixtures/pretool-subagent-2.1.219.json

@@ -0,0 +1,16 @@
+{
+  "session_id": "e2c9a4f0-1b3d-4c8a-9f21-parent000000",
+  "transcript_path": "/home/agent/.claude/projects/-home-agent-work/e2c9a4f0-1b3d-4c8a-9f21-parent000000.jsonl",
+  "cwd": "/home/agent/work",
+  "permission_mode": "default",
+  "agent_id": "7a1b9c3d-4e5f-6071-8293-subagentownid0",
+  "agent_type": "general-purpose",
+  "effort": "medium",
+  "hook_event_name": "PreToolUse",
+  "tool_name": "Bash",
+  "tool_input": {
+    "command": "npm run build",
+    "description": "Build the worker output"
+  },
+  "tool_use_id": "toolu_01SubAgentBashCall9x"
+}

package/telegram-plugin/tests/outbox-delivery.test.ts

@@ -119,7 +119,8 @@ describe('sweepOutbox — end to end (exactly-once, siblings, dedup)', () => {
       sent,
       send: async (chatId: string, threadId: number | null, text: string) => {
         sent.push({ chatId, threadId, text })
-        return sent.length
+        const id = sent.length
+        return { messageId: id, chunks: [{ messageId: id, text }] }
       },
     }
   }
@@ -136,6 +137,42 @@ describe('sweepOutbox — end to end (exactly-once, siblings, dedup)', () => {
     expect(listPendingRecords(dir)).toHaveLength(0)
   })
 
+  it('persist parity: recordOutbound fires ONCE with the delivered message_id(s) + text after a successful sweep', async () => {
+    // The safety-net delivery must land in history.db, exactly like the reply
+    // path and the turn-flush backstop. Pre-fix the sweep never called
+    // recordOutbound, so every net-delivered handback was silently absent from
+    // history — this asserts the recorder fires with the ACTUAL delivered ids +
+    // text, and exactly once across repeated (idempotent) sweeps.
+    writeOutboxRecordAtomic(rec({ turnNonce: 'p1', chatId: '444', text: 'the recovered final answer', createdAt: 0 }), dir)
+    const s = sink()
+    const recorded: Array<{ chatId: string; threadId: number | null; messageIds: number[]; texts: string[] }> = []
+    const deps = {
+      ...s,
+      recordOutbound: (chatId: string, threadId: number | null, messageIds: number[], texts: string[]) => {
+        recorded.push({ chatId, threadId, messageIds, texts })
+      },
+      textAlreadyDelivered: () => false,
+      stateDir: dir,
+      now: () => 10_000,
+    }
+    await sweepOutbox(deps)
+    await sweepOutbox(deps) // journal suppresses — recorder must NOT fire again
+    await sweepOutbox(deps)
+    expect(s.sent).toHaveLength(1)
+    expect(recorded).toHaveLength(1)
+    expect(recorded[0].chatId).toBe('444')
+    expect(recorded[0].messageIds).toEqual([1])
+    expect(recorded[0].texts).toEqual(['the recovered final answer'])
+  })
+
+  it('persist parity: a missing recordOutbound never throws (safety-net stays intact)', async () => {
+    // The recorder is optional; a sweep with no recorder wired must still deliver.
+    writeOutboxRecordAtomic(rec({ turnNonce: 'p2', chatId: '444', text: 'no recorder wired', createdAt: 0 }), dir)
+    const s = sink()
+    await sweepOutbox({ ...s, textAlreadyDelivered: () => false, stateDir: dir, now: () => 10_000 })
+    expect(s.sent).toHaveLength(1)
+  })
+
   it('two concurrent sibling handbacks with distinct nonces both deliver, no clobber', async () => {
     // Same content, distinct enqueue timestamps → distinct nonces (H2).
     const n1 = deriveTurnNonce({ chatId: null, threadId: null, messageId: null, anchorTimestampMs: 1000, anchorContent: 'sib' })

package/telegram-plugin/tests/outbox-flush-ack-claim-race.test.ts

@@ -0,0 +1,213 @@
+/**
+ * outbox-flush-ack-claim-race.test.ts — outcome regression for the turn-flush
+ * vs outbox-sweep DUPLICATE-MESSAGE race.
+ *
+ * The race (root-caused via journal forensics):
+ *   1. A gateway-visible turn ends with unsent trailing prose → the turn-flush
+ *      backstop delivers it through `runBackstopDelivery` (the flush core). The
+ *      chunks land (Telegram acks) immediately.
+ *   2. The flush's DURABLE exactly-once claim (`journalExternalDelivery`,
+ *      `deliverySource:'flush'`) used to run only in the caller's
+ *      post-`await deliverAnswer` bookkeeping — i.e. AFTER `runBackstopDelivery`
+ *      returned. But `runBackstopDelivery` does not return until its read-back
+ *      probe resolves, and that probe is issued at COSMETIC priority: when the
+ *      edit-flood-fuse is deferring cosmetic edits it blocks ~30s.
+ *   3. The out-of-band outbox sweep waits only `OUTBOX_QUIET_MS` (5s) before
+ *      checking the delivered-keys journal. In the 5–30s gap it saw no journal
+ *      entry (deferred behind the probe) and — because the Stop-hook-captured
+ *      record's text differs in length/hash from the flush text, so the in-memory
+ *      text dedup also misses — it sent a SECOND copy of the same answer.
+ *
+ * The fix claims the nonce at SEND-ACK time (`onAckClaim`), BEFORE the read-back
+ * probe. This test drives the REAL `runBackstopDelivery` with a read-back probe
+ * held open PAST the sweep's quiet window, plus a pending outbox record for the
+ * SAME nonce with DIFFERENT text, and asserts the REAL `sweepOutbox` delivers
+ * NOTHING. It is RED on pre-fix main (no ack-time claim → the journal is empty
+ * when the sweep ticks → the sweep sends the duplicate).
+ *
+ * The oracle is what the user observably received (sweep `send` invocations) and
+ * the durable journal — no assertion names an internal decision function.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import {
+  BackstopDeliveryLedger,
+  runBackstopDelivery,
+  type ReadBackResult,
+} from '../gateway/backstop-delivery.js'
+import { sweepOutbox, journalExternalDelivery } from '../gateway/outbox-sweep.js'
+import {
+  OUTBOX_QUIET_MS,
+  readDeliveredNonces,
+  sha256Hex,
+  writeOutboxRecordAtomic,
+  type OutboxRecord,
+} from '../outbox.js'
+
+const CHAT = '111'
+/** Gateway `deriveTurnId` shape — byte-identical to the Stop-hook record nonce. */
+const NONCE = `${CHAT}:_#42`
+/** The flush's answer (RICH). */
+const FLUSH_TEXT = 'The deploy is green across all three checks. '.padEnd(320, 'a')
+/** The Stop-hook-captured record for the SAME turn — a paraphrase, so its length
+ *  and sha differ from the flush text and the in-memory text dedup CANNOT match. */
+const RECORD_TEXT =
+  'Summary of the above in different words so byte-exact dedup can never catch it. '.padEnd(
+    420,
+    'b',
+  )
+
+/** A pending outbox record, aged PAST the sweep quiet window so it is eligible. */
+function writeAgedRecord(dir: string, createdAt: number): void {
+  const record: OutboxRecord = {
+    turnNonce: NONCE,
+    chatId: CHAT,
+    threadId: null,
+    text: RECORD_TEXT,
+    textSha256: sha256Hex(RECORD_TEXT),
+    createdAt,
+    source: 'channel',
+    replyAlreadyDeliveredThisTurn: false,
+  }
+  const ok = writeOutboxRecordAtomic(record, dir)
+  expect(ok).toBe(true)
+}
+
+describe('turn-flush vs outbox-sweep — the flush claims its nonce at SEND-ACK, before a slow read-back', () => {
+  let dir: string
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), 'flush-ack-race-'))
+  })
+  afterEach(() => rmSync(dir, { recursive: true, force: true }))
+
+  it('a read-back slower than OUTBOX_QUIET_MS + a same-nonce/different-text record ⇒ the sweep sends NOTHING (exactly-once)', async () => {
+    const now = 10_000_000
+    // The captured record was written well before the quiet window elapsed.
+    writeAgedRecord(dir, now - (OUTBOX_QUIET_MS + 5_000))
+
+    // Read-back gate — held OPEN so runBackstopDelivery cannot return until we
+    // release it, simulating the cosmetic-edit flood-fuse deferring the probe
+    // ~30s (far longer than the sweep's 5s quiet window).
+    let releaseReadBack!: () => void
+    const readBackGate = new Promise<void>((resolve) => {
+      releaseReadBack = resolve
+    })
+
+    const ledger = new BackstopDeliveryLedger()
+    ledger.claim(NONCE)
+
+    const sentChunks: string[] = []
+    const flushPromise = runBackstopDelivery(
+      ledger,
+      NONCE,
+      [FLUSH_TEXT],
+      null,
+      {
+        sendChunk: async (_i, text) => {
+          sentChunks.push(text)
+          return [777] // Telegram acked — a fresh non-card chat id.
+        },
+        // Mirrors the real deliverAnswer read-back: paced cosmetic, deferrable.
+        readBack: async (): Promise<ReadBackResult> => {
+          await readBackGate
+          return 'exists'
+        },
+        // The fix: journal the nonce at ack, BEFORE the read-back above resolves.
+        onAckClaim: (ackIds) => {
+          journalExternalDelivery(
+            {
+              turnNonce: NONCE,
+              text: FLUSH_TEXT,
+              tgMessageId: ackIds[0],
+              deliverySource: 'flush',
+            },
+            dir,
+          )
+        },
+      },
+      3,
+    )
+
+    // Let the send loop run its send + (with the fix) the ack claim, then park
+    // on the still-open read-back probe. Bounded macrotask flushes — no timers,
+    // no dependence on the fix, so a missing claim surfaces as a clean assertion
+    // failure below rather than a hang.
+    for (let i = 0; i < 5; i++) await new Promise((r) => setImmediate(r))
+    expect(sentChunks).toEqual([FLUSH_TEXT])
+    // Durable claim landed at ack-time — WHILE the read-back is still open.
+    expect(readDeliveredNonces(dir).has(NONCE)).toBe(true)
+
+    // Now the sweep ticks, past the quiet window, with the text dedup MISSING
+    // (record text ≠ flush text). Its only exactly-once guard is the journal.
+    const swept: string[] = []
+    const summary = await sweepOutbox({
+      stateDir: dir,
+      now: () => now,
+      send: async (_chatId, _threadId, text) => {
+        swept.push(text)
+        return { messageId: 500, chunks: [{ messageId: 500, text }] }
+      },
+      // The exact-text in-memory dedup cannot help — the texts differ.
+      textAlreadyDelivered: () => false,
+    })
+
+    // THE user outcome: the sweep sent nothing — the flush already owns this turn.
+    expect(swept).toEqual([])
+    expect(summary.delivered).toBe(0)
+
+    // Release the (slow) read-back and let the flush finish cleanly.
+    releaseReadBack()
+    const result = await flushPromise
+    expect(result.delivered).toBe(true)
+  })
+
+  it('no-loss guard: a flush whose send never acks does NOT claim, so the sweep still delivers the captured answer once', async () => {
+    const now = 20_000_000
+    writeAgedRecord(dir, now - (OUTBOX_QUIET_MS + 5_000))
+
+    const ledger = new BackstopDeliveryLedger()
+    ledger.claim(NONCE)
+
+    let ackClaimCount = 0
+    const result = await runBackstopDelivery(
+      ledger,
+      NONCE,
+      [FLUSH_TEXT],
+      null,
+      {
+        // Every attempt throws — the answer never lands, so the claim predicate
+        // (all chunks landed + fresh receipt) is never met.
+        sendChunk: async () => {
+          throw new Error('telegram send rejected')
+        },
+        readBack: async (): Promise<ReadBackResult> => 'exists',
+        onAckClaim: () => {
+          ackClaimCount++
+        },
+      },
+      3,
+    )
+    // The flush genuinely failed and never claimed the nonce.
+    expect(result.delivered).toBe(false)
+    expect(ackClaimCount).toBe(0)
+    expect(readDeliveredNonces(dir).has(NONCE)).toBe(false)
+
+    // The safety net now delivers the captured answer — exactly once, no loss.
+    const swept: string[] = []
+    const summary = await sweepOutbox({
+      stateDir: dir,
+      now: () => now,
+      send: async (_chatId, _threadId, text) => {
+        swept.push(text)
+        return { messageId: 501, chunks: [{ messageId: 501, text }] }
+      },
+      textAlreadyDelivered: () => false,
+    })
+    expect(swept).toEqual([RECORD_TEXT])
+    expect(summary.delivered).toBe(1)
+  })
+})

package/telegram-plugin/tests/outbox-reply-then-recap-e2e.test.ts

@@ -268,7 +268,7 @@ async function runTurn(opts: {
       send: async (_chatId, _threadId, text) => {
         delivered.push({ via: 'sweep', text })
         sentLog.push({ text, at: now })
-        return 500
+        return { messageId: 500, chunks: [{ messageId: 500, text }] }
       },
       // Mirrors the gateway's TTL-bounded exact-text `outboundDedup` cache:
       // anything sent (reply or sweep) within the TTL dedups; older evicts.

package/telegram-plugin/tests/outbox-sweep-flood-breaker.test.ts

@@ -61,7 +61,7 @@ describe('outbox sweep vs an open flood window', () => {
 
   it('does not hit the wire while a flood window is open, and keeps the record', async () => {
     writeOutboxRecordAtomic(rec(), dir)
-    const send = vi.fn(async () => 1)
+    const send = vi.fn(async () => ({ messageId: 1, chunks: [{ messageId: 1, text: rec().text }] }))
     const log = vi.fn()
 
     const summary = await sweepOutbox({
@@ -90,7 +90,7 @@ describe('outbox sweep vs an open flood window', () => {
 
   it('delivers the SAME record once the window closes', async () => {
     writeOutboxRecordAtomic(rec(), dir)
-    const send = vi.fn(async () => 42)
+    const send = vi.fn(async () => ({ messageId: 42, chunks: [{ messageId: 42, text: rec().text }] }))
     let remaining = 12_247_000
 
     const deferred = await sweepOutbox({
@@ -120,7 +120,7 @@ describe('outbox sweep vs an open flood window', () => {
 
   it('sweeps normally when no window is open', async () => {
     writeOutboxRecordAtomic(rec(), dir)
-    const send = vi.fn(async () => 7)
+    const send = vi.fn(async () => ({ messageId: 7, chunks: [{ messageId: 7, text: rec().text }] }))
     const summary = await sweepOutbox({
       stateDir: dir,
       send,
@@ -135,7 +135,7 @@ describe('outbox sweep vs an open flood window', () => {
 
   it('FAILS OPEN: a throwing probe must never strand the outbox', async () => {
     writeOutboxRecordAtomic(rec(), dir)
-    const send = vi.fn(async () => 7)
+    const send = vi.fn(async () => ({ messageId: 7, chunks: [{ messageId: 7, text: rec().text }] }))
     const summary = await sweepOutbox({
       stateDir: dir,
       send,

package/telegram-plugin/tests/outbox-sweep-listen-button.test.ts

@@ -20,6 +20,7 @@
  */
 
 import { describe, it, expect } from 'vitest'
+import { GrammyError } from 'grammy'
 import { createOutboxSend } from '../gateway/outbox-sweep.js'
 import { makeOutboxListenMarkupResolver } from '../gateway/outbox-listen-markup.js'
 import {
@@ -38,14 +39,37 @@ const kokoroOnDemand: ListenButtonVoiceOutPlan = {
 // fallback needed for the unit under test).
 const passthroughRetry = <U>(fn: () => Promise<U>): Promise<U> => fn()
 
-function fakeBot() {
+// The sweep now renders via sendRichMessage (raw GFM markdown → entities), the
+// SAME path the reply path uses; a markdown parse-reject falls back to plain
+// sendMessage. `calls` records the CANONICAL rich sends (with the raw markdown
+// pulled out of the `{ markdown }` body as `text`) so the existing assertions
+// keep asserting the bytes handed to the wire; `plainCalls` records the
+// parse-reject fallback sends.
+function fakeBot(opts?: { failRich?: boolean }) {
   const calls: Array<{ chatId: string; text: string; opts: Record<string, unknown> }> = []
+  const plainCalls: Array<{ chatId: string; text: string; opts: Record<string, unknown> }> = []
   let n = 100
   return {
     calls,
+    plainCalls,
     api: {
-      sendMessage: async (chatId: string, text: string, opts: object) => {
-        calls.push({ chatId, text, opts: opts as Record<string, unknown> })
+      sendRichMessage: async (chatId: string, body: { markdown: string }, o: object) => {
+        if (opts?.failRich) {
+          // A real Telegram markdown parse-reject (isParseEntitiesError keys on
+          // `instanceof GrammyError` + the description), so the sweep falls back
+          // to a plain sendMessage of the same chunk.
+          throw new GrammyError(
+            'Call to sendRichMessage failed!',
+            { ok: false, error_code: 400, description: "Bad Request: can't parse entities" },
+            'sendRichMessage',
+            {} as never,
+          )
+        }
+        calls.push({ chatId, text: body.markdown, opts: o as Record<string, unknown> })
+        return { message_id: n++ }
+      },
+      sendMessage: async (chatId: string, text: string, o: object) => {
+        plainCalls.push({ chatId, text, opts: o as Record<string, unknown> })
         return { message_id: n++ }
       },
     },
@@ -99,6 +123,44 @@ describe('planListenButton — shared Listen-button decision', () => {
   })
 })
 
+describe('createOutboxSend — RENDER PARITY (markdown is rendered, not raw)', () => {
+  it('sends through sendRichMessage with the markdown body, NOT a raw sendMessage', async () => {
+    // The bug: the sweep sent via a plain bot.api.sendMessage with no parse_mode
+    // and no rich render, so `**bold**` reached the operator verbatim. The fix
+    // routes each chunk through richMessage → sendRichMessage. This asserts the
+    // rendered payload (a `{ markdown }` body on the rich API), which the pre-fix
+    // raw-sendMessage path never produced.
+    const bot = fakeBot()
+    const send = createOutboxSend({ getBot: () => bot, retry: passthroughRetry })
+
+    const result = await send('123', null, 'Here is **bold** and `code`.')
+
+    // Rendered via the rich path (markdown preserved for Telegram to parse)…
+    expect(bot.calls).toHaveLength(1)
+    expect(bot.calls[0]!.text).toBe('Here is **bold** and `code`.')
+    // …and NOT via the raw plain-text path (the pre-fix bug).
+    expect(bot.plainCalls).toHaveLength(0)
+    // The landed chunk (id + text) is reported back for history persistence.
+    expect(result.chunks).toEqual([{ messageId: 100, text: 'Here is **bold** and `code`.' }])
+    expect(result.messageId).toBe(100)
+  })
+
+  it('falls back to a PLAIN sendMessage of the same chunk on a markdown parse-reject', async () => {
+    // Mirrors the reply path's plaintext fallback: if Telegram rejects the
+    // markdown entities, resend the raw source as plain text (readable prose)
+    // rather than dropping the answer.
+    const bot = fakeBot({ failRich: true })
+    const send = createOutboxSend({ getBot: () => bot, retry: passthroughRetry })
+
+    const result = await send('123', null, 'weird **[unbalanced markdown')
+
+    expect(bot.calls).toHaveLength(0) // rich rejected
+    expect(bot.plainCalls).toHaveLength(1) // plain fallback delivered
+    expect(bot.plainCalls[0]!.text).toBe('weird **[unbalanced markdown')
+    expect(result.chunks).toHaveLength(1) // still reported for history
+  })
+})
+
 describe('createOutboxSend — net-delivered answer carries the Listen button (#3502)', () => {
   it('attaches the Listen keyboard as reply_markup when voice-out on-demand is enabled', async () => {
     const bot = fakeBot()
@@ -128,8 +190,8 @@ describe('createOutboxSend — net-delivered answer carries the Listen button (#
       resolveReplyMarkup: () => markup,
     })
 
-    // > 4000 chars → two chunks.
-    await send('123', null, 'x'.repeat(4500))
+    // > RICH_MESSAGE_MAX_CHARS (32768) of a single unbreakable token → two chunks.
+    await send('123', null, 'x'.repeat(40000))
 
     expect(bot.calls).toHaveLength(2)
     expect(bot.calls[0]!.opts.reply_markup).toBeUndefined()
@@ -162,10 +224,10 @@ describe('createOutboxSend — net-delivered answer carries the Listen button (#
     expect(bot.calls[0]!.opts.reply_markup).toBeUndefined()
   })
 
-  it('empty text sends NOTHING and returns undefined (no empty-message retry wedge)', async () => {
+  it('empty text sends NOTHING and reports an empty result (no empty-message retry wedge)', async () => {
     // Telegram rejects an empty message body; a stray '' chunk would throw
     // every sweep tick and wedge the record in a permanent retry. The send
-    // must short-circuit instead of calling sendMessage.
+    // must short-circuit instead of calling sendMessage/sendRichMessage.
     const bot = fakeBot()
     const resolverCalls: string[] = []
     const send = createOutboxSend({
@@ -179,8 +241,9 @@ describe('createOutboxSend — net-delivered answer carries the Listen button (#
 
     const result = await send('123', null, '')
 
-    expect(result).toBeUndefined()
+    expect(result).toEqual({ messageId: undefined, chunks: [] })
     expect(bot.calls).toHaveLength(0)
+    expect(bot.plainCalls).toHaveLength(0)
     // No point resolving a Listen button for a body we never send.
     expect(resolverCalls).toEqual([])
   })