switchroom 0.16.28 → 0.16.38

package/telegram-plugin/auth-snapshot-format.ts

@@ -15,13 +15,14 @@
  *
  * No HTML escaping at the boundary — callers pass already-trusted
  * label strings (broker-vetted account labels). If that ever changes
- * the per-line `escapeHtml` helper below is the place to gate.
+ * the per-line `escapeMarkdown` helper (imported from card-format) is the place to gate.
  */
 
 import type { QuotaResult, QuotaUtilization } from './quota-check.js';
 import { isProbeThin, refillNormalizedUtils } from '../src/auth/quota.js';
 import type { AccountState, LastQuotaSnapshot, ListStateData } from '../src/auth/broker/client.js';
 import { maskEmail } from './demo-mask.js';
+import { escapeMarkdown, codeSpanSafe } from './card-format.js';
 
 // ── shared types ─────────────────────────────────────────────────────
 
@@ -190,9 +191,68 @@ export function formatAbsolute(
   });
 }
 
-/** Round-trim percentage to 1 dp (more precision is noise on a UX). */
+/**
+ * Render a future absolute time for the table's Status column, showing the
+ * DATE only when it's not "today" in the user's timezone — all in that tz so
+ * DST is handled by the tz database (never a hard-coded offset).
+ *
+ *   - same calendar day as `now` (user tz) → time only: `11:00 PM`
+ *   - a different day, but within the next 6 days → weekday + time: `Wed 1:00 AM`
+ *   - further out → weekday + day + month + time: `Wed 1 Jul 1:00 AM`
+ *
+ * `tz` is an IANA tz-database name (e.g. `Australia/Melbourne`); the caller
+ * sources it from `SWITCHROOM_TIMEZONE` / `TZ`. Returns "—" for null.
+ */
+export function formatStatusTime(
+  target: Date | null,
+  now: Date = new Date(),
+  tz: string = 'UTC',
+): string {
+  if (!target) return '—';
+  // Compare calendar dates in the user's tz using en-CA (YYYY-MM-DD) so the
+  // "is it today?" test is timezone-correct, not UTC-relative.
+  const dayFmt = new Intl.DateTimeFormat('en-CA', {
+    timeZone: tz,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  });
+  const timeFmt = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    hour: 'numeric',
+    minute: '2-digit',
+    hour12: true,
+  });
+  const timeStr = timeFmt.format(target);
+  if (dayFmt.format(target) === dayFmt.format(now)) {
+    return timeStr;
+  }
+  // Different day — always include the weekday. Add the day-of-month + month
+  // once the target falls outside the current week (≥ 7 days away), where a
+  // bare weekday would be ambiguous.
+  const withinWeek = target.getTime() - now.getTime() < 7 * 24 * 60 * 60 * 1000;
+  const dateFmt = new Intl.DateTimeFormat('en-US', {
+    timeZone: tz,
+    weekday: 'short',
+    ...(withinWeek ? {} : { day: 'numeric', month: 'short' }),
+  });
+  return `${dateFmt.format(target)} ${timeStr}`;
+}
+
+/**
+ * Render a utilization percentage for display, CLAMPED to [0, 100].
+ *
+ * Anthropic's unified rate-limit headers return a decimal utilization that can
+ * exceed 1.0 (e.g. 1.01 → 101%) when an account is over its window cap. A
+ * displayed value over 100% erodes trust ("how can I be at 101%?"), so the
+ * DISPLAYED number is clamped to 100 here at the format boundary. This does NOT
+ * mutate the source quota data — `classifyHealth` / `blockedReason` still read
+ * the true (possibly >100) value, so the blocked/exhausted state still surfaces
+ * via the Status column and the health emoji. Only the rendered number is
+ * clamped.
+ */
 export function fmtPct(pct: number): string {
-  return `${Math.round(pct)}%`;
+  return `${Math.min(100, Math.round(pct))}%`;
 }
 
 // ── /auth snapshot — Format 2 ────────────────────────────────────────
@@ -232,20 +292,7 @@ function displayLabel(label: string, opts: SnapshotRenderOpts): string {
   return opts.demo ? maskEmail(label) : label;
 }
 
