switchroom 0.21.8 → 0.21.10

package/telegram-plugin/tests/send-reply-golden.test.ts

@@ -31,7 +31,7 @@
  *   - structural: gateway constructs EXACTLY ONE OutboundDedupCache and the
  *     extracted module constructs NONE (the re-`new` hard-fail rule)
  */
-import { describe, it, expect } from 'vitest'
+import { describe, it, expect, afterEach } from 'vitest'
 import { GrammyError } from 'grammy'
 import { readFileSync, mkdtempSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
@@ -58,6 +58,10 @@ import { createPendingInboundBuffer } from '../gateway/pending-inbound-buffer.js
 import { SubagentReplyAuthority } from '../gateway/subagent-reply-authority.js'
 import { redact } from '../secret-detect/redact.js'
 import type { CurrentTurn, Access } from '../gateway/gateway.js'
+import {
+  SPEECH_CAPTURE_FILE_NAME,
+  __resetSpeechCaptureLogStateForTests,
+} from '../gateway/speech-capture.js'
 
 /**
  * Build the owner-resolution result the gateway's `resolveReplyOwnerTurn`
@@ -457,6 +461,100 @@ describe('sendReply golden harness — file sends', () => {
   })
 })
 
+describe('speech capture (PR-0) — driven through the REAL sendReply wiring, not a synthetic call', () => {
+  const priorCapture = process.env.SWITCHROOM_SPEECH_CAPTURE
+  const priorStateDir = process.env.TELEGRAM_STATE_DIR
+
+  afterEach(() => {
+    if (priorCapture === undefined) delete process.env.SWITCHROOM_SPEECH_CAPTURE
+    else process.env.SWITCHROOM_SPEECH_CAPTURE = priorCapture
+    if (priorStateDir === undefined) delete process.env.TELEGRAM_STATE_DIR
+    else process.env.TELEGRAM_STATE_DIR = priorStateDir
+    __resetSpeechCaptureLogStateForTests()
+  })
+
+  it('M3: a capture write failure (flag ON, unwritable state dir) never breaks the reply', async () => {
+    // The destination is a FILE, not a directory, so appendFileSync fails
+    // ENOTDIR every call — the exact swallow path the flag-on window depends
+    // on for 7 days unattended. This only pins the CURRENT synchronous,
+    // in-place-caught shape: it proves a swallowed-write-failure reply still
+    // ships, but it would NOT go red if a refactor made the capture call
+    // async and fire-and-forget (unawaited) — that rejection becomes an
+    // unhandled rejection, which this codebase's policy treats as fatal
+    // (see analytics-posthog.ts, chat-lock.ts), strictly worse than the one
+    // lost capture line this test guards against, and this test alone
+    // cannot detect it. The synchronous-return contract that WOULD catch
+    // that mutation is pinned directly on `captureSpeechText` in
+    // `speech-capture.test.ts` ("G1: captureSpeechText returns undefined").
+    const dir = mkdtempSync(join(tmpdir(), 'speech-capture-golden-'))
+    const notADir = join(dir, 'state-dir-is-actually-a-file')
+    writeFileSync(notADir, 'not a directory')
+    process.env.SWITCHROOM_SPEECH_CAPTURE = '1'
+    process.env.TELEGRAM_STATE_DIR = notADir
+
+    const h = makeHarness()
+    const res = await sendReply(h.deps, req('The reply must still ship. ✅ done.'))
+    const sends = h.calls.filter((c) => c.method === 'sendRichMessage')
+    expect(sends).toHaveLength(1)
+    expect(sends[0]!.text).toContain('The reply must still ship.')
+    expect(res.content[0]!.text).toMatch(/^sent \(id: \d+\)$/)
+  })
+
+  it('M3: the captured string IS the exact argument passed to resolveVoiceOutPlan — not merely textually adjacent', async () => {
+    const stateDir = mkdtempSync(join(tmpdir(), 'speech-capture-golden-'))
+    process.env.SWITCHROOM_SPEECH_CAPTURE = '1'
+    process.env.TELEGRAM_STATE_DIR = stateDir
+
+    const h = makeHarness()
+    let observedByVoicePlan: string | null = null
+    h.deps.resolveVoiceOutPlan = (_voiceOut, replyText) => {
+      observedByVoicePlan = replyText
+      return null
+    }
+
+    // Deliberately includes a spaced em-dash: `normalizeOutboundBody`'s
+    // punctuation/bold pass (`normalizePunctuation`, format.ts:695, step 4
+    // of the pipeline — outbound-send-path.ts's own docstring: "normalize →
+    // redact → punctuation/bold → voice-scrub") rewrites a bare/mid-prose
+    // em-dash into `, `. A golden fixture with nothing for the pipeline to
+    // transform can't tell "capture reads the normalised `text`" apart from
+    // "capture reads the raw `rawText`" — both would produce byte-identical
+    // output. This fixture makes that distinction observable (G2).
+    const raw = '| A | B |\n| --- | --- |\n| 1 | 2 |\n\n```ts\nconst x = 1 | 2\n```\n\nStatus update — done. ✅ `code` 😀.'
+    await sendReply(h.deps, req(raw))
+
+    expect(observedByVoicePlan).not.toBeNull()
+    const captured = readFileSync(join(stateDir, SPEECH_CAPTURE_FILE_NAME), 'utf8')
+      .split('\n')
+      .filter((l) => l.length > 0)
+      .map((l) => JSON.parse(l) as { ts: number; text: string })
+    expect(captured).toHaveLength(1)
+    // The load-bearing assertion: the capture is not "close to" or "derived
+    // from" resolveVoiceOutPlan's input — it is the SAME string, by identity
+    // of value, not by coincidence of two independent pipelines agreeing.
+    expect(captured[0]!.text).toBe(observedByVoicePlan)
+    // G2: the captured text is the NORMALISED form, downstream of
+    // `normalizePunctuation`'s em-dash rewrite — not the raw fixture. A
+    // regression that swapped in the pre-pipeline `rawText` would still
+    // satisfy the identity assertion above (both call sites would agree on
+    // SOME string), so this must check the captured content against the
+    // known transform independently, not just against `observedByVoicePlan`.
+    expect(captured[0]!.text).not.toBe(raw)
+    expect(captured[0]!.text).not.toContain('Status update — done')
+    expect(captured[0]!.text).toContain('Status update, done')
+  })
+
+  it('flag OFF: sendReply never creates the capture file, even with a writable state dir', async () => {
+    const stateDir = mkdtempSync(join(tmpdir(), 'speech-capture-golden-'))
+    delete process.env.SWITCHROOM_SPEECH_CAPTURE
+    process.env.TELEGRAM_STATE_DIR = stateDir
+
+    const h = makeHarness()
+    await sendReply(h.deps, req('Never captured.'))
+    expect(() => readFileSync(join(stateDir, SPEECH_CAPTURE_FILE_NAME), 'utf8')).toThrow()
+  })
+})
+
 describe('cross-surface dedup — the ONE OutboundDedupCache instance (Amendment 1/9)', () => {
   it('a stream-surface record suppresses the same-content reply (zero wire calls)', async () => {
     const dedup = new OutboundDedupCache()

package/telegram-plugin/tests/sent-text-capture.test.ts

@@ -43,9 +43,9 @@ const CHAT = 5550001
 /**
  * The response Telegram actually returns for `sendRichMessage` — the body lives
  * in `rich_message.blocks`; `text` and `caption` are ABSENT. Verified against
- * `@grammyjs/types` 3.28.0 (the version `grammy@^1.44` resolves)
- * `message.d.ts:94` (`RichMessageMessage = CommonMessage &
- * MsgWith<"rich_message">`) and `:180` (`rich_message?: RichMessage`), and
+ * `@grammyjs/types` 4.0.0 (the version `grammy@^1.45` resolves)
+ * `message.d.ts:98` (`RichMessageMessage = CommonMessage &
+ * MsgWith<"rich_message">`) and `:184` (`rich_message?: RichMessage`), and
  * against the Bot API reference: `sendRichMessage` "On success, the sent
  * Message is returned", `Message.rich_message: RichMessage` "Optional. Message
  * is a rich formatted message", `RichMessage.blocks` "Content of the message".

package/telegram-plugin/tests/speech-capture.test.ts

@@ -0,0 +1,296 @@
+import { describe, it, expect, afterEach, vi } from 'vitest'
+import { chmodSync, existsSync, mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import {
+  captureSpeechText,
+  SPEECH_CAPTURE_FILE_NAME,
+  __resetSpeechCaptureLogStateForTests,
+} from '../gateway/speech-capture.js'
+
+/**
+ * PR-0 (`/tmp/claude-0/tts/out/fable-plan-v2.md` §9): flag-gated raw-markdown
+ * capture hook. Every test here points at an explicit `stateDir` override —
+ * never at `process.env.TELEGRAM_STATE_DIR` — so nothing in this suite can
+ * touch a live agent's state tree (`TELEGRAM_STATE_DIR` is not covered by the
+ * repo's agent-state-dir hermeticity guard, see
+ * `tests/vitest-setup/agent-state-dir-guard-core.mjs`).
+ *
+ * The integration-level guarantees (a write failure never breaks the REAL
+ * `sendReply`; the captured string IS the exact `resolveVoiceOutPlan`
+ * argument, not merely textually adjacent) are pinned separately in
+ * `send-reply-golden.test.ts`, driven through the real wiring — this file
+ * covers the module's own contract in isolation.
+ */
+describe('captureSpeechText', () => {
+  const dirs: string[] = []
+  function freshDir(): string {
+    const d = mkdtempSync(join(tmpdir(), 'speech-capture-test-'))
+    dirs.push(d)
+    return d
+  }
+
+  afterEach(() => {
+    for (const d of dirs.splice(0)) {
+      rmSync(d, { recursive: true, force: true })
+    }
+    __resetSpeechCaptureLogStateForTests()
+  })
+
+  it('flag off (explicit enabled:false) writes nothing — true no-op', () => {
+    const stateDir = freshDir()
+    captureSpeechText('hello world', { enabled: false, stateDir })
+    expect(existsSync(join(stateDir, SPEECH_CAPTURE_FILE_NAME))).toBe(false)
+  })
+
+  it('G1: captureSpeechText returns undefined (sync contract), flag on and flag off alike', () => {
+    // Pins the SYNCHRONOUS return contract the swallow-on-write-failure
+    // guarantee depends on. `send-reply-golden.test.ts`'s M3 "write failure
+    // never breaks the reply" test only observes that the reply still ships
+    // — it would NOT go red if a refactor made this function `async` and
+    // fire-and-forget (an unawaited rejection there becomes an unhandled
+    // rejection, which this codebase's policy treats as fatal — see
+    // analytics-posthog.ts and chat-lock.ts). An `async function` always
+    // returns a Promise, never `undefined`, so THIS assertion is the one
+    // that goes red on that mutation, awaited or not.
+    const stateDir = freshDir()
+    expect(captureSpeechText('x', { enabled: false, stateDir })).toBeUndefined()
+    expect(captureSpeechText('x', { enabled: true, stateDir })).toBeUndefined()
+    // Also true on the swallowed-write-failure path (destination collides
+    // with a file, not a dir) — the exact shape M3's golden test exercises.
+    const notADir = join(freshDir(), 'not-a-directory-marker')
+    writeFileSync(notADir, 'not a directory')
+    expect(captureSpeechText('x', { enabled: true, stateDir: notADir })).toBeUndefined()
+  })
+
+  it('flag off via env (SWITCHROOM_SPEECH_CAPTURE unset) writes nothing', () => {
+    const stateDir = freshDir()
+    const prior = process.env.SWITCHROOM_SPEECH_CAPTURE
+    delete process.env.SWITCHROOM_SPEECH_CAPTURE
+    try {
+      captureSpeechText('hello world', { stateDir })
+      expect(existsSync(join(stateDir, SPEECH_CAPTURE_FILE_NAME))).toBe(false)
+    } finally {
+      if (prior === undefined) delete process.env.SWITCHROOM_SPEECH_CAPTURE
+      else process.env.SWITCHROOM_SPEECH_CAPTURE = prior
+    }
+  })
+
+  it('flag off: never touches the filesystem, even with a garbage stateDir', () => {
+    // Negligible-cost proof: an unwritable/garbage destination must not
+    // surface any error or side effect when the flag is off — the function
+    // should return before touching fs at all.
+    expect(() => captureSpeechText('x', {
+      enabled: false,
+      stateDir: '/definitely/does/not/exist/\0bad',
+    })).not.toThrow()
+  })
+
+  it('M1: flag accepts "1"', () => {
+    const stateDir = freshDir()
+    const prior = process.env.SWITCHROOM_SPEECH_CAPTURE
+    process.env.SWITCHROOM_SPEECH_CAPTURE = '1'
+    try {
+      captureSpeechText('x', { stateDir })
+      expect(existsSync(join(stateDir, SPEECH_CAPTURE_FILE_NAME))).toBe(true)
+    } finally {
+      if (prior === undefined) delete process.env.SWITCHROOM_SPEECH_CAPTURE
+      else process.env.SWITCHROOM_SPEECH_CAPTURE = prior
+    }
+  })
+
+  it('M1: flag accepts "true" (text-voice-scrub.ts:102 convention) — not silently a no-op', () => {
+    const stateDir = freshDir()
+    const prior = process.env.SWITCHROOM_SPEECH_CAPTURE
+    process.env.SWITCHROOM_SPEECH_CAPTURE = 'true'
+    try {
+      captureSpeechText('x', { stateDir })
+      expect(existsSync(join(stateDir, SPEECH_CAPTURE_FILE_NAME))).toBe(true)
+    } finally {
+      if (prior === undefined) delete process.env.SWITCHROOM_SPEECH_CAPTURE
+      else process.env.SWITCHROOM_SPEECH_CAPTURE = prior
+    }
+  })
+
+  it('flag on appends the exact string, byte-for-byte, including a table, a fenced code block, an emoji, and inline backticks', () => {
+    const stateDir = freshDir()
+    const raw = [
+      '# Heading',
+      '',
+      '| A | B |',
+      '| --- | --- |',
+      '| 1 | 2 |',
+      '',
+      '```ts',
+      'const x = 1 | 2',
+      '```',
+      '',
+      'Status: ✅ done, use `inline code` with a pipe | here, and an emoji 😀.',
+    ].join('\n')
+    captureSpeechText(raw, { enabled: true, stateDir, now: () => 1234567890 })
+    const filePath = join(stateDir, SPEECH_CAPTURE_FILE_NAME)
+    expect(existsSync(filePath)).toBe(true)
+    const contents = readFileSync(filePath, 'utf8')
+    const lines = contents.split('\n').filter((l) => l.length > 0)
+    expect(lines).toHaveLength(1)
+    const parsed = JSON.parse(lines[0]) as { ts: number; text: string }
+    expect(parsed.ts).toBe(1234567890)
+    // Byte-for-byte: exact equality, not a fuzzy/normalized comparison.
+    expect(parsed.text).toBe(raw)
+    // Explicitly pin the bytes the redesign depends on surviving capture.
+    expect(parsed.text).toContain('| A | B |')
+    expect(parsed.text).toContain('```ts')
+    expect(parsed.text).toContain('`inline code`')
+    expect(parsed.text).toContain('✅')
+    expect(parsed.text).toContain('😀')
+  })
+
+  it('flag on preserves a lone (unpaired) surrogate byte-for-byte through the JSON round-trip', () => {
+    const stateDir = freshDir()
+    // A lone high surrogate with no low-surrogate partner — the kind of
+    // malformed-but-real string content a JS string can hold (e.g. a
+    // truncated emoji from an upstream mangling) that a naive re-encoding
+    // pass can silently mutate or drop.
+    const raw = 'before \uD800 after'
+    captureSpeechText(raw, { enabled: true, stateDir, now: () => 1 })
+    const filePath = join(stateDir, SPEECH_CAPTURE_FILE_NAME)
+    const line = readFileSync(filePath, 'utf8').split('\n').filter((l) => l.length > 0)[0]!
+    const parsed = JSON.parse(line) as { ts: number; text: string }
+    expect(parsed.text).toBe(raw)
+    expect(parsed.text.charCodeAt(parsed.text.indexOf('\uD800'))).toBe(0xd800)
+  })
+
+  it('flag on appends one JSON line per call, in order', () => {
+    const stateDir = freshDir()
+    captureSpeechText('first', { enabled: true, stateDir, now: () => 1 })
+    captureSpeechText('second', { enabled: true, stateDir, now: () => 2 })
+    const filePath = join(stateDir, SPEECH_CAPTURE_FILE_NAME)
+    const lines = readFileSync(filePath, 'utf8').split('\n').filter((l) => l.length > 0)
+    expect(lines).toHaveLength(2)
+    expect(JSON.parse(lines[0])).toEqual({ ts: 1, text: 'first' })
+    expect(JSON.parse(lines[1])).toEqual({ ts: 2, text: 'second' })
+  })
+
+  it('flag on but stateDir unresolved (no TELEGRAM_STATE_DIR, no override) writes nothing and does not throw', () => {
+    const prior = process.env.TELEGRAM_STATE_DIR
+    delete process.env.TELEGRAM_STATE_DIR
+    try {
+      expect(() => captureSpeechText('x', { enabled: true })).not.toThrow()
+    } finally {
+      if (prior === undefined) delete process.env.TELEGRAM_STATE_DIR
+      else process.env.TELEGRAM_STATE_DIR = prior
+    }
+  })
+
+  it('B1: the capture file is created 0o600 (owner-only), not the umask default', () => {
+    const stateDir = freshDir()
+    captureSpeechText('x', { enabled: true, stateDir })
+    const filePath = join(stateDir, SPEECH_CAPTURE_FILE_NAME)
+    const mode = statSync(filePath).mode & 0o777
+    expect(mode).toBe(0o600)
+  })
+
+  it('B1: mode stays 0o600 across repeated appends to an already-created file', () => {
+    const stateDir = freshDir()
+    captureSpeechText('first', { enabled: true, stateDir })
+    // Second call appends to the now-existing file; mode must not have been
+    // relaxed by any subsequent create-mode default.
+    captureSpeechText('second', { enabled: true, stateDir })
+    const filePath = join(stateDir, SPEECH_CAPTURE_FILE_NAME)
+    const mode = statSync(filePath).mode & 0o777
+    expect(mode).toBe(0o600)
+  })
+
+  it('B1/no dead mkdir: a stateDir that does not exist is a swallowed write failure, not silently created', () => {
+    // The prior implementation's `mkdirSync(stateDir, {recursive:true, mode:
+    // 0o700})` protected nothing in production (TELEGRAM_STATE_DIR always
+    // pre-exists) and is gone; a genuinely-missing dir now fails the write
+    // (ENOENT) exactly like any other write-failure shape, swallowed.
+    const parent = freshDir()
+    const missing = join(parent, 'does', 'not', 'exist')
+    expect(() => captureSpeechText('x', { enabled: true, stateDir: missing })).not.toThrow()
+    expect(existsSync(missing)).toBe(false)
+  })
+
+  it('a write error (destination path collides with a file, not a dir) does not throw', () => {
+    const parent = freshDir()
+    const stateDir = join(parent, 'not-a-directory')
+    writeFileSync(stateDir, 'not a directory')
+    expect(() => captureSpeechText('should not throw', { enabled: true, stateDir })).not.toThrow()
+    expect(existsSync(join(stateDir, SPEECH_CAPTURE_FILE_NAME))).toBe(false)
+  })
+
+  it('a write error into a read-only directory does not throw', () => {
+    const stateDir = freshDir()
+    mkdirSync(stateDir, { recursive: true })
+    const originalMode = 0o755
+    try {
+      // Some sandboxes ignore chmod as non-root; this test still asserts the
+      // no-throw contract either way, it just may not exercise the EACCES
+      // path when running as root.
+      chmodSync(stateDir, 0o500)
+      expect(() => captureSpeechText('x', { enabled: true, stateDir })).not.toThrow()
+    } finally {
+      chmodSync(stateDir, originalMode)
+    }
+  })
+
+  describe('M2: observability — never silent for the full 7-day window', () => {
+    it('logs one stderr line the first time capture actually fires, not on every call', () => {
+      const stateDir = freshDir()
+      const spy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true)
+      try {
+        captureSpeechText('first', { enabled: true, stateDir })
+        captureSpeechText('second', { enabled: true, stateDir })
+        captureSpeechText('third', { enabled: true, stateDir })
+        const enableLines = spy.mock.calls.filter((c) => String(c[0]).includes('speech-capture: enabled'))
+        expect(enableLines).toHaveLength(1)
+      } finally {
+        spy.mockRestore()
+      }
+    })
+
+    it('does not log the "enabled" line when the flag is off', () => {
+      const stateDir = freshDir()
+      const spy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true)
+      try {
+        captureSpeechText('x', { enabled: false, stateDir })
+        const enableLines = spy.mock.calls.filter((c) => String(c[0]).includes('speech-capture: enabled'))
+        expect(enableLines).toHaveLength(0)
+      } finally {
+        spy.mockRestore()
+      }
+    })
+
+    it('logs a write-failure line on the first failure, then rate-limits further failures', () => {
+      // Manual Date.now mocking, NOT vi.useFakeTimers()/vi.setSystemTime():
+      // this file runs under both vitest AND `bun test` (telegram-plugin's
+      // bun-test-ci.sh substring-matches the whole tests/ dir), and bun's
+      // vitest shim does not implement `vi.setSystemTime` — see
+      // progress-update.test.ts's note on the same gotcha (CI build #48).
+      // `vi.spyOn` + `mockImplementation` works under both runners.
+      let mockNow = 0
+      const dateSpy = vi.spyOn(Date, 'now').mockImplementation(() => mockNow)
+      const parent = freshDir()
+      const stateDir = join(parent, 'not-a-directory')
+      writeFileSync(stateDir, 'not a directory')
+      const spy = vi.spyOn(process.stderr, 'write').mockImplementation(() => true)
+      try {
+        captureSpeechText('one', { enabled: true, stateDir })
+        captureSpeechText('two', { enabled: true, stateDir })
+        mockNow = 1000 // 1s later — still inside the rate-limit window
+        captureSpeechText('three', { enabled: true, stateDir })
+        const failLines = spy.mock.calls.filter((c) => String(c[0]).includes('speech-capture: write failed'))
+        expect(failLines).toHaveLength(1)
+
+        mockNow = 6 * 60_000 // past the 5-minute window
+        captureSpeechText('four', { enabled: true, stateDir })
+        const failLinesAfter = spy.mock.calls.filter((c) => String(c[0]).includes('speech-capture: write failed'))
+        expect(failLinesAfter).toHaveLength(2)
+      } finally {
+        spy.mockRestore()
+        dateSpy.mockRestore()
+      }
+    })
+  })
+})

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

