switchroom 0.5.0

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

@@ -0,0 +1,364 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, statSync, rmSync, existsSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import {
+  initHistory,
+  recordInbound,
+  recordOutbound,
+  recordEdit,
+  query,
+  getRecentOutboundCount,
+  getLatestInboundMessageId,
+  _resetForTests,
+} from '../history.js'
+
+let stateDir: string
+
+beforeEach(() => {
+  stateDir = mkdtempSync(join(tmpdir(), 'telegram-history-test-'))
+})
+
+afterEach(() => {
+  _resetForTests()
+  if (existsSync(stateDir)) {
+    rmSync(stateDir, { recursive: true, force: true })
+  }
+})
+
+describe('initHistory', () => {
+  it('creates history.db with chmod 0600', () => {
+    initHistory(stateDir, 30)
+    const dbPath = join(stateDir, 'history.db')
+    expect(existsSync(dbPath)).toBe(true)
+    const st = statSync(dbPath)
+    // Mask off the file-type bits — only the perm bits matter.
+    expect(st.mode & 0o777).toBe(0o600)
+  })
+
+  it('is idempotent — second call is a no-op', () => {
+    initHistory(stateDir, 30)
+    expect(() => initHistory(stateDir, 30)).not.toThrow()
+  })
+})
+
+describe('recordInbound + query', () => {
+  beforeEach(() => initHistory(stateDir, 30))
+
+  it('round-trips a single message', () => {
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 5,
+      user: 'alice',
+      user_id: '111',
+      ts: 1000,
+      text: 'hello',
+    })
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]).toMatchObject({
+      chat_id: '-100',
+      message_id: 5,
+      role: 'user',
+      user: 'alice',
+      text: 'hello',
+    })
+  })
+
+  it('returns oldest-first', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'first' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 2, user: 'a', user_id: '1', ts: 200, text: 'second' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 3, user: 'a', user_id: '1', ts: 300, text: 'third' })
+    const rows = query({ chat_id: '-100' })
+    expect(rows.map(r => r.text)).toEqual(['first', 'second', 'third'])
+  })
+
+  it('respects the limit', () => {
+    for (let i = 1; i <= 20; i++) {
+      recordInbound({ chat_id: '-100', thread_id: null, message_id: i, user: 'a', user_id: '1', ts: 100 + i, text: `m${i}` })
+    }
+    const rows = query({ chat_id: '-100', limit: 5 })
+    expect(rows).toHaveLength(5)
+    // Newest 5, returned oldest-first
+    expect(rows.map(r => r.text)).toEqual(['m16', 'm17', 'm18', 'm19', 'm20'])
+  })
+
+  it('caps limit at 50', () => {
+    for (let i = 1; i <= 100; i++) {
+      recordInbound({ chat_id: '-100', thread_id: null, message_id: i, user: 'a', user_id: '1', ts: 100 + i, text: `m${i}` })
+    }
+    const rows = query({ chat_id: '-100', limit: 999 })
+    expect(rows).toHaveLength(50)
+  })
+
+  it('paginates with before_message_id', () => {
+    for (let i = 1; i <= 20; i++) {
+      recordInbound({ chat_id: '-100', thread_id: null, message_id: i, user: 'a', user_id: '1', ts: 100 + i, text: `m${i}` })
+    }
+    const page1 = query({ chat_id: '-100', limit: 5 })
+    expect(page1.map(r => r.text)).toEqual(['m16', 'm17', 'm18', 'm19', 'm20'])
+    const oldestId = page1[0]!.message_id
+    const page2 = query({ chat_id: '-100', limit: 5, before_message_id: oldestId })
+    expect(page2.map(r => r.text)).toEqual(['m11', 'm12', 'm13', 'm14', 'm15'])
+  })
+
+  it('filters by thread_id', () => {
+    recordInbound({ chat_id: '-100', thread_id: 7, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'topicA' })
+    recordInbound({ chat_id: '-100', thread_id: 8, message_id: 2, user: 'a', user_id: '1', ts: 100, text: 'topicB' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 3, user: 'a', user_id: '1', ts: 100, text: 'root' })
+
+    expect(query({ chat_id: '-100', thread_id: 7 }).map(r => r.text)).toEqual(['topicA'])
+    expect(query({ chat_id: '-100', thread_id: 8 }).map(r => r.text)).toEqual(['topicB'])
+    expect(query({ chat_id: '-100', thread_id: null }).map(r => r.text)).toEqual(['root'])
+    // Omitted thread_id returns everything in the chat
+    expect(query({ chat_id: '-100' })).toHaveLength(3)
+  })
+
+  it('isolates chats from each other', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'A' })
+    recordInbound({ chat_id: '-200', thread_id: null, message_id: 1, user: 'b', user_id: '2', ts: 100, text: 'B' })
+    expect(query({ chat_id: '-100' }).map(r => r.text)).toEqual(['A'])
+    expect(query({ chat_id: '-200' }).map(r => r.text)).toEqual(['B'])
+  })
+
+  // Issue #119: Telegram-native reply context.
+  it('round-trips reply_to_message_id and reply_to_text', () => {
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 42,
+      user: 'alice',
+      user_id: '111',
+      ts: 1000,
+      text: 'how do we fix this?',
+      reply_to_message_id: 17,
+      reply_to_text: 'Morning briefing: cron job failed at 06:00',
+    })
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]?.reply_to_message_id).toBe(17)
+    expect(rows[0]?.reply_to_text).toBe('Morning briefing: cron job failed at 06:00')
+  })
+
+  it('stores null when no reply context is provided', () => {
+    recordInbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_id: 5,
+      user: 'a',
+      user_id: '1',
+      ts: 100,
+      text: 'plain message',
+    })
+    const rows = query({ chat_id: '-100' })
+    expect(rows[0]?.reply_to_message_id).toBeNull()
+    expect(rows[0]?.reply_to_text).toBeNull()
+  })
+
+  it('stores reply context independently across messages in the same chat', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'first', reply_to_message_id: null, reply_to_text: null })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 2, user: 'a', user_id: '1', ts: 200, text: 'reply', reply_to_message_id: 1, reply_to_text: 'first' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 3, user: 'a', user_id: '1', ts: 300, text: 'unrelated' })
+    const rows = query({ chat_id: '-100' })
+    expect(rows.map(r => r.reply_to_message_id)).toEqual([null, 1, null])
+    expect(rows.map(r => r.reply_to_text)).toEqual([null, 'first', null])
+  })
+})
+
+describe('getLatestInboundMessageId', () => {
+  beforeEach(() => initHistory(stateDir, 30))
+
+  it('returns null when no inbound messages exist', () => {
+    expect(getLatestInboundMessageId('-100')).toBeNull()
+  })
+
+  it('returns the highest-ts inbound message_id for a chat', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'a' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 2, user: 'a', user_id: '1', ts: 200, text: 'b' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 3, user: 'a', user_id: '1', ts: 150, text: 'c' })
+    // ts=200 wins even though id 3 > id 2 but lower ts.
+    expect(getLatestInboundMessageId('-100')).toBe(2)
+  })
+
+  it('ignores outbound (assistant) messages', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'hi' })
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [2],
+      texts: ['bot reply'],
+      ts: 200,
+    })
+    // Assistant row has higher ts but must not be returned.
+    expect(getLatestInboundMessageId('-100')).toBe(1)
+  })
+
+  it('scopes by thread when threadId passed', () => {
+    recordInbound({ chat_id: '-100', thread_id: 7, message_id: 10, user: 'a', user_id: '1', ts: 100, text: 'topicA' })
+    recordInbound({ chat_id: '-100', thread_id: 8, message_id: 20, user: 'a', user_id: '1', ts: 200, text: 'topicB' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 30, user: 'a', user_id: '1', ts: 300, text: 'root' })
+
+    expect(getLatestInboundMessageId('-100', 7)).toBe(10)
+    expect(getLatestInboundMessageId('-100', 8)).toBe(20)
+    expect(getLatestInboundMessageId('-100', null)).toBe(30)
+    // Omitted thread → any thread (highest ts wins).
+    expect(getLatestInboundMessageId('-100')).toBe(30)
+  })
+
+  it('isolates chats', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'a' })
+    recordInbound({ chat_id: '-200', thread_id: null, message_id: 99, user: 'b', user_id: '2', ts: 100, text: 'b' })
+    expect(getLatestInboundMessageId('-100')).toBe(1)
+    expect(getLatestInboundMessageId('-200')).toBe(99)
+    expect(getLatestInboundMessageId('-300')).toBeNull()
+  })
+})
+
+describe('recordOutbound', () => {
+  beforeEach(() => initHistory(stateDir, 30))
+
+  it('records a single-chunk reply', () => {
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [42],
+      texts: ['the answer'],
+      ts: 500,
+    })
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]).toMatchObject({
+      message_id: 42,
+      role: 'assistant',
+      text: 'the answer',
+      group_id: 42,
+    })
+  })
+
+  it('records each chunk of a multi-chunk reply with shared group_id', () => {
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [10, 11, 12],
+      texts: ['part 1', 'part 2', 'part 3'],
+      ts: 500,
+    })
+    const rows = query({ chat_id: '-100' })
+    expect(rows).toHaveLength(3)
+    expect(rows.map(r => r.message_id)).toEqual([10, 11, 12])
+    expect(rows.map(r => r.group_id)).toEqual([10, 10, 10])
+    expect(rows.map(r => r.text)).toEqual(['part 1', 'part 2', 'part 3'])
+  })
+
+  it('interleaves correctly with inbound when sorted by ts', () => {
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'q1' })
+    recordOutbound({ chat_id: '-100', thread_id: null, message_ids: [2], texts: ['a1'], ts: 200 })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 3, user: 'a', user_id: '1', ts: 300, text: 'q2' })
+    recordOutbound({ chat_id: '-100', thread_id: null, message_ids: [4], texts: ['a2'], ts: 400 })
+    const rows = query({ chat_id: '-100' })
+    expect(rows.map(r => `${r.role}:${r.text}`)).toEqual([
+      'user:q1',
+      'assistant:a1',
+      'user:q2',
+      'assistant:a2',
+    ])
+  })
+})
+
+describe('recordEdit', () => {
+  beforeEach(() => initHistory(stateDir, 30))
+
+  it('updates an existing outbound row', () => {
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: null,
+      message_ids: [42],
+      texts: ['original'],
+      ts: 500,
+    })
+    recordEdit({ chat_id: '-100', message_id: 42, text: 'edited' })
+    const rows = query({ chat_id: '-100' })
+    expect(rows[0]?.text).toBe('edited')
+  })
+
+  it('is a silent no-op for missing rows', () => {
+    expect(() =>
+      recordEdit({ chat_id: '-100', message_id: 999, text: 'oops' }),
+    ).not.toThrow()
+    expect(query({ chat_id: '-100' })).toHaveLength(0)
+  })
+
+  it('updates the row regardless of thread (Telegram message_ids are chat-unique)', () => {
+    recordOutbound({
+      chat_id: '-100',
+      thread_id: 7,
+      message_ids: [42],
+      texts: ['original in thread 7'],
+      ts: 500,
+    })
+    // Edit without knowing the thread — should still update the row.
+    recordEdit({ chat_id: '-100', message_id: 42, text: 'edited' })
+    const rows = query({ chat_id: '-100', thread_id: 7 })
+    expect(rows[0]?.text).toBe('edited')
+  })
+})
+
+describe('retention sweep', () => {
+  it('deletes rows older than retentionDays on init', () => {
+    initHistory(stateDir, 30)
+    const oldTs = Math.floor(Date.now() / 1000) - 40 * 86400
+    const recentTs = Math.floor(Date.now() / 1000) - 5 * 86400
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: oldTs, text: 'ancient' })
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 2, user: 'a', user_id: '1', ts: recentTs, text: 'recent' })
+    // Re-init to fire the sweep
+    _resetForTests()
+    initHistory(stateDir, 30)
+    const rows = query({ chat_id: '-100' })
+    expect(rows.map(r => r.text)).toEqual(['recent'])
+  })
+
+  it('retentionDays=0 disables the sweep', () => {
+    initHistory(stateDir, 0)
+    const ancientTs = Math.floor(Date.now() / 1000) - 365 * 86400
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: ancientTs, text: 'ancient' })
+    _resetForTests()
+    initHistory(stateDir, 0)
+    expect(query({ chat_id: '-100' })).toHaveLength(1)
+  })
+})
+
+describe('getRecentOutboundCount (backstop dedup helper)', () => {
+  it('counts assistant messages within the time window', () => {
+    initHistory(stateDir, 30)
+    const now = Math.floor(Date.now() / 1000)
+    recordOutbound({ chat_id: '-100', thread_id: null, message_ids: [10], texts: ['reply 1'], ts: now })
+    recordOutbound({ chat_id: '-100', thread_id: null, message_ids: [11], texts: ['reply 2'], ts: now - 1 })
+    // Message outside the 2-second window
+    recordOutbound({ chat_id: '-100', thread_id: null, message_ids: [9], texts: ['old reply'], ts: now - 5 })
+
+    expect(getRecentOutboundCount('-100', 2)).toBe(2)
+    expect(getRecentOutboundCount('-100', 10)).toBe(3)
+  })
+
+  it('returns 0 when no outbound messages exist', () => {
+    initHistory(stateDir, 30)
+    expect(getRecentOutboundCount('-100', 2)).toBe(0)
+  })
+
+  it('does not count inbound messages', () => {
+    initHistory(stateDir, 30)
+    const now = Math.floor(Date.now() / 1000)
+    recordInbound({ chat_id: '-100', thread_id: null, message_id: 10, user: 'u', user_id: '1', ts: now, text: 'user msg' })
+    expect(getRecentOutboundCount('-100', 2)).toBe(0)
+  })
+
+  it('scopes to the specified chat_id', () => {
+    initHistory(stateDir, 30)
+    const now = Math.floor(Date.now() / 1000)
+    recordOutbound({ chat_id: '-100', thread_id: null, message_ids: [10], texts: ['in chat -100'], ts: now })
+    recordOutbound({ chat_id: '-200', thread_id: null, message_ids: [11], texts: ['in chat -200'], ts: now })
+    expect(getRecentOutboundCount('-100', 2)).toBe(1)
+    expect(getRecentOutboundCount('-200', 2)).toBe(1)
+  })
+})

