switchroom 0.16.29 → 0.16.46

package/examples/minimal.yaml

@@ -23,7 +23,7 @@ memory:
   shared_collection: shared
 
 defaults:
-  model: claude-sonnet-4-6
+  model: claude-sonnet-5
   tools:
     allow: [all]
   subagents:

package/examples/switchroom.yaml

@@ -58,7 +58,7 @@ vault:
 # Every agent inherits this. Per-agent fields win on conflict.
 # tools/skills/schedule are unioned; scalars are overridden.
 defaults:
-  model: claude-sonnet-4-6
+  model: claude-sonnet-5
   # The switchroom-telegram fork is the default. Uncomment to fall back to
   # the upstream marketplace plugin: channels.telegram.plugin: official
   channels:

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "switchroom",
-  "version": "0.16.29",
+  "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
+  "version": "0.16.46",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {
@@ -25,7 +26,7 @@
     "pretest": "npm run build",
     "test": "vitest run && bun test telegram-plugin/tests/history.test.ts telegram-plugin/tests/cross-turn-card-gate.test.ts telegram-plugin/tests/emission-authority-open-gate.test.ts telegram-plugin/tests/emission-authority-ping-gate.test.ts telegram-plugin/tests/emission-authority-card-drain-gate.test.ts telegram-plugin/tests/per-topic-current-turn.test.ts telegram-plugin/tests/history-reaper.test.ts telegram-plugin/tests/ipc-server-client.test.ts telegram-plugin/tests/ipc-server-race.test.ts telegram-plugin/tests/gateway-bridge.test.ts telegram-plugin/tests/gateway-startup-mutex.test.ts telegram-plugin/tests/gateway-clean-shutdown-marker.test.ts telegram-plugin/tests/boot-card-dedupe.test.ts telegram-plugin/tests/boot-card-reason.test.ts telegram-plugin/tests/progress-update.test.ts telegram-plugin/tests/quota-cache.test.ts telegram-plugin/tests/silent-reply-guard.test.ts telegram-plugin/tests/unhandled-rejection-policy.test.ts telegram-plugin/tests/registry-turns.test.ts telegram-plugin/registry/subagents.test.ts telegram-plugin/registry/subagents-bugs.test.ts telegram-plugin/tests/subagent-watcher-parent-turn-key.test.ts telegram-plugin/tests/turns-writer.test.ts telegram-plugin/tests/resume-inbound-builder.test.ts telegram-plugin/registry/api-registry.test.ts telegram-plugin/registry/turns-schema.test.ts telegram-plugin/tests/idle-footer-wiring.test.ts telegram-plugin/tests/subagent-tracker-hooks.test.ts telegram-plugin/tests/resolve-calling-subagent.test.ts telegram-plugin/tests/gateway-update-placeholder-dispatch.test.ts telegram-plugin/tests/reaction-trigger.test.ts telegram-plugin/tests/reaction-trigger-flow.test.ts telegram-plugin/gateway/webhook-ingest-server.test.ts telegram-plugin/tests/skill-proposal-card.test.ts",
     "test:vitest": "vitest run",
-    "test:bun": "bun test src/watchdog/state.test.ts src/watchdog/policy.test.ts src/vault/grants.test.ts src/vault/write-grants.test.ts src/vault/broker/server-grants.test.ts src/vault/broker/server-write-grants.test.ts src/vault/broker/server-mint-grant-passphrase-attest.test.ts src/vault/broker/server-passphrase-attest.test.ts src/vault/broker/server-mint-grant-posture-attest.test.ts src/vault/broker/server-admin-only-keys.test.ts src/vault/broker/client-token.test.ts src/vault/broker/server-unlock.test.ts src/vault/broker/auto-unlock.test.ts src/vault/broker/drift-detection.test.ts tests/vault-broker-passphrase.test.ts src/cli/vault-get-broker.test.ts src/vault/resolver-via-broker.test.ts src/vault/broker/scope.test.ts src/vault/broker/server.test.ts src/litellm/provision-apply-e2e.test.ts src/drive/disconnect.test.ts src/drive/grants.test.ts src/drive/oauth.test.ts src/drive/onboarding.test.ts src/drive/reconciler.test.ts src/drive/vault-slots.test.ts src/drive/wrapper.test.ts src/vault/approvals/kernel.test.ts src/vault/approvals/approval-origin.test.ts src/vault/approvals/schema-idempotent.test.ts src/vault/broker/server-approvals.test.ts telegram-plugin/tests/boot-probes.test.ts telegram-plugin/tests/boot-version-string.test.ts telegram-plugin/tests/history.test.ts telegram-plugin/tests/cross-turn-card-gate.test.ts telegram-plugin/tests/emission-authority-open-gate.test.ts telegram-plugin/tests/emission-authority-ping-gate.test.ts telegram-plugin/tests/emission-authority-card-drain-gate.test.ts telegram-plugin/tests/per-topic-current-turn.test.ts telegram-plugin/tests/history-reaper.test.ts telegram-plugin/tests/ipc-server-client.test.ts telegram-plugin/tests/ipc-server-race.test.ts telegram-plugin/tests/gateway-bridge.test.ts telegram-plugin/tests/gateway-startup-mutex.test.ts telegram-plugin/tests/gateway-clean-shutdown-marker.test.ts telegram-plugin/tests/boot-card-dedupe.test.ts telegram-plugin/tests/boot-card-reason.test.ts telegram-plugin/tests/progress-update.test.ts telegram-plugin/tests/quota-cache.test.ts telegram-plugin/tests/silent-reply-guard.test.ts telegram-plugin/tests/unhandled-rejection-policy.test.ts telegram-plugin/tests/registry-turns.test.ts telegram-plugin/registry/subagents.test.ts telegram-plugin/registry/subagents-bugs.test.ts telegram-plugin/tests/subagent-watcher-parent-turn-key.test.ts telegram-plugin/tests/turns-writer.test.ts telegram-plugin/tests/resume-inbound-builder.test.ts telegram-plugin/tests/subagent-tracker-hooks.test.ts telegram-plugin/tests/resolve-calling-subagent.test.ts telegram-plugin/tests/gateway-update-placeholder-dispatch.test.ts telegram-plugin/tests/reaction-trigger.test.ts telegram-plugin/tests/reaction-trigger-flow.test.ts telegram-plugin/tests/subagent-watcher-workflow-visibility.test.ts telegram-plugin/uat/load-env.test.ts telegram-plugin/uat/feed-matcher.test.ts telegram-plugin/gateway/webhook-ingest-server.test.ts telegram-plugin/tests/skill-proposal-card.test.ts",
+    "test:bun": "bun test src/vault/grants.test.ts src/vault/write-grants.test.ts src/vault/broker/server-grants.test.ts src/vault/broker/server-write-grants.test.ts src/vault/broker/server-mint-grant-passphrase-attest.test.ts src/vault/broker/server-passphrase-attest.test.ts src/vault/broker/server-mint-grant-posture-attest.test.ts src/vault/broker/server-admin-only-keys.test.ts src/vault/broker/client-token.test.ts src/vault/broker/server-unlock.test.ts src/vault/broker/auto-unlock.test.ts src/vault/broker/drift-detection.test.ts tests/vault-broker-passphrase.test.ts src/cli/vault-get-broker.test.ts src/vault/resolver-via-broker.test.ts src/vault/broker/scope.test.ts src/vault/broker/server.test.ts src/litellm/provision-apply-e2e.test.ts src/drive/disconnect.test.ts src/drive/grants.test.ts src/drive/oauth.test.ts src/drive/onboarding.test.ts src/drive/reconciler.test.ts src/drive/vault-slots.test.ts src/drive/wrapper.test.ts src/vault/approvals/kernel.test.ts src/vault/approvals/approval-origin.test.ts src/vault/approvals/schema-idempotent.test.ts src/vault/broker/server-approvals.test.ts telegram-plugin/tests/boot-probes.test.ts telegram-plugin/tests/boot-version-string.test.ts telegram-plugin/tests/history.test.ts telegram-plugin/tests/cross-turn-card-gate.test.ts telegram-plugin/tests/emission-authority-open-gate.test.ts telegram-plugin/tests/emission-authority-ping-gate.test.ts telegram-plugin/tests/emission-authority-card-drain-gate.test.ts telegram-plugin/tests/per-topic-current-turn.test.ts telegram-plugin/tests/history-reaper.test.ts telegram-plugin/tests/ipc-server-client.test.ts telegram-plugin/tests/ipc-server-race.test.ts telegram-plugin/tests/gateway-bridge.test.ts telegram-plugin/tests/gateway-startup-mutex.test.ts telegram-plugin/tests/gateway-clean-shutdown-marker.test.ts telegram-plugin/tests/boot-card-dedupe.test.ts telegram-plugin/tests/boot-card-reason.test.ts telegram-plugin/tests/progress-update.test.ts telegram-plugin/tests/quota-cache.test.ts telegram-plugin/tests/silent-reply-guard.test.ts telegram-plugin/tests/unhandled-rejection-policy.test.ts telegram-plugin/tests/registry-turns.test.ts telegram-plugin/registry/subagents.test.ts telegram-plugin/registry/subagents-bugs.test.ts telegram-plugin/tests/subagent-watcher-parent-turn-key.test.ts telegram-plugin/tests/turns-writer.test.ts telegram-plugin/tests/resume-inbound-builder.test.ts telegram-plugin/tests/subagent-tracker-hooks.test.ts telegram-plugin/tests/resolve-calling-subagent.test.ts telegram-plugin/tests/gateway-update-placeholder-dispatch.test.ts telegram-plugin/tests/reaction-trigger.test.ts telegram-plugin/tests/reaction-trigger-flow.test.ts telegram-plugin/tests/subagent-watcher-workflow-visibility.test.ts telegram-plugin/uat/load-env.test.ts telegram-plugin/uat/feed-matcher.test.ts telegram-plugin/uat/uat-driver.test.ts telegram-plugin/gateway/webhook-ingest-server.test.ts telegram-plugin/tests/skill-proposal-card.test.ts",
     "test:watch": "vitest",
     "lint": "tsc --noEmit && node scripts/check-plugin-references.mjs && bash scripts/check-bot-api-wrapping.sh && node scripts/check-bun-test-imports.mjs && node scripts/check-no-pii-secrets.mjs && node scripts/check-vault-test-hermeticity.mjs && node scripts/check-no-broadcast-delivery.mjs && node scripts/check-stale-tool-descriptions.mjs && node scripts/check-web-subscription-honest.mjs",
     "lint:tsc": "tsc --noEmit",

package/profiles/_shared/agent-self-service.md.hbs

@@ -43,7 +43,9 @@ tools is to let you do the edit yourself.
     still shares your memory + tools but drops your accumulated conversation
     context). A **daily/weekly** cron defaults to a **full turn in your live
     session** (Tier 2: your model, your whole context). So routine frequent
