switchroom 0.16.23 → 0.16.24

package/telegram-plugin/tests/single-mode-stream-reply.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Single-mode stream-reply behaviour (post-#2669).
+ *
+ * The parse-mode rotation this file used to cover is GONE: there is now
+ * exactly ONE rendering mode (raw GFM markdown via `sendRichMessage` /
+ * `editMessageText({ markdown })`). The successor contract is:
+ *
+ *   - Every non-`text` format reuses the SAME draft stream for a
+ *     chat+thread+lane — no finalize-and-recreate dance, because no baked
+ *     parse_mode can ever go stale.
+ *   - The only fork is the literal `format:'text'` path (`literalText`),
+ *     which sends a plain string instead of a rich-markdown wrapper.
+ *
+ * This file is retained (rather than deleted) to lock in the
+ * single-mode-reuse invariant that replaced rotation, so a future
+ * regression that reintroduces per-mode stream churn is caught.
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import { handleStreamReply, type StreamReplyDeps, type StreamReplyState } from '../stream-reply-handler.js'
+import type { DraftStreamHandle } from '../draft-stream.js'
+import { createFakeBotApi, type FakeBot } from './fake-bot-api.js'
+
+function makeState(): StreamReplyState {
+  return {
+    activeDraftStreams: new Map<string, DraftStreamHandle>(),
+  }
+}
+
+function makeDeps(bot: FakeBot, overrides?: Partial<StreamReplyDeps>): StreamReplyDeps {
+  return {
+    bot: bot as unknown as StreamReplyDeps['bot'],
+    repairEscapedWhitespace: (t) => t,
+    assertAllowedChat: () => {},
+    resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
+    disableLinkPreview: true,
+    // Anything other than the literal 'text' is the rich-markdown path.
+    defaultFormat: 'markdown',
+    logStreamingEvent: () => {},
+    historyEnabled: false,
+    recordOutbound: () => {},
+    writeError: () => {},
+    throttleMs: 0,
+    ...overrides,
+  }
+}
+
+describe('stream-reply single-mode reuse (#2669)', () => {
+  let bot: FakeBot
+
+  beforeEach(() => {
+    bot = createFakeBotApi({ startMessageId: 500 })
+  })
+
+  it('same chat+thread+lane reuses the one stream — no recreate', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'v1' }, state, deps)
+    const streamBefore = state.activeDraftStreams.get('c:_')
+    await handleStreamReply({ chat_id: 'c', text: 'v2' }, state, deps)
+    const streamAfter = state.activeDraftStreams.get('c:_')
+
+    // Identity preserved — there is no rotation to churn the stream.
+    expect(streamBefore).toBe(streamAfter)
+    // First call sent a rich message; second edited it in place.
+    expect(bot.state.sent).toHaveLength(1)
+    expect(bot.state.sent[0].rich).toBe(true)
+    expect(bot.api.editMessageText).toHaveBeenCalled()
+  })
+
+  it('the rich path ships raw GFM markdown unescaped via sendRichMessage', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: '**bold** and _italic_' }, state, deps)
+
+    expect(bot.state.sent).toHaveLength(1)
+    expect(bot.state.sent[0].rich).toBe(true)
+    // Raw markdown is the wire payload — no HTML, no MarkdownV2 escaping.
+    expect(bot.state.sent[0].text).toBe('**bold** and _italic_')
+    expect(bot.state.sent[0].parse_mode).toBeUndefined()
+  })
+
+  it('format:"text" takes the literal plain path (no rich wrapper)', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'plain < text >', format: 'text' }, state, deps)
+
+    expect(bot.state.sent).toHaveLength(1)
+    expect(bot.state.sent[0].rich).toBeFalsy()
+    expect(bot.state.sent[0].text).toBe('plain < text >')
+  })
+
+  it('switching format on the same lane does NOT recreate the stream (single mode)', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    // First call as the default rich path…
+    await handleStreamReply({ chat_id: 'c', text: 'rich first', format: 'markdown' }, state, deps)
+    const first = state.activeDraftStreams.get('c:_')
+
+    // …then a call nominally requesting a different (non-text) format.
+    // Pre-#2669 this rotated the stream; now there's nothing to rotate.
+    await handleStreamReply({ chat_id: 'c', text: 'rich second', format: 'gfm' }, state, deps)
+    const second = state.activeDraftStreams.get('c:_')
+
+    expect(second).toBe(first)
+    // Still a single message — edited in place, not a second send.
+    expect(bot.state.sent).toHaveLength(1)
+  })
+
+  it('distinct lanes get independent streams', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'main', lane: 'main' }, state, deps)
+    await handleStreamReply({ chat_id: 'c', text: 'activity', lane: 'activity' }, state, deps)
+
+    expect(state.activeDraftStreams.size).toBe(2)
+    expect(bot.state.sent).toHaveLength(2)
+  })
+
+  it('distinct threads get independent streams', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot)
+
+    await handleStreamReply({ chat_id: 'c', text: 'thread-a', message_thread_id: '1' }, state, deps)
+    await handleStreamReply({ chat_id: 'c', text: 'thread-b', message_thread_id: '2' }, state, deps)
+
+    expect(state.activeDraftStreams.size).toBe(2)
+    expect(bot.state.sent).toHaveLength(2)
+    expect(bot.state.sent[0].message_thread_id).toBe(1)
+    expect(bot.state.sent[1].message_thread_id).toBe(2)
+  })
+})