-/**
- * Header line shape: emoji + group title + count.
- *
- *   🟢 HEALTHY (4)
- *   🟡 ACTIVE — REFRESHING SOON (1)
- *   🔴 BLOCKED (1)
- *   ⚪ UNKNOWN (1)
- */
-function groupHeader(health: AccountHealth, count: number): string {
-  const emoji = HEALTH_EMOJI[health];
-  const title = HEALTH_TITLE[health];
-  return `${emoji} **${title}** (${count})`;
-}
-
+/** Health → State-column emoji for the snapshot table. */
 const HEALTH_EMOJI: Record<AccountHealth, string> = {
   healthy: '🟢',
   throttling: '🟡',
@@ -253,13 +300,6 @@ const HEALTH_EMOJI: Record<AccountHealth, string> = {
   unknown: '⚪',
 };
 
-const HEALTH_TITLE: Record<AccountHealth, string> = {
-  healthy: 'HEALTHY',
-  throttling: 'THROTTLING',
-  blocked: 'BLOCKED',
-  unknown: 'UNKNOWN',
-};
-
 /**
  * One-line per-account summary inside its health group.
  *
@@ -284,10 +324,10 @@ function renderAccountRow(
 
   if (!snap.quota) {
     lines.push(
-      `${marker}\`${escapeHtml(label)}\`  _quota probe failed_`,
+      `${marker}\`${codeSpanSafe(label)}\`  _quota probe failed_`,
     );
     if (snap.quotaError) {
-      lines.push(`  _${escapeHtml(snap.quotaError)}_`);
+      lines.push(`  _${escapeMarkdown(snap.quotaError)}_`);
     }
     return lines;
   }
@@ -297,7 +337,7 @@ function renderAccountRow(
   // it as a data-quality gap, never a confident "0% / 0%".
   if (isProbeThin(q)) {
     lines.push(
-      `${marker}\`${escapeHtml(label)}\`  _quota unknown (thin probe)_`,
+      `${marker}\`${codeSpanSafe(label)}\`  _quota unknown (thin probe)_`,
     );
     return lines;
   }
@@ -307,7 +347,7 @@ function renderAccountRow(
   const fiveStr = fmtPct(norm.fiveHourUtilizationPct);
   const sevenStr = fmtPct(norm.sevenDayUtilizationPct);
   lines.push(
-    `${marker}\`${escapeHtml(label)}\`  ${fiveStr} / ${sevenStr}`,
+    `${marker}\`${codeSpanSafe(label)}\`  ${fiveStr} / ${sevenStr}`,
   );
 
   const health = classifyHealth(snap, now);
@@ -318,7 +358,9 @@ function renderAccountRow(
     const reset = win === '5h' ? q.fiveHourResetAt : q.sevenDayResetAt;
     const winLabel = win === '5h' ? '5-hour' : '7-day';
     lines.push(
-      `  _quota exhausted — back ${formatAbsolute(reset, tz)} (in ${formatRelative(reset, now)}, ${winLabel} cap)_`,
+      reset
+        ? `  _quota exhausted — back ${formatAbsolute(reset, tz)} (\`in ${formatRelative(reset, now)}\`, ${winLabel} cap)_`
+        : `  _quota exhausted — ${winLabel} cap, reset time unknown_`,
     );
     return lines;
   }
@@ -332,10 +374,10 @@ function renderAccountRow(
   const sevenResetIn = q.sevenDayResetAt ? q.sevenDayResetAt.getTime() - now.getTime() : Infinity;
   const fiveFirst = fiveResetIn <= sevenResetIn;
   const fiveSeg = q.fiveHourResetAt
-    ? `5h refills ${formatAbsolute(q.fiveHourResetAt, tz)} (in ${formatRelative(q.fiveHourResetAt, now)})`
+    ? `5h refills ${formatAbsolute(q.fiveHourResetAt, tz)} (\`in ${formatRelative(q.fiveHourResetAt, now)}\`)`
     : '5h refills —';
   const sevenSeg = q.sevenDayResetAt
-    ? `7d resets ${formatAbsolute(q.sevenDayResetAt, tz)} (in ${formatRelative(q.sevenDayResetAt, now)})`
+    ? `7d resets ${formatAbsolute(q.sevenDayResetAt, tz)} (\`in ${formatRelative(q.sevenDayResetAt, now)}\`)`
     : '7d resets —';
   lines.push(`  _${fiveFirst ? fiveSeg : sevenSeg}_`);
   lines.push(`  _${fiveFirst ? sevenSeg : fiveSeg}_`);
@@ -343,7 +385,7 @@ function renderAccountRow(
   // surface it as a sub-line on a healthy/throttling row — NOT a blocked badge.
   if (q.overageDisabledReason != null && OVERAGE_EXHAUSTED_REASONS.has(q.overageDisabledReason)) {
     lines.push(
-      `  _overage off (${escapeHtml(q.overageDisabledReason)}) — serving from quota_`,
+      `  _overage off (${escapeMarkdown(q.overageDisabledReason)}) — serving from quota_`,
     );
   }
   return lines;
@@ -374,42 +416,110 @@ function formatAgeStamp(atMs: number, now: Date = new Date()): string {
   return ageSec < 60 ? `${ageSec}s ago` : `${Math.round(ageSec / 60)}m ago`;
 }
 
+/**
+ * Health-group rank for the table's secondary sort (after active-first):
+ * problems before good news so the user scans the walled accounts at the top.
+ * blocked → throttling → unknown → healthy.
+ */
+const TABLE_HEALTH_RANK: Record<AccountHealth, number> = {
+  blocked: 0,
+  throttling: 1,
+  unknown: 2,
+  healthy: 3,
+};
+
+/** Escape a cell value for a GFM table cell: pipes break the column grid, and
+ *  newlines break the row. Emails don't normally carry either, but be safe. */
+function tableCell(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/\|/g, '\\|').replace(/\r?\n/g, ' ');
+}
+
+/** The two percent cells (5h / 7d), refill-normalized + clamped, or a
+ *  data-quality marker when the probe is missing/thin. */
+function pctCells(
+  snap: AccountSnapshot,
+  now: Date,
+): { five: string; seven: string } {
+  if (!snap.quota) return { five: '—', seven: '—' };
+  if (isProbeThin(snap.quota)) return { five: '?', seven: '?' };
+  const norm = refillNormalizedUtils(snap.quota, now);
+  return { five: fmtPct(norm.fiveHourUtilizationPct), seven: fmtPct(norm.sevenDayUtilizationPct) };
+}
+
+/**
+ * The Status cell: for a blocked account, when the binding window comes back
+ * (`back <when>`); for a healthy/throttling account, when the soonest window
+ * refills (`refills <when>`). `<when>` is the tz-aware absolute time (date shown
+ * only when not today) plus the concise relative hint in parens.
+ */
+function statusCell(snap: AccountSnapshot, now: Date, tz: string): string {
+  if (!snap.quota) {
+    return snap.quotaError ? `probe failed (${snap.quotaError})` : 'probe failed';
+  }
+  if (isProbeThin(snap.quota)) return 'quota unknown';
+  const q = snap.quota;
+  const health = classifyHealth(snap, now);
+  if (health === 'blocked') {
+    const win = bindingWindow(q);
+    const reset = win === '5h' ? q.fiveHourResetAt : q.sevenDayResetAt;
+    if (!reset) return 'back — (reset unknown)';
+    return `back ${formatStatusTime(reset, now, tz)} (in ${formatRelative(reset, now)})`;
+  }
+  // healthy / throttling — show the soonest refill across both windows.
+  const fiveIn = q.fiveHourResetAt ? q.fiveHourResetAt.getTime() - now.getTime() : Infinity;
+  const sevenIn = q.sevenDayResetAt ? q.sevenDayResetAt.getTime() - now.getTime() : Infinity;
+  const soonest = fiveIn <= sevenIn ? q.fiveHourResetAt : q.sevenDayResetAt;
+  if (!soonest) return 'refills —';
+  return `refills ${formatStatusTime(soonest, now, tz)} (in ${formatRelative(soonest, now)})`;
+}
+
 export function renderAuthSnapshotFormat2(
   snapshots: AccountSnapshot[],
   opts: SnapshotRenderOpts = {},
 ): string {
   const now = opts.now ?? new Date();
+  const tz = opts.tz ?? 'UTC';
   const lines: string[] = [];
   lines.push('🔋 **Auth — fleet status**');
 
-  // Group by health. Render BLOCKED first (it's the urgent action),
-  // then THROTTLING (potential next problem), then HEALTHY (good
-  // news), then UNKNOWN (data quality issue). The active account
-  // floats to the top of its group regardless.
-  const order: AccountHealth[] = ['blocked', 'throttling', 'healthy', 'unknown'];
-  const grouped = new Map<AccountHealth, AccountSnapshot[]>();
-  for (const s of snapshots) {
-    const h = classifyHealth(s, now);
-    if (!grouped.has(h)) grouped.set(h, []);
-    grouped.get(h)!.push(s);
-  }
-  // Within each group, active first.
-  for (const arr of grouped.values()) {
-    arr.sort((a, b) => Number(b.isActive) - Number(a.isActive));
-  }
+  // Single sorted table: the ACTIVE account always sorts to the top row,
+  // regardless of its health group. Remaining rows order by health so
+  // problems are visible — blocked → throttling → unknown → healthy — then
+  // stable/alpha on label for a deterministic order.
+  const ordered = [...snapshots].sort((a, b) => {
+    if (a.isActive !== b.isActive) return a.isActive ? -1 : 1;
+    const r = TABLE_HEALTH_RANK[classifyHealth(a, now)] - TABLE_HEALTH_RANK[classifyHealth(b, now)];
+    if (r !== 0) return r;
+    return a.label.localeCompare(b.label);
+  });
 
-  for (const h of order) {
-    const arr = grouped.get(h);
-    if (!arr || arr.length === 0) continue;
+  if (ordered.length > 0) {
     lines.push('');
-    lines.push(groupHeader(h, arr.length));
-    for (const s of arr) {
-      for (const ln of renderAccountRow(s, opts)) lines.push(ln);
+    lines.push('| State | Account | 5h | 7d | Status |');
+    lines.push('| --- | --- | --- | --- | --- |');
+    for (const s of ordered) {
+      const emoji = HEALTH_EMOJI[classifyHealth(s, now)];
+      // Account cell: FULL email, never truncated; active gets a (active) suffix.
+      // The black-dot active marker is intentionally removed — the suffix reads.
+      const label = displayLabel(s.label, opts);
+      // #2701 — the account label is an identifier (email / slug) that can
+      // contain markdown-active chars (`_ * ~` etc.). `tableCell` only guards
+      // the table grid (`\ | \n`), NOT inline formatting, so a raw label like
+      // `ken_max` was parsed as emphasis and corrupted the row. Render it in a
+      // code span (backtick content is literal) exactly like renderAccountRow
+      // does, defusing embedded backticks via codeSpanSafe. The wrapping
+      // backticks still need pipe/newline guarding for the grid, hence the
+      // tableCell wrap around the finished span.
+      const accountCell = `\`${codeSpanSafe(s.isActive ? `${label} (active)` : label)}\``;
+      const { five, seven } = pctCells(s, now);
+      const status = statusCell(s, now, tz);
+      lines.push(
+        `| ${emoji} | ${tableCell(accountCell)} | ${five} | ${seven} | ${tableCell(status)} |`,
+      );
     }
   }
 
   lines.push('');
-  lines.push('────────────────────────────');
   lines.push(`_${recommendation(snapshots, now, opts.demo ?? false)}_`);
   // #2495 Change 2 — a failed probe-on-open renders an explicit "cached Nm
   // ago" warning, never a false live stamp. The degraded variant takes
@@ -615,10 +725,10 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
     // same per-account row + earliest-recovery helpers the /auth table uses so
     // the formatting stays consistent with the rest of the auth surface.
     lines.push(
-      `🔴 **All accounts blocked · ${headerLimit} on ${escapeHtml(input.oldLabel)}**`,
+      `🔴 **All accounts blocked · ${headerLimit} on ${escapeMarkdown(input.oldLabel)}**`,
     );
     lines.push('');
-    lines.push(`Triggered by: agent **${escapeHtml(input.triggerAgent)}**`);
+    lines.push(`Triggered by: agent **${escapeMarkdown(input.triggerAgent)}**`);
 
     const fleet = input.fleetSnapshots ?? [];
     if (fleet.length > 0) {
@@ -639,7 +749,7 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
       if (earliest) {
         lines.push('');
         lines.push(
-          `Earliest recovery: \`${escapeHtml(earliest.label)}\` ` +
+          `Earliest recovery: \`${codeSpanSafe(earliest.label)}\` ` +
             `${formatAbsolute(earliest.at, tz)} (in ${formatRelative(earliest.at, now)})`,
         );
       }
@@ -648,7 +758,7 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
       const recovery = recoveryAtFor(input.oldQuota);
       if (recovery) {
         lines.push(
-          `${escapeHtml(input.oldLabel)} recovers ${formatAbsolute(recovery, tz)} ` +
+          `${escapeMarkdown(input.oldLabel)} recovers ${formatAbsolute(recovery, tz)} ` +
             `(in ${formatRelative(recovery, now)})`,
         );
       }
@@ -663,20 +773,20 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
 
   // Successful swap.
   lines.push(
-    `✓ **Switched fleet · ${headerLimit} on ${escapeHtml(input.oldLabel)}**`,
+    `✓ **Switched fleet · ${headerLimit} on ${escapeMarkdown(input.oldLabel)}**`,
   );
   lines.push('');
   lines.push(
-    `\`${escapeHtml(input.oldLabel)}\` → \`${escapeHtml(input.newLabel)}\``,
+    `\`${codeSpanSafe(input.oldLabel)}\` → \`${codeSpanSafe(input.newLabel)}\``,
   );
-  lines.push(`Triggered by: agent **${escapeHtml(input.triggerAgent)}**`);
+  lines.push(`Triggered by: agent **${escapeMarkdown(input.triggerAgent)}**`);
   lines.push('');
 
   if (input.oldQuota) {
     const recovery = recoveryAtFor(input.oldQuota);
     if (recovery) {
       lines.push(
-        `\`${escapeHtml(input.oldLabel)}\` recovers ` +
+        `\`${codeSpanSafe(input.oldLabel)}\` recovers ` +
           `${formatAbsolute(recovery, tz)} (in ${formatRelative(recovery, now)})`,
       );
     }
@@ -690,7 +800,7 @@ export function renderFallbackAnnouncement(input: FallbackAnnouncementInput): st
       input.newQuota.sevenDayUtilizationPct < THROTTLING_THRESHOLD_PCT;
     const headroomStr = hasHeadroom ? '_(plenty of headroom)_' : '_(near limit — watch this)_';
     lines.push(
-      `\`${escapeHtml(input.newLabel)}\` now: ${fiveStr} of 5h · ${sevenStr} of 7d ${headroomStr}`,
+      `\`${codeSpanSafe(input.newLabel)}\` now: ${fiveStr} of 5h · ${sevenStr} of 7d ${headroomStr}`,
     );
   } else {
     lines.push(
@@ -807,10 +917,6 @@ function switchPriority(s: AccountSnapshot, now: Date = new Date()): number {
 
 // ── shared HTML escape ───────────────────────────────────────────────
 
-function escapeHtml(s: string): string {
-  return s.replace(/([\\`*_~=\[\]|])/g, '\\$1');
-}
-
 // ── snapshot assembly helper ─────────────────────────────────────────
 
 /**

package/telegram-plugin/auto-fallback-fleet.ts

@@ -35,6 +35,7 @@
  */
 
 import type { QuotaResult, QuotaUtilization } from './quota-check.js';
+import { escapeMarkdown } from './card-format.js';
 import type { ListStateData } from '../src/auth/broker/client.js';
 import {
   renderFallbackAnnouncement,
@@ -54,16 +55,12 @@ import {
  */
 export function renderFallbackFailureNotice(triggerAgent: string, reason: string): string {
   return (
-    `⚠️ **Auto-failover could not run** (trigger: **${escFailureHtml(triggerAgent)}**)\n` +
-    `${escFailureHtml(reason)}\n\n` +
+    `⚠️ **Auto-failover could not run** (trigger: **${escapeMarkdown(triggerAgent)}**)\n` +
+    `${escapeMarkdown(reason)}\n\n` +
     `_Switch manually with \`/auth use <label>\`, or \`/auth\` for fleet status._`
   );
 }
 
-function escFailureHtml(s: string): string {
-  return s.replace(/([\\`*_~=\[\]|])/g, '\\$1');
-}
-
 /**
  * Cooldown for the failure notice. The fleetFallbackGate's dedup window
  * deliberately arms ONLY on a successful swap (fleet-fallback-gate.ts:

package/telegram-plugin/card-format.ts

@@ -27,13 +27,63 @@
  * which is itself state-free.
  */
 
-import { escapeMarkdown } from './format.js'
+import { escapeMarkdown, codeSpanSafe } from './format.js'
 
 /**
  * Re-export so card surfaces have one import for the markdown escaper they
  * use when interpolating dynamic values into a hand-built markdown card.
+ * `codeSpanSafe` is the code-span (backtick) counterpart: use it for values
+ * interpolated INSIDE `` `…` `` (where backslash escaping is wrong).
  */
-export { escapeMarkdown }
+export { escapeMarkdown, codeSpanSafe }
+
+/**
+ * Join a card's pre-rendered, single-line entries so they STACK in the
+ * Bot API 10.1 rich-message renderer (#2669) — the same visual result the
+ * main reply path gets after `normalizeParagraphBreaks`.
+ *
+ * Why this exists: the rich GFM renderer treats a LONE `\n` between two
+ * non-blank lines as a SOFT break and collapses them onto one visual line
+ * (this is the exact reason `normalizeParagraphBreaks` promotes prose `\n`
+ * to a hard break on the reply path). Status / worker / issues / boot
+ * cards build a list of styled prose lines (`_✓ step_`, `**→ step**`,
+ * header lines, a `─────` rule) and join them with `\n`. Sent verbatim via
+ * `richMessage`, those lines collapse into a run-on blob — the long-standing
+ * "progress-card bullets collapse into one line" bug.
+ *
+ * Each card line is a SINGLE styled line with no internal newline (steps are
+ * pre-clipped to one line, headers are emitted one-per-array-entry), so we
+ * can deterministically promote EVERY inter-line break to a GFM hard break
+ * (`  \n`, two trailing spaces) without risking a list/table/code corruption:
+ * card lines are never GFM block-structure lines (no leading `-`/`*`/`|`/```),
+ * they are inline-styled prose. A blank entry (intentional `\n\n` gap, if a
+ * caller ever inserts one) is preserved as a real paragraph break.
+ *
+ * This is the card-surface analogue of the reply path's
+ * `normalizeParagraphBreaks`: it guarantees a card authored as stacked
+ * bullet/step lines renders identically to a normal reply.
+ */
+export function stackCardLines(lines: string[]): string {
+  const pieces: string[] = []
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]
+    pieces.push(line)
+    if (i === lines.length - 1) break
+    const cur = line.trim()
+    const next = lines[i + 1].trim()
+    // A blank current or next line is a genuine `\n\n` paragraph gap — leave
+    // the separator a plain newline so the blank entry reconstructs the gap.
+    if (cur === '' || next === '') {
+      pieces.push('\n')
+      continue
+    }
+    // Strip any trailing whitespace the line already carried so we emit
+    // exactly one `  \n` hard break (never accumulate spaces on a re-run).
+    pieces[pieces.length - 1] = line.replace(/[ \t\r]+$/, '')
+    pieces.push('  \n')
+  }
+  return pieces.join('')
+}
 
 /**
  * Render a millisecond duration as `<n>ms` for sub-second values, or

package/telegram-plugin/credits-watch.ts

@@ -23,6 +23,7 @@
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
+import { escapeMarkdown } from "./card-format.js";
 
 const STATE_FILE = "credits-watch.json";
 
@@ -157,7 +158,7 @@ export function evaluateCreditState(args: {
   if (!currentIsFatal && prevIsFatal) {
     return {
       kind: "notify",
-      message: `✅ **${escapeHtml(agentName)}**: credits restored — agent should resume normal operation.`,
+      message: `✅ **${escapeMarkdown(agentName)}**: credits restored — agent should resume normal operation.`,
       newState: { lastNotifiedReason: null, lastNotifiedAt: now },
       transition: "exited",
     };
@@ -193,12 +194,12 @@ export function evaluateCreditState(args: {
 function buildEntryMessage(agentName: string, reason: string): string {
   const desc = humanizeReason(reason);
   return [
-    `⚠️ **${escapeHtml(agentName)}**: ${desc}`,
+    `⚠️ **${escapeMarkdown(agentName)}**: ${desc}`,
     ``,
     `Cron tasks and inbound replies will fail until this is resolved. Check`,
     `your subscription or pre-paid usage at [console.anthropic.com](https://console.anthropic.com).`,
     ``,
-    `_Source: Claude CLI cache (cachedExtraUsageDisabledReason=${escapeHtml(reason)})_`,
+    `_Source: Claude CLI cache (cachedExtraUsageDisabledReason=${escapeMarkdown(reason)})_`,
   ].join("\n");
 }
 
@@ -217,10 +218,6 @@ function humanizeReason(reason: string): string {
   }
 }
 
-function escapeHtml(s: string): string {
-  return s.replace(/([\\`*_~=\[\]|])/g, "\\$1");
-}
-
 // ─── State persistence ───────────────────────────────────────────────────────
 
 export function loadCreditState(stateDir: string): CreditState {