package/telegram-plugin/tests/html-balanced.ts

@@ -0,0 +1,63 @@
+/**
+ * Tiny HTML tag-balance validator for the Telegram allowlist.
+ *
+ * Replaces fast-check (not a current dep, see #662 P1) — paired with
+ * vitest `it.each` it gives us property-style coverage across many
+ * randomised renderer inputs without a new dependency.
+ *
+ * Telegram's HTML parser only accepts a small allowlist of tags
+ * (https://core.telegram.org/bots/api#html-style). Anything outside
+ * the allowlist is treated as raw text — we don't try to validate it.
+ *
+ * Self-closing tags inside Telegram's allowlist: only `<br/>` (and even
+ * that is normalised to `\n`). We treat any `<x/>` as self-closing for
+ * robustness, but emit nothing into the stack.
+ */
+
+const ALLOWED = new Set([
+  'b', 'strong',
+  'i', 'em',
+  'u', 'ins',
+  's', 'strike', 'del',
+  'a',
+  'code',
+  'pre',
+  'tg-spoiler',
+  'span',
+  'tg-emoji',
+  'blockquote',
+  'br',
+])
+
+export interface BalanceResult {
+  balanced: boolean
+  openTags: string[]
+  extraCloses: string[]
+}
+
+export function isBalancedHtml(html: string): BalanceResult {
+  const stack: string[] = []
+  const extraCloses: string[] = []
+  // Match tags but skip HTML entities (`&lt;` etc) — those are NOT tags.
+  const re = /<\/?\s*([A-Za-z][A-Za-z0-9-]*)([^>]*)>/g
+  let m: RegExpExecArray | null
+  while ((m = re.exec(html)) !== null) {
+    const raw = m[0]
+    const name = m[1].toLowerCase()
+    if (!ALLOWED.has(name)) continue
+    const isClose = raw.startsWith('</')
+    const selfClose = raw.endsWith('/>') || name === 'br'
+    if (selfClose && !isClose) continue
+    if (isClose) {
+      const top = stack[stack.length - 1]
+      if (top === name) {
+        stack.pop()
+      } else {
+        extraCloses.push(name)
+      }
+    } else {
+      stack.push(name)
+    }
+  }
+  return { balanced: stack.length === 0 && extraCloses.length === 0, openTags: stack, extraCloses }
+}

