switchroom 0.16.22 → 0.16.24

package/telegram-plugin/tests/boot-card-render.test.ts

@@ -18,21 +18,21 @@ import { renderBootCard, resolvePersonaName } from '../gateway/boot-card.js'
 describe('renderBootCard — quiet by default', () => {
   it('returns one-line ack with default ✅ when no probes and no restart reason', () => {
     const out = renderBootCard({ agentName: 'klanker', version: 'v0.3.0+44' })
-    expect(out).toBe('✅ <b>klanker</b> back up · v0.3.0+44')
+    expect(out).toBe('✅ **klanker** back up · v0.3.0+44')
     expect(out).not.toContain('\n')
   })
 
   it('uses ✅ for planned and graceful restart reasons (return-to-service)', () => {
     for (const reason of ['planned', 'graceful'] as const) {
       const out = renderBootCard({ agentName: 'agent', version: 'v1', restartReason: reason })
-      expect(out).toBe('✅ <b>agent</b> back up · v1')
+      expect(out).toBe('✅ **agent** back up · v1')
     }
   })
 
   it('uses 🆕 for fresh starts (no prior session marker — first boot)', () => {
     const out = renderBootCard({ agentName: 'a', version: 'v', restartReason: 'fresh' })
     expect(out.startsWith('🆕')).toBe(true)
-    expect(out).toBe('🆕 <b>a</b> back up · v')
+    expect(out).toBe('🆕 **a** back up · v')
   })
 
   it('all-ok probes produce no extra rows — same output as no probes at all', () => {
@@ -62,16 +62,16 @@ describe('renderBootCard — degraded conditions', () => {
       restartAgeMs: 2_100,
     })
     const lines = out.split('\n')
-    expect(lines[0]).toBe('⚠️ <b>lawgpt</b> back up · v0.3.0+44')
+    expect(lines[0]).toBe('⚠️ **lawgpt** back up · v0.3.0+44')
     expect(lines[1]).toBe('') // separator
-    expect(lines[2]).toContain('⚠️ <b>Restart</b>')
+    expect(lines[2]).toContain('⚠️ **Restart**')
     expect(lines[2]).toContain('crash recovery')
     expect(lines[2]).toContain('2.1s ago')
   })
 
   it('crash reason without restartAgeMs omits the "ago" suffix', () => {
     const out = renderBootCard({ agentName: 'a', version: 'v1', restartReason: 'crash' })
-    expect(out).toContain('⚠️ <b>Restart</b>  crash recovery')
+    expect(out).toContain('⚠️ **Restart**  crash recovery')
     expect(out).not.toMatch(/\d+\.\d+s ago/)
   })
 
@@ -88,13 +88,13 @@ describe('renderBootCard — degraded conditions', () => {
         crons:     { status: 'ok',       label: 'Crons',     detail: '4 timers' },
       },
     })
-    expect(out).toContain('🟡 <b>Account</b>  token expiring · 3d')
-    expect(out).toContain('🔴 <b>Quota</b>  rate limited')
+    expect(out).toContain('🟡 **Account**  token expiring · 3d')
+    expect(out).toContain('🔴 **Quota**  rate limited')
     // Healthy probes must not render.
-    expect(out).not.toContain('Agent</b>')
-    expect(out).not.toContain('Gateway</b>')
-    expect(out).not.toContain('Hindsight</b>')
-    expect(out).not.toContain('Scheduler</b>')
+    expect(out).not.toContain('Agent**')
+    expect(out).not.toContain('Gateway**')
+    expect(out).not.toContain('Hindsight**')
+    expect(out).not.toContain('Scheduler**')
   })
 
   it('orders probe rows in PROBE_KEYS canonical order regardless of object iteration', () => {
@@ -110,9 +110,9 @@ describe('renderBootCard — degraded conditions', () => {
         account:   { status: 'degraded', label: 'Account',   detail: 'expiring' },
       },
     })
-    const accountIdx = out.indexOf('Account</b>')
-    const hindsightIdx = out.indexOf('Hindsight</b>')
-    const schedulerIdx = out.indexOf('Scheduler</b>')
+    const accountIdx = out.indexOf('Account**')
+    const hindsightIdx = out.indexOf('Hindsight**')
+    const schedulerIdx = out.indexOf('Scheduler**')
     expect(accountIdx).toBeGreaterThan(-1)
     expect(hindsightIdx).toBeGreaterThan(accountIdx)
     expect(schedulerIdx).toBeGreaterThan(hindsightIdx)
@@ -131,14 +131,14 @@ describe('renderBootCard — degraded conditions', () => {
     const lines = out.split('\n')
     expect(lines[0].startsWith('⚠️')).toBe(true)
     expect(lines).toContain('') // separator after ack
-    expect(out).toContain('⚠️ <b>Restart</b>')
-    expect(out).toContain('🟡 <b>Account</b>  expiring')
+    expect(out).toContain('⚠️ **Restart**')
+    expect(out).toContain('🟡 **Account**  expiring')
   })
 
   it('renders nextStep as an indented continuation line beneath a degraded row', () => {
     // Principle 1 ("If they need the docs, we've failed"): every degraded
     // probe should surface its remediation inline. Plain backticks in the
-    // nextStep get translated to <code> spans so the command stays tap-to-
+    // nextStep get translated to ` spans so the command stays tap-to-
     // copy on mobile.
     const out = renderBootCard({
       agentName: 'lawgpt',
@@ -152,8 +152,8 @@ describe('renderBootCard — degraded conditions', () => {
         },
       },
     })
-    expect(out).toContain('🟡 <b>Skills</b>  10/10 dangling')
-    expect(out).toContain('    ↳ Run <code>switchroom agent reconcile lawgpt</code> to rebuild symlinks')
+    expect(out).toContain('🟡 **Skills**  10/10 dangling')
+    expect(out).toContain('    ↳ Run `switchroom agent reconcile lawgpt` to rebuild symlinks')
   })
 
   it('crash row carries a tail-logs next-step', () => {
@@ -163,8 +163,16 @@ describe('renderBootCard — degraded conditions', () => {
       restartReason: 'crash',
       restartAgeMs: 6_100,
     })
-    expect(out).toContain('⚠️ <b>Restart</b>  crash recovery · 6.1s ago')
-    expect(out).toContain('↳ Tail logs: <code>journalctl --user -u switchroom-lawgpt -n 100</code>')
+    expect(out).toContain('⚠️ **Restart**  crash recovery · 6.1s ago')
+    // The tail-logs command is runtime-aware: in-container (docker) vs
+    // host (journalctl). Assert against whichever branch the renderer
+    // selected so the suite is green under both bun (live container env)
+    // and vitest (env scrubbed) — see vitest.config.ts.
+    const expectedTail =
+      process.env.SWITCHROOM_RUNTIME === 'docker'
+        ? '↳ Tail logs: `docker logs --tail 100 switchroom-lawgpt`'
+        : '↳ Tail logs: `journalctl --user -u switchroom-lawgpt -n 100`'
+    expect(out).toContain(expectedTail)
   })
 
   it('crash row uses agentSlug for the systemd unit when provided', () => {
@@ -191,8 +199,9 @@ describe('renderBootCard — degraded conditions', () => {
         },
       },
     })
-    expect(out).toContain('<code>foo &lt;bar&gt; &amp; baz</code>')
-    expect(out).not.toContain('<bar>')
+    // #2669: the backtick-delimited content stays a literal code span — no
+    // HTML entities. < > & render verbatim inside the span.
+    expect(out).toContain('`foo <bar> & baz`')
   })
 
   it('unpaired backticks in nextStep fall back to plain escaped text', () => {
@@ -208,8 +217,9 @@ describe('renderBootCard — degraded conditions', () => {
         },
       },
     })
