switchroom 0.18.13 → 0.18.15

package/telegram-plugin/tests/history.test.ts

@@ -2,6 +2,9 @@ import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import { mkdtempSync, statSync, rmSync, existsSync } from 'fs'
 import { tmpdir } from 'os'
 import { join } from 'path'
+// bun-only (this file is vitest-excluded and runs under `bun test`): used to
+// build an OLD-schema DB file for the additive-migration test.
+import { Database } from 'bun:sqlite'
 import {
   initHistory,
   recordInbound,
@@ -715,3 +718,157 @@ describe('secret redaction at persistence (both directions)', () => {
     expect(query({ chat_id: '-100' })[0]!.text).toBe('hello, how are you?')
   })
 })
+
+describe('forwarded-message origin columns', () => {
+  it('round-trips forwarded_* fields on an inbound row', () => {
+    initHistory(stateDir, 30)
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 7,
+      user: 'alice',
+      user_id: '111',
+      ts: 1000,
+      text: 'fwd: look at this',
+      forwarded_from: 'Release Notes (@relnotes)',
+      forwarded_from_type: 'channel',
+      forwarded_from_id: '-100400500',
+      forwarded_date: '2026-06-15T13:46:40.000Z',
+      forwarded_message_id: 555,
+    })
+    const row = query({ chat_id: '-100' })[0]!
+    expect(row).toMatchObject({
+      forwarded_from: 'Release Notes (@relnotes)',
+      forwarded_from_type: 'channel',
+      forwarded_from_id: '-100400500',
+      forwarded_date: '2026-06-15T13:46:40.000Z',
+      forwarded_message_id: 555,
+    })
+  })
+
+  it('non-forwarded inbound stores NULL origin fields', () => {
+    initHistory(stateDir, 30)
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 8,
+      user: 'alice',
+      user_id: '111',
+      ts: 1000,
+      text: 'plain message',
+    })
+    const row = query({ chat_id: '-100' })[0]!
+    expect(row.forwarded_from).toBeNull()
+    expect(row.forwarded_from_type).toBeNull()
+    expect(row.forwarded_from_id).toBeNull()
+    expect(row.forwarded_date).toBeNull()
+    expect(row.forwarded_message_id).toBeNull()
+  })
+
+  it('migrates additively: pre-existing DB without the columns gains them and round-trips', () => {
+    // Build an OLD-schema DB file the way a pre-forward-origin build would
+    // have left it: messages table without any forwarded_* columns, one row
+    // already stored.
+    const dbPath = join(stateDir, 'history.db')
+    const old = new Database(dbPath, { create: true })
+    old.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        chat_id        TEXT    NOT NULL,
+        thread_id      INTEGER,
+        message_id     INTEGER NOT NULL,
+        role           TEXT    NOT NULL,
+        user           TEXT,
+        user_id        TEXT,
+        ts             INTEGER NOT NULL,
+        text           TEXT    NOT NULL,
+        attachment_kind TEXT,
+        group_id       INTEGER,
+        reply_to_message_id INTEGER,
+        reply_to_text  TEXT,
+        PRIMARY KEY (chat_id, thread_id, message_id)
+      )
+    `)
+    // Recent ts — initHistory's retention sweep deletes rows older than the
+    // cutoff, and this test is about migration, not retention.
+    const now = Math.floor(Date.now() / 1000)
+    old.exec(
+      `INSERT INTO messages (chat_id, thread_id, message_id, role, user, user_id, ts, text) ` +
+      `VALUES ('-100', NULL, 1, 'user', 'alice', '111', ${now - 60}, 'pre-migration row')`,
+    )
+    old.close()
+
+    // Re-open through the real init path — the additive ALTER TABLE loop
+    // must add the forwarded_* columns without touching existing rows.
+    initHistory(stateDir, 30)
+
+    const oldRow = query({ chat_id: '-100' })[0]!
+    expect(oldRow.text).toBe('pre-migration row')
+    expect(oldRow.forwarded_from).toBeNull()
+
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 2,
+      user: 'alice',
+      user_id: '111',
+      ts: now,
+      text: 'forwarded after migration',
+      forwarded_from: 'Ada Lovelace (@adalove)',
+      forwarded_from_type: 'user',
+      forwarded_from_id: '42',
+      forwarded_date: '2026-06-15T13:46:40.000Z',
+    })
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(2)
+    const fwd = rows.find((r) => r.message_id === 2)!
+    expect(fwd.forwarded_from).toBe('Ada Lovelace (@adalove)')
+    expect(fwd.forwarded_from_type).toBe('user')
+    expect(fwd.forwarded_from_id).toBe('42')
+    expect(fwd.forwarded_date).toBe('2026-06-15T13:46:40.000Z')
+    expect(fwd.forwarded_message_id).toBeNull()
+  })
+
+  it('hostile origin name is stored raw (XML metachars belong to the meta lane)', () => {
+    initHistory(stateDir, 30)
+    // Raw XML metacharacters are EXPECTED here — escaping belongs to the
+    // channel-meta lane, the history buffer stores what the user saw.
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 9,
+      user: 'alice',
+      user_id: '111',
+      ts: 1000,
+      text: 'fwd',
+      forwarded_from: '<b>"Bob"&\'friends\'</b>',
+      forwarded_from_type: 'user',
+      forwarded_from_id: '42',
+    })
+    expect(query({ chat_id: '-100' })[0]!.forwarded_from).toBe('<b>"Bob"&\'friends\'</b>')
+  })
+
+  it('masks a secret-shaped origin name before it is stored (redaction backstop)', () => {
+    initHistory(stateDir, 30)
+    // Built by concatenation so the source never holds a contiguous
+    // secret-shaped literal (repo Push Protection / no-pii lint). Same
+    // pattern as the text/reply_to_text redaction tests above — a display
+    // name is user-controlled text and rides the same redact() backstop.
+    const GH_PAT = `ghp_${'F6g7H8i9J0'.repeat(3)}` // ghp_<30 base62>
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 10,
+      user: 'alice',
+      user_id: '111',
+      ts: 1000,
+      text: 'fwd',
+      forwarded_from: `Bob ${GH_PAT}`,
+      forwarded_from_type: 'user',
+      forwarded_from_id: '42',
+    })
+    const stored = query({ chat_id: '-100' })[0]!.forwarded_from as string
+    expect(stored).not.toContain(GH_PAT)
+    expect(stored).toContain('[REDACTED')
+    expect(stored).toContain('Bob') // surrounding name preserved
+  })
+})

package/telegram-plugin/tests/model-unavailable.test.ts

@@ -14,10 +14,52 @@ import { describe, it, expect } from 'vitest'
 import {
   detectModelUnavailable,
   formatModelUnavailableCard,
+  isLitellmProxyLocal429,
+  parseLitellmLimitDetail,
   resolveModelUnavailableFromOperatorEvent,
   type ModelUnavailableDetection,
 } from '../model-unavailable.js'
 
+// Real LiteLLM proxy-local 429 bodies, verbatim shapes from BerriAI/litellm
+// source (see the provenance comment on `litellmProxyLocal429Signals`).
+const LITELLM_DEPLOYMENT_CAP_BODY =
+  'Deployment over user-defined ratelimit. tpm limit=8000. current usage=8241. ' +
+  'id=abc123def, model_group=claude-fable-5'
+const LITELLM_DEPLOYMENT_CAP_MESSAGE =
+  'litellm.RateLimitError: Model rate limit exceeded. TPM limit=8000, current usage=8241'
+const LITELLM_V2_STRATEGY_BODY =
+  "Deployment over defined rpm limit=60. current usage=61. id=abc123def, " +
+  "model_group=claude-fable-5. Get the model info by calling 'router.get_model_info(id)"
+const LITELLM_ROUTER_COOLDOWN_BODY =
+  'No deployments available for selected model, Try again in 27.5 seconds. ' +
+  "Passed model=claude-fable-5. pre-call-checks=False, cooldown_list=['abc123def']"
+const LITELLM_V3_KEY_LIMIT_BODY =
+  'Rate limit exceeded for api_key: hashed-key-1a2b3c. Limit type: tokens. ' +
+  'Current limit: 8000, Remaining: 0. Limit resets at: 2026-07-12 08:05:00 UTC'
+// v1 shape A — the ProxyRateLimitError detail (parallel_request_limiter.py
+// ~line 124; the interpolated CommonProxyErrors.max_parallel_request_limit_
+// reached.value is "Crossed TPM / RPM / Max Parallel Request Limit").
+const LITELLM_V1_PARALLEL_BODY =
+  'LiteLLM Rate Limit Handler for rate limit type = requests. ' +
+  'Crossed TPM / RPM / Max Parallel Request Limit. ' +
+  'current rpm: 61, rpm limit: 60, current tpm: 100, tpm limit: 8000, ' +
+  'current max_parallel_requests: 1, max_parallel_requests: 10'
+// v1 shape B — raise_rate_limit_error's zero-limit branch: the standalone
+// "Max parallel request limit reached" prefix + additional_details
+// (parallel_request_limiter.py ~lines 88 + 183).
+const LITELLM_V1_ZERO_LIMIT_BODY =
+  'Max parallel request limit reached Crossed TPM / RPM / Max Parallel ' +
+  'Request Limit. Hit limit for tokens. Current limits: ' +
+  'max_parallel_requests: 10, tpm_limit: 0, rpm_limit: 60'
+// v3 limiter with a descriptor OUTSIDE any enumerated list — covered by the
+// litellmV3LimiterSignalPair co-occurrence rule (v3 descriptor keys also
+// include organization / team_member / model_per_team / agent / tag_per_key
+// / mcp_per_key and keep growing, so enumeration is a treadmill).
+const LITELLM_V3_TEAM_MODEL_BODY =
+  'Rate limit exceeded for model_per_team: team-1a2b3c:claude-fable-5. ' +
+  'Limit type: tokens. Current limit: 50000, Remaining: 0. ' +
+  'Limit resets at: 2026-07-12 08:05:00 UTC'
+
 // ─── detectModelUnavailable ──────────────────────────────────────────────────
 
 describe('detectModelUnavailable — quota / billing strings', () => {
@@ -117,6 +159,151 @@ describe('detectModelUnavailable — transient upstream 429 vs account quota (#2
   })
 })
 
+describe('detectModelUnavailable — LiteLLM-proxy-LOCAL 429s (never quota)', () => {
+  // A 429 raised by LiteLLM's OWN limiter never reached Anthropic — it must
+  // classify to the calm retryable kind, never quota_exhausted (which drives
+  // the scary card + mark-exhausted + fleet failover for an account that was
+  // never touched). Bodies are verbatim LiteLLM source shapes.
+  it.each([
+    ['deployment tpm cap (model_rate_limit_check body)', LITELLM_DEPLOYMENT_CAP_BODY],
+    ['deployment tpm cap (RateLimitError message)', LITELLM_DEPLOYMENT_CAP_MESSAGE],
+    ['usage-based-routing v2 rpm wording', LITELLM_V2_STRATEGY_BODY],
+    ['router cooldown (RouterRateLimitError)', LITELLM_ROUTER_COOLDOWN_BODY],
+    ['virtual-key tpm_limit (parallel_request_limiter_v3)', LITELLM_V3_KEY_LIMIT_BODY],
+    ['team model cap — non-enumerated v3 descriptor (co-occurrence rule)', LITELLM_V3_TEAM_MODEL_BODY],
+    ['v1 parallel-request limiter (Rate Limit Handler detail)', LITELLM_V1_PARALLEL_BODY],
+    ['v1 zero-limit branch (Max parallel request limit reached prefix)', LITELLM_V1_ZERO_LIMIT_BODY],
+  ])('classifies %s as overload, NOT quota_exhausted', (_name, body) => {
+    const d = detectModelUnavailable(body)
+    expect(d?.kind).toBe('overload')
+  })
+
+  it('a rate-limited operator event with a LiteLLM-local body resolves to NO model-unavailable card', () => {
+    // End-to-end seam the gateway uses: resolveModelUnavailableFromOperatorEvent
+    // returning null is what keeps the calm 🚦 card AND blocks the
+    // auto-fallback branch (fallback only fires when a detection resolves).
+    for (const body of [
+      LITELLM_DEPLOYMENT_CAP_BODY,
+      LITELLM_V3_KEY_LIMIT_BODY,
+      LITELLM_ROUTER_COOLDOWN_BODY,
+    ]) {
+      expect(
+        resolveModelUnavailableFromOperatorEvent({ kind: 'rate-limited', detail: body }),
+      ).toBeNull()
+    }
+  })
+})
+
+describe('isLitellmProxyLocal429 — signal matching', () => {
+  it('matches every canonical LiteLLM limiter wording', () => {
+    for (const body of [
+      LITELLM_DEPLOYMENT_CAP_BODY,
+      LITELLM_DEPLOYMENT_CAP_MESSAGE,
+      LITELLM_V2_STRATEGY_BODY,
+      LITELLM_ROUTER_COOLDOWN_BODY,
+      LITELLM_V3_KEY_LIMIT_BODY,
+      LITELLM_V1_PARALLEL_BODY,
+      LITELLM_V1_ZERO_LIMIT_BODY,
+    ]) {
+      expect(isLitellmProxyLocal429(body)).toBe(true)
+    }
+  })
+
+  it('matches ANY v3 descriptor via the co-occurrence pair, not an enumerated list', () => {
+    // model_per_team is not in litellmProxyLocal429Signals — only the
+    // "rate limit exceeded for " + "limit type:" pair catches it. Same for
+    // any descriptor litellm adds later.
+    expect(isLitellmProxyLocal429(LITELLM_V3_TEAM_MODEL_BODY)).toBe(true)
+    expect(
+      isLitellmProxyLocal429(
+        'Rate limit exceeded for organization: org-1a2b3c. Limit type: requests. ' +
+          'Current limit: 100, Remaining: 0. Limit resets at: 2026-07-12 08:05:00 UTC',
+      ),
+    ).toBe(true)
+    // HALF the pair is not enough — "rate limit exceeded for" prose without
+    // the v3 "Limit type:" field must not classify proxy-local.
+    expect(
+      isLitellmProxyLocal429('Rate limit exceeded for this account, try later'),
+    ).toBe(false)
+    expect(isLitellmProxyLocal429('Limit type: tokens')).toBe(false)
+  })
+
+  it('does NOT match Anthropic account/wall/server wordings', () => {
+    expect(
+      isLitellmProxyLocal429(
+        "This request would exceed your account's rate limit. Please try again later.",
+      ),
+    ).toBe(false)
+    expect(
+      isLitellmProxyLocal429('Server is temporarily limiting requests (not your usage limit)'),
+    ).toBe(false)
+    expect(isLitellmProxyLocal429("You've hit your limit · resets 8:50am")).toBe(false)
+  })
+
+  it('does NOT match the bare litellm.RateLimitError exception-mapping prefix', () => {
+    // The pass-through wraps FORWARDED upstream 429s with the same prefix —
+    // it is not evidence the limit was proxy-local.
+    expect(
+      isLitellmProxyLocal429(
+        "litellm.RateLimitError: RateLimitError: This request would exceed your account's rate limit.",
+      ),
+    ).toBe(false)
+  })
+
+  it('never throws on weird input', () => {
+    expect(isLitellmProxyLocal429('')).toBe(false)
+    expect(isLitellmProxyLocal429(undefined as unknown as string)).toBe(false)
+    expect(isLitellmProxyLocal429(42 as unknown as string)).toBe(false)
+    // Slice guard: signal past the 16KB sample is not scanned.
+    expect(isLitellmProxyLocal429('A'.repeat(100_000) + LITELLM_DEPLOYMENT_CAP_BODY)).toBe(false)
+  })
+})
+
+describe('parseLitellmLimitDetail — instrumentation extraction', () => {
+  const NOW = new Date(Date.UTC(2026, 6, 12, 8, 0, 0))
+
+  it('extracts tpm limit + current usage from the deployment-cap body', () => {
+    const d = parseLitellmLimitDetail(LITELLM_DEPLOYMENT_CAP_BODY, NOW)
+    expect(d.limitType).toBe('tpm')
+    expect(d.limit).toBe(8000)
+    expect(d.currentUsage).toBe(8241)
+    expect(d.resetAtMs).toBeNull()
+  })
+
+  it('extracts rpm limit from the v2 strategy body', () => {
+    const d = parseLitellmLimitDetail(LITELLM_V2_STRATEGY_BODY, NOW)
+    expect(d.limitType).toBe('rpm')
+    expect(d.limit).toBe(60)
+    expect(d.currentUsage).toBe(61)
+  })
+
+  it('extracts the v3 limiter limit type, limit, and "Limit resets at" UTC timestamp', () => {
+    const d = parseLitellmLimitDetail(LITELLM_V3_KEY_LIMIT_BODY, NOW)
+    expect(d.limitType).toBe('tokens')
+    expect(d.limit).toBe(8000)
+    expect(d.resetAtMs).toBe(Date.UTC(2026, 6, 12, 8, 5, 0))
+  })
+
+  it('extracts the router-cooldown "Try again in N seconds" relative reset', () => {
+    const d = parseLitellmLimitDetail(LITELLM_ROUTER_COOLDOWN_BODY, NOW)
+    expect(d.resetAtMs).toBe(NOW.getTime() + 27_500)
+  })
+
+  it('extracts the v1 limiter colon-form rpm limit', () => {
+    const d = parseLitellmLimitDetail(LITELLM_V1_PARALLEL_BODY, NOW)
+    expect(d.limitType).toBe('rpm')
+    expect(d.limit).toBe(60)
+  })
+
+  it('returns all-null on non-LiteLLM prose and never throws on weird input', () => {
+    const empty = { limitType: null, limit: null, currentUsage: null, resetAtMs: null }
+    expect(parseLitellmLimitDetail('Please try again later.', NOW)).toEqual(empty)
+    expect(parseLitellmLimitDetail('', NOW)).toEqual(empty)
+    expect(parseLitellmLimitDetail(undefined as unknown as string, NOW)).toEqual(empty)
+    expect(parseLitellmLimitDetail({} as unknown as string, NOW)).toEqual(empty)
+  })
+})
+
 describe('detectModelUnavailable — network failures', () => {
   it('classifies ECONNREFUSED', () => {
     expect(detectModelUnavailable('connect ECONNREFUSED 1.2.3.4:443')?.kind).toBe('network')

package/telegram-plugin/tests/operator-events-session-tail.test.ts

@@ -198,6 +198,61 @@ describe('detectErrorInTranscriptLine — error detection', () => {
     expect(detection).toBeNull()
   })
 
+  // A 429 whose body carries LiteLLM-proxy-LOCAL limiter wording is the
+  // proxy's own tpm_limit/rpm_limit cap tripping BEFORE the request reached
+  // Anthropic. Nothing about the account is exhausted — it must take the
+  // calm rate-limited path (no model-unavailable card, no mark-exhausted,
+  // no fleet failover). Prerequisite for enabling litellm tpm caps on the
+  // fleet: without this, every cap trip would bench a healthy account.
+  it('classifies a LiteLLM-proxy-local 429 as rate-limited, NOT quota-exhausted', () => {
+    const litellmBodies = [
+      // Deployment tpm cap (model_rate_limit_check.py body, verbatim shape).
+      'API Error: 429 Deployment over user-defined ratelimit. tpm limit=8000. ' +
+        'current usage=8241. id=abc123def, model_group=claude-fable-5',
+      // Virtual-key tpm_limit (parallel_request_limiter_v3.py).
+      'API Error: 429 Rate limit exceeded for api_key: hashed-key-1a2b3c. ' +
+        'Limit type: tokens. Current limit: 8000, Remaining: 0. ' +
+        'Limit resets at: 2026-07-12 08:05:00 UTC',
+      // Router cooldown (RouterRateLimitError).
+      'API Error: 429 No deployments available for selected model, ' +
+        'Try again in 27.5 seconds. Passed model=claude-fable-5.',
+      // Team-level model cap — a v3 descriptor OUTSIDE the enumerated signal
+      // list, covered only by the co-occurrence pair
+      // (litellmV3LimiterSignalPair). Pre-fix this missed every signal →
+      // quota-exhausted → scary card + failover.
+      'API Error: 429 Rate limit exceeded for model_per_team: ' +
+        'team-1a2b3c:claude-fable-5. Limit type: tokens. ' +
+        'Current limit: 50000, Remaining: 0. ' +
+        'Limit resets at: 2026-07-12 08:05:00 UTC',
+    ]
+    for (const text of litellmBodies) {
+      const line = JSON.stringify({
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          model: '<synthetic>',
+          content: [{ type: 'text', text }],
+        },
+        error: 'rate_limit',
+        isApiErrorMessage: true,
+        apiErrorStatus: 429,
+      })
+      const result = detectErrorInTranscriptLine(line)
+      expect(result).not.toBeNull()
+      expect(result!.kind).toBe('rate-limited')
+      expect(result!.transient).toBe(true)
+      // End-to-end: the resolver must NOT produce a model-unavailable card —
+      // null is what keeps the calm 🚦 card and blocks the auto-fallback
+      // branch in emitGatewayOperatorEvent.
+      expect(
+        resolveModelUnavailableFromOperatorEvent({
+          kind: result!.kind,
+          detail: result!.detail,
+        }),
+      ).toBeNull()
+    }
+  })
+
   // Guard against over-correcting: a GENUINE quota wall (no transient marker)
   // must STILL be quota-exhausted AND still resolve to a card.
   it('a genuine quota-wall 429 still produces the quota-exhausted card', () => {

package/telegram-plugin/tests/render/render-outbound-chunks.test.ts

@@ -17,8 +17,10 @@ import { describe, it, expect } from "vitest";
 import { renderOutboundChunks, PLAIN_TEXT_MAX_CHARS } from "../../render/rich-render.js";
 import { RICH_MESSAGE_MAX_CHARS } from "../../format.js";
 
-const ON = { SWITCHROOM_RICH_RENDER: "1" } as NodeJS.ProcessEnv;
-const OFF = {} as NodeJS.ProcessEnv;
+// Rendering is ON BY DEFAULT (escape hatch, not opt-in — mirrors the send
+// gate): an empty env exercises the real default; "0" is the kill-switch.
+const ON = {} as NodeJS.ProcessEnv;
+const OFF = { SWITCHROOM_RICH_RENDER: "0" } as NodeJS.ProcessEnv;
 
 /** Count fenced-code delimiter lines (```) in a body. A piece that bisects a
  *  fenced block has an ODD count. */
