switchroom 0.16.29 → 0.16.46

package/telegram-plugin/tests/status-vocabulary-unification.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest'
+import { describeToolUse } from '../tool-activity-summary.js'
+import { computeLabel } from '../hooks/tool-label-pretool.mjs'
+
+/**
+ * SINGLE STATUS-VOCABULARY GUARANTEE (know-what-my-agent-is-doing).
+ *
+ * Every activity surface renders per-tool status wording from ONE composer:
+ * `computeLabel` (hooks/tool-label-pretool.mjs). The consumers:
+ *
+ *   - real-time live feed  — the PreToolUse sidecar runs computeLabel at
+ *     tool-call time (`tool_label` events → appendActivityLabel);
+ *   - flush-time feed      — appendActivityLine → describeToolUse;
+ *   - nested sub-agent / worker-card steps — subagent-watcher →
+ *     describeToolUse (whose lines the 🛠 Worker card renders via
+ *     renderStatusCard).
+ *
+ * `describeToolUse` is a thin delegating wrapper over computeLabel. Before
+ * the delegation the two tables had drifted (same action, different copy on
+ * different surfaces — the wording drift the spec bars). This test is the
+ * anti-drift lock: it sweeps a corpus of every tool shape both composers
+ * handle and asserts they emit IDENTICAL labels. If someone re-forks the
+ * vocabulary — a second wording table in describeToolUse, a hook-only
+ * rewording — this fails CI.
+ */
+
+// Corpus: (toolName, input) pairs spanning every branch of the composer.
+const CORPUS: Array<[string, Record<string, unknown>]> = [
+  ['Bash', { command: 'ls -la', description: 'List repo files' }],
+  ['Bash', { command: 'grep -r foo .' }],
+  ['BashOutput', {}],
+  ['KillShell', {}],
+  ['Read', { file_path: '/home/u/code/gateway.ts' }],
+  ['Read', {}],
+  ['Edit', { file_path: '/a/b/CLAUDE.md' }],
+  ['MultiEdit', { file_path: '/a/b/x.ts' }],
+  ['Edit', {}],
+  ['Write', { file_path: 'notes.txt' }],
+  ['Write', {}],
+  ['NotebookEdit', { notebook_path: '/n/analysis.ipynb' }],
+  ['NotebookEdit', {}],
+  ['Grep', { pattern: 'TODO' }],
+  ['Grep', { pattern: 'TODO', path: 'src/' }],
+  ['Grep', {}],
+  ['Glob', { pattern: '**/*.ts' }],
+  ['Glob', {}],
+  ['WebFetch', { url: 'https://www.example.com/path?q=1' }],
+  ['WebFetch', {}],
+  ['WebSearch', { query: 'best running shoes' }],
+  ['WebSearch', {}],
+  ['Task', { description: 'Review the migration' }],
+  ['Agent', {}],
+  ['TodoWrite', {}],
+  ['TaskCreate', {}],
+  ['TaskUpdate', {}],
+  ['TaskList', {}],
+  ['ToolSearch', {}],
+  ['Skill', { skill: 'switchroom' }],
+  ['SomeFutureBuiltin', {}],
+  ['mcp__hindsight__recall', { query: 'x' }],
+  ['mcp__hindsight__reflect', { query: 'x' }],
+  ['mcp__hindsight__retain', {}],
+  ['mcp__hindsight__update_memory', {}],
+  ['mcp__hindsight__list_memories', {}],
+  ['mcp__claude_ai_Google_Calendar__list_events', {}],
+  ['mcp__claude_ai_Gmail__search', {}],
+  ['mcp__claude_ai_Google_Drive__search_files', {}],
+  ['mcp__claude_ai_Notion__notion-search', {}],
+  ['mcp__perplexity__perplexity_search', { query: 'weather sydney' }],
+  ['mcp__webkite__read', { url: 'https://example.org/docs' }],
+  ['mcp__acme__do_thing', { description: 'Fetched the report' }],
+  ['mcp__acme__do_thing', {}],
+  ['mcp__switchroom-telegram__get_recent_messages', {}],
+]
+
+// Suppressed-on-both corpus: surfaces must agree these render NOTHING.
+const SUPPRESSED: Array<[string, Record<string, unknown>]> = [
+  ['mcp__switchroom-telegram__reply', { text: 'hi' }],
+  ['mcp__switchroom-telegram__stream_reply', {}],
+  ['mcp__switchroom-telegram__edit_message', {}],
+  ['mcp__switchroom-telegram__react', {}],
+  ['mcp__clerk-telegram__reply', {}],
+  ['mcp__hindsight__sync_retain', {}],
+  ['Skill', {}], // empty-slug Skill stays suppressed (#2111 sidecar contract)
+]
+
+describe('single status-vocabulary composer (drift fails CI)', () => {
+  it('describeToolUse and computeLabel emit identical labels across the corpus', () => {
+    for (const [tool, input] of CORPUS) {
+      expect(describeToolUse(tool, input), `label drift for ${tool}`).toBe(
+        computeLabel(tool, input),
+      )
+    }
+  })
+
+  it('both composers agree on suppression (never a surfaced reply/control tool)', () => {
+    for (const [tool, input] of SUPPRESSED) {
+      expect(describeToolUse(tool, input), `describeToolUse must suppress ${tool}`).toBeNull()
+      expect(computeLabel(tool, input), `computeLabel must suppress ${tool}`).toBeNull()
+    }
+  })
+
+  it('the previously-drifted wordings are unified (the Ken-observed drift)', () => {
+    // These exact pairs rendered DIFFERENT copy per surface before the
+    // unification. Pin the unified form on both composers.
+    expect(computeLabel('Grep', { pattern: 'TODO' })).toBe('Searching for TODO')
+    expect(describeToolUse('Grep', { pattern: 'TODO' })).toBe('Searching for TODO')
+    expect(computeLabel('WebFetch', { url: 'https://www.example.com/path?q=1' })).toBe(
+      'Reading example.com',
+    )
+    expect(describeToolUse('WebFetch', { url: 'https://www.example.com/path?q=1' })).toBe(
+      'Reading example.com',
+    )
+    expect(computeLabel('mcp__hindsight__retain', {})).toBe('Saving to memory')
+    expect(describeToolUse('mcp__hindsight__retain', {})).toBe('Saving to memory')
+  })
+
+  it('never emits raw shell/query syntax from either composer', () => {
+    for (const [tool, input] of CORPUS) {
+      const label = computeLabel(tool, input)
+      if (label == null) continue
+      expect(label, `raw syntax leaked for ${tool}`).not.toMatch(/grep -r|ls -la/)
+    }
+  })
+})