-    expect(out).toContain('↳ Run `switchroom foo to fix')
-    expect(out).not.toContain('<code>')
+    // Unpaired backtick → the whole nextStep is markdown-escaped, so the lone
+    // backtick is rendered as a literal `\`` and never opens a real code span.
+    expect(out).toContain('↳ Run \\`switchroom foo to fix')
   })
 
   it('degraded rows without nextStep render unchanged (backwards compat)', () => {
@@ -220,7 +230,7 @@ describe('renderBootCard — degraded conditions', () => {
         quota: { status: 'fail', label: 'Quota', detail: 'rate limited' },
       },
     })
-    expect(out).toContain('🔴 <b>Quota</b>  rate limited')
+    expect(out).toContain('🔴 **Quota**  rate limited')
     expect(out).not.toContain('↳')
   })
 
@@ -234,23 +244,25 @@ describe('renderBootCard — degraded conditions', () => {
       },
     })
     expect(out).not.toContain('Account')
-    expect(out).toContain('🔴 <b>Agent</b>  service deactivating')
+    expect(out).toContain('🔴 **Agent**  service deactivating')
   })
 })
 
-describe('renderBootCard — HTML escaping', () => {
-  it('escapes special chars in agent name', () => {
+describe('renderBootCard — markdown escaping (#2669)', () => {
+  it('passes < > literally in agent name; escapes emphasis specials', () => {
+    // < > are literal in rich markdown; an underscore would be escaped.
     const out = renderBootCard({ agentName: 'foo<bar>', version: 'v1' })
-    expect(out).toContain('foo&lt;bar&gt;')
-    expect(out).not.toContain('foo<bar>')
+    expect(out).toContain('foo<bar>')
+    const out2 = renderBootCard({ agentName: 'foo_bar', version: 'v1' })
+    expect(out2).toContain('foo\\_bar')
   })
 
-  it('escapes special chars in version', () => {
+  it('passes < > literally in version', () => {
     const out = renderBootCard({ agentName: 'a', version: 'v<1>' })
-    expect(out).toContain('v&lt;1&gt;')
+    expect(out).toContain('v<1>')
   })
 
-  it('escapes special chars in probe detail', () => {
+  it('passes < > literally in probe detail', () => {
     const out = renderBootCard({
       agentName: 'a',
       version: 'v',
@@ -258,8 +270,7 @@ describe('renderBootCard — HTML escaping', () => {
         quota: { status: 'fail', label: 'Quota', detail: 'rate <limited>' },
       },
     })
-    expect(out).toContain('rate &lt;limited&gt;')
-    expect(out).not.toContain('rate <limited>')
+    expect(out).toContain('rate <limited>')
   })
 })
 
@@ -303,8 +314,8 @@ describe('resolvePersonaName — persona name over slug (#169)', () => {
     const displayName = resolvePersonaName('finn', fakeCfg)
     const out = renderBootCard({ agentName: displayName, version: 'v0.3.0+50' })
     // User sees "Finn", not the slug "finn"
-    expect(out).toBe('✅ <b>Finn</b> back up · v0.3.0+50')
-    expect(out).not.toContain('<b>finn</b>')
+    expect(out).toBe('✅ **Finn** back up · v0.3.0+50')
+    expect(out).not.toContain('**finn**')
   })
 })
 
@@ -322,8 +333,8 @@ describe('renderBootCard — resolved / snooze rendering', () => {
       },
       resolvedRows: ['hindsight'],
     })
-    expect(out).toContain('✅ <b>Hindsight</b>  resolved')
-    expect(out).toContain('🔴 <b>Broker</b>  socket missing')
+    expect(out).toContain('✅ **Hindsight**  resolved')
+    expect(out).toContain('🔴 **Broker**  socket missing')
     // Resolved appears BEFORE Broker.
     expect(out.indexOf('Hindsight')).toBeLessThan(out.indexOf('Broker'))
   })
@@ -351,7 +362,7 @@ describe('renderBootCard — resolved / snooze rendering', () => {
       },
       snoozeRows: ['broker'],
     })
-    expect(out).toBe('✅ <b>k</b> back up · v0.1')
+    expect(out).toBe('✅ **k** back up · v0.1')
   })
 
   it('resolvedRows alone (no probes degraded) renders the resolved row beneath the ack', () => {
@@ -360,8 +371,8 @@ describe('renderBootCard — resolved / snooze rendering', () => {
       version: 'v',
       resolvedRows: ['skills', 'broker'],
     })
-    expect(out).toContain('✅ <b>Skills</b>  resolved')
-    expect(out).toContain('✅ <b>Broker</b>  resolved')
+    expect(out).toContain('✅ **Skills**  resolved')
+    expect(out).toContain('✅ **Broker**  resolved')
   })
 })
 