package/telegram-plugin/tests/html-sanitize.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Unit tests for the Telegram-HTML sanitizer (issue #657).
+ *
+ * The sanitizer is the pre-validation layer that runs after
+ * markdownToHtml() and before bot.api.sendMessage. Its job is to
+ * guarantee that whatever HTML it emits, Telegram will accept under
+ * parse_mode=HTML — closing the `400 Bad Request: can't parse entities`
+ * loophole that produced the duplicate-message symptom in #657.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  sanitizeTelegramHtml,
+  htmlToPlainText,
+  escapeAllHtml,
+} from '../html-sanitize.js'
+
+describe('sanitizeTelegramHtml', () => {
+  it('passes whitelisted tags through unchanged', () => {
+    expect(sanitizeTelegramHtml('<b>bold</b>')).toBe('<b>bold</b>')
+    expect(sanitizeTelegramHtml('<i>italic</i>')).toBe('<i>italic</i>')
+    expect(sanitizeTelegramHtml('<code>x</code>')).toBe('<code>x</code>')
+    expect(sanitizeTelegramHtml('<pre>block</pre>')).toBe('<pre>block</pre>')
+    expect(sanitizeTelegramHtml('<blockquote>q</blockquote>')).toBe('<blockquote>q</blockquote>')
+  })
+
+  it('escapes unknown tags', () => {
+    expect(sanitizeTelegramHtml('<frobnicate>x</frobnicate>')).toBe(
+      '&lt;frobnicate&gt;x&lt;/frobnicate&gt;',
+    )
+    expect(sanitizeTelegramHtml('<div>hi</div>')).toBe('&lt;div&gt;hi&lt;/div&gt;')
+  })
+
+  it('escapes stray < that does not open a tag', () => {
+    expect(sanitizeTelegramHtml('1 < 2 < 3')).toBe('1 &lt; 2 &lt; 3')
+    expect(sanitizeTelegramHtml('a < b')).toBe('a &lt; b')
+  })
+
+  it('auto-closes unclosed whitelisted tags', () => {
+    expect(sanitizeTelegramHtml('<b>unfinished')).toBe('<b>unfinished</b>')
+    expect(sanitizeTelegramHtml('<b><i>nested')).toBe('<b><i>nested</i></b>')
+  })
+
+  it('drops unmatched closing tags', () => {
+    expect(sanitizeTelegramHtml('hello</b>')).toBe('hello')
+    expect(sanitizeTelegramHtml('</i>plain')).toBe('plain')
+  })
+
+  it('auto-closes inner tags when an outer is closed early', () => {
+    // <b><i>x</b>  →  <b><i>x</i></b>
+    const out = sanitizeTelegramHtml('<b><i>x</b>')
+    expect(out).toBe('<b><i>x</i></b>')
+  })
+
+  it('strips disallowed attributes', () => {
+    expect(sanitizeTelegramHtml('<b class="evil" onclick="x()">x</b>')).toBe('<b>x</b>')
+    // <code class> is allowed
+    expect(sanitizeTelegramHtml('<code class="language-ts">x</code>')).toBe(
+      '<code class="language-ts">x</code>',
+    )
+  })
+
+  it('blocks dangerous href schemes', () => {
+    expect(sanitizeTelegramHtml('<a href="javascript:alert(1)">x</a>')).toBe('<a>x</a>')
+    expect(sanitizeTelegramHtml('<a href="data:text/html,x">x</a>')).toBe('<a>x</a>')
+    expect(sanitizeTelegramHtml('<a href="https://example.com">x</a>')).toBe(
+      '<a href="https://example.com">x</a>',
+    )
+  })
+
+  it('escapes naked ampersands but preserves entities', () => {
+    expect(sanitizeTelegramHtml('a & b')).toBe('a &amp; b')
+    expect(sanitizeTelegramHtml('a &amp; b')).toBe('a &amp; b')
+    expect(sanitizeTelegramHtml('a &lt;b&gt;')).toBe('a &lt;b&gt;')
+    expect(sanitizeTelegramHtml('a &#123;')).toBe('a &#123;')
+  })
+
+  it('is idempotent', () => {
+    const fixtures = [
+      '<b>x</b>',
+      '<b><i>nested</i></b>',
+      '<b>unclosed',
+      '<frobnicate>x</frobnicate>',
+      '1 < 2',
+      '<b><i>x</b>',
+      'a & b & c',
+    ]
+    for (const f of fixtures) {
+      const once = sanitizeTelegramHtml(f)
+      const twice = sanitizeTelegramHtml(once)
+      expect(twice).toBe(once)
+    }
+  })
+
+  it('handles the #657 repro fixture (1799-char "Where I route" message shape)', () => {
+    // Reconstruct the structural shape of the body that tripped Telegram.
+    // The exact text isn't checked into the repo; what matters is the
+    // pattern: nested <code> inside <b> inside <pre>, plus a stray `<`
+    // in the middle of the prose, plus an unclosed tag near the end.
+    const fixture = [
+      '<b>Where I route:</b>',
+      '',
+      '<pre><b><code>switchroom &lt;cmd&gt;</code></b></pre>',
+      '',
+      'When the user types `cmd <args>` in the bridge, the gateway forwards…',
+      '',
+      '<b>Some unclosed bold here',
+      '<frobnicate>not a real tag</frobnicate>',
+    ].join('\n')
+
+    const out = sanitizeTelegramHtml(fixture)
+
+    // Must not contain any unknown tag literally.
+    expect(out).not.toMatch(/<frobnicate/)
+    // Stray < (in `cmd <args>`) is escaped.
+    expect(out).toContain('&lt;args&gt;')
+    // The unclosed <b> at end has been auto-closed.
+    const opens = (out.match(/<b\b[^>]*>/g) ?? []).length
+    const closes = (out.match(/<\/b>/g) ?? []).length
+    expect(opens).toBe(closes)
+  })
+
+  it('treats an attribute on a void/unknown tag like any unknown tag', () => {
+    expect(sanitizeTelegramHtml('<img src="x">')).toBe('&lt;img src="x"&gt;')
+  })
+
+  it('preserves blockquote expandable bare attribute', () => {
+    expect(sanitizeTelegramHtml('<blockquote expandable>x</blockquote>')).toBe(
+      '<blockquote expandable>x</blockquote>',
+    )
+  })
+})
+
+describe('htmlToPlainText', () => {
+  it('strips tags and unescapes entities', () => {
+    expect(htmlToPlainText('<b>hi</b>')).toBe('hi')
+    expect(htmlToPlainText('<b>a</b> &lt;b&gt; c')).toBe('a <b> c')
+    expect(htmlToPlainText('a &amp; b')).toBe('a & b')
+  })
+})
+
+describe('escapeAllHtml', () => {
+  it('escapes all three HTML metachars', () => {
+    expect(escapeAllHtml('<b>&hi</b>')).toBe('&lt;b&gt;&amp;hi&lt;/b&gt;')
+  })
+})