package/telegram-plugin/tests/stream-reply-handler.test.ts

@@ -117,6 +117,45 @@ describe('handleStreamReply', () => {
     expect(bot.api.sendMessage.mock.calls[0][2]?.parse_mode).toBeUndefined()
   })
 
+  it('applies addParagraphSpacers on the rich path (multi-paragraph gap spaced)', async () => {
+    const state = makeState()
+    // Spacer dep replaces every `\n\n` gap with a visible marker so we can
+    // assert the rich path ran it (mirrors the real gateway wiring).
+    const deps = makeDeps(bot, {
+      addParagraphSpacers: (t) => t.replace(/\n\n/g, '\n\nSPACER\n\n'),
+    })
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Para one.\n\nPara two.', done: true },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(richSendMarkdown(bot)).toBe('Para one.\n\nSPACER\n\nPara two.')
+  })
+
+  it('does NOT apply addParagraphSpacers on the literal format=text path', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot, {
+      addParagraphSpacers: (t) => t.replace(/\n\n/g, '\n\nSPACER\n\n'),
+    })
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Para one.\n\nPara two.', format: 'text', done: true },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    // Literal path is byte-exact — no spacer injected.
+    expect(bot.api.sendMessage.mock.calls[0][1]).toBe('Para one.\n\nPara two.')
+  })
+
   it('throws when text exceeds the rich-message cap (no silent id:pending)', async () => {
     const state = makeState()
     const deps = makeDeps(bot)

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

@@ -19,6 +19,8 @@ import {
   repairEscapedWhitespace,
   escapeMarkdown,
   splitMarkdownChunks,
+  addParagraphSpacers,
+  PARAGRAPH_SPACER,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
 
@@ -63,6 +65,26 @@ describe('escapeMarkdown', () => {
     // `\*` in the input is backslash + star → both get escaped exactly once.
     expect(escapeMarkdown('\\*')).toBe('\\\\\\*')
   })
+
+  // The de-dup pass (#2695) replaced ~12 local escaper copies with this one
+  // canonical function. Every consolidated caller now depends on this exact
+  // contract: the FULL metacharacter set in a single string, each escaped.
+  test('escapes the full metacharacter set in one combined string', () => {
+    // Backslash placed last so it doesn't re-escape the chars after it.
+    expect(escapeMarkdown('`*_~=[]|\\')).toBe('\\`\\*\\_\\~\\=\\[\\]\\|\\\\')
+  })
+
+  test('already-safe text passes through unchanged', () => {
+    const safe = 'Switched fleet to alice (5h window 29% resets in 2h)'
+    expect(escapeMarkdown(safe)).toBe(safe)
+  })
+
+  // card-format.ts re-exports this same symbol; the consolidated callers
+  // import from one or the other. Lock that they are the identical function.
+  test('card-format re-exports the identical canonical escaper', async () => {
+    const cardFormat = await import('../card-format.js')
+    expect(cardFormat.escapeMarkdown).toBe(escapeMarkdown)
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -101,7 +123,10 @@ describe('splitMarkdownChunks', () => {
     // A long body with a fenced code block straddling the cap. The chunker
     // must move the whole fence to a single chunk so no chunk has an odd
     // number of fence delimiters (which would swallow the next chunk).
-    const fence = '```\n' + 'code line\n'.repeat(20) + '```'
+    // The fence FITS within the cap, so the chunker can move it whole to a
+    // single chunk and keep every chunk's fence count balanced. (An oversized
+    // fence that cannot fit is hard-sliced instead — see the F7 tests below.)
+    const fence = '```\n' + 'code line\n'.repeat(8) + '```'
     const text = 'intro paragraph '.repeat(15) + '\n\n' + fence + '\n\noutro paragraph'
     const chunks = splitMarkdownChunks(text, 180)
     for (const c of chunks) {
@@ -128,15 +153,103 @@ describe('splitMarkdownChunks', () => {
     }
   })
 
-  test('emits an oversized indivisible block whole rather than looping forever', () => {
-    // A single fenced block larger than maxLen has no safe interior cut —
-    // the chunker emits it whole (a louder, debuggable Telegram reject
-    // beats an infinite loop).
+  test('hard-slices an indivisible block that exceeds the cap (F7 — no oversized chunk)', () => {
+    // A single fenced block larger than maxLen has no safe interior cut. The
+    // OLD behaviour emitted it whole, which Telegram rejects with
+    // RICH_MESSAGE_TEXT_TOO_LONG and drops the entire answer. F7 delegates to
+    // hardSliceToCap so the region comes out as multiple <= cap character
+    // slices instead — degraded-but-delivered beats a hard reject.
     const giant = '```\n' + 'x'.repeat(500) + '\n```'
     const chunks = splitMarkdownChunks(giant, 100)
-    // It comes out as one (oversized) chunk, not split mid-fence.
-    expect(chunks.length).toBe(1)
-    expect(chunks[0]).toBe(giant)
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const c of chunks) expect(c.length).toBeLessThanOrEqual(100)
+    // No content is dropped — the slices concatenate back to the original.
+    expect(chunks.join('')).toBe(giant)
+  })
+
+  test('hard-slices a single unbreakable >maxLen token run into <= cap chunks (F7)', () => {
+    // One giant pipe-bearing line with no space/newline boundary below the
+    // cap: neither the blank-line, newline, nor space heuristic can find a
+    // cut, and the table-row back-off cannot help either. This is the exact
+    // "cut <= 0" path — it must hard-slice, not emit an oversized chunk.
+    const runaway = 'a|b|'.repeat(200) // 800 chars, no spaces/newlines
+    const chunks = splitMarkdownChunks(runaway, 100)
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const c of chunks) expect(c.length).toBeLessThanOrEqual(100)
+    expect(chunks.join('')).toBe(runaway)
+  })
+
+  test('an indivisible region larger than the real 32768 cap still slices to <= cap (F7)', () => {
+    const giant = 'z'.repeat(RICH_MESSAGE_MAX_CHARS + 5000)
+    const chunks = splitMarkdownChunks(giant) // default cap = RICH_MESSAGE_MAX_CHARS
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const c of chunks) expect(c.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS)
+  })
+
+  // -------------------------------------------------------------------------
+  // Chunk-boundary spacer hygiene. addParagraphSpacers injects a
+  // `\n\n${PARAGRAPH_SPACER}\n\n` gap between prose paragraphs. When a cut
+  // lands inside that gap, the boundary must not leave a chunk that opens or
+  // ends with a bare U+00A0 spacer line (a stray blank bubble line).
+  // -------------------------------------------------------------------------
+
+  test('no chunk starts or ends with a bare U+00A0 spacer line (reviewer repro)', () => {
+    // The exact reviewer repro: a spacer gap straddling a small cap.
+    const A = 'Alpha sentence one'
+    const B = 'Bravo sentence two'
+    const spaced = addParagraphSpacers(`${A}.\n\n${B}.`)
+    const chunks = splitMarkdownChunks(spaced, 33)
+    expect(chunks.length).toBeGreaterThan(1)
+    const spacerOnly = new RegExp(`^[ \\t]*${PARAGRAPH_SPACER}[ \\t]*$`)
+    for (const c of chunks) {
+      const lines = c.split('\n')
+      expect(spacerOnly.test(lines[0])).toBe(false)
+      expect(spacerOnly.test(lines[lines.length - 1])).toBe(false)
+    }
+  })
+
+  test('visible paragraph content survives the boundary (no text dropped)', () => {
+    const A = 'Alpha sentence one'
+    const B = 'Bravo sentence two'
+    const spaced = addParagraphSpacers(`${A}.\n\n${B}.`)
+    const chunks = splitMarkdownChunks(spaced, 33)
+    const rejoined = chunks.join('\n')
+    expect(rejoined).toContain(`${A}.`)
+    expect(rejoined).toContain(`${B}.`)
+  })
+
+  test('spacer-boundary strip is robust across several gaps and small caps', () => {
+    const paras = Array.from({ length: 6 }, (_, i) => `Paragraph ${i} body text here.`)
+    const spaced = addParagraphSpacers(paras.join('\n\n'))
+    const spacerOnly = new RegExp(`^[ \\t]*${PARAGRAPH_SPACER}[ \\t]*$`)
+    for (const cap of [20, 31, 40, 64]) {
+      const chunks = splitMarkdownChunks(spaced, cap)
+      for (const c of chunks) {
+        const lines = c.split('\n')
+        expect(spacerOnly.test(lines[0])).toBe(false)
+        expect(spacerOnly.test(lines[lines.length - 1])).toBe(false)
+      }
+      // No visible word is dropped: concatenating the chunks' non-blank,
+      // non-spacer tokens reproduces the original word sequence. (Word-level,
+      // not line-level, because a small cap may split mid-word — that's the
+      // chunker's normal space-boundary behaviour, orthogonal to spacers.)
+      const words = (s: string): string[] =>
+        s.split(/\s+/).filter((w) => w.length > 0 && w !== PARAGRAPH_SPACER)
+      // Join chunks with a space — each chunk is a separate Telegram message,
+      // so inter-chunk whitespace is irrelevant; what matters is no word is
+      // lost or fused. (A small cap may end a chunk mid-sentence at a space
+      // boundary, e.g. "...here." | "Paragraph 1...", which is normal.)
+      expect(words(chunks.join(' '))).toEqual(words(paras.join(' ')))
+    }
+  })
+
+  test('a boundary with NO spacer is unaffected (legacy ^\\n+ behaviour preserved)', () => {
+    const text = Array.from({ length: 10 }, (_, i) => `plain line ${i}`).join('\n\n')
+    const chunks = splitMarkdownChunks(text, 40)
+    // No spacer was ever present, so no chunk gains/loses anything beyond the
+    // normal leading-newline strip; content is preserved.
+    const rejoined = chunks.join('\n').replace(/\n+/g, '\n')
+    expect(rejoined).toBe(text.replace(/\n+/g, '\n'))
   })
 })
 

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

@@ -10,7 +10,95 @@
 
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 
-import { scrubVoice } from '../text-voice-scrub.js'
+import { scrubVoice, normalizeDashes } from '../text-voice-scrub.js'
+
+/**
+ * Regression guard for the em-dash comma-splice bug seen in a real reply
+ * (the #2737-era voice scrub). The original #1683 rule degraded a
+ * clause-joining em-dash to a comma when the next word was lowercase, which
+ * joined two independent clauses with a comma — a comma splice ("voice came
+ * back, three PRs stacked"). The fix degrades to a full stop and recapitalizes
+ * the following word, so the output is never a splice. These tests use the
+ * verbatim failure strings from the stored bad message.
+ */
+describe('scrubVoice — em-dash between clauses never produces a comma splice', () => {
+  beforeEach(() => {
+    delete process.env.SWITCHROOM_DISABLE_VOICE_SCRUB
+    delete process.env.SWITCHROOM_VOICE_STRIP_OPENERS
+  })
+
+  it('lowercase-continued independent clause becomes two sentences, not a splice (real string 1)', () => {
+    const r = scrubVoice('**Why voice came back** — three PRs stacked')
+    // Was: "**Why voice came back**, three PRs stacked" (comma splice).
+    expect(r.scrubbed).toBe('**Why voice came back**. Three PRs stacked')
+    expect(r.scrubbed).not.toContain('**, three')
+    expect(r.replaced).toBe(1)
+  })
+
+  it('lowercase-continued independent clause becomes two sentences, not a splice (real string 2)', () => {
+    const r = scrubVoice(
+      'never reached the agents — this is what unblocked everything today.',
+    )
+    // Was: "...the agents, this is what unblocked..." (comma splice).
+    expect(r.scrubbed).toBe(
+      'never reached the agents. This is what unblocked everything today.',
+    )
+    expect(r.scrubbed).not.toContain('agents, this')
+    expect(r.replaced).toBe(1)
+  })
+
+  it('the scrubbed output contains no ", <lowercase clause>" splice for any spaced dash', () => {
+    const r = scrubVoice(
+      'first thing — second independent clause and — third one here',
+    )
+    // No comma directly joining the two independent clauses.
+    expect(r.scrubbed).toBe(
+      'first thing. Second independent clause and. Third one here',
+    )
+  })
+
+  it('normalizeDashes (card / worker-narration path) also avoids the splice', () => {
+    // The non-reply surfaces reuse normalizeDashes; same splice-free rule.
+    expect(normalizeDashes('came back — three PRs stacked')).toBe(
+      'came back. Three PRs stacked',
+    )
+  })
+
+  it('a dash before a NON-letter (digit / paren) is not wrongly recapitalized', () => {
+    // capFirst only touches an ASCII lowercase letter; a digit / punctuation
+    // start is left as-is after the full stop.
+    expect(normalizeDashes('the count — 3 items remain')).toBe(
+      'the count. 3 items remain',
+    )
+    expect(normalizeDashes('the note — (see appendix)')).toBe(
+      'the note. (see appendix)',
+    )
+  })
+
+  it('dashes inside code spans, fenced blocks, and URLs are still never touched', () => {
+    const input =
+      'prose — one\n' +
+      'inline `a — b — c` stays\n' +
+      '```\nfenced x — y — z stays\n```\n' +
+      'link https://ex.io/a—b—c stays too — end'
+    const r = scrubVoice(input)
+    expect(r.scrubbed).toContain('`a — b — c`')
+    expect(r.scrubbed).toContain('fenced x — y — z stays')
+    expect(r.scrubbed).toContain('https://ex.io/a—b—c')
+    // Only the two prose dashes were scrubbed (to full stops).
+    expect(r.scrubbed).toContain('prose. One')
+    expect(r.scrubbed).toContain('stays too. End')
+    expect(r.replaced).toBe(2)
+  })
+
+  it('a double-space inside inline code / a URL is left untouched by the scrub', () => {
+    // The scrub must not normalize whitespace inside protected regions.
+    const r = scrubVoice('keep `foo  bar` and http://h/a  b intact — done')
+    expect(r.scrubbed).toContain('`foo  bar`')
+    expect(r.scrubbed).toContain('http://h/a  b')
+    expect(r.scrubbed).toContain('intact. Done')
+  })
+})
 
 describe('scrubVoice — em / en dash replacement', () => {
   beforeEach(() => {
@@ -21,9 +109,13 @@ describe('scrubVoice — em / en dash replacement', () => {
   })
 
   describe('mechanical rewrite of spaced dashes', () => {
-    it('replaces a spaced em-dash before lowercase with a comma', () => {
+    it('replaces a spaced em-dash before lowercase with a full stop (no comma splice)', () => {
+      // #1683 originally emitted a comma here, which produced a comma splice
+      // between two independent clauses ("on it, checking the calendar"). The
+      // splice-free rule degrades the clause-joining dash to a period and
+      // recapitalizes the following word.
       const r = scrubVoice('on it — checking the calendar')
-      expect(r.scrubbed).toBe('on it, checking the calendar')
+      expect(r.scrubbed).toBe('on it. Checking the calendar')
       expect(r.replaced).toBe(1)
     })
 
@@ -34,22 +126,23 @@ describe('scrubVoice — em / en dash replacement', () => {
       expect(r.replaced).toBe(1)
     })
 
-    it('handles multiple em-dashes in one sentence', () => {
+    it('handles multiple em-dashes in one sentence (each becomes a full stop)', () => {
       const r = scrubVoice('one — two — three — done')
-      expect(r.scrubbed).toBe('one, two, three, done')
+      expect(r.scrubbed).toBe('one. Two. Three. Done')
       expect(r.replaced).toBe(3)
     })
 
     it('treats en-dash (–) identically to em-dash', () => {
       const r = scrubVoice('on it – checking the calendar')
-      expect(r.scrubbed).toBe('on it, checking the calendar')
+      expect(r.scrubbed).toBe('on it. Checking the calendar')
       expect(r.replaced).toBe(1)
     })
 
-    it('replaces unspaced word-dash-word as a comma', () => {
-      // Less common but seen in tightly-typed prose.
+    it('replaces unspaced word-dash-word with a full stop (no comma splice)', () => {
+      // Less common but seen in tightly-typed prose. Same splice-free rule as
+      // the spaced form: a period plus a recapitalized following word.
       const r = scrubVoice('flag—on or flag—off')
-      expect(r.scrubbed).toBe('flag, on or flag, off')
+      expect(r.scrubbed).toBe('flag. On or flag. Off')
       expect(r.replaced).toBe(2)
     })
 
@@ -66,6 +159,32 @@ describe('scrubVoice — em / en dash replacement', () => {
       expect(r.scrubbed).toBe('- note: ship it')
       expect(r.replaced).toBe(1)
     })
+
+    it('does not recapitalize a mixed-case brand token after a dash', () => {
+      // capFirst must leave a lowercase-initial mixed-case token (iOS, eBay,
+      // iPhone, macOS) alone — recapitalizing "iOS" to "IOS" corrupts the
+      // brand. A normal lowercase word still gets recapitalized.
+      const r = scrubVoice('foo—iOS build')
+      expect(r.scrubbed).toBe('foo. iOS build')
+      expect(r.replaced).toBe(1)
+
+      const spaced = scrubVoice('shipped — iPhone ready')
+      expect(spaced.scrubbed).toBe('shipped. iPhone ready')
+
+      const normal = scrubVoice('foo—done here')
+      expect(normal.scrubbed).toBe('foo. Done here')
+    })
+
+    it('preserves numeric ranges as ASCII hyphens, not full stops', () => {
+      // A digit-flanked dash is a range, not a clause break. It falls through
+      // to the catch-all rule and becomes an ASCII hyphen.
+      const unspaced = scrubVoice('10–20')
+      expect(unspaced.scrubbed).toBe('10-20')
+      expect(unspaced.replaced).toBe(1)
+
+      const tight = scrubVoice('scored 3–2')
+      expect(tight.scrubbed).toBe('scored 3-2')
+    })
   })
 
   describe('protected regions are left alone', () => {
@@ -73,33 +192,33 @@ describe('scrubVoice — em / en dash replacement', () => {
       const input = 'here is code:\n```bash\nfoo --bar — baz\n```\nand prose — done'
       const r = scrubVoice(input)
       expect(r.scrubbed).toBe(
-        'here is code:\n```bash\nfoo --bar — baz\n```\nand prose, done',
+        'here is code:\n```bash\nfoo --bar — baz\n```\nand prose. Done',
       )
       expect(r.replaced).toBe(1)
     })
 
     it('preserves dashes inside inline code', () => {
       const r = scrubVoice('the flag `--really — keep` matters — yes')
-      expect(r.scrubbed).toBe('the flag `--really — keep` matters, yes')
+      expect(r.scrubbed).toBe('the flag `--really — keep` matters. Yes')
       expect(r.replaced).toBe(1)
     })
 
     it('preserves dashes inside <code> HTML tags', () => {
       const r = scrubVoice('see <code>x — y</code> and note — ok')
-      expect(r.scrubbed).toBe('see <code>x — y</code> and note, ok')
+      expect(r.scrubbed).toBe('see <code>x — y</code> and note. Ok')
       expect(r.replaced).toBe(1)
     })
 
     it('preserves dashes inside <pre> HTML tags', () => {
       const r = scrubVoice('block:\n<pre>x — y\nz — w</pre>\nend — ok')
-      expect(r.scrubbed).toBe('block:\n<pre>x — y\nz — w</pre>\nend, ok')
+      expect(r.scrubbed).toBe('block:\n<pre>x — y\nz — w</pre>\nend. Ok')
       expect(r.replaced).toBe(1)
     })
 
     it('preserves dashes inside URLs', () => {
       const r = scrubVoice('see https://example.com/a—b for context — ok')
       expect(r.scrubbed).toBe(
-        'see https://example.com/a—b for context, ok',
+        'see https://example.com/a—b for context. Ok',
       )
       expect(r.replaced).toBe(1)
     })
@@ -110,7 +229,7 @@ describe('scrubVoice — em / en dash replacement', () => {
       const fence =
         '```\n# heading — title\nfunction f() {}\n```'
       const r = scrubVoice(fence + '\ntrailing — yes')
-      expect(r.scrubbed).toBe(fence + '\ntrailing, yes')
+      expect(r.scrubbed).toBe(fence + '\ntrailing. Yes')
       expect(r.replaced).toBe(1)
     })
   })
@@ -151,8 +270,8 @@ describe('scrubVoice — em / en dash replacement', () => {
         'Result: empty for Saturday — nothing scheduled. Anything else?'
       const r = scrubVoice(input)
       expect(r.scrubbed).toBe(
-        "I'll check the calendar, should take a few seconds. " +
-        'Result: empty for Saturday, nothing scheduled. Anything else?',
+        "I'll check the calendar. Should take a few seconds. " +
+        'Result: empty for Saturday. Nothing scheduled. Anything else?',
       )
       expect(r.replaced).toBe(2)
     })
@@ -164,9 +283,9 @@ describe('scrubVoice — em / en dash replacement', () => {
         'Ready to commit — go?'
       const r = scrubVoice(input)
       expect(r.scrubbed).toBe(
-        'Running `git status --short`, looks clean. ' +
+        'Running `git status --short`. Looks clean. ' +
         '```\nM file.ts — modified\n```\n' +
-        'Ready to commit, go?',
+        'Ready to commit. Go?',
       )
       expect(r.replaced).toBe(2)
     })
@@ -293,15 +412,16 @@ describe('scrubVoice — opener strip is OFF by default (prompt carries tone)',
 
   it('STILL normalizes em-dashes by default (punctuation, no content removed)', () => {
     const r = scrubVoice('on it — checking the calendar')
-    expect(r.scrubbed).toBe('on it, checking the calendar')
+    expect(r.scrubbed).toBe('on it. Checking the calendar')
     expect(r.replaced).toBe(1)
     expect(r.openersStripped).toBe(0)
   })
 
   it('an affirmation opener with an em-dash keeps the words, fixes only the dash', () => {
     const r = scrubVoice('Exactly right — the token had expired.')
-    // Opener preserved; the em-dash after it becomes a comma.
-    expect(r.scrubbed).toBe('Exactly right, the token had expired.')
+    // Opener preserved (strip is OFF); the em-dash between two independent
+    // clauses becomes a full stop, not a comma (no splice).
+    expect(r.scrubbed).toBe('Exactly right. The token had expired.')
     expect(r.openersStripped).toBe(0)
     expect(r.replaced).toBe(1)
   })