switchroom 0.16.22 → 0.16.24

package/telegram-plugin/gateway/boot-card.ts

@@ -51,7 +51,7 @@ import {
   AGENT_LIVE_WINDOW_MS,
   AGENT_LIVE_POLL_INTERVAL_MS,
 } from './boot-probes.js'
-import { escapeHtml } from '../card-format.js'
+import { escapeMarkdown } from '../card-format.js'
 import {
   loadCache as loadBootIssueCache,
   diffProbes as diffBootProbes,
@@ -348,26 +348,28 @@ export interface RenderBootCardOpts {
  * the eye; everything else stays out of the way.
  */
 /**
- * Render a probe's `nextStep` hint as Telegram HTML. The hint is
- * authored as plain text with backtick-quoted commands (one shell idiom
- * across the codebase — search "Run `switchroom"). We translate those
- * to <code> spans and escape everything else, so commands stay tap-to-
- * copy on mobile without bleeding raw HTML through.
+ * Render a probe's `nextStep` hint as GFM markdown. The hint is authored
+ * as plain text with backtick-quoted commands (one shell idiom across the
+ * codebase — search "Run `switchroom"). The backtick spans already ARE
+ * markdown code spans, so commands stay tap-to-copy on mobile; non-code
+ * text is markdown-escaped so stray syntax chars render literally.
  */
 function renderNextStep(text: string): string {
   const parts = text.split('`')
-  // Odd-count backticks means an unterminated <code> span — fall back to
-  // plain-escaped text rather than rendering the trailing tail inside a
-  // code block. Author error, not user-input, but defensive is cheap.
-  if (parts.length % 2 === 0) return escapeHtml(text)
-  return parts.map((p, i) => (i % 2 === 0 ? escapeHtml(p) : `<code>${escapeHtml(p)}</code>`)).join('')
+  // Odd-count backticks means an unterminated code span — fall back to
+  // plain-escaped text rather than emitting a half-open span. Author
+  // error, not user-input, but defensive is cheap.
+  if (parts.length % 2 === 0) return escapeMarkdown(text)
+  // Code-span content (odd indices) is literal — backtick content is not
+  // re-interpreted, so it must NOT be markdown-escaped.
+  return parts.map((p, i) => (i % 2 === 0 ? escapeMarkdown(p) : `\`${p}\``)).join('')
 }
 
 export function renderBootCard(opts: RenderBootCardOpts): string {
   const { agentName, version, probes, restartReason, restartAgeMs } = opts
   const agentSlug = opts.agentSlug ?? agentName
   const ackEmoji = restartReason ? REASON_EMOJI[restartReason] : '✅'
-  const ack = `${ackEmoji} <b>${escapeHtml(agentName)}</b> back up · ${escapeHtml(version)}`
+  const ack = `${ackEmoji} **${escapeMarkdown(agentName)}** back up · ${escapeMarkdown(version)}`
 
   const degradedRows: string[] = []
   const snoozeSet = new Set<ProbeKey>(opts.snoozeRows ?? [])
@@ -380,7 +382,7 @@ export function renderBootCard(opts: RenderBootCardOpts): string {
     for (const key of opts.resolvedRows) {
       const lbl = PROBE_LABELS[key]
       if (!lbl) continue
-      degradedRows.push(`✅ <b>${escapeHtml(lbl)}</b>  resolved`)
+      degradedRows.push(`✅ **${escapeMarkdown(lbl)}**  resolved`)
     }
   }
 
@@ -392,15 +394,15 @@ export function renderBootCard(opts: RenderBootCardOpts): string {
     const ageStr = restartAgeMs != null && restartAgeMs > 0
       ? ` · ${(restartAgeMs / 1000).toFixed(1)}s ago`
       : ''
-    degradedRows.push(`⚠️ <b>Restart</b>  ${escapeHtml(REASON_LABEL.crash)}${ageStr}`)
+    degradedRows.push(`⚠️ **Restart**  ${escapeMarkdown(REASON_LABEL.crash)}${ageStr}`)
     // Principle 1: every failure carries its next step. The crash row
     // tells the user how to inspect why. Runtime-aware: v0.7+ agents run
     // in Docker (no systemd/journalctl in-container) — the canonical
     // detection is SWITCHROOM_RUNTIME (see doctor-docker.ts).
     const tailCmd = process.env.SWITCHROOM_RUNTIME === 'docker'
-      ? `docker logs --tail 100 switchroom-${escapeHtml(agentSlug)}`
-      : `journalctl --user -u switchroom-${escapeHtml(agentSlug)} -n 100`
-    degradedRows.push(`    ↳ Tail logs: <code>${tailCmd}</code>`)
+      ? `docker logs --tail 100 switchroom-${agentSlug}`
+      : `journalctl --user -u switchroom-${agentSlug} -n 100`
+    degradedRows.push(`    ↳ Tail logs: \`${tailCmd}\``)
   }
 
   // Probe rows — only those that surfaced as degraded/fail. Healthy
@@ -427,7 +429,7 @@ export function renderBootCard(opts: RenderBootCardOpts): string {
       // We surface the existing row format unchanged here; the
       // "Still:" / "New:" distinction is conveyed by which rows the
       // user does or doesn't see across consecutive boots.
-      degradedRows.push(`${dot} <b>${PROBE_LABELS[key]}</b>  ${escapeHtml(r.detail)}`)
+      degradedRows.push(`${dot} **${PROBE_LABELS[key]}**  ${escapeMarkdown(r.detail)}`)
       if (r.nextStep) {
         degradedRows.push(`    ↳ ${renderNextStep(r.nextStep)}`)
       }
@@ -692,7 +694,6 @@ export async function startBootCard(
   if (reuseId != null && bot.editMessageTextStrict != null) {
     try {
       const outcome = await bot.editMessageTextStrict(chatId, reuseId, ackText, {
-        parse_mode: 'HTML',
         link_preview_options: { is_disabled: true },
         ...(threadId != null ? { message_thread_id: threadId } : {}),
       })
@@ -708,7 +709,6 @@ export async function startBootCard(
   if (messageId < 0) {
     try {
       const sent = await bot.sendMessage(chatId, ackText, {
-        parse_mode: 'HTML',
         link_preview_options: { is_disabled: true },
         ...(threadId != null ? { message_thread_id: threadId } : {}),
         ...(ackMessageId != null ? { reply_parameters: { message_id: ackMessageId } } : {}),
@@ -858,7 +858,6 @@ export async function startBootCard(
         if (currentText !== ackText) {
           try {
             await bot.editMessageText(chatId, messageId, currentText, {
-              parse_mode: 'HTML',
               link_preview_options: { is_disabled: true },
               ...(threadId != null ? { message_thread_id: threadId } : {}),
             })
@@ -915,7 +914,6 @@ export async function startBootCard(
 
           try {
             await bot.editMessageText(chatId, messageId, updatedText, {
-              parse_mode: 'HTML',
               link_preview_options: { is_disabled: true },
               ...(threadId != null ? { message_thread_id: threadId } : {}),
             })

package/telegram-plugin/gateway/boot-version.ts

@@ -41,8 +41,9 @@ export function formatRelativeAgo(iso: string | null): string | null {
  *
  * Sanitization: claude --version output is whitespace-collapsed before
  * embedding — a malicious or rogue `claude` on PATH must not be able to
- * smuggle newlines into the ack line. HTML escaping happens at the
- * boot-card boundary (see boot-card.ts: escapeHtml(version)).
+ * smuggle newlines into the ack line. Markdown escaping happens at the
+ * boot-card boundary (see boot-card.ts: escapeMarkdown(version)) so any
+ * GFM formatting specials in the version render literally (#2669).
  */
 export function composeBootVersionString(inputs: BootVersionInputs): string {
   const ago = formatRelativeAgo(inputs.commitDate)

package/telegram-plugin/gateway/config-approval-handler.test.ts

@@ -81,39 +81,45 @@ afterEach(() => {
   _resetPendingConfigApprovalsForTest();
 });
 
+// #2669: the diff now ships inside a fenced code block (``` … ```) on the
+// rich-message path. Content inside a fence is LITERAL — `<` / `&` need no
+// escaping and cannot inject formatting. The inline-body cap is the rich
+// 32768-char wire limit (RENDERED_BODY_CAP=32000), not the old 4096.
+const RICH_LIMIT = 32768;
 describe("buildConfigApprovalCardBody", () => {
-  it("HTML-escapes the diff body so `<` / `&` can't break out of the <pre> block", () => {
+  it("ships the diff verbatim inside a fenced code block (< / & stay literal)", () => {
     const { body } = buildConfigApprovalCardBody({
       agentName: "klanker",
-      reason: "<script>",
+      reason: "a_reason",
       unifiedDiff: "a & b <c>",
     });
-    expect(body).toContain("&lt;script&gt;");
-    expect(body).toContain("a &amp; b &lt;c&gt;");
+    // The diff content is literal inside the fence — no HTML entities.
+    expect(body).toContain("```\na & b <c>\n```");
   });
 
-  it("rendered body stays under Telegram's 4096-char limit when raw diff is all `&` (worst-case 5x escape inflation)", () => {
-    // 3000 `&` chars escape to 15000 `&amp;` chars — far past 4096.
-    // The post-escape cap MUST kick in and truncate the rendered body.
-    const evilDiff = "&".repeat(3000);
+  it("rendered body stays under the rich-message limit when the raw diff is enormous", () => {
+    // A diff far larger than the 32000 cap must be truncated with the sentinel.
+    const evilDiff = "&".repeat(40000);
     const { body } = buildConfigApprovalCardBody({
       agentName: "klanker",
       reason: "test",
       unifiedDiff: evilDiff,
     });
-    expect(body.length).toBeLessThanOrEqual(4096);
+    expect(body.length).toBeLessThanOrEqual(RICH_LIMIT);
     expect(body).toContain("diff continues, see attached file");
   });
 
-  it("rendered body stays under 4096 when raw diff is all `<` (5x escape)", () => {
-    const evilDiff = "<".repeat(3000);
-    const { body } = buildConfigApprovalCardBody({
+  it("a small `<`-heavy diff fits and stays literal (no escape inflation, #2669)", () => {
+    const diff = "<".repeat(3000);
+    const { body, truncated } = buildConfigApprovalCardBody({
       agentName: "klanker",
       reason: "test",
-      unifiedDiff: evilDiff,
+      unifiedDiff: diff,
     });
-    expect(body.length).toBeLessThanOrEqual(4096);
-    expect(body).toContain("&lt;");
+    // 3000 chars is well under the 32000 cap and no longer 5x-inflated.
+    expect(truncated).toBe(false);
+    expect(body.length).toBeLessThanOrEqual(RICH_LIMIT);
+    expect(body).toContain("<".repeat(3000));
   });
 
   it("clips an unbounded operator-supplied `reason` to ~500 chars with ellipsis", () => {
@@ -123,7 +129,6 @@ describe("buildConfigApprovalCardBody", () => {
       reason: longReason,
       unifiedDiff: "small",
     });
-    // The escaped reason should appear, but capped.
     const reasonLine = body
       .split("\n")
       .find((l) => l.startsWith("Reason: "))!;
@@ -139,48 +144,43 @@ describe("buildConfigApprovalCardBody", () => {
       unifiedDiff: "-a\n+b\n",
     });
     expect(truncated).toBe(false);
-    expect(body).toContain("<pre>-a\n+b\n</pre>");
+    expect(body).toContain("```\n-a\n+b\n\n```");
   });
 
   it("returns truncated:true and appends the sentinel when the body has to shrink", () => {
     const { body, truncated } = buildConfigApprovalCardBody({
       agentName: "klanker",
       reason: "test",
-      unifiedDiff: "&".repeat(3000),
+      unifiedDiff: "&".repeat(40000),
     });
     expect(truncated).toBe(true);
     expect(body).toContain("diff continues, see attached file");
   });
 
   it("handles a single unbroken line (no `\\n` to snap to) by char-truncation fallback", () => {
-    // 8000 `x` chars on a single line. After HTML escape (no inflation
-    // for `x`) the diff body alone is 8000 chars + framing — way past
-    // the cap. There's no newline to snap to, so the helper must fall
-    // through to char-truncation rather than returning empty.
-    const oneLongLine = "x".repeat(8000);
+    // A single 40000-char line, way past the 32000 cap, with no newline to
+    // snap to → the helper must fall through to char-truncation.
+    const oneLongLine = "x".repeat(40000);
     const { body, truncated } = buildConfigApprovalCardBody({
       agentName: "klanker",
       reason: "test",
       unifiedDiff: oneLongLine,
     });
     expect(truncated).toBe(true);
-    expect(body.length).toBeLessThanOrEqual(4096);
-    // Should still contain SOME of the line content — the helper
-    // shouldn't degenerate to "framing + sentinel only" when char-
-    // truncation is available.
+    expect(body.length).toBeLessThanOrEqual(RICH_LIMIT);
     expect(body).toMatch(/x{100,}/);
     expect(body).toContain("diff continues, see attached file");
   });
 
-  it("rendered body stays under 4096 even when reason is also adversarial", () => {
-    const evilDiff = "&".repeat(3000);
+  it("rendered body stays under the rich limit even when reason is also adversarial", () => {
+    const evilDiff = "&".repeat(40000);
     const evilReason = "&".repeat(2000);
     const { body } = buildConfigApprovalCardBody({
       agentName: "klanker",
       reason: evilReason,
       unifiedDiff: evilDiff,
     });
-    expect(body.length).toBeLessThanOrEqual(4096);
+    expect(body.length).toBeLessThanOrEqual(RICH_LIMIT);
   });
 });
 
@@ -304,8 +304,10 @@ describe("buildLiveNote", () => {
     expect(buildLiveNote([], false)).toBe("");
     expect(buildLiveNote(undefined, undefined)).toBe("");
   });
-  it("HTML-escapes agent names", () => {
-    expect(buildLiveNote(["a<b>"], false)).toContain("a&lt;b&gt;");
+  it("markdown-escapes agent names (< > stay literal, #2669)", () => {
+    // < > are literal in rich markdown; an emphasis special is escaped.
+    expect(buildLiveNote(["a<b>"], false)).toContain("a<b>");
+    expect(buildLiveNote(["a_b"], false)).toContain("a\\_b");
   });
 });
 
@@ -412,7 +414,7 @@ describe("oversize diff → attachment fallback (#1762)", () => {
     expect(deps.postCard).toHaveBeenCalledTimes(1);
     const postArgs = (deps.postCard as ReturnType<typeof vi.fn>).mock
       .calls[0]![0] as { text: string; replyMarkup: unknown };
-    expect(postArgs.text.length).toBeLessThanOrEqual(4096);
+    expect(postArgs.text.length).toBeLessThanOrEqual(32768);
     expect(postArgs.text).toMatch(/diff continues, see attached file/);
     expect(postArgs.replyMarkup).toBeDefined();
 

package/telegram-plugin/gateway/config-approval-handler.ts

@@ -161,13 +161,13 @@ export function truncateDiffForCard(
 }
 
 /**
- * Telegram `sendMessage` hard limit. We render with `parse_mode=HTML`,
- * so the limit applies to the rendered (escaped) body, NOT the raw
- * pre-escape source. Worst-case escape is `&` → `&` (5x).
+ * Telegram rich-message hard limit (#2669). We render as GFM markdown and
+ * ship the diff inside a fenced code block (content is literal there, so no
+ * escape inflation).
  */
-const TELEGRAM_SENDMESSAGE_LIMIT = 4096;
+const TELEGRAM_SENDMESSAGE_LIMIT = 32768;
 /** Safety margin under the hard limit for invisible framing wobble. */
-const RENDERED_BODY_CAP = 3900;
+const RENDERED_BODY_CAP = 32000;
 /** Operator-supplied `reason` is unbounded at the wire — clip it. */
 const REASON_MAX_CHARS = 500;
 const REASON_ELLIPSIS = "…";
@@ -180,8 +180,8 @@ const REASON_ELLIPSIS = "…";
  */
 export const DIFF_SENTINEL = "\n[… diff continues, see attached file]";
 
-function escapeHtml(s: string): string {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function escapeMd(s: string): string {
+  return s.replace(/([\\`*_~=\[\]|])/g, "\\$1");
 }
 
 function clipReason(reason: string): string {
@@ -212,10 +212,10 @@ export function buildConfigApprovalCardBody(args: {
 }): { body: string; truncated: boolean } {
   const safeReason = clipReason(args.reason);
   const render = (diff: string): string =>
-    `🛠 <b>Config edit proposed</b>\n` +
-    `Agent: <code>${escapeHtml(args.agentName)}</code>\n` +
-    `Reason: ${escapeHtml(safeReason)}\n\n` +
-    `<pre>${escapeHtml(diff)}</pre>`;
+    `🛠 **Config edit proposed**\n` +
+    `Agent: \`${args.agentName}\`\n` +
+    `Reason: ${escapeMd(safeReason)}\n\n` +
+    "```\n" + diff + "\n```";
 
   return truncateRawToFit({
     raw: args.unifiedDiff,
@@ -287,10 +287,10 @@ export async function handleRequestConfigApproval(
     return;
   }
 
-  // Pre-flight oversize handling (#1762). Telegram caps sendMessage
-  // at 4096 chars and we render with parse_mode=HTML, so the limit
-  // applies to the rendered (escaped) body — worst-case `&` → `&amp;`
-  // inflates 5x. Fast-path with a cheap raw-input cap, then let
+  // Pre-flight oversize handling (#1762 / #2669). The rich-message body
+  // caps at 32768 chars; the diff ships inside a fenced code block (literal,
+  // no escape inflation) but the framing still counts. Fast-path with a
+  // cheap raw-input cap, then let
   // buildConfigApprovalCardBody enforce the post-escape rendered cap
   // (which re-truncates the diff if escaping blew past the limit). We
   // ship the full diff as a `.patch` attachment whenever truncation
@@ -409,10 +409,10 @@ export async function resolvePendingConfigApproval(
   // Edit the card to an interim/terminal state.
   const interim =
     verdict === "approve"
-      ? "👀 <b>Applying…</b>"
+      ? "👀 **Applying…**"
       : verdict === "deny"
-        ? "🚫 <b>Denied</b>"
-        : "⏱ <b>Expired</b>";
+        ? "🚫 **Denied**"
+        : "⏱ **Expired**";
   try {
     // Strip the keyboard: once resolved (approve/deny/timeout) the buttons
     // must not stay tappable — a stale tap could otherwise re-hit the
@@ -442,14 +442,14 @@ export function buildLiveNote(affectedAgents?: string[], fleetWide?: boolean): s
   if (fleetWide) {
     return (
       `\n\n⚠️ Shared config changed — affects all agents. Not live until they ` +
-      `restart: run <code>switchroom rollout</code> (or <code>/update apply</code>).`
+      `restart: run \`switchroom rollout\` (or \`/update apply\`).`
     );
   }
   const agents = (affectedAgents ?? []).filter((a) => typeof a === "string" && a.length > 0);
   if (agents.length === 0) return "";
-  const list = agents.map(escapeHtml).join(", ");
-  const cmds = agents.map((a) => `/restart ${escapeHtml(a)}`).join(" · ");
-  return `\n\n🔄 Not live until restart — affects: <b>${list}</b>\n${cmds}`;
+  const list = agents.map(escapeMd).join(", ");
+  const cmds = agents.map((a) => `/restart ${escapeMd(a)}`).join(" · ");
+  return `\n\n🔄 Not live until restart — affects: **${list}**\n${cmds}`;
 }
 
 /** IPC `request_config_finalize` handler — edits the card to the terminal outcome. */
@@ -476,8 +476,8 @@ export async function handleRequestConfigFinalize(
     msg.outcome === "applied" ? buildLiveNote(msg.affectedAgents, msg.fleetWide) : "";
   const body =
     msg.outcome === "applied"
-      ? `✅ <b>Applied</b>${msg.detail ? `\n${escapeHtml(msg.detail)}` : ""}${liveNote}`
-      : `⚠️ <b>Reconcile failed; rolled back</b>${msg.detail ? `\n${escapeHtml(msg.detail)}` : ""}`;
+      ? `✅ **Applied**${msg.detail ? `\n${escapeMd(msg.detail)}` : ""}${liveNote}`
+      : `⚠️ **Reconcile failed; rolled back**${msg.detail ? `\n${escapeMd(msg.detail)}` : ""}`;
   try {
     // Finalize is terminal — strip the keyboard so the buttons are gone.
     await deps.editCard({

package/telegram-plugin/gateway/config-snapshot.ts

@@ -32,7 +32,7 @@
 import { createHash } from 'crypto'
 import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'fs'
 import { dirname } from 'path'
-import { escapeHtml } from '../card-format.js'
+import { escapeMarkdown } from '../card-format.js'
 
 // ─── Types ──────────────────────────────────────────────────────────────────
 
@@ -189,19 +189,19 @@ export function diffSnapshots(
 export function renderConfigChangeDim(dim: ConfigChangeDim): string {
   switch (dim.field) {
     case 'model': {
-      const from = escapeHtml(dim.from ?? '(default)')
-      const to = escapeHtml(dim.to ?? '(default)')
-      return `⚙️ <b>Config</b>  model: ${from} → ${to}`
+      const from = escapeMarkdown(dim.from ?? '(default)')
+      const to = escapeMarkdown(dim.to ?? '(default)')
+      return `⚙️ **Config**  model: ${from} → ${to}`
     }
     case 'memoryBackend': {
-      const from = escapeHtml(dim.from ?? '(default)')
-      const to = escapeHtml(dim.to ?? '(default)')
-      return `⚙️ <b>Config</b>  memory backend: ${from} → ${to}`
+      const from = escapeMarkdown(dim.from ?? '(default)')
+      const to = escapeMarkdown(dim.to ?? '(default)')
+      return `⚙️ **Config**  memory backend: ${from} → ${to}`
     }
     case 'tools':
-      return `⚙️ <b>Config</b>  tools allowlist changed — run /status for details`
+      return `⚙️ **Config**  tools allowlist changed — run /status for details`
     case 'skills':
-      return `⚙️ <b>Config</b>  skills changed — run /status for details`
+      return `⚙️ **Config**  skills changed — run /status for details`
   }
 }
 

package/telegram-plugin/gateway/diff-preview-card.test.ts

@@ -45,8 +45,8 @@ describe("buildDiffPreviewCard — suggest mode (default)", () => {
       writeRequestId: "11223344112233441122334411223344",
     });
 
-    // Body: title bold + all preview lines.
-    expect(card.text).toContain("<b>");
+    // Body: title bold (markdown **) + all preview lines.
+    expect(card.text).toContain("**");
     expect(card.text).toContain("klanker");
     expect(card.text).toContain("Q3 Strategy Notes");
     expect(card.text).toContain("📍 after heading 'Goals' (level 2)");
@@ -152,20 +152,20 @@ describe("buildDiffPreviewCard — fragility guards", () => {
       preview,
       suggestRequestId: "aabbccddaabbccddaabbccddaabbccdd",
     });
-    expect(card.text).not.toContain("<script>");
-    expect(card.text).toContain("&lt;script&gt;");
+    // < > are literal in rich markdown — the doc name is shown verbatim and
+    // cannot inject formatting (#2669).
+    expect(card.text).toContain("<script>");
   });
 
-  it("HTML-escapes the agent-supplied summary", () => {
+  it("passes < > & literally in the agent-supplied summary; escapes emphasis specials (#2669)", () => {
     const preview = buildDiffPreview(
-      baseInput({ agentSummary: "Hi <b>bold</b> & <i>tags</i>" }),
+      baseInput({ agentSummary: "Hi <tag> & a_b" }),
     );
     const card = buildDiffPreviewCard({
       preview,
       suggestRequestId: "aabbccddaabbccddaabbccddaabbccdd",
     });
-    expect(card.text).not.toMatch(/💬.*<b>/);
-    expect(card.text).toContain("&lt;b&gt;");
+    expect(card.text).toContain("<tag> & a\\_b");
   });
 });
 

package/telegram-plugin/gateway/diff-preview-card.ts

@@ -88,7 +88,7 @@ export function buildDiffPreviewCard(
   // The 📍 + line-count rows are surfaced verbatim — they're
   // wrapper-attested and the agent has no input into their content.
   const bodyLines: string[] = [];
-  bodyLines.push(`<b>${escapeHtml(preview.title)}</b>`);
+  bodyLines.push(`**${escapeHtml(preview.title)}**`);
   for (const line of preview.lines) {
     bodyLines.push(escapeHtml(line.text));
   }
@@ -163,8 +163,5 @@ export function buildDiffPreviewCard(
 }
 
 function escapeHtml(s: string): string {
-  return s
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;");
+  return s.replace(/([\\`*_~=\[\]|])/g, "\\$1");
 }

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

@@ -45,8 +45,6 @@ export interface DisconnectFlushDeps<Ctrl extends { finalize: (reason?: 'done' |
 
   /** Open draft-stream handles keyed by chat:thread:replyId. */
   activeDraftStreams: Map<string, Stream>
-  /** Mirror map: same keys → parse mode. */
-  activeDraftParseModes: Map<string, 'HTML' | 'MarkdownV2' | undefined>
 
   /** Persist-side reaction registry (per-agent on-disk state). */
   clearActiveReactions: () => void
@@ -85,7 +83,6 @@ export function flushOnAgentDisconnect<
     activeTurnStartedAt,
     claudeBusyKeys,
     activeDraftStreams,
-    activeDraftParseModes,
     clearActiveReactions,
     disposeProgressDriver,
     onDanglingTurnsSwept,
@@ -177,7 +174,6 @@ export function flushOnAgentDisconnect<
   for (const [key, stream] of activeDraftStreams.entries()) {
     if (!stream.isFinal()) void stream.finalize().catch(() => {})
     activeDraftStreams.delete(key)
-    activeDraftParseModes.delete(key)
   }
 
   return true

package/telegram-plugin/gateway/effort-command.ts

@@ -95,17 +95,17 @@ export interface EffortCommandReply {
 }
 
 const PERSIST_NOTE =
-  '<i>Session-only — reverts to the configured default on restart. To change the default, set <code>thinking_effort:</code> in switchroom.yaml and restart.</i>'
+  '_Session-only — reverts to the configured default on restart. To change the default, set \`thinking_effort:\` in switchroom.yaml and restart._'
 
-const LEVELS_INLINE = EFFORT_LEVELS.map(l => `<code>${l}</code>`).join(' · ')
+const LEVELS_INLINE = EFFORT_LEVELS.map(l => `\`${l}\``).join(' · ')
 
 function helpText(deps: EffortCommandDeps, reason?: string): EffortCommandReply {
   const lines: string[] = []
   if (reason) lines.push(`⚠️ ${deps.escapeHtml(reason)}`)
   lines.push(
-    '<b>/effort</b> — show or switch the reasoning effort (faster→smarter)',
-    '<code>/effort</code> — show the configured effort + a tap menu',
-    `<code>/effort &lt;level&gt;</code> — switch the live session (${LEVELS_INLINE})`,
+    '**/effort** — show or switch the reasoning effort (faster→smarter)',
+    '\`/effort\` — show the configured effort + a tap menu',
+    `\`/effort <level>\` — switch the live session (${LEVELS_INLINE})`,
     PERSIST_NOTE,
   )
   return { text: lines.join('\n'), html: true }
@@ -122,9 +122,9 @@ export async function handleEffortCommand(
     const shown = configured && configured.length > 0 ? configured : 'low'
     return {
       text: [
-        `<b>Effort — ${deps.escapeHtml(deps.getAgentName())}</b>`,
-        `Configured default: <code>${deps.escapeHtml(shown)}</code>`,
-        `Switch the live session: ${EFFORT_LEVELS.map(l => `<code>/effort ${l}</code>`).join(' · ')}`,
+        `**Effort — ${deps.escapeHtml(deps.getAgentName())}**`,
+        `Configured default: \`${deps.escapeHtml(shown)}\``,
+        `Switch the live session: ${EFFORT_LEVELS.map(l => `\`/effort ${l}\``).join(' · ')}`,
         PERSIST_NOTE,
       ].join('\n'),
       html: true,
@@ -136,7 +136,7 @@ export async function handleEffortCommand(
   if (!isValidEffortArg(parsed.level)) {
     return helpText(deps, `not a valid effort level: ${parsed.level}`)
   }
-  const verbHtml = `<code>/effort ${deps.escapeHtml(parsed.level)}</code>`
+  const verbHtml = `\`/effort ${deps.escapeHtml(parsed.level)}\``
   let result: EffortApplyResult
   try {
     result = await deps.applyEffort(deps.getAgentName(), parsed.level)
@@ -153,17 +153,17 @@ export async function handleEffortCommand(
  * say so honestly rather than just claiming success.
  */
 function applyResultText(level: string, result: EffortApplyResult, deps: EffortCommandDeps): string {
-  const verbHtml = `<code>/effort ${deps.escapeHtml(level)}</code>`
+  const verbHtml = `\`/effort ${deps.escapeHtml(level)}\``
   if (result.ok) {
     const lines = [`✅ ${verbHtml} — ${deps.escapeHtml(result.output)}`]
     if (result.confirmed) {
-      lines.push('<i>Switched mid-conversation — your next turn re-reads the cached history (slower, one time).</i>')
+      lines.push('_Switched mid-conversation — your next turn re-reads the cached history (slower, one time)._')
     }
     lines.push(PERSIST_NOTE)
     return lines.join('\n')
   }
   if (result.reason === 'session_missing') {
-    return '❌ tmux session not found — the agent must be running under the tmux supervisor (the default). Remove <code>experimental.legacy_pty: true</code> if set.'
+    return '❌ tmux session not found — the agent must be running under the tmux supervisor (the default). Remove \`experimental.legacy_pty: true\` if set.'
   }
   if (result.reason === 'confirm_failed') {
     const wedged = result.wedged
@@ -172,7 +172,7 @@ function applyResultText(level: string, result: EffortApplyResult, deps: EffortC
     return `❌ ${verbHtml} — couldn't confirm the switch.${wedged}`
   }
   // apply_unverified
-  return `❌ ${verbHtml} — sent, but couldn't confirm it applied. The agent may be mid-turn; check <code>/inject /status</code>.`
+  return `❌ ${verbHtml} — sent, but couldn't confirm it applied. The agent may be mid-turn; check \`/inject /status\`.`
 }
 
 // ---------------------------------------------------------------------------
@@ -220,8 +220,8 @@ export function buildEffortMenu(deps: EffortCommandDeps, highlight?: string): Ef
   const live = highlight ?? configured
   return {
     text: [
-      `<b>Effort — ${deps.escapeHtml(deps.getAgentName())}</b>`,
-      `Default: <code>${deps.escapeHtml(configured)}</code> · faster → smarter: ${LEVELS_INLINE}`,
+      `**Effort — ${deps.escapeHtml(deps.getAgentName())}**`,
+      `Default: \`${deps.escapeHtml(configured)}\` · faster → smarter: ${LEVELS_INLINE}`,
       'Tap to switch the live session:',
       PERSIST_NOTE,
     ].join('\n'),
@@ -260,8 +260,8 @@ export async function handleEffortMenuCallback(
     const result = await deps.applyEffort(deps.getAgentName(), level)
     if (result.ok) {
       banner = result.confirmed
-        ? `✅ Effort → <code>${deps.escapeHtml(level)}</code> (mid-conversation: next turn re-reads history)`
-        : `✅ Effort → <code>${deps.escapeHtml(level)}</code> for this session`
+        ? `✅ Effort → \`${deps.escapeHtml(level)}\` (mid-conversation: next turn re-reads history)`
+        : `✅ Effort → \`${deps.escapeHtml(level)}\` for this session`
       selected = level
     } else if (result.reason === 'session_missing') {
       banner = '❌ tmux session not found — is the agent running under the supervisor?'

package/telegram-plugin/gateway/folder-picker-handler.test.ts

@@ -42,12 +42,18 @@ function fakeCtx(userId = 12345): { ctx: Context; spy: FakeCtx } {
       });
       return { message_id: 1 };
     },
-    editMessageText: async (text: string, opts?: { reply_markup?: { inline_keyboard?: unknown[][] } }) => {
+    editMessageText: async (
+      text: string | { markdown: string },
+      opts?: { reply_markup?: { inline_keyboard?: unknown[][] } },
+    ) => {
       const rows = (opts?.reply_markup?.inline_keyboard ?? []) as Array<
         Array<{ text: string }>
       >;
+      // #2669: the rich path passes `{ markdown }`; normalize to the body
+      // string so the substring assertions keep working.
+      const body = typeof text === "object" && text != null ? text.markdown : text;
       spy.edits.push({
-        text,
+        text: body,
         keyboardRows: opts?.reply_markup
           ? rows.map((r) => r.map((b) => b.text))
           : undefined,