@@ -27,7 +29,7 @@ function fenceCount(s: string): number {
 }
 
 describe("renderOutboundChunks", () => {
-  it("flag OFF is a single passthrough piece (byte-for-byte)", () => {
+  it("disabled (=0) is a single passthrough piece (byte-for-byte)", () => {
     const raw = "**bold** and _italic_ | a | table |";
     const pieces = renderOutboundChunks(raw, OFF);
     expect(pieces).toHaveLength(1);
@@ -35,7 +37,7 @@ describe("renderOutboundChunks", () => {
     expect(pieces[0].mode).toBe("markdown");
   });
 
-  it("flag ON, body that fits is a single piece (common case)", () => {
+  it("default (env unset), body that fits is a single piece (common case)", () => {
     const pieces = renderOutboundChunks("just some plain prose", ON);
     expect(pieces).toHaveLength(1);
     expect(pieces[0].text.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS);

package/telegram-plugin/tests/render/rich-render.test.ts

@@ -7,24 +7,32 @@ import {
 } from "../../render/rich-render.js";
 
 describe("parseRichRenderEnabled", () => {
-  it("defaults OFF when unset", () => {
-    expect(parseRichRenderEnabled(undefined)).toBe(false);
+  it("defaults ON when unset (escape hatch, not opt-in)", () => {
+    expect(parseRichRenderEnabled(undefined)).toBe(true);
   });
-  it("accepts the truthy tokens", () => {
+  it("disabled only by the explicit off tokens (case-insensitive, trimmed)", () => {
+    for (const v of ["0", "false", "off", "no", "FALSE", " Off ", "NO"]) {
+      expect(parseRichRenderEnabled(v)).toBe(false);
+    }
+  });
+  it("truthy tokens stay ON", () => {
     for (const v of ["1", "true", "on", "yes", "TRUE", " On "]) {
       expect(parseRichRenderEnabled(v)).toBe(true);
     }
   });
-  it("treats everything else as OFF", () => {
-    for (const v of ["0", "false", "off", "no", "", "maybe"]) {
-      expect(parseRichRenderEnabled(v)).toBe(false);
+  it("empty / unrecognised values stay ON (fail-open to the default)", () => {
+    for (const v of ["", "  ", "maybe", "2", "disable"]) {
+      expect(parseRichRenderEnabled(v)).toBe(true);
     }
   });
 });
 
 describe("richRenderEnabled", () => {
-  it("reads SWITCHROOM_RICH_RENDER, default OFF", () => {
-    expect(richRenderEnabled({} as NodeJS.ProcessEnv)).toBe(false);
+  it("reads SWITCHROOM_RICH_RENDER, default ON", () => {
+    expect(richRenderEnabled({} as NodeJS.ProcessEnv)).toBe(true);
+    expect(
+      richRenderEnabled({ SWITCHROOM_RICH_RENDER: "0" } as NodeJS.ProcessEnv),
+    ).toBe(false);
     expect(
       richRenderEnabled({ SWITCHROOM_RICH_RENDER: "1" } as NodeJS.ProcessEnv),
     ).toBe(true);
@@ -32,41 +40,52 @@ describe("richRenderEnabled", () => {
 });
 
 describe("maybeRenderOutbound", () => {
-  it("flag OFF is a byte-for-byte passthrough (no behavioural change)", () => {
+  it("disabled (=0) is a byte-for-byte passthrough (the escape hatch)", () => {
     const raw = "**bold** and a\n\n**> collapsible quote\n> second line";
-    const r = maybeRenderOutbound(raw, {} as NodeJS.ProcessEnv);
+    const r = maybeRenderOutbound(raw, {
+      SWITCHROOM_RICH_RENDER: "0",
+    } as NodeJS.ProcessEnv);
     expect(r.mode).toBe("markdown");
     expect(r.text).toBe(raw);
   });
 
-  it("flag ON routes through parse -> renderSafe", () => {
-    const r = maybeRenderOutbound("**> collapsible", {
-      SWITCHROOM_RICH_RENDER: "1",
-    } as NodeJS.ProcessEnv);
+  it("default (env unset) routes through parse -> renderSafe", () => {
+    const r = maybeRenderOutbound("**> collapsible", {} as NodeJS.ProcessEnv);
     expect(r.mode).toBe("markdown");
     // The expandable blockquote round-trips back to the `**> ` marker.
     expect(r.text).toContain("**> ");
   });
 
-  it("flag ON preserves plain prose through the round-trip", () => {
-    const r = maybeRenderOutbound("just some plain text", {
-      SWITCHROOM_RICH_RENDER: "1",
-    } as NodeJS.ProcessEnv);
+  it("default preserves plain prose through the round-trip", () => {
+    const r = maybeRenderOutbound(
+      "just some plain text",
+      {} as NodeJS.ProcessEnv,
+    );
     expect(r.text).toContain("just some plain text");
   });
 
-  it("flag ON round-trips underline / spoiler / highlight", () => {
-    const on = { SWITCHROOM_RICH_RENDER: "1" } as NodeJS.ProcessEnv;
+  it("default round-trips underline / spoiler / highlight", () => {
+    const on = {} as NodeJS.ProcessEnv;
     expect(maybeRenderOutbound("__u__", on).text).toBe("__u__");
     expect(maybeRenderOutbound("a ||s|| b", on).text).toBe("a ||s|| b");
     expect(maybeRenderOutbound("a ==m== b", on).text).toBe("a ==m== b");
   });
 
-  it("flag OFF passes new constructs through untouched too", () => {
+  it("disabled (=0) passes new constructs through untouched too", () => {
     const raw = "__u__ and ||s|| and ==m==";
-    const r = maybeRenderOutbound(raw, {} as NodeJS.ProcessEnv);
+    const r = maybeRenderOutbound(raw, {
+      SWITCHROOM_RICH_RENDER: "0",
+    } as NodeJS.ProcessEnv);
     expect(r.text).toBe(raw);
   });
+
+  it("a junk env value still renders (fail-open to the default)", () => {
+    const r = maybeRenderOutbound("**> collapsible", {
+      SWITCHROOM_RICH_RENDER: "maybe",
+    } as NodeJS.ProcessEnv);
+    expect(r.mode).toBe("markdown");
+    expect(r.text).toContain("**> ");
+  });
 });
 
 describe("renderOutbound (flag-independent)", () => {

package/telegram-plugin/tests/runtime-metrics.test.ts

@@ -91,6 +91,30 @@ describe('runtime-metrics — JSONL sink', () => {
     expect(typeof parsed.ts).toBe('number')
   })
 
+  it('rate_limit_429_classified carries classification + action + limit/reset detail', () => {
+    emitRuntimeMetric({
+      kind: 'rate_limit_429_classified',
+      agent: 'carrie',
+      classification: 'litellm-local',
+      action: 'calm',
+      reset_at_ms: 1_783_850_700_000,
+      reset_in_ms: 300_000,
+      limit_type: 'tpm',
+      limit: 8000,
+      current_usage: 8241,
+    })
+    const parsed = JSON.parse(readFileSync(metricsPath, 'utf-8').trim())
+    expect(parsed.kind).toBe('rate_limit_429_classified')
+    expect(parsed.agent).toBe('carrie')
+    expect(parsed.classification).toBe('litellm-local')
+    expect(parsed.action).toBe('calm')
+    expect(parsed.reset_in_ms).toBe(300_000)
+    expect(parsed.limit_type).toBe('tpm')
+    expect(parsed.limit).toBe(8000)
+    expect(parsed.current_usage).toBe(8241)
+    expect(typeof parsed.ts).toBe('number')
+  })
+
   it('appends — does not overwrite — across calls', () => {
     for (let i = 0; i < 5; i++) {
       emitRuntimeMetric({

package/telegram-plugin/tests/single-mode-stream-reply.test.ts

@@ -69,7 +69,7 @@ describe('stream-reply single-mode reuse (#2669)', () => {
     expect(bot.api.editMessageText).toHaveBeenCalled()
   })
 
-  it('the rich path ships raw GFM markdown unescaped via sendRichMessage', async () => {
+  it('the rich path ships GFM markdown unescaped via sendRichMessage', async () => {
     const state = makeState()
     const deps = makeDeps(bot)
 
@@ -77,8 +77,10 @@ describe('stream-reply single-mode reuse (#2669)', () => {
 
     expect(bot.state.sent).toHaveLength(1)
     expect(bot.state.sent[0].rich).toBe(true)
-    // Raw markdown is the wire payload — no HTML, no MarkdownV2 escaping.
-    expect(bot.state.sent[0].text).toBe('**bold** and _italic_')
+    // GFM markdown is the wire payload — no HTML, no MarkdownV2 escaping.
+    // The default-on rich renderer normalises the italic marker
+    // (`_italic_` -> `*italic*`, same wire entity).
+    expect(bot.state.sent[0].text).toBe('**bold** and *italic*')
     expect(bot.state.sent[0].parse_mode).toBeUndefined()
   })
 

package/telegram-plugin/tests/status-accent.test.ts

@@ -91,8 +91,10 @@ describe('handleStreamReply accent integration', () => {
     await pending
 
     const sent = sentMarkdown(bot)
-    expect(sent).toMatch(/^🔵 _In progress…_\n\n/)
-    expect(sent).toBe('🔵 _In progress…_\n\nStill working...')
+    // The default-on rich renderer normalises the italic marker
+    // (`_In progress…_` -> `*In progress…*`, same wire entity).
+    expect(sent).toMatch(/^🔵 \*In progress…\*\n\n/)
+    expect(sent).toBe('🔵 *In progress…*\n\nStill working...')
   })
 
   it("accent='done' prepends the checkmark markdown header before the body", async () => {
@@ -176,6 +178,6 @@ describe('handleStreamReply accent integration', () => {
     await microtaskFlush()
     await p2
 
-    expect(editedMarkdown(bot)).toBe('🔵 _In progress…_\n\nPart one Part two')
+    expect(editedMarkdown(bot)).toBe('🔵 *In progress…*\n\nPart one Part two')
   })
 })