switchroom 0.16.23 → 0.16.27

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

@@ -62,10 +62,9 @@ function makeDeps(agentName: string | null) {
     ['chat1:thr1:r1', { isFinal: () => false, finalize: finalizeA }],
     ['chat2:thr2:r2', { isFinal: () => true, finalize: finalizeB }],
   ])
-  const activeDraftParseModes = new Map<string, 'HTML' | 'MarkdownV2' | undefined>([
-    ['chat1:thr1:r1', 'HTML'],
-    ['chat2:thr2:r2', undefined],
-  ])
+  // #2669: the activeDraftParseModes map was retired with parse-mode rotation
+  // (single rich-markdown path now), so the disconnect-flush deps no longer
+  // carry or clear it.
 
   return {
     spies: { setDoneA, setDoneB, finalizeA, finalizeB, clearActiveReactions, disposeProgressDriver, log },
@@ -76,7 +75,6 @@ function makeDeps(agentName: string | null) {
       activeTurnStartedAt,
       claudeBusyKeys,
       activeDraftStreams,
-      activeDraftParseModes,
       clearActiveReactions,
       disposeProgressDriver,
       log,
@@ -103,7 +101,6 @@ describe('flushOnAgentDisconnect — anonymous clients (the regression scenario)
     expect(deps.activeReactionMsgIds.size).toBe(2)
     expect(deps.activeTurnStartedAt.size).toBe(2)
     expect(deps.activeDraftStreams.size).toBe(2)
-    expect(deps.activeDraftParseModes.size).toBe(2)
 
     // But it should log so the operator can correlate the no-op decision.
     expect(spies.log).toHaveBeenCalledTimes(1)
@@ -150,7 +147,6 @@ describe('flushOnAgentDisconnect — registered agent disconnects (existing beha
     expect(spies.finalizeB).not.toHaveBeenCalled()
     // Both stream maps cleared regardless.
     expect(deps.activeDraftStreams.size).toBe(0)
-    expect(deps.activeDraftParseModes.size).toBe(0)
   })
 })
 
@@ -180,7 +176,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       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,
       disposeProgressDriver,
       onDanglingTurnsSwept,
@@ -238,7 +233,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       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(),
       disposeProgressDriver: vi.fn(),
       onDanglingTurnsSwept,
@@ -273,7 +267,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       // 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,
@@ -306,7 +299,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       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(),
     }
@@ -342,7 +334,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       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,
@@ -362,7 +353,6 @@ describe('flushOnAgentDisconnect — dangling-turn sweep (2026-05-23 wedge fix)'
       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(),
       disposeProgressDriver: vi.fn(),
       // onDanglingTurnsSwept intentionally omitted.

package/telegram-plugin/tests/ipc-server-validate-send-outbound.test.ts

@@ -7,6 +7,7 @@
  */
 import { describe, it, expect } from "vitest";
 import { validateClientMessage } from "../gateway/ipc-server.js";
+import { RICH_MESSAGE_MAX_CHARS } from "../format.js";
 
 const base = { type: "send_outbound", agentName: "clerk", chatId: "12345", text: "Daily heartbeat" };
 
@@ -38,8 +39,11 @@ describe("validateClientMessage — send_outbound", () => {
     expect(validateClientMessage({ ...base, text: undefined })).toBe(false);
     expect(validateClientMessage({ ...base, text: "" })).toBe(false);
     expect(validateClientMessage({ ...base, text: 5 })).toBe(false);
-    expect(validateClientMessage({ ...base, text: "x".repeat(4096) })).toBe(true); // at the cap
-    expect(validateClientMessage({ ...base, text: "x".repeat(4097) })).toBe(false); // over Telegram's limit
+    // send_outbound posts via sendRichMessage (rich path), so the cap is the
+    // rich-message wire limit (RICH_MESSAGE_MAX_CHARS, 32768) post-#2669, not
+    // the legacy 4096 plain-text limit.
+    expect(validateClientMessage({ ...base, text: "x".repeat(RICH_MESSAGE_MAX_CHARS) })).toBe(true); // at the cap
+    expect(validateClientMessage({ ...base, text: "x".repeat(RICH_MESSAGE_MAX_CHARS + 1) })).toBe(false); // over the cap
   });
 
   it("rejects a non-integer threadId", () => {

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

@@ -40,7 +40,7 @@ describe("renderIssuesCard", () => {
       makeEvent({ fingerprint: "a::3", code: "3", severity: "info" }),
     ];
     const out = renderIssuesCard({ agentName: "klanker", events });
-    expect(out).toMatch(/^🚨 <b>klanker<\/b>/);
+    expect(out).toMatch(/^🚨 \*\*klanker\*\*/);
     expect(out).toContain("3 issues");
   });
 
@@ -54,7 +54,7 @@ describe("renderIssuesCard", () => {
         }),
       ];
       const out = renderIssuesCard({ agentName: "kengpt", events });
-      expect(out).toContain("→ <i>switchroom vault unlock</i>");
+      expect(out).toContain("→ _switchroom vault unlock_");
       // Summary still rendered above the remediation.
       expect(out).toContain("Morning brief skipped");
     });