package/telegram-plugin/tests/skill-proposal-card.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Unit tests for telegram-plugin/gateway/skill-proposal-card.ts (#2670).
+ *
+ * Pure builders — no SQLite, no gateway. Contract under test:
+ *   - parseSkillProposalCallback round-trips the keyboard's callback_data.
+ *   - renderSkillProposalCard escapes HTML and shows lesson + steps.
+ *   - buildSkillProposalApplyInbound pins source='skill_proposal_apply' +
+ *     meta fields the bridge keys on.
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  parseSkillProposalCallback,
+  skillProposalKeyboard,
+  renderSkillProposalCard,
+  buildSkillProposalApplyInbound,
+  previewSteps,
+  SKILL_PROPOSAL_CALLBACK_PREFIX,
+} from '../gateway/skill-proposal-card.js'
+
+describe('skill-proposal callback round-trip', () => {
+  it('keyboard callback_data parses back to action + id', () => {
+    const kb = skillProposalKeyboard('abc-123')
+    const [approve, deny] = kb.inline_keyboard[0]!
+    expect(parseSkillProposalCallback(approve!.callback_data)).toEqual({
+      action: 'approve',
+      id: 'abc-123',
+    })
+    expect(parseSkillProposalCallback(deny!.callback_data)).toEqual({
+      action: 'deny',
+      id: 'abc-123',
+    })
+  })
+
+  it('rejects foreign / malformed callback_data', () => {
+    expect(parseSkillProposalCallback('vra:approve:x')).toBeNull()
+    expect(parseSkillProposalCallback(`${SKILL_PROPOSAL_CALLBACK_PREFIX}bogus:x`)).toBeNull()
+    expect(parseSkillProposalCallback(`${SKILL_PROPOSAL_CALLBACK_PREFIX}approve:`)).toBeNull()
+  })
+
+  it('callback_data fits Telegram 64-byte limit for a UUID id', () => {
+    const kb = skillProposalKeyboard('00000000-0000-0000-0000-000000000000')
+    for (const row of kb.inline_keyboard) {
+      for (const b of row) {
+        expect(Buffer.byteLength(b.callback_data, 'utf8')).toBeLessThanOrEqual(64)
+      }
+    }
+  })
+})
+
+describe('renderSkillProposalCard', () => {
+  it('shows lesson, evidence, and escapes HTML', () => {
+    const text = renderSkillProposalCard({
+      id: 'x',
+      skill_slug: 'deploy-checklist',
+      is_new: true,
+      lesson: 'Always run <smoke> first',
+      evidence: 'seen across 3 sessions',
+      skill_md: '---\nname: deploy-checklist\ndescription: d\n---\n\n1. step one\n2. step two',
+    })
+    expect(text).toContain('New personal skill')
+    expect(text).toContain('deploy-checklist')
+    expect(text).toContain('&lt;smoke&gt;') // escaped
+    expect(text).toContain('seen across 3 sessions')
+    expect(text).toContain('step one')
+  })
+
+  it('previewSteps drops frontmatter + headings', () => {
+    const steps = previewSteps('---\nname: x\n---\n\n# Title\n1. alpha\n- beta\n')
+    expect(steps).toEqual(['alpha', 'beta'])
+  })
+})
+
+describe('buildSkillProposalApplyInbound', () => {
+  it('pins source and meta for a new skill', () => {
+    const inb = buildSkillProposalApplyInbound({
+      ctx: { agent: 'klanker', chat_id: '12345' },
+      proposalId: 'p1',
+      skillSlug: 'deploy-checklist',
+      isNew: true,
+      operatorId: '999',
+      nowMs: 1000,
+    })
+    expect(inb.meta.source).toBe('skill_proposal_apply')
+    expect(inb.meta.proposal_id).toBe('p1')
+    expect(inb.meta.skill_slug).toBe('deploy-checklist')
+    expect(inb.meta.is_new).toBe('true')
+    expect(inb.chatId).toBe('12345')
+    expect(inb.text).toContain('skill_init_personal')
+  })
+
+  it('points at the edit tool when isNew=false', () => {
+    const inb = buildSkillProposalApplyInbound({
+      ctx: { agent: 'klanker', chat_id: '12345' },
+      proposalId: 'p2',
+      skillSlug: 'deploy-checklist',
+      isNew: false,
+      operatorId: '999',
+    })
+    expect(inb.text).toContain('skill_edit_personal')
+    expect(inb.meta.is_new).toBe('false')
+  })
+})