@@ -165,7 +165,7 @@ describe('markdownToTelegraphNodes — block elements', () => {
   })
 
   it('folds an expandable `**>` quote into one blockquote, marker stripped', () => {
-    // The Bot API 10.1 expandable-blockquote syntax: `**>` opener on the first
+    // The LEGACY switchroom expandable-quote encoding: `**>` opener on the first
     // line, `>` continuation lines. Telegra.ph has no collapsible-blockquote
     // tag, so it degrades to a normal blockquote — but the `**>` marker MUST be
     // recognised. Before the fix the `**>` line became a paragraph with literal

package/telegram-plugin/tests/tts-normalize.test.ts

@@ -184,6 +184,120 @@ describe('numbers', () => {
       'rename class5 and my5thing',
     )
   })
+
+  // Regression: unit-suffix lookbehind + case sensitivity. Corpus in
+  // /tmp/claude-0/tts/corpus.json (1,679 samples of ALREADY-NORMALIZED
+  // production output, not raw input): 146 samples already carry the
+  // shipped mangle artifact this fix removes, 53 carry an unfixed decimal/
+  // comma+unit token (see the "known gap" test below), and 61 samples
+  // change under this fix. A decimal seconds value like "0.17s" was matched
+  // by \b re-anchoring between the "." and the following digits, so "17s"
+  // alone got read as "seventeen seconds" and split the decimal apart; and
+  // the /i flag let a bare capital letter (money shorthand "5M", a memory
+  // size "4G", a product name "4080S") match a single-letter unit
+  // alternative it was never meant to.
+  test('decimal seconds survive intact — no mid-decimal unit match', () => {
+    expect(normalizeForTts('latency was 0.17s')).toBe('latency was 0.17s')
+    expect(normalizeForTts('took 1.5s to load')).toBe('took 1.5s to load')
+    expect(normalizeForTts('waited 2.25s')).toBe('waited 2.25s')
+    expect(normalizeForTts('under 0.9s')).toBe('under 0.9s')
+  })
+
+  // KNOWN GAP (disclosed, not fixed in this hotfix — see the comment above
+  // the unit-suffix regex in tts-normalize.ts): a decimal- or comma-glued
+  // number+unit token is now left completely unexpanded (unit unspoken)
+  // rather than mangled. This is a real, measured trade-off — corpus
+  // samples carrying an unspoken digit-adjacent unit go 65 → 122 (61
+  // samples change, every one gaining an unspoken unit) — pinned here as
+  // the baseline a future decimal-expansion pass should move.
+  test('KNOWN GAP: decimal/comma-glued number+unit is left unexpanded, not mangled', () => {
+    expect(normalizeForTts('free: 13.0 GB')).toBe('free: 13.0 GB')
+    expect(normalizeForTts('weighs 89.5g')).toBe('weighs 89.5g')
+    expect(normalizeForTts('ran for 27.5 s')).toBe('ran for 27.5 s')
+    expect(normalizeForTts('paused 9.5 min')).toBe('paused 9.5 min')
+    expect(normalizeForTts('spread over 0.7-0.8 m')).toBe('spread over 0.7-0.8 m')
+  })
+
+  // MINOR: comma leak — same defect class as the decimal lookbehind, closed
+  // in the same lookbehind by also excluding `,`. Before this: "1,500s" →
+  // "1,five hundred seconds", "12,000s" → "12,zero seconds", "1,024MB" →
+  // "1,twenty-four megabytes". The lookbehind is adjacency-only so an
+  // ordinary sentence comma ("wait, 5s") still expands correctly — only a
+  // digit glued directly to the comma is blocked.
+  test('comma-glued numbers are left unmangled; a sentence comma still expands', () => {
+    expect(normalizeForTts('rate limited: 1,500s')).toBe('rate limited: 1,500s')
+    expect(normalizeForTts('timeout after 12,000s')).toBe('timeout after 12,000s')
+    expect(normalizeForTts('buffer is 1,024MB')).toBe('buffer is 1,024MB')
+    expect(normalizeForTts('wait, 5s')).toBe('wait, five seconds')
+  })
+
+  test('whole-number seconds still expand: 90s → ninety seconds', () => {
+    expect(normalizeForTts('done in 90s')).toBe('done in ninety seconds')
+  })
+
+  test('units unaffected by the case-sensitivity fix: 500ms, 5MB, 2GB, 16 m', () => {
+    expect(normalizeForTts('took 500ms')).toBe('took five hundred milliseconds')
+    expect(normalizeForTts('file is 5MB')).toBe('file is five megabytes')
+    expect(normalizeForTts('disk has 2GB')).toBe('disk has two gigabytes')
+    expect(normalizeForTts('ran 16 m')).toBe('ran sixteen metres')
+  })
+
+  test('bare capital M never reads as minutes/metres (money shorthand, corpus)', () => {
+    expect(normalizeForTts('Revenue was 5M this year')).toBe(
+      'Revenue was 5M this year',
+    )
+    // Pre-existing quirk, not introduced or fixed here: the currency regex
+    // consumes "$5" before the unit pass ever sees the dangling "M", so this
+    // never read as "minutes" even on unpatched main — pin the ACTUAL output
+    // instead of an assertion that can't fail in either direction.
+    expect(normalizeForTts('raised $5M in the round')).toBe(
+      'raised five dollarsM in the round',
+    )
+  })
+
+  test('HTTP-status-shaped input adjacent to a capital letter is not read as a duration', () => {
+    expect(normalizeForTts('a 503M error occurred')).toBe(
+      'a 503M error occurred',
+    )
+    expect(normalizeForTts('status 503M')).toBe('status 503M')
+  })
+
+  // Corpus wins from the case-sensitivity split (22 samples improved, 14 of
+  // them "G" memory sizes wrongly read as GRAMS, plus an RTX "4080S" wrongly
+  // read as a duration). These already passed after the original fix but
+  // were previously unpinned.
+  test('single-letter units case-split: bare capitals stay untouched (was misread pre-fix)', () => {
+    expect(normalizeForTts('done in 5S')).toBe('done in 5S')
+    expect(normalizeForTts('wait 3H')).toBe('wait 3H')
+    expect(normalizeForTts('ships in 10D')).toBe('ships in 10D')
+    expect(normalizeForTts('needs 2G')).toBe('needs 2G')
+    expect(normalizeForTts('ran 16 M')).toBe('ran 16 M')
+  })
+
+  test('memory-size "G" no longer read as grams (corpus: 4G/12G/97G)', () => {
+    expect(normalizeForTts('upgrade to 4G')).toBe('upgrade to 4G')
+    expect(normalizeForTts('needs 12G')).toBe('needs 12G')
+    expect(normalizeForTts('disk has 97G')).toBe('disk has 97G')
+  })
+
+  test('product name "4080S" (RTX 4080 Super) not read as a duration', () => {
+    expect(normalizeForTts('bought a 4080S')).toBe('bought a 4080S')
+  })
+})
+
+describe('composed pipeline: normalizeForTts(normalizeForSpeech(x))', () => {
+  // Fleet-critical, previously unguarded: production always composes pass 1
+  // (voice-normalize-text.ts, NO \s? between number and unit, "m" → minute)
+  // with pass 2 (tts-normalize.ts, optional \s?, "m" → metre). The
+  // minute-vs-metre reading is an EMERGENT property of that composition, not
+  // a property either pass exhibits alone.
+  test('glued "5m" reads as minutes (pass 1 claims it first, no space)', () => {
+    expect(normalizeForTts(normalizeForSpeech('run 5m'))).toBe('run five minutes')
+  })
+
+  test('spaced "16 m" reads as metres (pass 1 has no \\s?, so pass 2 claims it)', () => {
+    expect(normalizeForTts(normalizeForSpeech('ran 16 m'))).toBe('ran sixteen metres')
+  })
 })
 
 describe('URLs', () => {

package/telegram-plugin/tests/voice-normalize-text.test.ts

@@ -193,6 +193,95 @@ describe('normalizeForSpeech — numbers, units & symbols', () => {
     expect(normalizeForSpeech('my5thing works')).toBe('my5thing works')
     expect(normalizeForSpeech('class5 room')).toBe('class5 room')
   })
+
+  // Regression: unit-suffix lookbehind + case sensitivity. Corpus in
+  // /tmp/claude-0/tts/corpus.json (1,679 samples of ALREADY-NORMALIZED
+  // production output, not raw input): 146 samples already carry the
+  // shipped mangle artifact this fix removes, 53 carry an unfixed decimal/
+  // comma+unit token (see the "known gap" test below), and 61 samples
+  // change under this fix. A decimal seconds value like "0.17s" was matched
+  // by \b re-anchoring between the "." and the following digits, so "17s"
+  // alone got read as "seventeen seconds" and split the decimal apart; and
+  // the /i flag let a bare capital letter (money shorthand "5M", a memory
+  // size "4G", a product name "4080S") match a single-letter unit
+  // alternative it was never meant to.
+  it('decimal seconds survive intact — no mid-decimal unit match', () => {
+    expect(normalizeForSpeech('latency was 0.17s')).toBe('latency was 0.17s')
+    expect(normalizeForSpeech('took 1.5s to load')).toBe('took 1.5s to load')
+    expect(normalizeForSpeech('waited 2.25s')).toBe('waited 2.25s')
+    expect(normalizeForSpeech('under 0.9s')).toBe('under 0.9s')
+  })
+
+  // KNOWN GAP (disclosed, not fixed in this hotfix — see the comment above
+  // the unit-suffix regex in voice-normalize-text.ts): a decimal- or
+  // comma-glued number+unit token is now left completely unexpanded (unit
+  // unspoken) rather than mangled. Measured: samples carrying an unspoken
+  // digit-adjacent unit go 65 → 122 across the corpus (61 samples change,
+  // every one gaining an unspoken unit) — pinned here as the baseline a
+  // future decimal-expansion pass should move.
+  it('KNOWN GAP: decimal/comma-glued number+unit is left unexpanded, not mangled', () => {
+    expect(normalizeForSpeech('free: 13.0 GB')).toBe('free: 13.0 GB')
+    expect(normalizeForSpeech('weighs 89.5g')).toBe('weighs 89.5g')
+    expect(normalizeForSpeech('ran for 27.5 s')).toBe('ran for 27.5 s')
+    expect(normalizeForSpeech('paused 9.5 min')).toBe('paused 9.5 min')
+  })
+
+  // MINOR: comma leak — same defect class as the decimal lookbehind, closed
+  // in the same lookbehind by also excluding `,`. Before this: "1,500s" →
+  // "1,five hundred seconds", "12,000s" → "12,zero seconds", "1,024MB" →
+  // "1,twenty-four megabytes". The lookbehind is adjacency-only so an
+  // ordinary sentence comma ("wait, 5s") still expands correctly — only a
+  // digit glued directly to the comma is blocked.
+  it('comma-glued numbers are left unmangled; a sentence comma still expands', () => {
+    expect(normalizeForSpeech('rate limited: 1,500s')).toBe('rate limited: 1,500s')
+    expect(normalizeForSpeech('timeout after 12,000s')).toBe('timeout after 12,000s')
+    expect(normalizeForSpeech('buffer is 1,024MB')).toBe('buffer is 1,024MB')
+    expect(normalizeForSpeech('wait, 5s')).toBe('wait, five seconds')
+  })
+
+  it('whole-number seconds still expand: 90s → ninety seconds', () => {
+    expect(normalizeForSpeech('done in 90s')).toBe('done in ninety seconds')
+  })
+
+  it('units unaffected by the case-sensitivity fix: 500ms, 5MB, 2GB', () => {
+    expect(normalizeForSpeech('took 500ms')).toBe('took five hundred milliseconds')
+    expect(normalizeForSpeech('a 5MB image')).toBe('a five megabytes image')
+    expect(normalizeForSpeech('a 2GB dump')).toBe('a two gigabytes dump')
+    expect(normalizeForSpeech('run 5m')).toBe('run five minutes')
+  })
+
+  it('bare capital M never reads as minutes (money shorthand, corpus)', () => {
+    expect(normalizeForSpeech('Revenue was 5M this year')).toBe(
+      'Revenue was 5M this year',
+    )
+    // Pre-existing quirk, not introduced or fixed here: the currency regex
+    // consumes "$5" before the unit pass ever sees the dangling "M", so this
+    // never read as "minutes" even on unpatched main — pin the ACTUAL output
+    // instead of an assertion that can't fail in either direction.
+    expect(normalizeForSpeech('raised $5M in the round')).toBe(
+      'raised five dollarsM in the round',
+    )
+  })
+
+  it('HTTP-status-shaped input adjacent to a capital letter is not read as a duration', () => {
+    expect(normalizeForSpeech('a 503M error occurred')).toBe(
+      'a 503M error occurred',
+    )
+    expect(normalizeForSpeech('status 503M')).toBe('status 503M')
+  })
+
+  // Corpus wins from the case-sensitivity split (22 samples improved fleet-
+  // wide across both passes, 14 of them "G" memory sizes wrongly read via
+  // pass 2 as GRAMS, plus an RTX "4080S" wrongly read as a duration).
+  // Pass 1 has no "g" in its own UNIT_MAP, so these were already inert here
+  // pre-fix; pinned to lock in the no-op and guard the composed pipeline
+  // (see tts-normalize.test.ts for the pass-2 "grams"/"4080S" regression).
+  it('single-letter units case-split: bare capitals stay untouched', () => {
+    expect(normalizeForSpeech('done in 5S')).toBe('done in 5S')
+    expect(normalizeForSpeech('wait 3H')).toBe('wait 3H')
+    expect(normalizeForSpeech('ships in 10D')).toBe('ships in 10D')
+    expect(normalizeForSpeech('bought a 4080S')).toBe('bought a 4080S')
+  })
 })
 
 describe('normalizeForSpeech — abbreviations (phase 2)', () => {