switchroom 0.19.17 → 0.19.19

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

@@ -306,3 +306,46 @@ describe('normalizeForTts — review findings (fixpoint decode, metachar, nits)'
     expect(normalizeForTts('X\Y')).not.toContain('\\')
   })
 })
+
+describe('voice-out pipeline: normalizeForSpeech → normalizeForTts', () => {
+  const speak = (s: string) => normalizeForTts(normalizeForSpeech(s))
+
+  test('a mixed markdown list survives both passes as paced sentences', () => {
+    expect(
+      speak(
+        '- Check /var/log/syslog\n' +
+          '- Cost was $1,000\n' +
+          '- Ran at 14:30:46\n' +
+          '- Use HTTPS and/or SSH',
+      ),
+    ).toBe(
+      'Check syslog. Cost was one thousand dollars. Ran at 14:30:46. ' +
+        'Use H T T P S and slash or S S H.',
+    )
+  })
+
+  test('the HH:MM:SS guard holds in both normalizers', () => {
+    expect(normalizeForTts('Done at 14:30:46 today')).toBe('Done at 14:30:46 today')
+    expect(normalizeForSpeech('Done at 14:30:46 today')).toBe(
+      'Done at 14:30:46 today',
+    )
+  })
+
+  // `14:30:46` survives even an unguarded scan because `30` is not a legal
+  // HH — so on its own it certifies nothing. These are the timestamps whose
+  // TAIL is itself a legal HH:MM, i.e. the ones a missing lookbehind
+  // actually half-reads ("09:zero o'clock").
+  test('an on-the-hour timestamp is not half-read (lookbehind guard)', () => {
+    for (const t of ['09:00:00', '12:00:15', '01:02:03']) {
+      expect(normalizeForTts(`ran at ${t} ok`)).toBe(`ran at ${t} ok`)
+      expect(normalizeForSpeech(`ran at ${t} ok`)).toBe(`ran at ${t} ok`)
+    }
+  })
+
+  test('thousands separators are spoken identically by both normalizers', () => {
+    expect(normalizeForTts('It costs $1,000')).toBe('It costs one thousand dollars')
+    expect(normalizeForSpeech('It costs $1,000')).toBe(
+      'It costs one thousand dollars',
+    )
+  })
+})

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

@@ -29,9 +29,11 @@ describe('normalizeForSpeech — reported markdown/symbol cases', () => {
     expect(normalizeForSpeech('run `npm test` now')).toBe('run npm test now')
   })
 
