switchroom 0.16.28 → 0.16.38

package/telegram-plugin/dist/server.js

@@ -16994,7 +16994,6 @@ var init_plugin_logger = __esm(() => {
   DEFAULT_LOG_PATH2 = join2(homedir2(), ".switchroom", "logs", "telegram-plugin.log");
   ROTATE_AT_BYTES2 = 50 * 1024 * 1024;
 });
-
 // operator-events.ts
 function classifyClaudeError(raw) {
   try {

package/telegram-plugin/format.ts

@@ -53,6 +53,24 @@ export function escapeMarkdown(text: string): string {
   return text.replace(/([\\`*_~=\[\]|])/g, '\\$1')
 }
 
+/**
+ * Make a string safe to interpolate INSIDE a `code span`.
+ *
+ * Inside a GFM code span the content is LITERAL — backslash escaping does
+ * NOT apply, so `escapeMarkdown` is exactly wrong there: it emits visible
+ * backslashes (e.g. `openai\_key` for an identifier containing `_`). The
+ * only character that can prematurely CLOSE the span is a backtick, so the
+ * sole transform needed is to defuse embedded backticks. We insert a
+ * zero-width space after each backtick so the raw ``` ` ``` can no longer
+ * terminate the surrounding span while remaining visually identical.
+ *
+ * This is the canonical home for the helper (#2695 regression fix); other
+ * modules re-export from here so there's one implementation.
+ */
+export function codeSpanSafe(s: string): string {
+  return s.replace(/`/g, '`​')
+}
+
 /**
  * Repair LLM-side JSON escape bungles.
  *
@@ -190,11 +208,63 @@ function maskCodeRegions(text: string, nonce: string): MaskedCode {
  * Code fences and inline code are masked out before any of this runs, so their
  * interior `\n`s are never touched.
  */
+/**
+ * Split a collapsed inline bullet list onto separate lines.
+ *
+ * Agents sometimes emit an entire bullet list on ONE line using interior
+ * `•`/`·` separators, e.g.:
+ *
+ *   • Master Bath 1, clean • <b>Master Bath 2</b>, 33% loss • Cabinet, clean
+ *
+ * which renders as a single run-on line instead of stacked bullets (the GFM
+ * rich path treats `•`/`·` as ordinary text, not list syntax, so nothing
+ * stacks). This deterministically inserts a newline before each interior
+ * unicode-bullet separator so each bullet lands on its own line.
+ *
+ * Conservative by construction:
+ *  - Only a line that STARTS (after optional leading whitespace) with a bullet
+ *    marker (`•`, `·`, `-`, or `*` followed by a space) is eligible — prose
+ *    with a mid-sentence `•` is left untouched.
+ *  - Only the unicode bullets `•`/`·` are split on (an interior whitespace +
+ *    `•`/`·` + whitespace). `-`/`*` are NEVER used as interior split points —
+ *    too many false positives (hyphens, ranges, "a * b" multiplication).
+ *    They are only accepted as the LEADING marker.
+ *  - The bullet glyphs are left as-is; we only insert `\n` before each split
+ *    bullet and normalize the inter-bullet whitespace to a single space.
+ *  - Idempotent: once split, each bullet begins its own line, so the
+ *    interior-separator pattern (whitespace + bullet + whitespace) no longer
+ *    matches anywhere on those lines.
+ *
+ * Runs on already-code-masked text, so a `•` inside a code span/fence is safe.
+ */
+export function splitCollapsedInlineBullets(text: string): string {
+  if (!/[•·]/.test(text)) return text
+  // Leading marker: optional indent, then • · - or * followed by a space.
+  // Interior separator to split on: whitespace + • or · + whitespace.
+  const interiorSep = /[ \t]+([•·])[ \t]+/g
+  return text
+    .split('\n')
+    .map((line) => {
+      if (!/^[ \t]*[•·*-] /.test(line)) return line
+      if (!/[ \t][•·][ \t]/.test(line)) return line
+      return line.replace(interiorSep, '\n$1 ')
+    })
+    .join('\n')
+}
+
 export function normalizeParagraphBreaks(text: string): string {
-  if (!text.includes('\n')) return text
+  // A text with no newline still needs the inline-bullet split (a collapsed
+  // bullet list is a SINGLE line). Only bail early when there is neither a
+  // newline nor a unicode bullet to potentially split.
+  if (!text.includes('\n') && !/[•·]/.test(text)) return text
 
   const nonce = Math.random().toString(36).slice(2)
-  const { masked, restore, placeholder } = maskCodeRegions(text, nonce)
+  const { masked: maskedRaw, restore, placeholder } = maskCodeRegions(text, nonce)
+
+  // Step 0: split a collapsed inline bullet list onto separate lines. Done on
+  // the code-masked text so a `•` inside a fenced block or inline code span is
+  // never touched. See splitCollapsedInlineBullets for the exact rule.
+  const masked = splitCollapsedInlineBullets(maskedRaw)
 
   // Step 1: collapse 3+ newlines to exactly two. This also normalizes runs that
   // contain interleaved spaces only between the newlines is NOT done here —
@@ -236,8 +306,10 @@ export function normalizeParagraphBreaks(text: string): string {
   // Step 3: guarantee a blank line (`\n\n`) at BLOCK BOUNDARIES. The
   // prose-promotion above keeps lists/tables tight by leaving their single
   // `\n` separators alone — but GFM's rich renderer needs a blank line to
-  // START a new block, so a block that is glued to the previous line by a
-  // single `\n` fails to render (a table prints as literal pipe text, prose
+  // START a new block. A properly block-separated table DOES render as a
+  // real table (Bot API 10.1 rich messages); the failure mode this pass
+  // fixes is the *glued* case — a block joined to the previous line by a
+  // single `\n` (an un-separated table degrades to literal pipe text, prose
   // after a list is absorbed as a lazy list continuation). This pass inserts
   // the missing blank line at those transitions only, on the same masked text,
   // never touching code interiors, never collapsing/expanding existing `\n\n`,
@@ -247,6 +319,156 @@ export function normalizeParagraphBreaks(text: string): string {
   return restore(out)
 }
 
+// ---------------------------------------------------------------------------
+// Paragraph spacers — restore a VISIBLE blank line between prose paragraphs
+// ---------------------------------------------------------------------------
+
+/**
+ * The non-collapsible spacer paragraph injected between two prose paragraphs.
+ *
+ * Telegram's Bot API 10.1 rich-message renderer (the GFM/CommonMark engine
+ * behind `sendRichMessage` / `editMessageText({ markdown })`) renders a `\n\n`
+ * paragraph break TIGHT — the two paragraphs sit on adjacent lines with no
+ * visible empty line between them. The legacy markdown→HTML path (removed in
+ * #2669) sent `\n\n` literally with `parse_mode:"HTML"`, where two newlines
+ * render as a real blank line. That regression is the operator-confirmed
+ * "paragraphs jammed together" symptom.
+ *
+ * CommonMark discards blank lines made of ASCII whitespace, but a line whose
+ * only content is a NON-breaking space (U+00A0) is a genuine, non-empty
+ * paragraph — it renders as a visible empty line. So `A\n\n \n\nB`
+ * renders as three paragraphs: A, a blank-looking line, then B — the visible
+ * gap the HTML path used to produce.
+ */
+export const PARAGRAPH_SPACER = ' '
+
+/**
+ * Insert a visible blank-line spacer into each genuine `\n\n` paragraph gap so
+ * the rich GFM renderer shows a real empty line between paragraphs (matching
+ * the pre-#2669 HTML behaviour). See PARAGRAPH_SPACER for why a U+00A0 line is
+ * the reliable trick.
+ *
+ * Conservative by construction — a spacer is inserted into a `\n\n` gap ONLY
+ * when BOTH the block ENDING above the gap and the block STARTING below it are
+ * ordinary prose. A gap adjacent to a structural block (list item, table row,
+ * fenced code, blockquote, heading, indented code) is left exactly as it was:
+ * those blocks already carry their own vertical rhythm, and a spacer paragraph
+ * wedged against a tight list / table would either re-introduce the cramped
+ * look from the other side or break the block's contiguity.
+ *
+ * Runs on code-masked text (so a blank line inside a fenced block is never
+ * touched) and is idempotent — a gap that already contains a U+00A0 spacer
+ * paragraph is recognised and never doubled.
+ *
+ * Intended to run in the outbound send path AFTER normalizeParagraphBreaks,
+ * which has already collapsed 3+ newline runs to `\n\n`, promoted lone prose
+ * breaks, and guaranteed block-boundary blank lines. normalizeParagraphBreaks
+ * itself deliberately does NOT do this so its (well-tested) `\n\n`-preserving
+ * contract is unchanged.
+ */
+export function addParagraphSpacers(text: string): string {
+  if (!text.includes('\n\n')) return text
+
+  const nonce = Math.random().toString(36).slice(2)
+  const { masked, restore, placeholder } = maskCodeRegions(text, nonce)
+
+  if (!masked.includes('\n\n')) return restore(masked)
+
+  // The line we inject for a spacer paragraph (its only content is U+00A0).
+  const spacerLine = PARAGRAPH_SPACER
+
+  // CRITICAL: `String.prototype.trim()` strips U+00A0, so a spacer line would
+  // read as "blank" and the pass would lose idempotency (re-spacing an
+  // already-spaced gap). Detect blank-ness with an ASCII-whitespace-only test
+  // so the U+00A0 spacer line is correctly seen as NON-blank.
+  const isBlankLine = (line: string): boolean => /^[ \t\r\f\v]*$/.test(line)
+  // Trim ASCII-only (preserve U+00A0) so the spacer line is recognisable.
+  const asciiTrim = (line: string): string => line.replace(/^[ \t\r\f\v]+|[ \t\r\f\v]+$/g, '')
+
+  // A line is "prose" for spacing purposes when it is non-blank, not a
+  // structural block marker, not the spacer line itself. Only a gap with prose
+  // on BOTH sides earns a visible spacer.
+  const isProseLine = (line: string): boolean => {
+    if (isBlankLine(line)) return false
+    if (asciiTrim(line) === spacerLine) return false
+    if (isMarkerLine(line, placeholder)) return false
+    // A standalone masked fenced block line is structural.
+    if (isFenceOpenLine(line, placeholder)) return false
+    return true
+  }
+
+  // Split into blank-line-delimited segments, then re-join inserting a spacer
+  // paragraph between two adjacent NON-blank segments whose facing lines are
+  // both prose and which are not already separated by a spacer.
+  // A `\n\n` paragraph gap is a SINGLE blank entry between two content lines
+  // (`"A\n\nB".split('\n')` → `["A", "", "B"]`). normalizeParagraphBreaks has
+  // already collapsed 3+ newline runs to exactly `\n\n`, so we only ever see a
+  // one-blank gap here; a multi-blank run is handled defensively the same way
+  // (the FIRST blank of the run carries the spacer decision).
+  const lines = masked.split('\n')
+  const out: string[] = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    const isBlank = isBlankLine(line)
+    // The spacer decision is made at the FIRST blank of a gap, i.e. when the
+    // previously emitted line is non-blank prose. Inject the spacer BEFORE the
+    // blank so the result is `above \n\n   \n\n below`.
+    if (isBlank) {
+      const prevEmitted = out.length > 0 ? out[out.length - 1] : null
+      const prevIsBlank = prevEmitted != null && isBlankLine(prevEmitted)
+      if (!prevIsBlank) {
+        const above = lastNonBlank(out, isBlankLine)
+        const below = nextNonBlank(lines, i + 1, isBlankLine)
+        const alreadySpaced =
+          (above != null && asciiTrim(above) === spacerLine) ||
+          (below != null && asciiTrim(below) === spacerLine)
+        if (
+          !alreadySpaced &&
+          above != null &&
+          below != null &&
+          isProseLine(above) &&
+          isProseLine(below)
+        ) {
+          // Emit: blank, spacer paragraph, blank — a U+00A0 paragraph wedged
+          // between two real blank lines so CommonMark renders it as a visible
+          // empty line between the two prose paragraphs.
+          out.push('')
+          out.push(spacerLine)
+          out.push('')
+          continue
+        }
+      }
+    }
+    out.push(line)
+  }
+
+  return restore(out.join('\n'))
+}
+
+/**
+ * Last non-blank entry already emitted into `arr`, or null. `isBlank` is the
+ * caller's blank test (ASCII-only, so a U+00A0 spacer line counts as
+ * non-blank — `String.trim()` would wrongly strip it).
+ */
+function lastNonBlank(arr: string[], isBlank: (s: string) => boolean): string | null {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (!isBlank(arr[i])) return arr[i]
+  }
+  return null
+}
+
+/** First non-blank line at or after index `from` in `lines`, or null. */
+function nextNonBlank(
+  lines: string[],
+  from: number,
+  isBlank: (s: string) => boolean,
+): string | null {
+  for (let i = from; i < lines.length; i++) {
+    if (!isBlank(lines[i])) return lines[i]
+  }
+  return null
+}
+
 // ---------------------------------------------------------------------------
 // Block-boundary blank-line guarantee (Step 3 of normalizeParagraphBreaks)
 // ---------------------------------------------------------------------------
@@ -495,11 +717,46 @@ export function splitMarkdownChunks(text: string, maxLen = RICH_MESSAGE_MAX_CHAR
       break
     }
 
-    chunks.push(rest.slice(0, cut))
-    rest = rest.slice(cut).replace(/^\n+/, '')
+    chunks.push(stripBoundarySpacers(rest.slice(0, cut), 'trailing'))
+    rest = stripBoundarySpacers(rest.slice(cut), 'leading')
   }
 
-  return chunks
+  return chunks.map((c) => stripBoundarySpacers(c, 'trailing'))
+}
+
+/**
+ * Strip stray paragraph-spacer / blank lines off a chunk boundary so a cut that
+ * lands inside an injected spacer gap (`\n\n${PARAGRAPH_SPACER}\n\n`, see
+ * addParagraphSpacers) never leaves a continuation chunk that OPENS with a bare
+ * U+00A0 spacer line, nor a prior chunk that ENDS with one.
+ *
+ * A "boundary blank run" is any sequence of newlines and spacer-only lines (a
+ * line whose only content is the U+00A0 spacer, optionally surrounded by ASCII
+ * spaces/tabs) in ANY interleaving — `\n \n`, ` \n\n`, `\n\n \n`, etc. The
+ * legacy behaviour (strip leading ASCII `\n+` only) is a strict subset, so a
+ * boundary with NO spacer is unaffected. Idempotent: a chunk already trimmed
+ * has nothing left to strip.
+ *
+ *  - `'leading'`  → strip the run from the START (the continuation chunk).
+ *  - `'trailing'` → strip the run from the END (the just-emitted prior chunk).
+ */
+function stripBoundarySpacers(chunk: string, side: 'leading' | 'trailing'): string {
+  // One blank-or-spacer line: optional ASCII ws, optional one U+00A0, optional
+  // ASCII ws — i.e. a line that renders empty. A run of these (joined by \n,
+  // with leading/trailing \n) is what we peel off the boundary.
+  const sp = PARAGRAPH_SPACER
+  if (side === 'leading') {
+    // Leading: one-or-more newlines, optionally with spacer-only lines mixed in.
+    return chunk.replace(
+      new RegExp(`^(?:[ \\t]*${sp}?[ \\t]*\\n+)+`),
+      '',
+    )
+  }
+  // Trailing: a newline run, optionally with spacer-only lines, at the very end.
+  return chunk.replace(
+    new RegExp(`(?:\\n+[ \\t]*${sp}?[ \\t]*)+$`),
+    '',
+  )
 }
 
 /**

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

@@ -14,8 +14,13 @@
  *     param  = (for ttl) 1h | 24h | 7d
  */
 
+import { escapeMarkdown, codeSpanSafe } from '../format.js';
 import { InlineKeyboard } from "grammy";
 
+// Re-export so existing importers (e.g. vault-request-access-card.ts) keep
+// resolving `codeSpanSafe` from here; the canonical impl lives in format.ts.
+export { codeSpanSafe };
+
 export interface ApprovalCardOptions {
   request_id: string;       // 8-hex from kernel.requestApproval
   agent: string;            // shown in the title
@@ -37,7 +42,7 @@ export interface BuiltApprovalCard {
  */
 export function buildApprovalCard(opts: ApprovalCardOptions): BuiltApprovalCard {
   const lines: string[] = [];
-  lines.push(`🔐 **${escapeHtml(opts.agent)}** wants approval`);
+  lines.push(`🔐 **${escapeMarkdown(opts.agent)}** wants approval`);
   // The scope rides in a `code span` — content there is LITERAL, so it must
   // NOT be markdown-escaped (escaping would leak visible backslashes, e.g.
   // `secret:OPENAI\_API\_KEY`). Only an embedded backtick could break out of
@@ -45,7 +50,7 @@ export function buildApprovalCard(opts: ApprovalCardOptions): BuiltApprovalCard
   lines.push(`\`${codeSpanSafe(opts.scope_humanized)}\``);
   if (opts.why && opts.why.trim().length > 0) {
     lines.push("");
-    lines.push(escapeHtml(opts.why.trim()));
+    lines.push(escapeMarkdown(opts.why.trim()));
   }
   const text = lines.join("\n");
 
@@ -123,15 +128,3 @@ export function ttlMsFromToken(token: string): number | null {
   return null;
 }
 
-function escapeHtml(s: string): string {
-  return s.replace(/([\\`*_~=\[\]|])/g, "\\$1");
-}
-
-/**
- * Make a string safe to interpolate INSIDE a `code span` without escaping
- * (content there is literal). The only character that can prematurely close
- * the span is a backtick, so split it with a zero-width space.
- */
-function codeSpanSafe(s: string): string {
-  return s.replace(/`/g, "`​");
-}

package/telegram-plugin/gateway/approvals-commands.ts

@@ -13,6 +13,7 @@
  * add on top of the same client. Tracked in the migration TODO inline.
  */
 
+import { escapeMarkdown, codeSpanSafe } from '../format.js';
 import type { Bot, Context } from "grammy";
 import { richMessage } from "../rich-send.js";
 import {
@@ -65,7 +66,7 @@ export function registerApprovalsCommands(
       const byAgent = new Map<string, number>();
       for (const d of decisions) byAgent.set(d.agent_unit, (byAgent.get(d.agent_unit) ?? 0) + 1);
       const summary = Array.from(byAgent.entries())
-        .map(([a, n]) => `• **${escapeHtml(a)}**: ${n}`)
+        .map(([a, n]) => `• **${escapeMarkdown(a)}**: ${n}`)
         .join("\n");
       const detail = decisions
         .slice(0, 20)
@@ -76,10 +77,10 @@ export function registerApprovalsCommands(
               : `until ${new Date(d.ttl_expires_at).toISOString().slice(0, 16).replace("T", " ")}`;
           return (
             `\`${d.id.slice(0, 8)}\` ` +
-            `${escapeHtml(d.agent_unit)} → ` +
-            `\`${d.scope}\` ` +
-            `(${escapeHtml(d.action)}, ${ttl}) ` +
-            `· /approvals revoke ${escapeHtml(d.id)}`
+            `${escapeMarkdown(d.agent_unit)} → ` +
+            `\`${codeSpanSafe(d.scope)}\` ` +
+            `(${escapeMarkdown(d.action)}, ${ttl}) ` +
+            `· /approvals revoke ${escapeMarkdown(d.id)}`
           );
         })
         .join("\n");
@@ -114,7 +115,3 @@ export function registerApprovalsCommands(
     ));
   });
 }
-
-function escapeHtml(s: string): string {
-  return s.replace(/([\\`*_~=\[\]|])/g, "\\$1");
-}

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

@@ -28,6 +28,7 @@
  * rather than throwing.
  */
 
+import { escapeMarkdown, codeSpanSafe } from '../format.js'
 import type { ListStateData, AccountState } from './auth-line.js'
 import {
   buildSnapshotsFromState,
@@ -158,7 +159,7 @@ export function parseAuthCommand(text: string): ParsedAuthCommand | null {
       if (tail.length > 0) {
         return {
           kind: 'help',
-          reason: `Unknown \`rm\` modifier: \`${escapeHtml(tail)}\`. Use \`/auth rm <label> confirm\` to confirm.`,
+          reason: `Unknown \`rm\` modifier: \`${codeSpanSafe(tail)}\`. Use \`/auth rm <label> confirm\` to confirm.`,
         }
       }
       return { kind: 'rm-prompt', label }
@@ -180,7 +181,7 @@ export function parseAuthCommand(text: string): ParsedAuthCommand | null {
       if (sub !== 'override') {
         return {
           kind: 'help',
-          reason: `Unknown \`agent\` subcommand: \`${escapeHtml(sub || '(none)')}\`. Try \`/auth agent override <agent> <label|clear>\`.`,
+          reason: `Unknown \`agent\` subcommand: \`${codeSpanSafe(sub || '(none)')}\`. Try \`/auth agent override <agent> <label|clear>\`.`,
         }
       }
       const agent = parts[2]
@@ -201,7 +202,7 @@ export function parseAuthCommand(text: string): ParsedAuthCommand | null {
     case 'help':
       return { kind: 'help' }
     default:
-      return { kind: 'help', reason: `Unknown verb: \`${escapeHtml(verb)}\`` }
+      return { kind: 'help', reason: `Unknown verb: \`${codeSpanSafe(verb)}\`` }
   }
 }
 
@@ -417,7 +418,7 @@ export async function handleAuthCommand(
       }
     } catch (err) {
       return {
-        text: `**/auth show failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth show failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -432,7 +433,7 @@ export async function handleAuthCommand(
       if (!agent) {
         return {
           text:
-            `**/auth show:** no agent named \`${escapeHtml(agentName)}\` in broker view.\n` +
+            `**/auth show:** no agent named \`${codeSpanSafe(agentName)}\` in broker view.\n` +
             `Run \`/auth show\` for the fleet snapshot.`,
           html: true,
         }
@@ -440,7 +441,7 @@ export async function handleAuthCommand(
       return { text: renderAgentDetail(state, agent), html: true }
     } catch (err) {
       return {
-        text: `**/auth show failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth show failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -476,13 +477,13 @@ export async function handleAuthCommand(
       const result = await ctx.client.setActive(parsed.label)
       return {
         text:
-          `**Active account →** \`${escapeHtml(result.active)}\`\n` +
+          `**Active account →** \`${codeSpanSafe(result.active)}\`\n` +
           `Re-mirrored credentials for ${result.fanned.length} agent${result.fanned.length === 1 ? '' : 's'}.`,
         html: true,
       }
     } catch (err) {
       return {
-        text: `**/auth use failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth use failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -504,13 +505,13 @@ export async function handleAuthCommand(
       const result = await ctx.client.setActive(nextLabel)
       return {
         text:
-          `**Rotated:** active → \`${escapeHtml(result.active)}\`\n` +
+          `**Rotated:** active → \`${codeSpanSafe(result.active)}\`\n` +
           `Re-mirrored credentials for ${result.fanned.length} agent${result.fanned.length === 1 ? '' : 's'}.`,
         html: true,
       }
     } catch (err) {
       return {
-        text: `**/auth rotate failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth rotate failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -525,7 +526,7 @@ export async function handleAuthCommand(
       state = await ctx.client.listState()
     } catch (err) {
       return {
-        text: `**/auth rm failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth rm failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -533,7 +534,7 @@ export async function handleAuthCommand(
     if (!exists) {
       return {
         text:
-          `**/auth rm:** no account named \`${escapeHtml(parsed.label)}\`. ` +
+          `**/auth rm:** no account named \`${codeSpanSafe(parsed.label)}\`. ` +
           `Run \`/auth show\` for the current list.`,
         html: true,
       }
@@ -541,7 +542,7 @@ export async function handleAuthCommand(
     if (state.active === parsed.label) {
       return {
         text:
-          `**/auth rm refused.** \`${escapeHtml(parsed.label)}\` is the fleet active. ` +
+          `**/auth rm refused.** \`${codeSpanSafe(parsed.label)}\` is the fleet active. ` +
           `Switch with \`/auth use <other>\` or \`/auth rotate\` first.`,
         html: true,
       }
@@ -560,9 +561,9 @@ export async function handleAuthCommand(
     }
     return {
       text:
-        `**⚠ /auth rm** — about to remove \`${escapeHtml(parsed.label)}\` from the broker.\n` +
-        `The fleet active is unchanged. Any agent override pointing at \`${escapeHtml(parsed.label)}\` will stop working.\n\n` +
-        `Send \`/auth rm ${escapeHtml(parsed.label)} confirm\` within ${Math.round(
+        `**⚠ /auth rm** — about to remove \`${codeSpanSafe(parsed.label)}\` from the broker.\n` +
+        `The fleet active is unchanged. Any agent override pointing at \`${codeSpanSafe(parsed.label)}\` will stop working.\n\n` +
+        `Send \`/auth rm ${codeSpanSafe(parsed.label)} confirm\` within ${Math.round(
           AUTH_RM_CONFIRM_TTL_MS / 1000,
         )}s to proceed.`,
       html: true,
@@ -578,8 +579,8 @@ export async function handleAuthCommand(
       }
       return {
         text:
-          `**/auth rm:** no pending confirm for \`${escapeHtml(parsed.label)}\` (expired or not started). ` +
-          `Send \`/auth rm ${escapeHtml(parsed.label)}\` first.`,
+          `**/auth rm:** no pending confirm for \`${codeSpanSafe(parsed.label)}\` (expired or not started). ` +
+          `Send \`/auth rm ${codeSpanSafe(parsed.label)}\` first.`,
         html: true,
       }
     }
@@ -589,12 +590,12 @@ export async function handleAuthCommand(
     try {
       const data = await ctx.client.rmAccount(parsed.label)
       return {
-        text: `**Removed** \`${escapeHtml(data.label)}\` from the broker.`,
+        text: `**Removed** \`${codeSpanSafe(data.label)}\` from the broker.`,
         html: true,
       }
     } catch (err) {
       return {
-        text: `**/auth rm failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth rm failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -609,7 +610,7 @@ export async function handleAuthCommand(
       if (parsed.label && targets.length === 0) {
         return {
           text:
-            `**/auth refresh:** no account named \`${escapeHtml(parsed.label)}\`.`,
+            `**/auth refresh:** no account named \`${codeSpanSafe(parsed.label)}\`.`,
           html: true,
         }
       }
@@ -629,13 +630,13 @@ export async function handleAuthCommand(
           ])
         } catch (err) {
           failures.push(
-            `${label}: ${escapeHtml((err as Error)?.message ?? String(err))}`,
+            `${label}: ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
           )
         }
       }
       const head =
         targets.length === 1
-          ? `**Refreshed** \`${escapeHtml(targets[0]!)}\``
+          ? `**Refreshed** \`${codeSpanSafe(targets[0]!)}\``
           : `**Refreshed** ${rows.length - 1}/${targets.length} account${targets.length === 1 ? '' : 's'}`
       const table = rows.length > 1
         ? "\n```\n" + alignTable(rows) + "\n```"
@@ -646,7 +647,7 @@ export async function handleAuthCommand(
       return { text: head + table + failBlock, html: true }
     } catch (err) {
       return {
-        text: `**/auth refresh failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth refresh failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -657,13 +658,13 @@ export async function handleAuthCommand(
       const data = await ctx.client.setOverride(parsed.agent, parsed.label)
       return {
         text:
-          `**Override set.** \`${escapeHtml(data.agent)}\` is now pinned to ` +
-          `\`${escapeHtml(data.account ?? parsed.label)}\`.`,
+          `**Override set.** \`${codeSpanSafe(data.agent)}\` is now pinned to ` +
+          `\`${codeSpanSafe(data.account ?? parsed.label)}\`.`,
         html: true,
       }
     } catch (err) {
       return {
-        text: `**/auth agent override failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth agent override failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -674,13 +675,13 @@ export async function handleAuthCommand(
       const data = await ctx.client.setOverride(parsed.agent, null)
       return {
         text:
-          `**Override cleared** on \`${escapeHtml(data.agent)}\` ` +
+          `**Override cleared** on \`${codeSpanSafe(data.agent)}\` ` +
           `— back to fleet active.`,
         html: true,
       }
     } catch (err) {
       return {
-        text: `**/auth agent override failed:** ${escapeHtml((err as Error)?.message ?? String(err))}`,
+        text: `**/auth agent override failed:** ${escapeMarkdown((err as Error)?.message ?? String(err))}`,
         html: true,
       }
     }
@@ -852,7 +853,7 @@ function formatAccountsTable(state: ListStateData, now: number, demo = false): s
         ? formatRelativeMs(acc.exhausted_until - now)
         : '—'
     rows.push([
-      `${marker} ${escapeHtml(demo ? maskEmail(acc.label) : acc.label)}`,
+      `${marker} ${escapeMarkdown(demo ? maskEmail(acc.label) : acc.label)}`,
       status,
       expires,
       formatQuotaUtilCell(acc, now),
@@ -892,7 +893,7 @@ function formatAgentsTable(state: ListStateData, demo = false): string {
       : a.account === state.active
         ? 'fleet-active'
         : 'pinned'
-    rows.push([escapeHtml(a.name), escapeHtml(demo ? maskEmail(a.account) : a.account), source])
+    rows.push([escapeMarkdown(a.name), escapeMarkdown(demo ? maskEmail(a.account) : a.account), source])
   }
   return alignTable(rows)
 }
@@ -909,10 +910,10 @@ export function renderAgentDetail(
   now: number = Date.now(),
 ): string {
   const lines: string[] = []
-  lines.push(`**${escapeHtml(agent.name)}**`)
+  lines.push(`**${escapeMarkdown(agent.name)}**`)
   const source = agent.override ? 'override' : 'fleet-active'
   lines.push(
-    `Active account: \`${escapeHtml(agent.account)}\` (${source})`,
+    `Active account: \`${codeSpanSafe(agent.account)}\` (${source})`,
   )
   const acct = state.accounts.find((a) => a.label === agent.account)
   if (acct) {
@@ -948,17 +949,13 @@ function formatConsumersTable(state: ListStateData, now: number, demo = false):
       c.last_seen_at == null
         ? 'socket bound'
         : `socket bound (last seen ${formatRelativeMs(now - c.last_seen_at)} ago)`
-    rows.push([escapeHtml(c.name), escapeHtml(demo ? maskEmail(c.account) : c.account), status])
+    rows.push([escapeMarkdown(c.name), escapeMarkdown(demo ? maskEmail(c.account) : c.account), status])
   }
   return alignTable(rows)
 }
 
 // ─── Plain-text helpers ────────────────────────────────────────────────────
 
-function escapeHtml(s: string): string {
-  return s.replace(/([\\`*_~=\[\]|])/g, '\\$1')
-}
-
 function formatRelativeMs(ms: number): string {
   if (ms <= 0) return '0s'
   const totalSec = Math.floor(ms / 1000)