switchroom 0.16.23 → 0.16.27

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/drive-write-approval.test.ts

@@ -12,6 +12,7 @@ import {
   type DriveApprovalHandlerDeps,
   handleRequestDriveApproval,
 } from "./drive-write-approval.js";
+import { RICH_MESSAGE_MAX_CHARS } from "../format.js";
 
 // ────────────────────────────────────────────────────────────────────────
 // Fixtures
@@ -284,17 +285,16 @@ describe("handleRequestDriveApproval — TTL clamping", () => {
 // ────────────────────────────────────────────────────────────────────────
 
 describe("handleRequestDriveApproval — oversize card body fit (#1767)", () => {
-  it("truncates the rendered text under 4096 chars before posting", async () => {
+  it("truncates the rendered text under the rich-message cap before posting", async () => {
     const spy = makeSpy();
-    // buildCard returns a body well past Telegram's 4096-char limit
-    // (simulates a docTitle / anchor / summary whose HTML-escape
-    // inflated past the limit). Handler must shrink it before postCard.
+    // buildCard returns a body well past the rich-message wire cap
+    // (RICH_MESSAGE_MAX_CHARS, 32768 post-#2669 — simulates a docTitle /
+    // anchor / summary whose escape inflated past the limit). Handler must
+    // shrink it before postCard.
     const giantText =
       "<b>Title</b>\n" +
-      Array.from({ length: 200 }, (_, i) => `line-${i}-${"x".repeat(40)}`).join(
-        "\n",
-      );
-    expect(giantText.length).toBeGreaterThan(4096);
+      "x".repeat(RICH_MESSAGE_MAX_CHARS + 4000);
+    expect(giantText.length).toBeGreaterThan(RICH_MESSAGE_MAX_CHARS);
     await handleRequestDriveApproval(
       clientFor(spy),
       msgFor(),
@@ -304,7 +304,7 @@ describe("handleRequestDriveApproval — oversize card body fit (#1767)", () =>
       }),
     );
     expect(spy.posted).toHaveLength(1);
-    expect(spy.posted[0]!.text.length).toBeLessThanOrEqual(4096);
+    expect(spy.posted[0]!.text.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS);
     expect(spy.posted[0]!.text).toContain("preview truncated");
     // Card was successfully posted → ok:true response went back.
     expect(spy.sent[0]?.ok).toBe(true);
@@ -334,7 +334,7 @@ describe("handleRequestDriveApproval — oversize card body fit (#1767)", () =>
   it("post failure after truncation surfaces a structured reason", async () => {
     const spy = makeSpy();
     const giantText =
-      "<b>Title</b>\n" + "x".repeat(8000);
+      "<b>Title</b>\n" + "x".repeat(RICH_MESSAGE_MAX_CHARS + 4000);
     await handleRequestDriveApproval(
       clientFor(spy),
       msgFor(),

package/telegram-plugin/gateway/drive-write-approval.ts

@@ -31,6 +31,7 @@ import type {
   RequestDriveApprovalMessage,
 } from "./ipc-protocol.js";
 import { truncateRawToFit } from "./oversize-card-body.js";
+import { RICH_MESSAGE_MAX_CHARS } from "../format.js";
 
 // ────────────────────────────────────────────────────────────────────────
 // Injected deps — caller (gateway.ts) wires these from the existing
@@ -102,15 +103,20 @@ const MAX_TTL_MS = 30 * 60 * 1000; // 30 minutes
 const MIN_TTL_MS = 30 * 1000; // 30 seconds
 
 /**
- * Telegram `sendMessage` hard limit. `buildDiffPreviewCard` HTML-
- * escapes the docTitle + every body line with no upstream length
- * cap, so an adversarial or just-unusually-long docTitle / anchor
- * displayName / agent-supplied summary can render past 4096 once
- * `&` / `<` / `>` inflate up to 5x. We rebuild a truncated body
- * keyed off the wrapper-attested fields when that happens. (#1767)
+ * Telegram rich-message hard limit. `buildDiffPreviewCard` escapes the
+ * docTitle + every body line with no upstream length cap, so an adversarial
+ * or just-unusually-long docTitle / anchor displayName / agent-supplied
+ * summary can render past the wire cap once escaping inflates it. We rebuild a
+ * truncated body keyed off the wrapper-attested fields when that happens.
+ * (#1767)
+ *
+ * Post-#2669 every card renders as GFM markdown via `sendRichMessage`, so the
+ * hard cap is `RICH_MESSAGE_MAX_CHARS` (32768), not the legacy 4096 plain-text
+ * limit. RENDERED_BODY_CAP keeps the proportional ~5% headroom under the hard
+ * cap that the original 3900-under-4096 budget carried.
  */
-const TELEGRAM_SENDMESSAGE_LIMIT = 4096;
-const RENDERED_BODY_CAP = 3900;
+const TELEGRAM_SENDMESSAGE_LIMIT = RICH_MESSAGE_MAX_CHARS;
+const RENDERED_BODY_CAP = RICH_MESSAGE_MAX_CHARS - 200;
 const OVERSIZE_SENTINEL = "\n[… preview truncated; open in Drive for full context]";
 
 /**