-  it('strips headings markers', () => {
-    expect(normalizeForSpeech('# Summary\nAll good')).toBe('Summary All good')
-    expect(normalizeForSpeech('### Deep heading')).toBe('Deep heading')
+  it('strips headings markers and gives the heading a spoken full stop', () => {
+    // The heading is its own spoken sentence — without the terminator the
+    // newline-collapse ran the heading straight into the body text.
+    expect(normalizeForSpeech('# Summary\nAll good')).toBe('Summary. All good')
+    expect(normalizeForSpeech('### Deep heading')).toBe('Deep heading.')
   })
 
   it('speaks link text and drops the URL', () => {
@@ -118,6 +120,18 @@ describe('normalizeForSpeech — emoji & pictographs', () => {
     expect(normalizeForSpeech('nice :rocket: work')).toBe('nice work')
   })
 
+  // Digit-bodied shortcodes are real. A letter-only body left them in the
+  // text AND glued them to the previous word ("Nice:100: work").
+  it('drops a DIGIT-bodied :shortcode: without eating the space', () => {
+    expect(normalizeForSpeech('Nice :100: work')).toBe('Nice work')
+    expect(normalizeForSpeech('a :8ball: b')).toBe('a b')
+    expect(normalizeForSpeech('a :1st_place_medal: b')).toBe('a b')
+  })
+
+  it('the digit-bodied form still cannot eat a timestamp colon', () => {
+    expect(normalizeForSpeech('Ran at 14:30:46 ok')).toBe('Ran at 14:30:46 ok')
+  })
+
   it('leaves ordinary colon usage alone', () => {
     expect(normalizeForSpeech('note: this is fine')).toBe('note: this is fine')
   })
@@ -335,3 +349,198 @@ describe('normalizeForSpeech — review findings (fixpoint decode, metachar, nit
     expect(decodeHtmlEntities('Q&A test')).toBe('Q&A test')
   })
 })
+
+describe('normalizeForSpeech — list & heading pacing', () => {
+  it('speaks a 4-bullet list as 4 separate sentences', () => {
+    const out = normalizeForSpeech(
+      'Here are the steps:\n' +
+        '- Check the logs\n' +
+        '- Restart the container\n' +
+        '- Verify health\n' +
+        '- Report back',
+    )
+    expect(out).toBe(
+      'Here are the steps: Check the logs. Restart the container. ' +
+        'Verify health. Report back.',
+    )
+    // Four sentence-terminated spoken units after the lead-in.
+    const units = out
+      .split(/(?<=[.:])\s+/)
+      .filter((u) => u.trim().length > 0)
+    expect(units).toEqual([
+      'Here are the steps:',
+      'Check the logs.',
+      'Restart the container.',
+      'Verify health.',
+      'Report back.',
+    ])
+  })
+
+  it('separates ordered-list items into sentences', () => {
+    expect(normalizeForSpeech('1. first\n2. second\n3. third')).toBe(
+      'first. second. third.',
+    )
+  })
+
+  it('does not double punctuation when the item already ends in . ! or ?', () => {
+    const out = normalizeForSpeech('- Done.\n- Really?\n- Ship it!')
+    expect(out).toBe('Done. Really? Ship it!')
+    expect(out).not.toContain('..')
+    expect(out).not.toContain('. .')
+    expect(out).not.toContain('?.')
+    expect(out).not.toContain('!.')
+  })
+
+  it('terminates the line that introduces a list when it lacks punctuation', () => {
+    expect(normalizeForSpeech('Steps\n- one\n- two')).toBe('Steps. one. two.')
+  })
+
+  it('does not chop a wrapped list item mid-clause', () => {
+    expect(normalizeForSpeech('- a long item that\ncontinues here\n- second')).toBe(
+      'a long item that continues here. second.',
+    )
+  })
+
+  it('separates heading sections into sentences', () => {
+    expect(normalizeForSpeech('# One\nbody one\n\n# Two\nbody two')).toBe(
+      'One. body one. Two. body two',
+    )
+  })
+})
+
+describe('normalizeForSpeech — time guard (HH:MM:SS)', () => {
+  it('leaves a full HH:MM:SS timestamp as digits rather than half-reading it', () => {
+    expect(normalizeForSpeech('Done at 14:30:46 today')).toBe(
+      'Done at 14:30:46 today',
+    )
+  })
+
+  // `14:30:46` survives even an unguarded scan because `30` is not a legal
+  // HH. These are the timestamps whose TAIL is itself a legal HH:MM — the
+  // ones a missing lookbehind half-reads ("09:zero o'clock").
+  it('leaves an on-the-hour timestamp alone (lookbehind guard)', () => {
+    expect(normalizeForSpeech('t 09:00:00 z')).toBe('t 09:00:00 z')
+    expect(normalizeForSpeech('t 12:00:15 z')).toBe('t 12:00:15 z')
+    expect(normalizeForSpeech('t 01:02:03 y')).toBe('t 01:02:03 y')
+  })
+
+  it('still speaks a plain HH:MM clock time', () => {
+    expect(normalizeForSpeech('Meeting at 14:30 today')).toBe(
+      'Meeting at fourteen thirty today',
+    )
+    expect(normalizeForSpeech('at 9:05')).toBe("at nine oh five")
+  })
+})
+
+describe('normalizeForSpeech — thousands separators', () => {
+  it('speaks $1,000 as one thousand dollars (not "one dollar,000")', () => {
+    expect(normalizeForSpeech('It costs $1,000 up front')).toBe(
+      'It costs one thousand dollars up front',
+    )
+  })
+
+  it('speaks a millions-scale amount', () => {
+    expect(normalizeForSpeech('Budget $1,234,567 total')).toBe(
+      'Budget one million two hundred thirty-four thousand five hundred ' +
+        'sixty-seven dollars total',
+    )
+  })
+
+  it('does not regress plain currency or ordinary comma prose', () => {
+    expect(normalizeForSpeech('It costs $500')).toBe('It costs five hundred dollars')
+    expect(normalizeForSpeech('$5.50 each')).toBe('five dollars fifty each')
+    expect(normalizeForSpeech('a, b, 3')).toBe('a, b, 3')
+    expect(normalizeForSpeech('We saw 12,500 requests')).toBe(
+      'We saw 12,500 requests',
+    )
+  })
+
+  // The thousands guard must not mistake an ordinary SENTENCE comma for a
+  // partial digit group — that left a raw "$" unspoken.
+  it('still speaks currency followed by a sentence comma', () => {
+    expect(normalizeForSpeech('It costs $500, plus tax')).toBe(
+      'It costs five hundred dollars, plus tax',
+    )
+    expect(normalizeForSpeech('We paid $1,000, then left')).toBe(
+      'We paid one thousand dollars, then left',
+    )
+  })
+
+  it('still bails on a genuinely malformed amount', () => {
+    expect(normalizeForSpeech('$1,00 partial')).toBe('$1,00 partial')
+    expect(normalizeForSpeech('$5.203 odd')).toBe('$5.203 odd')
+  })
+})
+
+describe('normalizeForSpeech — file paths', () => {
+  it('speaks an absolute path as its last segment', () => {
+    expect(normalizeForSpeech('Check /var/log/syslog now')).toBe(
+      'Check syslog now',
+    )
+  })
+
+  it('handles ~/ and relative multi-segment paths', () => {
+    expect(normalizeForSpeech('Edit ~/.config/nvim/init.lua please')).toBe(
+      'Edit init.lua please',
+    )
+    expect(normalizeForSpeech('See src/telegram-plugin/gateway.ts')).toBe(
+      'See gateway.ts',
+    )
+  })
+
+  it('says "a path" when the final segment is unspeakable noise', () => {
+    expect(normalizeForSpeech('Path /tmp/a1b2c3d4e5f6a7b8 there')).toBe(
+      'Path a path there',
+    )
+  })
+
+  it('leaves a single-slash word/word pair for the downstream slash pass', () => {
+    expect(normalizeForSpeech('and/or maybe')).toBe('and/or maybe')
+  })
+
+  it('does not treat an all-numeric date as a path', () => {
+    expect(normalizeForSpeech('the date 12/25/2026 works')).toBe(
+      'the date 12/25/2026 works',
+    )
+  })
+
+  // "Two or more slashes ⇒ path" is false in English. Without a path-ish
+  // anchor the pass DELETES words from ordinary prose ("yes/no/maybe" →
+  // "maybe"). Each of these must survive verbatim for the downstream
+  // "word slash word" pass to speak.
+  it('never swallows a multi-slash PROSE run (no path anchor)', () => {
+    expect(normalizeForSpeech('yes/no/maybe')).toBe('yes/no/maybe')
+    expect(normalizeForSpeech('read/write/exec perms')).toBe(
+      'read/write/exec perms',
+    )
+    expect(normalizeForSpeech('he/she/they pronouns')).toBe(
+      'he/she/they pronouns',
+    )
+    expect(normalizeForSpeech('a client/server/proxy split')).toBe(
+      'a client/server/proxy split',
+    )
+    expect(normalizeForSpeech('reading input/output/error')).toBe(
+      'reading input/output/error',
+    )
+    expect(normalizeForSpeech('tests in unit/integration/e2e are green')).toBe(
+      'tests in unit/integration/e2e are green',
+    )
+  })
+})
+
+describe('normalizeForSpeech — extended acronym set', () => {
+  it('spells the newly-added initialisms letter-by-letter', () => {
+    expect(normalizeForSpeech('use HTTPS not HTTP')).toBe('use H T T P S not H T T P')
+    expect(normalizeForSpeech('over SSH via DNS')).toBe('over S S H via D N S')
+    expect(normalizeForSpeech('the CLI on AWS at UTC')).toBe(
+      'the C L I on A W S at U T C',
+    )
+    expect(normalizeForSpeech('MCP PDF VM LLM YAML RAM USB ID OK')).toBe(
+      'M C P P D F V M L L M Y A M L R A M U S B I D O K',
+    )
+  })
+
+  it('still leaves word-style all-caps tokens alone', () => {
+    expect(normalizeForSpeech('NASA ALWAYS SHOUTING')).toBe('NASA ALWAYS SHOUTING')
+  })
+})

package/telegram-plugin/tests/worker-feed-repeat-steps.test.ts

@@ -0,0 +1,147 @@
+import { describe, it, expect } from 'vitest'
+import {
+  createWorkerActivityFeed,
+  stripRepeatSuffix,
+  repeatCountOf,
+  type WorkerActivityView,
+  type BotApiForWorkerFeed,
+} from '../worker-activity-feed.js'
+
+/**
+ * A worker whose steps all carry the SAME label must still visibly advance.
+ *
+ * The bug (observed live 2026-07-25, klanker): `description` is optional on
+ * Bash, so a sub-agent that never wrote one produced the constant label
+ * "Running a command" for every call. `accumulateNarrative` dropped every
+ * repeat as a duplicate, and the card held ONE line at a constant byte length
+ * for the whole job — editMessageText kept succeeding, so the surface looked
+ * healthy while conveying nothing. A wedged worker and a busy worker rendered
+ * identically.
+ *
+ * The fix counts repeats (`·×N`) instead of discarding them, gated on
+ * `view.toolCount` so that a re-emitted UNCHANGED view (the watcher does this
+ * every tick) never inflates the count.
+ */
+
+function view(partial: Partial<WorkerActivityView> = {}): WorkerActivityView {
+  return {
+    description: 'fix the thing',
+    lastTool: { name: 'Bash', sanitisedArg: 'x' },
+    toolCount: 1,
+    latestSummary: 'Running a command',
+    elapsedMs: 10_000,
+    state: 'running',
+    ...partial,
+  }
+}
+
+interface FakeBot extends BotApiForWorkerFeed {
+  sent: Array<{ text: string }>
+  edits: Array<{ text: string }>
+}
+
+function makeFakeBot(): FakeBot {
+  let nextId = 1000
+  const fb: FakeBot = {
+    sent: [],
+    edits: [],
+    sendMessage: async (_chatId, text) => {
+      fb.sent.push({ text })
+      return { message_id: nextId++ }
+    },
+    editMessageText: async (_chatId, _messageId, text) => {
+      fb.edits.push({ text })
+      return {}
+    },
+  }
+  return fb
+}
+
+/** Latest rendered body for the group (last edit, else the first paint). */
+function latestBody(bot: FakeBot): string {
+  return bot.edits.length > 0 ? bot.edits[bot.edits.length - 1].text : bot.sent[0].text
+}
+
+describe('worker feed — repeated step labels', () => {
+  it('renders a climbing ·×N counter instead of freezing on one line', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+
+    for (let i = 1; i <= 5; i++) {
+      clock += 10_000
+      await feed.update('w1', 'chat', view({ toolCount: i, elapsedMs: clock }))
+    }
+
+    const body = latestBody(bot)
+    expect(body).toContain('Running a command ·×5')
+    // …and the frozen single-count line is gone from the newest render.
+    expect(body).not.toMatch(/Running a command\*{0,2}\s*$/m)
+  })
+
+  it('does NOT inflate the count when the watcher re-emits an unchanged view', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+
+    // Same toolCount across many ticks = the SAME tool call, re-observed.
+    for (let i = 0; i < 6; i++) {
+      clock += 5_000
+      await feed.update('w1', 'chat', view({ toolCount: 2, elapsedMs: clock }))
+    }
+
+    const body = latestBody(bot)
+    expect(body).toContain('Running a command')
+    expect(body).not.toContain('·×')
+  })
+
+  it('starts a NEW step (no counter) when the label actually changes', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+
+    clock += 10_000
+    await feed.update('w1', 'chat', view({ toolCount: 1, elapsedMs: clock }))
+    clock += 10_000
+    await feed.update('w1', 'chat', view({ toolCount: 2, elapsedMs: clock }))
+    clock += 10_000
+    await feed.update('w1', 'chat', view({ toolCount: 3, latestSummary: 'Running git status', elapsedMs: clock }))
+
+    const body = latestBody(bot)
+    expect(body).toContain('Running a command ·×2')
+    expect(body).toContain('Running git status')
+    expect(body).not.toContain('Running git status ·×')
+  })
+
+  it('keeps the non-adjacent A,B,A dedup (no duplicate step lines)', async () => {
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, minEditIntervalMs: 0 })
+
+    const steps = ['Reading alpha.ts', 'Running grep', 'Reading alpha.ts']
+    for (const [i, summary] of steps.entries()) {
+      clock += 10_000
+      await feed.update('w1', 'chat', view({ toolCount: i + 1, latestSummary: summary, elapsedMs: clock }))
+    }
+
+    const body = latestBody(bot)
+    expect((body.match(/Reading alpha\.ts/g) ?? []).length).toBe(1)
+    // Non-adjacent repeats are dropped, not counted — the A,B,A duplication
+    // guard predates this change and stays intact.
+    expect(body).not.toContain('Reading alpha.ts ·×')
+  })
+})
+
+describe('repeat-suffix helpers', () => {
+  it('round-trips the marker', () => {
+    expect(stripRepeatSuffix('Running a command ·×12')).toBe('Running a command')
+    expect(stripRepeatSuffix('Running a command')).toBe('Running a command')
+    expect(repeatCountOf('Running a command')).toBe(1)
+    expect(repeatCountOf('Running a command ·×12')).toBe(12)
+  })
+
+  it('does not mistake ordinary text for a marker', () => {
+    expect(stripRepeatSuffix('Comparing 3 ×2 grids')).toBe('Comparing 3 ×2 grids')
+    expect(repeatCountOf('Comparing 3 ×2 grids')).toBe(1)
+  })
+})

package/telegram-plugin/tts-normalize.ts

@@ -292,10 +292,12 @@ export function normalizeForTts(text: string): string {
     return words.join(' ')
   })
 
-  // -- Times HH:MM (24h) → spoken. The (?!:?\d) guard skips HH:MM:SS
-  //    entirely — a half-spoken time with a dangling ":46" reads worse
-  //    than leaving the digits as-is.
-  s = s.replace(/\b([01]?\d|2[0-3]):([0-5]\d)(?!:?\d)/g, (_m, hh: string, mm: string) => {
+  // -- Times HH:MM (24h) → spoken. The (?<![\d:]) / (?!:?\d) guards skip
+  //    HH:MM:SS entirely — a half-spoken time with a dangling ":46" reads
+  //    worse than leaving the digits as-is. The LOOKBEHIND is load-bearing:
+  //    without it the scan re-anchors INSIDE the timestamp (`09:00:00` →
+  //    "09:zero o'clock") because the trailing `00` is itself a legal HH:MM.
+  s = s.replace(/(?<![\d:])\b([01]?\d|2[0-3]):([0-5]\d)(?!:?\d)/g, (_m, hh: string, mm: string) => {
     const h = Number(hh)
     const min = Number(mm)
     const hw = belowThousand(h)