package/telegram-plugin/tests/slot-banner-driver.e2e.test.ts

@@ -65,13 +65,14 @@ describe('refreshBanner — transitions from clean state', () => {
     expect(next).not.toBeNull();
     expect(next?.slot).toBe('personal');
     expect(next?.messageId).toBe(100);
-    // sendMessage + pinChatMessage called in that order.
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    // sendRichMessage + pinChatMessage called in that order (#2669).
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1);
     expect(bot.api.pinChatMessage).toHaveBeenCalledTimes(1);
-    const sendArgs = bot.api.sendMessage.mock.calls[0];
+    const sendArgs = bot.api.sendRichMessage.mock.calls[0];
     expect(sendArgs[0]).toBe(OWNER);
-    expect(sendArgs[1]).toContain('clerk');
-    expect(sendArgs[1]).toContain('personal');
+    const md = (sendArgs[1] as { markdown: string }).markdown;
+    expect(md).toContain('clerk');
+    expect(md).toContain('personal');
     // Pin call should disable notifications so users don't get pinged.
     const pinArgs = bot.api.pinChatMessage.mock.calls[0];
     expect(pinArgs[2]).toMatchObject({ disable_notification: true });
@@ -100,6 +101,7 @@ describe('refreshBanner — transitions from pinned state', () => {
     prior = seeded;
     // Reset the spy counts so the under-test transition starts from zero.
     bot.api.sendMessage.mockClear();
+    bot.api.sendRichMessage.mockClear();
     bot.api.editMessageText.mockClear();
     bot.api.pinChatMessage.mockClear();
     bot.api.unpinChatMessage.mockClear();
@@ -132,10 +134,12 @@ describe('refreshBanner — transitions from pinned state', () => {
     expect(next).toEqual({ messageId: prior.messageId, slot: 'work' });
     expect(bot.api.editMessageText).toHaveBeenCalledTimes(1);
     expect(bot.api.sendMessage).not.toHaveBeenCalled();
+    expect(bot.api.sendRichMessage).not.toHaveBeenCalled();
     const editArgs = bot.api.editMessageText.mock.calls[0];
     expect(editArgs[0]).toBe(OWNER);
     expect(editArgs[1]).toBe(prior.messageId);
-    expect(editArgs[2]).toContain('work');
+    // #2669: the edit carries the rich { markdown } wrapper, not a string.
+    expect((editArgs[2] as { markdown: string }).markdown).toContain('work');
   });
 
   it('return to default slot unpins, clears state', async () => {
@@ -216,7 +220,7 @@ describe('refreshBanner — full lifecycle (sequenced)', () => {
     expect(state).toBeNull();
 
     // Final tally on the chat model.
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1);
     expect(bot.api.editMessageText).toHaveBeenCalledTimes(1);
     expect(bot.api.unpinChatMessage).toHaveBeenCalledTimes(1);
     expect(bot.api.pinChatMessage).toHaveBeenCalledTimes(1);
@@ -241,13 +245,13 @@ describe('refreshBanner — error paths', () => {
       onError,
     });
     expect(next).toBeNull(); // prior state was null, preserved
-    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1);
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1);
     expect(bot.api.pinChatMessage).toHaveBeenCalledTimes(1);
     expect(onError).toHaveBeenCalledWith('pin', expect.any(Error));
   });
 
-  it('sendMessage failure surfaces but does not throw', async () => {
-    bot.faults.next('sendMessage', errors.forbidden('sendMessage'));
+  it('sendRichMessage failure surfaces but does not throw', async () => {
+    bot.faults.next('sendRichMessage', errors.forbidden('sendRichMessage'));
     const onError = vi.fn();
     const next = await refreshBanner({
       bot,
@@ -311,30 +315,33 @@ describe('refreshBanner — banner content', () => {
       defaultSlot: 'default',
       prevState: null,
     });
-    const text = bot.api.sendMessage.mock.calls[0][1] as string;
+    const rich = bot.api.sendRichMessage.mock.calls[0][1] as { markdown: string };
+    const text = rich.markdown;
     expect(text).toContain('klanker');
     expect(text).toContain('backup');
     expect(text).toContain('default');
     expect(text.toLowerCase()).toMatch(/failover/);
   });
 
-  it('escapes HTML in agent and slot names (no XSS via slot rename)', async () => {
+  it('markdown-escapes emphasis specials in agent name; slot names ride in code spans (#2669)', async () => {
     await refreshBanner({
       bot,
       ownerChatId: OWNER,
-      agentName: '<bad>',
-      currentSlot: '"hax"',
-      defaultSlot: '&def',
+      agentName: 'a_b*c',
+      currentSlot: 'slot_1',
+      defaultSlot: 'def_2',
       prevState: null,
     });
-    const text = bot.api.sendMessage.mock.calls[0][1] as string;
-    expect(text).not.toContain('<bad>');
-    expect(text).toContain('&lt;bad&gt;');
-    expect(text).toContain('&quot;hax&quot;');
-    expect(text).toContain('&amp;def');
+    const rich = bot.api.sendRichMessage.mock.calls[0][1] as { markdown: string };
+    const text = rich.markdown;
+    // The agent name is bolded — its emphasis specials are escaped.
+    expect(text).toContain('**a\\_b\\*c**');
+    // Slot names ride in `code spans` — literal, never escaped.
+    expect(text).toContain('`slot_1`');
+    expect(text).toContain('`def_2`');
   });
 
-  it('uses HTML parse_mode + disables link preview', async () => {
+  it('sends via the rich path (no parse_mode, no link_preview_options) #2669', async () => {
     await refreshBanner({
       bot,
       ownerChatId: OWNER,
@@ -343,8 +350,13 @@ describe('refreshBanner — banner content', () => {
       defaultSlot: DEFAULT,
       prevState: null,
     });
-    const opts = bot.api.sendMessage.mock.calls[0][2] as Record<string, unknown>;
-    expect(opts.parse_mode).toBe('HTML');
-    expect(opts.link_preview_options).toEqual({ is_disabled: true });
+    // The banner ships raw GFM markdown via sendRichMessage — no parse_mode,
+    // and sendRichMessage doesn't accept link_preview_options (it's omitted).
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1);
+    expect(bot.api.sendMessage).not.toHaveBeenCalled();
+    const opts = bot.api.sendRichMessage.mock.calls[0][2] as Record<string, unknown>;
+    expect(opts.parse_mode).toBeUndefined();
+    expect(opts.link_preview_options).toBeUndefined();
+    expect(opts.disable_notification).toBe(true);
   });
 });

package/telegram-plugin/tests/slot-banner.test.ts

@@ -58,12 +58,15 @@ describe('decideBannerAction — non-default state', () => {
 });
 
 describe('formatBannerHtml', () => {
-  it('escapes HTML in agent and slot names', () => {
-    const text = formatBannerHtml('<bad>', '"hax"', '&def');
-    expect(text).not.toContain('<bad>');
-    expect(text).toContain('&lt;bad&gt;');
-    expect(text).toContain('&quot;hax&quot;');
-    expect(text).toContain('&amp;def');
+  it('markdown-escapes emphasis specials in the agent name (#2669)', () => {
+    // The agent name is interpolated into a **bold** run, so an emphasis
+    // special in it must be backslash-escaped or it would break the run.
+    // Slot names live in `code spans` (literal) and need no escaping.
+    const text = formatBannerHtml('a_b*c', 'slot_1', 'def_2');
+    expect(text).toContain('**a\\_b\\*c**');
+    // Slot names ride in code spans verbatim (literal inside backticks).
+    expect(text).toContain('`slot_1`');
+    expect(text).toContain('`def_2`');
   });
 
   it('mentions the failover-from default for context', () => {

package/telegram-plugin/tests/status-accent.test.ts

@@ -1,9 +1,9 @@
 /**
  * Tests for the inline status-accent header feature (issue #320 fallback).
  *
- * Covers both the pure `buildAccentHeader` helper and the integration paths
- * through `handleStreamReply` (stream_reply) and the server reply case
- * (exercised via the handler directly since server.ts wires it the same way).
+ * Post-#2669 the header is GFM markdown (every outbound goes through the
+ * rich-message path), and the body ships as raw markdown via
+ * `sendRichMessage` / `editMessageText({ markdown })`.
  */
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
 import { buildAccentHeader, handleStreamReply, type StreamReplyDeps, type StreamReplyState } from '../stream-reply-handler.js'
@@ -13,16 +13,16 @@ import { createMockBot, installBotResetHook, microtaskFlush } from './bot-api.ha
 // ─── buildAccentHeader unit tests ────────────────────────────────────────────
 
 describe('buildAccentHeader', () => {
-  it("'in-progress' returns the blue circle header", () => {
-    expect(buildAccentHeader('in-progress')).toBe('🔵 <i>In progress…</i>\n\n')
+  it("'in-progress' returns the blue circle markdown header", () => {
+    expect(buildAccentHeader('in-progress')).toBe('🔵 _In progress…_\n\n')
   })
 
-  it("'done' returns the checkmark header", () => {
-    expect(buildAccentHeader('done')).toBe('✅ <b>Done</b>\n\n')
+  it("'done' returns the checkmark markdown header", () => {
+    expect(buildAccentHeader('done')).toBe('✅ **Done**\n\n')
   })
 
-  it("'issue' returns the warning header", () => {
-    expect(buildAccentHeader('issue')).toBe('⚠️ <b>Issue</b>\n\n')
+  it("'issue' returns the warning markdown header", () => {
+    expect(buildAccentHeader('issue')).toBe('⚠️ **Issue**\n\n')
   })
 
   it('undefined returns empty string (no header)', () => {
@@ -41,7 +41,6 @@ describe('buildAccentHeader', () => {
 function makeState(): StreamReplyState {
   return {
     activeDraftStreams: new Map<string, DraftStreamHandle>(),
-    activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
   }
 }
 
@@ -51,13 +50,11 @@ function makeDeps(
 ): StreamReplyDeps {
   return {
     bot,
-    markdownToHtml: (t) => `<b>${t}</b>`,
-    escapeMarkdownV2: (t) => `\\${t}\\`,
     repairEscapedWhitespace: (t) => t,
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,
-    defaultFormat: 'html',
+    defaultFormat: 'markdown',
     logStreamingEvent: () => {},
     historyEnabled: false,
     recordOutbound: () => {},
@@ -67,6 +64,13 @@ function makeDeps(
   }
 }
 
+function sentMarkdown(bot: ReturnType<typeof createMockBot>, i = 0): string {
+  return (bot.api.sendRichMessage.mock.calls[i][1] as { markdown: string }).markdown
+}
+function editedMarkdown(bot: ReturnType<typeof createMockBot>, i = 0): string {
+  return (bot.api.editMessageText.mock.calls[i][2] as { markdown: string }).markdown
+}
+
 describe('handleStreamReply accent integration', () => {
   const bot = createMockBot()
   installBotResetHook(bot)
@@ -74,7 +78,7 @@ describe('handleStreamReply accent integration', () => {
   beforeEach(() => vi.useFakeTimers())
   afterEach(() => vi.useRealTimers())
 
-  it("accent='in-progress' prepends the blue-circle header before the body", async () => {
+  it("accent='in-progress' prepends the blue-circle markdown header before the body", async () => {
     const state = makeState()
     const deps = makeDeps(bot)
 
@@ -86,12 +90,12 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await pending
 
-    const sent = bot.api.sendMessage.mock.calls[0][1] as string
-    expect(sent).toMatch(/^🔵 <i>In progress…<\/i>\n\n/)
-    expect(sent).toBe('🔵 <i>In progress…</i>\n\n<b>Still working...</b>')
+    const sent = sentMarkdown(bot)
+    expect(sent).toMatch(/^🔵 _In progress…_\n\n/)
+    expect(sent).toBe('🔵 _In progress…_\n\nStill working...')
   })
 
-  it("accent='done' prepends the checkmark header before the body", async () => {
+  it("accent='done' prepends the checkmark markdown header before the body", async () => {
     const state = makeState()
     const deps = makeDeps(bot)
 
@@ -103,11 +107,10 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await pending
 
-    const sent = bot.api.sendMessage.mock.calls[0][1] as string
-    expect(sent).toBe('✅ <b>Done</b>\n\n<b>Task complete.</b>')
+    expect(sentMarkdown(bot)).toBe('✅ **Done**\n\nTask complete.')
   })
 
-  it("accent='issue' prepends the warning header before the body", async () => {
+  it("accent='issue' prepends the warning markdown header before the body", async () => {
     const state = makeState()
     const deps = makeDeps(bot)
 
@@ -119,11 +122,10 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await pending
 
-    const sent = bot.api.sendMessage.mock.calls[0][1] as string
-    expect(sent).toBe('⚠️ <b>Issue</b>\n\n<b>Blocked on X.</b>')
+    expect(sentMarkdown(bot)).toBe('⚠️ **Issue**\n\nBlocked on X.')
   })
 
-  it('no accent — output is unchanged from today (regression guard)', async () => {
+  it('no accent — body ships as raw markdown unchanged (regression guard)', async () => {
     const state = makeState()
     const deps = makeDeps(bot)
 
@@ -135,8 +137,7 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await pending
 
-    const sent = bot.api.sendMessage.mock.calls[0][1] as string
-    expect(sent).toBe('<b>Hello world</b>')
+    expect(sentMarkdown(bot)).toBe('Hello world')
   })
 
   it('invalid accent is silently ignored — output equals no-accent path', async () => {
@@ -151,15 +152,13 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await pending
 
-    const sent = bot.api.sendMessage.mock.calls[0][1] as string
-    expect(sent).toBe('<b>Hello world</b>')
+    expect(sentMarkdown(bot)).toBe('Hello world')
   })
 
   it('accent header is included on every call that passes it (full-text replace model)', async () => {
     const state = makeState()
     const deps = makeDeps(bot)
 
-    // First call
     const p1 = handleStreamReply(
       { chat_id: '1', text: 'Part one', accent: 'in-progress' },
       state,
@@ -168,7 +167,6 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await p1
 
-    // Second call — same turn, same accent
     vi.advanceTimersByTime(1000)
     const p2 = handleStreamReply(
       { chat_id: '1', text: 'Part one Part two', accent: 'in-progress' },
@@ -178,7 +176,6 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await p2
 
-    const edited = bot.api.editMessageText.mock.calls[0][2] as string
-    expect(edited).toBe('🔵 <i>In progress…</i>\n\n<b>Part one Part two</b>')
+    expect(editedMarkdown(bot)).toBe('🔵 _In progress…_\n\nPart one Part two')
   })
 })