switchroom 0.18.13 → 0.18.14

package/telegram-plugin/tests/forward-origin.test.ts

@@ -0,0 +1,309 @@
+/**
+ * Unit tests for the forwarded-message origin helpers
+ * (telegram-plugin/gateway/forward-origin.ts).
+ *
+ * These pin the pure pieces of the forward-origin metadata path that live
+ * outside gateway.ts so they can be exercised without loadAccess()/IPC:
+ *   1. parseForwardOrigin — all four Bot API 7.0 origin shapes, missing
+ *      fields, hostile (attacker-controlled) names, hidden_user marking.
+ *   2. buildForwardOriginMeta — fixed attribute order, XML escaping at the
+ *      channel-meta boundary, numbered `_2..` siblings for multi-origin
+ *      bursts (same convention as image_path_2 / attachment_file_id_2).
+ *   3. dedupeForwardOrigins — the coalescer's burst collapse: a
+ *      single-origin album emits one attr set; distinct origins keep
+ *      arrival order and get numbered.
+ *
+ * Trust model under test: origin info rides the ATTRS lane only, names are
+ * truncated + escaped (they're attacker-controlled), and hidden_user is
+ * explicitly marked so agents don't treat a self-reported display name as
+ * an authenticated identity.
+ */
+
+import { describe, expect, it } from 'vitest'
+import type { MessageOrigin } from 'grammy/types'
+import {
+  parseForwardOrigin,
+  buildForwardOriginMeta,
+  dedupeForwardOrigins,
+  forwardOriginKey,
+  forwardOriginDateIso,
+  FORWARDED_FROM_NAME_MAX,
+  type ForwardOriginInfo,
+} from '../gateway/forward-origin.js'
+
+// Synthetic fixtures only — no real Telegram ids/names (check-no-pii-secrets).
+const DATE = 1750000000 // unix seconds
+const DATE_ISO = new Date(DATE * 1000).toISOString()
+
+function userOrigin(overrides: Partial<{
+  first_name: string
+  last_name?: string
+  username?: string
+  id: number
+}> = {}): MessageOrigin {
+  return {
+    type: 'user',
+    date: DATE,
+    sender_user: {
+      id: 42,
+      is_bot: false,
+      first_name: 'Ada',
+      last_name: 'Lovelace',
+      username: 'adalove',
+      ...overrides,
+    },
+  }
+}
+
+describe('parseForwardOrigin — the four origin shapes', () => {
+  it('user: first + last name plus (@username), id and date captured', () => {
+    const info = parseForwardOrigin(userOrigin())
+    expect(info).toEqual({
+      name: 'Ada Lovelace (@adalove)',
+      type: 'user',
+      id: 42,
+      date: DATE,
+    })
+  })
+
+  it('user: first name only, no username', () => {
+    const info = parseForwardOrigin(userOrigin({ last_name: undefined, username: undefined }))
+    expect(info?.name).toBe('Ada')
+    expect(info?.id).toBe(42)
+  })
+
+  it('hidden_user: self-reported name, marked hidden_user, NO id', () => {
+    const info = parseForwardOrigin({
+      type: 'hidden_user',
+      date: DATE,
+      sender_user_name: 'Mystery Sender',
+    })
+    expect(info).toEqual({
+      name: 'Mystery Sender',
+      type: 'hidden_user',
+      date: DATE,
+    })
+    // The whole point of the type marker: no verifiable id exists.
+    expect(info?.id).toBeUndefined()
+  })
+
+  it('chat: sender_chat title plus (@username)', () => {
+    const info = parseForwardOrigin({
+      type: 'chat',
+      date: DATE,
+      sender_chat: { id: -100200300, type: 'supergroup', title: 'Ops Room', username: 'opsroom' } as never,
+    })
+    expect(info).toEqual({
+      name: 'Ops Room (@opsroom)',
+      type: 'chat',
+      id: -100200300,
+      date: DATE,
+    })
+  })
+
+  it('channel: chat.title plus (@username), message_id captured', () => {
+    const info = parseForwardOrigin({
+      type: 'channel',
+      date: DATE,
+      message_id: 555,
+      chat: { id: -100400500, type: 'channel', title: 'Release Notes', username: 'relnotes' } as never,
+    })
+    expect(info).toEqual({
+      name: 'Release Notes (@relnotes)',
+      type: 'channel',
+      id: -100400500,
+      date: DATE,
+      messageId: 555,
+    })
+  })
+})
+
+describe('parseForwardOrigin — missing / malformed fields', () => {
+  it('returns undefined for a non-forwarded message (no origin)', () => {
+    expect(parseForwardOrigin(undefined)).toBeUndefined()
+  })
+
+  it('returns undefined for an unknown future origin type', () => {
+    expect(parseForwardOrigin({ type: 'giveaway', date: DATE } as never)).toBeUndefined()
+  })
+
+  it('user origin without sender_user is dropped', () => {
+    expect(parseForwardOrigin({ type: 'user', date: DATE } as never)).toBeUndefined()
+  })
+
+  it('hidden_user with an empty name is dropped (nothing to show)', () => {
+    expect(
+      parseForwardOrigin({ type: 'hidden_user', date: DATE, sender_user_name: '' }),
+    ).toBeUndefined()
+  })
+
+  it('user with no printable name falls back to the numeric id as name', () => {
+    const info = parseForwardOrigin({
+      type: 'user',
+      date: DATE,
+      sender_user: { id: 42, is_bot: false, first_name: '' },
+    })
+    expect(info).toEqual({ name: '42', type: 'user', id: 42, date: DATE })
+  })
+
+  it('missing date yields no date (and later no forwarded_date attr)', () => {
+    const info = parseForwardOrigin({
+      type: 'hidden_user',
+      sender_user_name: 'Mystery Sender',
+    } as never)
+    expect(info?.date).toBeUndefined()
+    expect(buildForwardOriginMeta([info!]).forwarded_date).toBeUndefined()
+    expect(forwardOriginDateIso(info)).toBeNull()
+  })
+
+  it('channel origin without a title falls back to first/last name shape, then id', () => {
+    const noName = parseForwardOrigin({
+      type: 'channel',
+      date: DATE,
+      message_id: 9,
+      chat: { id: -100777888, type: 'channel' } as never,
+    })
+    expect(noName).toEqual({
+      name: '-100777888',
+      type: 'channel',
+      id: -100777888,
+      date: DATE,
+      messageId: 9,
+    })
+  })
+})
+
+describe('parseForwardOrigin — hostile names (attacker-controlled)', () => {
+  it('truncates a 4KB name to the cap (raw, ellipsis-terminated)', () => {
+    const bomb = 'x'.repeat(4096)
+    const info = parseForwardOrigin(userOrigin({ first_name: bomb, last_name: undefined, username: undefined }))
+    expect(info?.name).toHaveLength(FORWARDED_FROM_NAME_MAX)
+    expect(info?.name?.endsWith('…')).toBe(true)
+  })
+
+  it('keeps XML metacharacters RAW in the parsed record (SQLite lane)', () => {
+    const info = parseForwardOrigin(
+      userOrigin({ first_name: '<b>"Bob"&\'friends\'</b>', last_name: undefined, username: undefined }),
+    )
+    // Escaping happens at the channel-meta boundary, not at parse time —
+    // the history buffer stores what the user actually saw.
+    expect(info?.name).toBe('<b>"Bob"&\'friends\'</b>')
+  })
+})
+
+describe('buildForwardOriginMeta — channel-tag attrs', () => {
+  it('single origin: bare keys in the fixed order name, type, id, date', () => {
+    const meta = buildForwardOriginMeta([parseForwardOrigin(userOrigin())!])
+    expect(Object.keys(meta)).toEqual([
+      'forwarded_from',
+      'forwarded_from_type',
+      'forwarded_from_id',
+      'forwarded_date',
+    ])
+    expect(meta).toEqual({
+      forwarded_from: 'Ada Lovelace (@adalove)',
+      forwarded_from_type: 'user',
+      forwarded_from_id: '42',
+      forwarded_date: DATE_ISO,
+    })
+  })
+
+  it('id-less origin (hidden_user) omits forwarded_from_id entirely', () => {
+    const meta = buildForwardOriginMeta([
+      { name: 'Mystery Sender', type: 'hidden_user', date: DATE },
+    ])
+    expect(Object.keys(meta)).toEqual([
+      'forwarded_from',
+      'forwarded_from_type',
+      'forwarded_date',
+    ])
+    expect(meta.forwarded_from_type).toBe('hidden_user')
+  })
+
+  it('XML-escapes hostile names — the rendered attribute value cannot break out', () => {
+    const meta = buildForwardOriginMeta([
+      { name: '<script>"a"&\'b\'</script>', type: 'user', id: 42, date: DATE },
+    ])
+    expect(meta.forwarded_from).toBe(
+      '&lt;script&gt;&quot;a&quot;&amp;&apos;b&apos;&lt;/script&gt;',
+    )
+    // Outcome assertion: rendered into a channel tag, the value carries no
+    // raw quote/angle characters that could terminate the attribute.
+    const rendered = `<channel source="telegram" forwarded_from="${meta.forwarded_from}">`
+    expect(rendered).not.toMatch(/forwarded_from="[^"]*[<>][^"]*"/)
+    expect((rendered.match(/"/g) ?? []).length).toBe(4) // only the delimiters
+  })
+
+  it('defense in depth: a name that skipped parse-time truncation is capped here too', () => {
+    const meta = buildForwardOriginMeta([
+      { name: 'y'.repeat(4096), type: 'user', id: 42, date: DATE },
+    ])
+    // 99 chars + '…' — no 4KB payload reaches the tag.
+    expect(meta.forwarded_from).toHaveLength(FORWARDED_FROM_NAME_MAX)
+  })
+
+  it('no origins → empty record (no attrs on a normal message)', () => {
+    expect(buildForwardOriginMeta([])).toEqual({})
+  })
+})
+
+describe('coalesced bursts — dedupe + numbered siblings', () => {
+  const alice: ForwardOriginInfo = { name: 'Alice Q (@aliceq)', type: 'user', id: 42, date: DATE }
+  const relnotes: ForwardOriginInfo = {
+    name: 'Release Notes (@relnotes)',
+    type: 'channel',
+    id: -100400500,
+    date: DATE + 60,
+    messageId: 7,
+  }
+
+  it('single-origin album (N parts, one sender) collapses to ONE attr set', () => {
+    const origins = dedupeForwardOrigins([alice, { ...alice, date: DATE + 5 }, { ...alice, date: DATE + 9 }])
+    expect(origins).toHaveLength(1)
+    const meta = buildForwardOriginMeta(origins)
+    expect(meta.forwarded_from).toBe('Alice Q (@aliceq)')
+    expect(meta.forwarded_from_2).toBeUndefined()
+    // First occurrence wins — the emitted date is the first part's.
+    expect(meta.forwarded_date).toBe(DATE_ISO)
+  })
+
+  it('multi-origin burst: first origin bare, second gets _2 keys in order', () => {
+    const meta = buildForwardOriginMeta(dedupeForwardOrigins([alice, relnotes]))
+    expect(Object.keys(meta)).toEqual([
+      'forwarded_from',
+      'forwarded_from_type',
+      'forwarded_from_id',
+      'forwarded_date',
+      'forwarded_from_2',
+      'forwarded_from_type_2',
+      'forwarded_from_id_2',
+      'forwarded_date_2',
+    ])
+    expect(meta.forwarded_from_2).toBe('Release Notes (@relnotes)')
+    expect(meta.forwarded_from_type_2).toBe('channel')
+    expect(meta.forwarded_from_id_2).toBe('-100400500')
+  })
+
+  it('non-forwarded entries in the burst are skipped', () => {
+    expect(dedupeForwardOrigins([undefined, alice, undefined])).toEqual([alice])
+    expect(dedupeForwardOrigins([undefined, undefined])).toEqual([])
+  })
+
+  it('id-less origins dedupe by name; same type+id dedupes despite name drift', () => {
+    const hidden: ForwardOriginInfo = { name: 'Mystery Sender', type: 'hidden_user', date: DATE }
+    expect(dedupeForwardOrigins([hidden, { ...hidden, date: DATE + 3 }])).toHaveLength(1)
+    // Same user id, renamed mid-burst — still one origin.
+    expect(dedupeForwardOrigins([alice, { ...alice, name: 'Alice Renamed' }])).toHaveLength(1)
+    // Same numeric id but different type stays distinct.
+    expect(forwardOriginKey(alice)).not.toBe(forwardOriginKey({ ...alice, type: 'chat' }))
+  })
+
+  it('arrival order is preserved across three distinct origins', () => {
+    const hidden: ForwardOriginInfo = { name: 'Mystery Sender', type: 'hidden_user', date: DATE }
+    const meta = buildForwardOriginMeta(dedupeForwardOrigins([relnotes, hidden, alice]))
+    expect(meta.forwarded_from).toBe('Release Notes (@relnotes)')
+    expect(meta.forwarded_from_2).toBe('Mystery Sender')
+    expect(meta.forwarded_from_3).toBe('Alice Q (@aliceq)')
+    expect(meta.forwarded_from_type_3).toBe('user')
+  })
+})

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/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/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')
   })
 })