@@ -66,7 +66,7 @@ describe("renderIssuesCard", () => {
         }),
       ];
       const out = renderIssuesCard({ agentName: "kengpt", events });
-      expect(out).toMatch(/→ <i>run.*auth heal/);
+      expect(out).toMatch(/→ _run.*auth heal/);
     });
 
     it("ignores multi-line detail (likely stderr tail, not remediation)", () => {
@@ -98,13 +98,12 @@ describe("renderIssuesCard", () => {
       expect((out ?? "").split("\n").every((line) => line.length < 600)).toBe(true);
     });
 
-    it("escapes HTML in remediation hints", () => {
+    it("passes < > literally in remediation hints (markdown, #2669)", () => {
       const events = [
         makeEvent({ detail: "Fix: <script>alert('xss')</script>" }),
       ];
       const out = renderIssuesCard({ agentName: "kengpt", events });
-      expect(out).not.toContain("<script>");
-      expect(out).toContain("&lt;script&gt;");
+      expect(out).toContain("<script>alert('xss')</script>");
     });
   });
 
@@ -158,7 +157,7 @@ describe("renderIssuesCard", () => {
     expect(out).toContain("+10 more not shown");
   });
 
-  it("HTML-escapes user-supplied fields", () => {
+  it("passes < > & literally in user-supplied fields (markdown, #2669)", () => {
     const events = [
       makeEvent({
         agent: "<script>",
@@ -169,10 +168,12 @@ describe("renderIssuesCard", () => {
       }),
     ];
     const out = renderIssuesCard({ agentName: "<script>", events });
-    expect(out).not.toContain("<script>");
-    expect(out).toContain("&lt;script&gt;");
-    expect(out).toContain("&lt;x&gt;::&lt;y&gt;");
-    expect(out).toContain("&lt;dangerous &amp; stuff&gt;");
+    // < > & are literal in rich markdown — no HTML entities. The fingerprint
+    // rides in a `code span` (also literal) and the summary is escaped only
+    // for emphasis specials.
+    expect(out).toContain("<script>");
+    expect(out).toContain("`<x>::<y>`");
+    expect(out).toContain("<dangerous & stuff>");
   });
 });
 
@@ -233,7 +234,9 @@ describe("createIssuesCardHandle", () => {
     });
     await handle.refresh([makeEvent({})]);
     expect(bot.sent).toHaveLength(1);
-    expect(bot.sent[0].opts?.parse_mode).toBe("HTML");
+    // #2669: the card body is raw GFM markdown sent through the rich path
+    // (the gateway wires sendMessage → sendRichMessage). No parse_mode.
+    expect(bot.sent[0].opts?.parse_mode).toBeUndefined();
     expect(handle.messageId()).toBe(1000);
   });
 

package/telegram-plugin/tests/length-error-classify.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Tests for the over-length error classification (task E of the Telegram-
+ * formatting bundle) and the hardSliceToCap last-resort slicer.
+ *
+ * The rich path rejects a 32769+ char body with `RICH_MESSAGE_TEXT_TOO_LONG`
+ * (and the legacy plain path with `MESSAGE_TOO_LONG`). That is a LENGTH error,
+ * not a markdown-parse error — it must be classified so the caller re-splits
+ * the body rather than (a) misclassifying it as a parse-reject and resending
+ * the same oversized payload as plain text, or (b) surfacing the raw 400.
+ */
+import { describe, test, expect } from 'vitest'
+import { GrammyError } from 'grammy'
+import { isLengthError, isParseEntitiesError } from '../rich-send.js'
+import { isMessageTooLongError, isHtmlParseRejectError } from '../retry-api-call.js'
+import { hardSliceToCap, splitMarkdownChunks, RICH_MESSAGE_MAX_CHARS } from '../format.js'
+
+// Build a GrammyError with a given 400 description. GrammyError's constructor
+// takes (message, payload, method, parameters) in grammy 1.44.
+function grammy400(description: string): GrammyError {
+  return new GrammyError(
+    `Call to 'sendRichMessage' failed! (400: ${description})`,
+    { ok: false, error_code: 400, description },
+    'sendRichMessage',
+    {},
+  )
+}
+
+describe('length-error classification (rich-send.isLengthError)', () => {
+  test('RICH_MESSAGE_TEXT_TOO_LONG is a length error', () => {
+    const err = grammy400('RICH_MESSAGE_TEXT_TOO_LONG')
+    expect(isLengthError(err)).toBe(true)
+  })
+
+  test('legacy MESSAGE_TOO_LONG / "message is too long" are length errors', () => {
+    expect(isLengthError(grammy400('MESSAGE_TOO_LONG'))).toBe(true)
+    expect(isLengthError(grammy400('Bad Request: message is too long'))).toBe(true)
+  })
+
+  test('a parse-entities error is NOT a length error', () => {
+    expect(isLengthError(grammy400("can't parse entities: bad offset"))).toBe(false)
+  })
+
+  test('a length error is NOT misclassified as a parse-entities error', () => {
+    const err = grammy400('RICH_MESSAGE_TEXT_TOO_LONG')
+    expect(isParseEntitiesError(err)).toBe(false)
+  })
+
+  test('non-GrammyError and non-400 are neither', () => {
+    expect(isLengthError(new Error('boom'))).toBe(false)
+    const err403 = new GrammyError(
+      'forbidden',
+      { ok: false, error_code: 403, description: 'Forbidden: bot was blocked' },
+      'sendRichMessage',
+      {},
+    )
+    expect(isLengthError(err403)).toBe(false)
+  })
+})
+
+describe('length-error classification (retry-api-call.isMessageTooLongError)', () => {
+  test('RICH_MESSAGE_TEXT_TOO_LONG is a length error', () => {
+    expect(isMessageTooLongError(grammy400('RICH_MESSAGE_TEXT_TOO_LONG'))).toBe(true)
+  })
+
+  test('a length error is NOT misclassified as an html-parse-reject', () => {
+    const err = grammy400('RICH_MESSAGE_TEXT_TOO_LONG')
+    expect(isHtmlParseRejectError(err)).toBe(false)
+  })
+
+  test('a parse-reject error still classifies as a parse-reject (not length)', () => {
+    const err = grammy400("can't parse entities: unexpected end")
+    expect(isHtmlParseRejectError(err)).toBe(true)
+    expect(isMessageTooLongError(err)).toBe(false)
+  })
+})
+
+describe('hardSliceToCap', () => {
+  test('returns the input as one piece when it already fits', () => {
+    expect(hardSliceToCap('short', 100)).toEqual(['short'])
+  })
+
+  test('slices an oversized body into pieces each <= cap', () => {
+    const body = 'x'.repeat(250)
+    const pieces = hardSliceToCap(body, 100)
+    expect(pieces).toHaveLength(3)
+    for (const p of pieces) expect(p.length).toBeLessThanOrEqual(100)
+    expect(pieces.join('')).toBe(body)
+  })
+
+  test('defaults the cap to RICH_MESSAGE_MAX_CHARS', () => {
+    const body = 'y'.repeat(RICH_MESSAGE_MAX_CHARS + 5)
+    const pieces = hardSliceToCap(body)
+    expect(pieces).toHaveLength(2)
+    expect(pieces[0].length).toBe(RICH_MESSAGE_MAX_CHARS)
+    expect(pieces[1].length).toBe(5)
+  })
+})
+
+// The gateway length-error recovery (gateway.ts sendChunkResplit, ~8758) re-splits
+// an oversized chunk with `splitMarkdownChunks` and falls back to `hardSliceToCap`
+// when the block is indivisible. These tests pin that seam at the function level:
+// a >RICH_MESSAGE_MAX_CHARS body is ALWAYS chunked into >=2 sends (each <= cap),
+// never silently dropped or resent whole on a RICH_MESSAGE_TEXT_TOO_LONG reject.
+describe('resplit-on-reject: oversized body chunks into >=2 sends', () => {
+  test('a >cap body with prose boundaries re-splits into >=2 chunks each <= cap', () => {
+    // A paragraph-separated body twice the cap: splitMarkdownChunks finds the
+    // `\n\n` boundaries and yields multiple chunks.
+    const para = 'x'.repeat(4000)
+    const body = Array.from({ length: 20 }, () => para).join('\n\n')
+    expect(body.length).toBeGreaterThan(RICH_MESSAGE_MAX_CHARS)
+    const pieces = splitMarkdownChunks(body, RICH_MESSAGE_MAX_CHARS)
+    expect(pieces.length).toBeGreaterThanOrEqual(2)
+    for (const p of pieces) expect(p.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS)
+  })
+
+  test('an indivisible >cap blob falls back through hardSliceToCap to >=2 chunks each <= cap', () => {
+    // A single boundary-free blob larger than the cap: splitMarkdownChunks
+    // cannot break it and emits it whole (length > cap), so the recovery path
+    // hands it to hardSliceToCap — mirroring sendChunkResplit's fallback.
+    const blob = 'z'.repeat(RICH_MESSAGE_MAX_CHARS + 5000)
+    const subPieces = splitMarkdownChunks(blob, RICH_MESSAGE_MAX_CHARS)
+    const pieces =
+      subPieces.length > 1 && subPieces.every((p) => p.length <= RICH_MESSAGE_MAX_CHARS)
+        ? subPieces
+        : hardSliceToCap(blob, RICH_MESSAGE_MAX_CHARS)
+    expect(pieces.length).toBeGreaterThanOrEqual(2)
+    for (const p of pieces) expect(p.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS)
+    // Nothing is dropped — the pieces reconstitute the original body.
+    expect(pieces.join('')).toBe(blob)
+  })
+})

package/telegram-plugin/tests/linear-agent-activity.test.ts

@@ -247,7 +247,7 @@ describe('emitLinearAgentActivity — operator alert when auth is unrecoverable
   it('buildLinearAuthDeadMessage: no_bundle names the missing oauth key + re-auth command', () => {
     const msg = buildLinearAuthDeadMessage('clerk', 'no_bundle')
     expect(msg).toMatch(/Linear auth needs you/)
-    expect(msg).toContain('<code>linear/clerk/oauth</code>')
+    expect(msg).toContain('`linear/clerk/oauth`')
     expect(msg).toContain('switchroom linear-agent setup --agent clerk')
   })
 
@@ -257,10 +257,13 @@ describe('emitLinearAgentActivity — operator alert when auth is unrecoverable
     expect(msg).not.toContain('/oauth</code> is missing')
   })
 
-  it('buildLinearAuthDeadMessage: HTML-escapes a hostile agent slug', () => {
-    const msg = buildLinearAuthDeadMessage('a<b>&c', 'no_bundle')
-    expect(msg).toContain('a&lt;b&gt;&amp;c')
-    expect(msg).not.toContain('a<b>&c')
+  it('buildLinearAuthDeadMessage: markdown-escapes a hostile agent slug in prose (#2669)', () => {
+    // < > & are literal in rich markdown; an emphasis special is escaped so it
+    // can't break out of the **…** bold run.
+    const msg = buildLinearAuthDeadMessage('a_b*c', 'no_bundle')
+    expect(msg).toContain('**a\\_b\\*c**')
+    // Inside the `code span`, the slug is literal (no escaping).
+    expect(msg).toContain('`linear/a_b*c/oauth`')
   })
 
   it('successful auto-refresh does NOT page the operator', async () => {

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

@@ -172,7 +172,7 @@ describe("handleModelCommand — show / help never inject (picker-wedge guard)",
     const { deps, calls } = makeDeps({ getConfiguredModel: () => null });
     const reply = await handleModelCommand({ kind: "show" }, deps);
     expect(calls.length).toBe(0);
-    expect(reply.text).toContain("<code>default</code>");
+    expect(reply.text).toContain("`default`");
   });
 
   it("help never injects", async () => {
@@ -445,7 +445,7 @@ describe("buildModelMenu", () => {
     const { deps, calls } = makeMenuDeps();
     const menu = await buildModelMenu(deps);
     expect(calls.discover).toBe(1);
-    expect(menu.text).toContain("<b>Sonnet</b>");
+    expect(menu.text).toContain("**Sonnet**");
     expect(menu.text).toContain("29% / 5h · 33% / 7d");
     expect(menu.keyboard).toBeDefined();
     // 3 option rows + refresh row

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

@@ -288,13 +288,13 @@ describe('formatModelUnavailableCard — actionable card', () => {
       { now: NOW },
     )
     expect(card).toMatchInlineSnapshot(`
-      "⚠️ <b>Model unavailable</b> on agent <b>gymbro</b>
+      "⚠️ **Model unavailable** on agent **gymbro**
       Reason: quota exhausted (resets in 5h)
 
-      <b>What to try</b>
-      • <code>/auth use &lt;label&gt;</code> — switch the fleet to a healthy account
-      • <code>/auth add</code> — attach another subscription
-      • <code>/usage</code> — show quota breakdown"
+      **What to try**
+      • \`/auth use <label>\` — switch the fleet to a healthy account
+      • \`/auth add\` — attach another subscription
+      • \`/usage\` — show quota breakdown"
     `)
   })
 
@@ -330,9 +330,9 @@ describe('formatModelUnavailableCard — actionable card', () => {
 
   it('default (no autoFallback) variant includes the actionable suggestions', () => {
     const card = formatModelUnavailableCard(detection('quota_exhausted'), 'gymbro', { now: NOW })
-    expect(card).toContain('<code>/auth use')
-    expect(card).toContain('<code>/auth add</code>')
-    expect(card).toContain('<code>/usage</code>')
+    expect(card).toContain('`/auth use')
+    expect(card).toContain('`/auth add`')
+    expect(card).toContain('`/usage`')
     // Regression — `/authfallback` is no longer a verb (post-RFC-H);
     // pre-fix the card lied by suggesting it.
     expect(card).not.toContain('/authfallback')
@@ -343,17 +343,17 @@ describe('formatModelUnavailableCard — actionable card', () => {
       slot: 'pro-1',
       now: NOW,
     })
-    expect(card).toContain('slot <b>pro-1</b>')
+    expect(card).toContain('slot **pro-1**')
   })
 
-  it('escapes HTML in agent and slot names', () => {
+  it('passes < > literally in agent and slot names (markdown, #2669)', () => {
+    // < > " are literal in rich markdown; emphasis specials are escaped.
     const card = formatModelUnavailableCard(detection('overload'), '<evil>', {
       slot: '"injected"',
       now: NOW,
     })
-    expect(card).toContain('&lt;evil&gt;')
-    expect(card).toContain('&quot;injected&quot;')
-    expect(card).not.toContain('<evil>')
+    expect(card).toContain('<evil>')
+    expect(card).toContain('"injected"')
   })
 })
 

package/telegram-plugin/tests/multi-turn-continuity.test.ts

@@ -2,9 +2,10 @@
  * Integration tests for multi-turn state isolation.
  *
  * Verifies that state carried across turns in the same chat+thread
- * (activeDraftStreams, activeDraftParseModes, suppressPtyPreview)
- * resets cleanly when a new turn starts — i.e. the previous turn's
- * stream handle is finalized/discarded before the next begins.
+ * (activeDraftStreams, suppressPtyPreview) resets cleanly when a new turn
+ * starts — i.e. the previous turn's stream handle is finalized/discarded
+ * before the next begins. (The activeDraftParseModes map was retired with
+ * parse-mode rotation — there is one rich-markdown path now, #2669.)
  *
  * This is one of the "per-chat continuity" gaps the plan called out:
  * previously tested only through the full server.ts orchestration in
@@ -14,13 +15,11 @@
 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 { markdownToHtml as realMarkdownToHtml } from '../format.js'
 import { createFakeBotApi, type FakeBot } from './fake-bot-api.js'
 
 function makeState(): StreamReplyState {
   return {
     activeDraftStreams: new Map<string, DraftStreamHandle>(),
-    activeDraftParseModes: new Map<string, 'HTML' | 'MarkdownV2' | undefined>(),
     suppressPtyPreview: new Set<string>(),
   }
 }
@@ -28,13 +27,11 @@ function makeState(): StreamReplyState {
 function makeDeps(bot: FakeBot, overrides?: Partial<StreamReplyDeps>): StreamReplyDeps {
   return {
     bot: bot as unknown as StreamReplyDeps['bot'],
-    markdownToHtml: (t) => realMarkdownToHtml(t),
-    escapeMarkdownV2: (t) => t,
     repairEscapedWhitespace: (t) => t,
     assertAllowedChat: () => {},
     resolveThreadId: (_, explicit) => (explicit != null ? Number(explicit) : undefined),
     disableLinkPreview: true,
-    defaultFormat: 'html',
+    defaultFormat: 'markdown',
     logStreamingEvent: () => {},
     historyEnabled: false,
     recordOutbound: () => {},
@@ -51,13 +48,12 @@ describe('multi-turn continuity', () => {
     bot = createFakeBotApi({ startMessageId: 500 })
   })
 
-  it('done=true clears the stream entry and parse-mode map', async () => {
+  it('done=true clears the stream entry', async () => {
     const state = makeState()
     const deps = makeDeps(bot)
 
     await handleStreamReply({ chat_id: 'c', text: 'turn-1', done: true }, state, deps)
     expect(state.activeDraftStreams.has('c:_')).toBe(false)
-    expect(state.activeDraftParseModes.has('c:_')).toBe(false)
   })
 
   it('two sequential turns on the same chat each get their own message', async () => {

package/telegram-plugin/tests/operator-events.test.ts

@@ -158,7 +158,7 @@ describe('renderOperatorEvent — credentials-expired', () => {
   it('produces reauth button', () => {
     const { text, keyboard } = renderOperatorEvent(makeEvent('credentials-expired'))
     expect(text).toContain('expired')
-    expect(text).toContain('<b>gymbro</b>')
+    expect(text).toContain('**gymbro**')
     expect(keyboard.inline_keyboard.flat().some(b => b.callback_data?.includes('reauth'))).toBe(true)
   })
 
@@ -193,7 +193,7 @@ describe('renderOperatorEvent — quota-exhausted', () => {
   it('renders quota text with /auth use hint and no stub buttons (E5)', () => {
     const { text, keyboard } = renderOperatorEvent(makeEvent('quota-exhausted'))
     expect(text).toContain('Quota exhausted')
-    expect(text).toContain('<b>gymbro</b>')
+    expect(text).toContain('**gymbro**')
     expect(text).toContain('/auth use')
     const buttons = keyboard.inline_keyboard.flat()
     // swap-slot and add-slot buttons removed (E5 — they redirected to terminal)
@@ -253,17 +253,15 @@ describe('renderOperatorEvent — unknown-5xx', () => {
   })
 })
 
-describe('renderOperatorEvent — HTML escaping', () => {
-  it('escapes agent name with special chars', () => {
+describe('renderOperatorEvent — markdown escaping (#2669)', () => {
+  it('passes < > literally in agent name (markdown, #2669)', () => {
     const { text } = renderOperatorEvent(makeEvent('unknown-4xx', { agent: '<evil>' }))
-    expect(text).toContain('&lt;evil&gt;')
-    expect(text).not.toContain('<evil>')
+    expect(text).toContain('<evil>')
   })
 
-  it('escapes detail with special chars', () => {
+  it('passes < > literally in detail (markdown, #2669)', () => {
     const { text } = renderOperatorEvent(makeEvent('credentials-expired', { detail: '<script>alert(1)</script>' }))
-    expect(text).toContain('&lt;script&gt;')
-    expect(text).not.toContain('<script>')
+    expect(text).toContain('<script>alert(1)</script>')
   })
 })