@@ -370,13 +381,13 @@ describe('renderBootCard — resolved / snooze rendering', () => {
 describe('renderBootCard — configChanges rows', () => {
   it('silent when configChanges is absent', () => {
     const out = renderBootCard({ agentName: 'k', version: 'v' })
-    expect(out).toBe('✅ <b>k</b> back up · v')
+    expect(out).toBe('✅ **k** back up · v')
     expect(out).not.toContain('Config')
   })
 
   it('silent when configChanges is empty array', () => {
     const out = renderBootCard({ agentName: 'k', version: 'v', configChanges: [] })
-    expect(out).toBe('✅ <b>k</b> back up · v')
+    expect(out).toBe('✅ **k** back up · v')
     expect(out).not.toContain('Config')
   })
 
@@ -386,7 +397,7 @@ describe('renderBootCard — configChanges rows', () => {
       version: 'v',
       configChanges: [{ field: 'model', from: 'claude-opus-4', to: 'claude-sonnet-4-5' }],
     })
-    expect(out).toContain('⚙️ <b>Config</b>')
+    expect(out).toContain('⚙️ **Config**')
     expect(out).toContain('claude-opus-4')
     expect(out).toContain('claude-sonnet-4-5')
     expect(out).toContain('→')
@@ -454,6 +465,6 @@ describe('renderBootCard — configChanges rows', () => {
   it('bare ack still returned when configChanges fires but produces only empty rows (defensive)', () => {
     // Edge: empty configChanges array passed → should not produce rows.
     const out = renderBootCard({ agentName: 'k', version: 'v', configChanges: [] })
-    expect(out).toBe('✅ <b>k</b> back up · v')
+    expect(out).toBe('✅ **k** back up · v')
   })
 })

package/telegram-plugin/tests/bot-api.harness.ts

@@ -26,11 +26,29 @@ export interface MockBotApi {
       opts?: Record<string, unknown>,
     ) => Promise<{ message_id: number }>
   >
+  /**
+   * Bot API 10.1 rich-message send (#2669). Receives the
+   * `InputRichMessage` ({ markdown }) as the 2nd arg, mirroring grammy
+   * 1.44's `sendRichMessage`. Tests assert on
+   * `sendRichMessage.mock.calls[i][1].markdown` for the raw GFM body.
+   */
+  sendRichMessage: MockInstance<
+    (
+      chat_id: string,
+      rich_message: { markdown: string },
+      opts?: Record<string, unknown>,
+    ) => Promise<{ message_id: number }>
+  >
+  /**
+   * editMessageText's 3rd arg is `string | { markdown: string }` — a
+   * plain string on the literal path, an `InputRichMessage` on the rich
+   * path (#2669).
+   */
   editMessageText: MockInstance<
     (
       chat_id: string,
       message_id: number,
-      text: string,
+      text: string | { markdown: string },
       opts?: Record<string, unknown>,
     ) => Promise<unknown>
   >
@@ -65,6 +83,7 @@ export function createMockBot(startMessageId = 500): MockBot {
 
   const api: MockBotApi = {
     sendMessage: vi.fn(async () => ({ message_id: state.nextMessageId++ })),
+    sendRichMessage: vi.fn(async () => ({ message_id: state.nextMessageId++ })),
     editMessageText: vi.fn(async () => undefined),
     deleteMessage: vi.fn(async () => true as const),
     setMessageReaction: vi.fn(async () => true as const),
@@ -100,6 +119,9 @@ export function installBotResetHook(bot: MockBot): void {
     bot.api.sendMessage.mockImplementation(async () => ({
       message_id: bot.nextMessageId++,
     }))
+    bot.api.sendRichMessage.mockImplementation(async () => ({
+      message_id: bot.nextMessageId++,
+    }))
     bot.api.editMessageText.mockImplementation(async () => undefined)
     bot.api.deleteMessage.mockImplementation(async () => true as const)
     bot.api.setMessageReaction.mockImplementation(async () => true as const)

package/telegram-plugin/tests/bot-runtime.test.ts

@@ -44,21 +44,16 @@ afterEach(() => {
 
 // ─── escapeHtmlForTg ─────────────────────────────────────────────────────
 
-describe('escapeHtmlForTg', () => {
-  it('escapes ampersands', () => {
-    expect(escapeHtmlForTg('a & b')).toBe('a & b')
+describe('escapeHtmlForTg (now a markdown escaper, kept under the legacy name, #2669)', () => {
+  it('leaves & < > literal (they are not markdown specials)', () => {
+    expect(escapeHtmlForTg('a & b')).toBe('a & b')
+    expect(escapeHtmlForTg('<script>')).toBe('<script>')
+    expect(escapeHtmlForTg('a > b')).toBe('a > b')
+    expect(escapeHtmlForTg('<a & b>')).toBe('<a & b>')
   })
 
-  it('escapes less-than', () => {
-    expect(escapeHtmlForTg('<script>')).toBe('&lt;script&gt;')
-  })
-
-  it('escapes greater-than', () => {
-    expect(escapeHtmlForTg('a > b')).toBe('a &gt; b')
-  })
-
-  it('escapes all three in one string', () => {
-    expect(escapeHtmlForTg('<a & b>')).toBe('&lt;a &amp; b&gt;')
+  it('escapes the inline-markdown specials (\\ ` * _ ~ = [ ] |)', () => {
+    expect(escapeHtmlForTg('a *b* _c_')).toBe('a \\*b\\* \\_c\\_')
   })
 
   it('returns plain text unchanged', () => {
@@ -68,13 +63,23 @@ describe('escapeHtmlForTg', () => {
 
 // ─── preBlock ────────────────────────────────────────────────────────────
 
-describe('preBlock', () => {
-  it('wraps text in pre tags', () => {
-    expect(preBlock('hello')).toBe('<pre>hello</pre>')
+describe('preBlock (now a fenced code block, #2669)', () => {
+  it('wraps text in a triple-backtick fence', () => {
+    expect(preBlock('hello')).toBe('```\nhello\n```')
+  })
+
+  it('keeps content literal inside the fence (no HTML escaping needed)', () => {
+    // Inside a fenced code block everything is verbatim; HTML/markdown is inert.
+    expect(preBlock('<b>bold</b>')).toBe('```\n<b>bold</b>\n```')
   })
 
-  it('escapes HTML inside the block', () => {
-    expect(preBlock('<b>bold</b>')).toBe('<pre>&lt;b&gt;bold&lt;/b&gt;</pre>')
+  it('defuses a fence-closing ``` sequence embedded in the content', () => {
+    const out = preBlock('a ``` b')
+    // The embedded ``` is broken with a zero-width space so it cannot close
+    // the fence early.
+    expect(out.startsWith('```\n')).toBe(true)
+    expect(out.endsWith('\n```')).toBe(true)
+    expect(out).not.toContain('a ``` b')
   })
 })
 

package/telegram-plugin/tests/card-format.test.ts

@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest'
 import {
   cleanWorkerResultParagraph,
-  escapeHtml,
   formatDuration,
   stripMarkdown,
   truncate,
 } from '../card-format.js'
+import { escapeMarkdown } from '../format.js'
 
 describe('stripMarkdown', () => {
   it('strips paired bold and emphasis', () => {
@@ -85,9 +85,11 @@ describe('formatDuration', () => {
   })
 })
 
-describe('escapeHtml / truncate', () => {
-  it('escapes the three HTML-significant characters', () => {
-    expect(escapeHtml('a <b> & c')).toBe('a &lt;b&gt; &amp; c')
+describe('escapeMarkdown / truncate', () => {
+  it('escapes the inline-markdown specials, leaving < > & literal (#2669)', () => {
+    // The HTML escaper is gone; escapeMarkdown escapes \ ` * _ ~ = [ ] | only.
+    expect(escapeMarkdown('a <b> & c')).toBe('a <b> & c')
+    expect(escapeMarkdown('a *b* _c_')).toBe('a \\*b\\* \\_c\\_')
   })
   it('truncates with an ellipsis', () => {
     expect(truncate('abcdef', 4)).toBe('abc…')

package/telegram-plugin/tests/config-snapshot.test.ts

@@ -285,7 +285,7 @@ describe('renderConfigChangeDim', () => {
     for (const field of fields) {
       const row = renderConfigChangeDim({ field, from: 'a', to: 'b' })
       expect(row).toContain('⚙️')
-      expect(row).toContain('<b>Config</b>')
+      expect(row).toContain('**Config**')
     }
   })
 })

package/telegram-plugin/tests/credits-watch.test.ts

@@ -103,7 +103,7 @@ describe("evaluateCreditState — transition decisions (machinery, explicit fata
     if (d.kind !== "notify") return;
     expect(d.transition).toBe("entered");
     expect(d.message).toContain("out of pre-paid credits");
-    expect(d.message).toContain("<b>lawgpt</b>");
+    expect(d.message).toContain("**lawgpt**");
     expect(d.newState.lastNotifiedReason).toBe("out_of_credits");
     expect(d.newState.lastNotifiedAt).toBe(NOW);
   });
@@ -175,9 +175,9 @@ describe("evaluateCreditState — transition decisions (machinery, explicit fata
     expect(d.kind).toBe("skip");
   });
 
-  it("escapes HTML in the agent name (defensive)", () => {
+  it("markdown-escapes emphasis specials in the agent name; < > stay literal (#2669)", () => {
     const d = evaluateCreditState({
-      agentName: "<evil>",
+      agentName: "ev_il",
       currentReason: "out_of_credits",
       prev: HEALTHY,
       now: NOW,
@@ -185,8 +185,8 @@ describe("evaluateCreditState — transition decisions (machinery, explicit fata
     });
     expect(d.kind).toBe("notify");
     if (d.kind !== "notify") return;
-    expect(d.message).toContain("&lt;evil&gt;");
-    expect(d.message).not.toContain("<evil>");
+    // The underscore is escaped so it can't open an italic run inside **…**.
+    expect(d.message).toContain("ev\\_il");
   });
 });
 

package/telegram-plugin/tests/fake-bot-api.ts

@@ -27,10 +27,21 @@ export interface SentMessage {
   readonly message_id: number
   readonly chat_id: string
   readonly text: string
+  /**
+   * True when the message landed via the Bot API 10.1 rich path
+   * (`sendRichMessage`) rather than plain `sendMessage` (#2669). `text`
+   * holds the raw GFM markdown body in both cases (for a rich send it is
+   * `rich_message.markdown`), so existing text assertions keep working;
+   * tests that care about the path assert on this flag.
+   */
+  readonly rich?: boolean
   readonly parse_mode?: string
   readonly reply_to_message_id?: number
+  readonly reply_parameters?: { message_id: number; quote?: { text: string; position: number } }
+  readonly reply_markup?: unknown
   readonly message_thread_id?: number
   readonly disable_notification?: boolean
+  readonly link_preview_options?: unknown
 }
 
 export interface PinnedRef {
@@ -184,6 +195,7 @@ export const errors = {
 
 export interface FakeBotApi {
   sendMessage: ReturnType<typeof vi.fn>
+  sendRichMessage: ReturnType<typeof vi.fn>
   editMessageText: ReturnType<typeof vi.fn>
   deleteMessage: ReturnType<typeof vi.fn>
   setMessageReaction: ReturnType<typeof vi.fn>
@@ -367,27 +379,69 @@ export function createFakeBotApi(opts: CreateFakeBotApiOpts = {}): FakeBot {
         text,
         parse_mode: opts?.parse_mode as string | undefined,
         reply_to_message_id: opts?.reply_to_message_id as number | undefined,
+        reply_parameters: opts?.reply_parameters as SentMessage['reply_parameters'],
+        reply_markup: opts?.reply_markup,
         message_thread_id: opts?.message_thread_id as number | undefined,
         disable_notification: opts?.disable_notification as boolean | undefined,
+        link_preview_options: opts?.link_preview_options,
       }
       sent.push(record)
       currentText.set(message_id, text)
       return { message_id, chat: { id: chat_id }, date: Math.floor(Date.now() / 1000), text }
     }),
 
+    // Bot API 10.1 rich-message send (#2669). Records the raw GFM markdown
+    // (`rich_message.markdown`) into `text` so existing text/state
+    // assertions keep working, flags the record `rich: true`, and captures
+    // reply_markup / reply_parameters / message_thread_id the same way
+    // sendMessage does. sendRichMessage does NOT accept link_preview_options
+    // on the wire — the controller strips it before calling — so it is not
+    // recorded here.
+    sendRichMessage: vi.fn(
+      async (chat_id: string, rich_message: { markdown: string }, opts?: Record<string, unknown>) => {
+        await applyEntryGates('sendRichMessage', chat_id)
+        const markdown = rich_message?.markdown ?? ''
+        const message_id = nextMessageId++
+        const record: SentMessage = {
+          message_id,
+          chat_id,
+          text: markdown,
+          rich: true,
+          reply_to_message_id: opts?.reply_to_message_id as number | undefined,
+          reply_parameters: opts?.reply_parameters as SentMessage['reply_parameters'],
+          reply_markup: opts?.reply_markup,
+          message_thread_id: opts?.message_thread_id as number | undefined,
+          disable_notification: opts?.disable_notification as boolean | undefined,
+        }
+        sent.push(record)
+        currentText.set(message_id, markdown)
+        return { message_id, chat: { id: chat_id }, date: Math.floor(Date.now() / 1000), text: markdown }
+      },
+    ),
+
     editMessageText: vi.fn(
-      async (chat_id: string, message_id: number, text: string, opts?: Record<string, unknown>) => {
+      async (
+        chat_id: string,
+        message_id: number,
+        text: string | { markdown: string },
+        opts?: Record<string, unknown>,
+      ) => {
         await applyEntryGates('editMessageText', chat_id)
-        checkParseMode('editMessageText', text, opts?.parse_mode as string | undefined)
+        // #2669: the rich path passes `{ markdown }`; the literal path
+        // passes a plain string. Normalize to the body string for the
+        // not-modified / currentText bookkeeping.
+        const isRich = typeof text === 'object' && text != null
+        const body = isRich ? (text as { markdown: string }).markdown : (text as string)
+        if (!isRich) checkParseMode('editMessageText', body, opts?.parse_mode as string | undefined)
         if (deleted.has(message_id) || !currentText.has(message_id)) {
           // Simulate Telegram's real 400 when the target is gone.
           throw errors.messageToEditNotFound()
         }
         const prev = currentText.get(message_id)
-        if (prev === text) {
+        if (prev === body) {
           throw errors.notModified()
         }
-        currentText.set(message_id, text)
+        currentText.set(message_id, body)
         return true
       },
     ),

package/telegram-plugin/tests/finalize-callback.test.ts

@@ -15,7 +15,7 @@ import { finalizeCallback, type FinalizeCallbackContext } from '../inline-keyboa
 
 interface Capture {
   acks: Array<{ text?: string; show_alert?: boolean }>
-  edits: Array<{ text: string; opts: Record<string, unknown> }>
+  edits: Array<{ text: string | { markdown: string }; opts: Record<string, unknown> }>
   ackThrows?: Error
   editThrows?: Error
 }
@@ -57,25 +57,27 @@ describe('finalizeCallback — three-invariant contract', () => {
     expect(cap.acks[0]?.show_alert).toBe(true)
   })
 
-  it('invariant 2: strips reply_markup AND edits the body in one atomic call', async () => {
+  it('invariant 2: strips reply_markup AND rich-edits the body in one atomic call', async () => {
     const cap: Capture = { acks: [], edits: [] }
     await finalizeCallback(mkCtx(cap), {
       ackText: 'Approved',
-      newText: '✓ Approved\n\nGrant minted at 22:38 UTC',
-      parseMode: 'HTML',
+      newText: '**✓ Approved**\n\nGrant minted at 22:38 UTC',
     })
     expect(cap.edits).toHaveLength(1)
-    expect(cap.edits[0]?.text).toBe('✓ Approved\n\nGrant minted at 22:38 UTC')
+    // Default (non-literal) path wraps the body in the rich-message
+    // { markdown } object — raw GFM markdown, no parse_mode (#2669).
+    expect(cap.edits[0]?.text).toEqual({ markdown: '**✓ Approved**\n\nGrant minted at 22:38 UTC' })
     expect(cap.edits[0]?.opts.reply_markup).toEqual({ inline_keyboard: [] })
-    expect(cap.edits[0]?.opts.parse_mode).toBe('HTML')
+    expect(cap.edits[0]?.opts.parse_mode).toBeUndefined()
     // link_preview_options disabled by default — keeps the edited
     // status line from rendering a stale preview card.
     expect(cap.edits[0]?.opts.link_preview_options).toEqual({ is_disabled: true })
   })
 
-  it('invariant 2: omits parse_mode when not specified (plain text)', async () => {
+  it('invariant 2: literalText edits a plain string (no rich wrapper, no parse_mode)', async () => {
     const cap: Capture = { acks: [], edits: [] }
-    await finalizeCallback(mkCtx(cap), { ackText: 'ok', newText: 'plain' })
+    await finalizeCallback(mkCtx(cap), { ackText: 'ok', newText: 'plain', literalText: true })
+    expect(cap.edits[0]?.text).toBe('plain')
     expect(cap.edits[0]?.opts.parse_mode).toBeUndefined()
   })
 
@@ -170,7 +172,7 @@ describe('finalizeCallback — three-invariant contract', () => {
       log: (l) => logs.push(l),
     })
     expect(cap.edits).toHaveLength(1)
-    expect(cap.edits[0]?.text).toBe('edited body')
+    expect(cap.edits[0]?.text).toEqual({ markdown: 'edited body' })
     expect(synthFired).toBe(true)
     // ack fire-and-forget — its catch fires asynchronously; give it a tick
     // so the log assertion is stable across runs.

package/telegram-plugin/tests/foreground-nesting.test.ts

@@ -91,7 +91,7 @@ describe('end-to-end render shape under ack-first', () => {
     )
     expect(html).not.toBeNull()
     // newest child is the live, bold current step
-    expect(html).toContain('<b>→ ranking by resolution</b>')
+    expect(html).toContain('**→ ranking by resolution**')
     // an earlier child is present as a done/italic step
     expect(html).toContain('checking license on 4 candidates')
   })