package/telegram-plugin/tests/idle-footer-wiring.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Integration test for the idle-footer wiring layer.
+ *
+ * Tests the composed pipeline:
+ *   findRecentTurnsForChat → TurnRow mapping → formatIdleFooter
+ *
+ * These must run under Bun (bun:sqlite). Run via:
+ *   bun test telegram-plugin/tests/idle-footer-wiring.test.ts
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  openTurnsDbInMemory,
+  recordTurnStart,
+  recordTurnEnd,
+  findRecentTurnsForChat,
+} from '../registry/turns-schema.js'
+import { formatIdleFooter, type TurnRow } from '../idle-footer.js'
+
+/** Map Turn rows (from findRecentTurnsForChat) into the TurnRow shape that formatIdleFooter expects. */
+function toFooterRows(rows: ReturnType<typeof findRecentTurnsForChat>): TurnRow[] {
+  return rows.map(r => ({
+    turnKey: r.turn_key,
+    chatId: r.chat_id,
+    startedAt: r.started_at,
+    endedAt: r.ended_at,
+  }))
+}
+
+describe('idle-footer wiring pipeline', () => {
+  it('renders "quiet · no turns yet" when the DB has no turns for the chat', () => {
+    const db = openTurnsDbInMemory()
+    const rows = findRecentTurnsForChat(db, 'chat_empty')
+    const footer = formatIdleFooter(toFooterRows(rows), Date.now())
+    expect(footer).toBe('🟡 quiet · no turns yet')
+    db.close()
+  })
+
+  it('renders "working since" when the most recent turn is still running', () => {
+    const db = openTurnsDbInMemory()
+    const startedAt = Date.now() - 3 * 60_000 // 3 minutes ago
+    recordTurnStart(db, { turnKey: 'turn_live', chatId: 'chat_1' })
+    // Backdate started_at so the "ago" formatting is predictable.
+    db.prepare(`UPDATE turns SET started_at = ? WHERE turn_key = 'turn_live'`).run(startedAt)
+
+    const rows = findRecentTurnsForChat(db, 'chat_1', 1)
+    const footer = formatIdleFooter(toFooterRows(rows), Date.now())
+    expect(footer).toContain('⚙️ working since')
+    expect(footer).toContain('3m ago')
+    db.close()
+  })
+
+  it('renders "idle · last reply" when the most recent turn has ended', () => {
+    const db = openTurnsDbInMemory()
+    const endedAt = Date.now() - 12 * 60_000 // 12 minutes ago
+    recordTurnStart(db, { turnKey: 'turn_past', chatId: 'chat_2' })
+    recordTurnEnd(db, { turnKey: 'turn_past', endedVia: 'stop' })
+    // Backdate ended_at so the "ago" formatting is predictable.
+    db.prepare(`UPDATE turns SET ended_at = ? WHERE turn_key = 'turn_past'`).run(endedAt)
+
+    const rows = findRecentTurnsForChat(db, 'chat_2', 1)
+    const footer = formatIdleFooter(toFooterRows(rows), Date.now())
+    expect(footer).toContain('🟢 idle · last reply')
+    expect(footer).toContain('12m ago')
+    db.close()
+  })
+
+  it('uses the most recently STARTED turn (not most recently ended)', () => {
+    const db = openTurnsDbInMemory()
+    const now = Date.now()
+
+    // turn_a: started earlier, ended later
+    recordTurnStart(db, { turnKey: 'turn_a', chatId: 'chat_3' })
+    db.prepare(`UPDATE turns SET started_at = ? WHERE turn_key = 'turn_a'`).run(now - 20 * 60_000)
+    recordTurnEnd(db, { turnKey: 'turn_a', endedVia: 'stop' })
+    db.prepare(`UPDATE turns SET ended_at = ? WHERE turn_key = 'turn_a'`).run(now - 1 * 60_000)
+
+    // turn_b: started more recently, still running
+    recordTurnStart(db, { turnKey: 'turn_b', chatId: 'chat_3' })
+    db.prepare(`UPDATE turns SET started_at = ? WHERE turn_key = 'turn_b'`).run(now - 5 * 60_000)
+
+    const rows = findRecentTurnsForChat(db, 'chat_3', 2)
+    const footer = formatIdleFooter(toFooterRows(rows), now)
+    // turn_b has the larger started_at; its ended_at is null → "working since"
+    expect(footer).toContain('⚙️ working since')
+    db.close()
+  })
+})