-    checks are already cheap without you doing anything.
+    checks are already cheap without you doing anything. Cron-fresh sessions
+    render rich markdown too, so scheduled/digest/daily-memory output should
+    use **bold** section headers + `code` for identifiers, just like a live reply.
   - *`model: "sonnet"` / `context: "fresh"`* — force the cheap Tier-1 session
     even for a **daily/weekly** self-contained job (summarise a feed, format a
     digest) — overrides the cadence default. *`context: "agent"`* does the
@@ -53,7 +55,10 @@ tools is to let you do the edit yourself.
     ping — text fully determined, no thinking) — ask the **operator** for a
     **`kind: action`**: it runs **model-free, zero tokens** (no session at all),
     posting your fixed/templated text or firing a fixed request. The cheapest
-    tier there is.
+    tier there is. The action `text` is rendered as full GFM markdown
+    (**bold**, _italic_, `code`, ~~strikethrough~~, links) — so a literal `*`
+    or `_` in fixed text becomes formatting unless you set `parse_mode: text`,
+    which sends the string verbatim (the escape hatch).
   - *"Only act when X changes"* — don't poll with a frequent prompt cron (every
     fire is a wasted turn when nothing changed). Ask the **operator** for a
     **`kind: poll`** (model-free check, e.g. a webpage/API — only a *change*

package/profiles/_shared/reply-discipline.md.hbs

@@ -0,0 +1,9 @@
+## ⛔ SENDING YOUR ANSWER (read first, applies every turn)
+
+**Plain text you write is INVISIBLE to the user.** The only thing that reaches Telegram is text passed through the `mcp__switchroom-telegram__reply` tool. Writing the answer in your response is NOT sending it — the user sees nothing until you call the reply tool.
+
+- Every turn that answers a user **MUST end with a `reply` tool call** carrying the full answer. No exceptions, no "I'll just write it out."
+- If you did work first (tool calls, lookups), the reply call is still required at the end — don't let the turn end on a tool result or plain prose.
+- If you genuinely have nothing to add, emit exactly `NO_REPLY` and nothing else.
+
+If you skip this, the gateway's safety net eventually forces your answer out 2-4 minutes late and burns extra turns. Don't rely on the net. Send it yourself.

package/skills/switchroom-status/SKILL.md

@@ -82,7 +82,7 @@ End with a one-line summary: "X of Y agents running."
 
 ```
 assistant — running (2h 14m)
-  model: claude-sonnet-4-6  collection: general
+  model: claude-sonnet-5  collection: general
 
 dev — running (45m)
   model: claude-opus-4-8  collection: coding

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/bridge/bridge.ts

@@ -434,7 +434,8 @@ const TOOL_SCHEMAS = [
         chat_id: { type: 'string', description: 'Chat to render the approval card in (use the chat_id of the user message that triggered the workflow).' },
         key: { type: 'string', description: 'Vault key the agent wants access to (matches the key shown in the VAULT-BROKER-DENIED error, e.g. `fatsecret/credentials`).' },
         scope: { type: 'string', enum: ['read', 'write'], description: 'Access scope: "read" (default) for `vault:<key>` references; "write" if the agent needs to put new values.' },
-        reason: { type: 'string', description: 'REQUIRED in practice — short human-readable rationale rendered on the card (e.g. "to look up today\'s food log entries"). The approval card now renders "why: not provided" when this is omitted, which signals to the operator that the agent skipped its explanation — they will usually Deny. Always supply a one-line rationale.' },
+        reason: { type: 'string', description: 'REQUIRED in practice — short human-readable rationale rendered on the card (e.g. "to look up today\'s food log entries"). The approval card now renders "why: not provided" when this is omitted, which signals to the operator that the agent skipped its explanation — they will usually Deny. Always supply a one-line rationale. `why` is accepted as an alias (matching `vault_request_save`).' },
+        why: { type: 'string', description: 'Alias for `reason` (matches the sibling tool `vault_request_save`). If both are supplied, `reason` wins.' },
         duration: { type: 'string', description: 'Requested grant TTL, like "30d" or "12h". Default 30d, capped at 90d. Beyond 90d the operator should use the host CLI explicitly.' },
         message_thread_id: { type: 'string', description: 'Forum topic thread ID. Auto-applied from the last inbound message if not specified.' },
       },

package/telegram-plugin/card-format.ts

@@ -27,13 +27,64 @@
  * which is itself state-free.
  */
 
-import { escapeMarkdown } from './format.js'
+import { escapeMarkdown, codeSpanSafe } from './format.js'
+import { normalizeDashes } from './text-voice-scrub.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
@@ -77,7 +128,12 @@ export function truncate(s: string, n: number): string {
  * Run this BEFORE `truncate` + `escapeMarkdown`: clean → measure → escape.
  */
 export function stripMarkdown(s: string): string {
-  let out = s;
+  // Close the em-dash leak on this model-authored-prose surface using the
+  // SAME dash logic as the reply-path voice scrub (no duplicated regex). Run
+  // it FIRST, while code spans (`` `…` ``) still have their backticks intact,
+  // so `normalizeDashes`'s own code-region masking preserves a dash inside a
+  // code span before the backtick-stripping below erases the fences.
+  let out = normalizeDashes(s);
   // Inline + leftover code spans → bare text.
   out = out.replace(/`+/g, '');
   // Links / images: [text](url) and ![alt](url) → the label.