switchroom 0.16.29 → 0.16.46

package/telegram-plugin/tests/formatting-parse-regression.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Parse-level formatting regression suite.
+ *
+ * GOAL: catch formatting regressions at the *parse* level, not the string
+ * level. For every torture-set fixture we run the raw intent through the SAME
+ * outbound transform pipeline the gateway uses, then assert TWO independent
+ * signals via `rich-markdown-oracle.ts` (an independent CommonMark/GFM
+ * validator — NOT the formatter echoing itself):
+ *
+ *   (a) PARSE-ACCEPT — every emitted chunk is well-formed enough that
+ *       Telegram's rich-message path would not 400 on it (balanced fences,
+ *       terminated code spans, closed links, complete table rows, balanced
+ *       emphasis). This is the signal that would have caught "we shipped
+ *       markdown Telegram rejects."
+ *
+ *   (b) STRUCTURE — the transformed body parses into the entity structure the
+ *       fixture intended (bold/italic/code/pre/link at the right inner text).
+ *
+ * The pipeline mirrors `telegram-plugin/gateway/gateway.ts`:
+ *   repairEscapedWhitespace -> normalizeParagraphBreaks -> addParagraphSpacers
+ *   -> splitMarkdownChunks. (Card-surface fixtures also apply `normalizeDashes`
+ *   first — that is where F1's voice scrub lives.)
+ *
+ * This suite is TEST-ONLY. It changes no production formatting behaviour. If a
+ * fixture ever fails signal (a), it means the formatter emits markdown Telegram
+ * would reject — a real regression, not a test to relax.
+ */
+
+import { describe, test, expect } from 'vitest'
+import {
+  repairEscapedWhitespace,
+  normalizeParagraphBreaks,
+  addParagraphSpacers,
+  splitMarkdownChunks,
+  RICH_MESSAGE_MAX_CHARS,
+} from '../format.js'
+import { normalizeDashes } from '../text-voice-scrub.js'
+import {
+  validateRichMarkdown,
+  isRichMarkdownValid,
+  parseRichEntities,
+  entitiesOfType,
+  scanFences,
+  type RichEntity,
+} from './rich-markdown-oracle.js'
+import { TORTURE_SET, type TortureFixture, type ExpectEntity } from './formatting-torture-set.js'
+
+/**
+ * The outbound transform, mirroring the gateway. `cardSurfaceScrub` prepends
+ * the voice-scrub pass (F1's surface). `cap` overrides the chunk cap so the
+ * F7 hard-slice path is reachable in a test without a 32k fixture.
+ */
+function transform(input: string, opts: { cardSurfaceScrub?: boolean; cap?: number } = {}): {
+  chunks: string[]
+  /** The full transformed body BEFORE chunking — used for structure assertions. */
+  body: string
+} {
+  let text = input
+  if (opts.cardSurfaceScrub) text = normalizeDashes(text)
+  text = normalizeParagraphBreaks(repairEscapedWhitespace(text))
+  const body = addParagraphSpacers(text)
+  const chunks = splitMarkdownChunks(body, opts.cap ?? RICH_MESSAGE_MAX_CHARS)
+  return { chunks, body }
+}
+
+/** Assert an expected entity is present among `got` (membership, not index). */
+function expectEntityPresent(got: ReadonlyArray<RichEntity>, want: ExpectEntity): void {
+  const match = got.find(
+    (e) =>
+      e.type === want.type &&
+      e.text === want.text &&
+      (want.url == null || e.url === want.url) &&
+      (want.lang == null || e.lang === want.lang),
+  )
+  expect(
+    match,
+    `expected a ${want.type} entity with text ${JSON.stringify(want.text)}` +
+      (want.url != null ? ` url ${want.url}` : '') +
+      (want.lang != null ? ` lang ${want.lang}` : '') +
+      `; got: ${JSON.stringify(got)}`,
+  ).toBeDefined()
+}
+
+// ---------------------------------------------------------------------------
+// Oracle self-tests — prove the oracle is a real, non-vacuous validator.
+// If the oracle accepted everything (signal a) or found nothing (signal b),
+// the whole suite would be a rubber stamp. These guard against that.
+// ---------------------------------------------------------------------------
+
+describe('rich-markdown-oracle — self-tests (guards against a vacuous oracle)', () => {
+  test('parse-accept: rejects an UNCLOSED fenced code block', () => {
+    const bad = 'intro\n```bash\necho hi\n' // no closing ```
+    const issues = validateRichMarkdown(bad)
+    expect(issues.some((i) => i.kind === 'unbalanced-fence')).toBe(true)
+  })
+
+  test('parse-accept: rejects an unterminated inline code span', () => {
+    const issues = validateRichMarkdown('here is `unclosed code')
+    expect(issues.some((i) => i.kind === 'unterminated-code-span')).toBe(true)
+  })
+
+  test('parse-accept: rejects an unclosed inline link destination', () => {
+    const issues = validateRichMarkdown('see [label](https://example.com/path')
+    expect(issues.some((i) => i.kind === 'malformed-link')).toBe(true)
+  })
+
+  test('parse-accept: rejects a bisected (half) table row', () => {
+    const issues = validateRichMarkdown('| a | b')
+    expect(issues.some((i) => i.kind === 'incomplete-table-row')).toBe(true)
+  })
+
+  test('parse-accept: rejects an unbalanced ** bold delimiter', () => {
+    const issues = validateRichMarkdown('this is **bold with no close')
+    expect(issues.some((i) => i.kind === 'unbalanced-emphasis')).toBe(true)
+  })
+
+  test('parse-accept: ACCEPTS well-formed markdown with mixed entities', () => {
+    const good =
+      'Intro **bold** and _italic_ and `code`.\n\n```js\nconst x = 1\n```\n\n| a | b |\n| --- | --- |\n| 1 | 2 |\n\nSee [x](https://e.com).'
+    expect(validateRichMarkdown(good)).toEqual([])
+  })
+
+  test('structure: extracts bold/italic/code/pre/link at the right text', () => {
+    const md = 'A **b** and _i_ and `c`.\n```py\nprint(1)\n```\n[lab](https://u.co)'
+    const ents = parseRichEntities(md)
+    expect(ents).toContainEqual({ type: 'bold', text: 'b' })
+    expect(ents).toContainEqual({ type: 'italic', text: 'i' })
+    expect(ents).toContainEqual({ type: 'code', text: 'c' })
+    expect(ents).toContainEqual({ type: 'pre', text: 'print(1)', lang: 'py' })
+    expect(ents).toContainEqual({ type: 'link', text: 'lab', url: 'https://u.co' })
+  })
+
+  test('inline code interior is verbatim — reserved chars do not leak as entities', () => {
+    // `*not bold*` inside code must NOT produce a bold/italic entity.
+    const ents = parseRichEntities('literal `*x*` here')
+    expect(ents.filter((e) => e.type === 'bold' || e.type === 'italic')).toEqual([])
+    expect(ents).toContainEqual({ type: 'code', text: '*x*' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+// The torture set — signal (a) + (b) for every fixture.
+// ---------------------------------------------------------------------------
+
+describe('formatting torture-set — parse-accept + structure', () => {
+  // F7 is the deliberate degraded path: a >cap indivisible fenced block is
+  // hard-sliced, so its individual chunks are intentionally NOT balanced
+  // markdown. Handled separately below.
+  const standard = TORTURE_SET.filter((f) => f.name !== 'F7-over-cap-hard-slice')
+
+  for (const fx of standard) {
+    describe(fx.name, () => {
+      test(`(intent) ${fx.intent}`, () => {
+        // (a) PARSE-ACCEPT — every emitted chunk is well-formed.
+        const { chunks, body } = transform(fx.input, { cardSurfaceScrub: fx.cardSurfaceScrub })
+        for (const c of chunks) {
+          const issues = validateRichMarkdown(c)
+          expect(
+            issues,
+            `chunk failed parse-accept for fixture "${fx.name}":\n${c}\nissues: ${JSON.stringify(issues)}`,
+          ).toEqual([])
+        }
+
+        // (b) STRUCTURE — the transformed body parses into the intended shape.
+        const ents = parseRichEntities(body)
+        for (const want of fx.expect) expectEntityPresent(ents, want)
+      })
+    })
+  }
+
+  // ── F1 extra assertion: the em/en-dash glyph is actually gone. ────────────
+  test('F1: card-surface scrub removes the em/en-dash glyph before the wire', () => {
+    const fx = TORTURE_SET.find((f) => f.name === 'F1-card-surface-dash-scrub')!
+    const { body } = transform(fx.input, { cardSurfaceScrub: true })
+    expect(body).not.toContain('—') // em dash
+    expect(body).not.toContain('–') // en dash
+    // And the scrubbed body is still parse-accept clean.
+    expect(isRichMarkdownValid(body)).toBe(true)
+  })
+
+  // ── F2 extra assertion: the paragraph break survives (not collapsed). ─────
+  test('F2: a loose interior pipe does not swallow the following paragraph break', () => {
+    const fx = TORTURE_SET.find((f) => f.name === 'F2-stray-pipe-keeps-paragraph-spacing')!
+    const { body } = transform(fx.input)
+    // Both paragraphs are present and separated by a blank line (>= one \n\n).
+    expect(body).toContain('plan A | plan B')
+    expect(body).toContain('one pass')
+    expect(body).toMatch(/\n\s*\n/) // a real paragraph gap survived
+    // The loose pipe line must NOT have been turned into / read as a table
+    // row — the oracle would flag a half-row; it must be clean.
+    expect(isRichMarkdownValid(body)).toBe(true)
+  })
+
+  // ── F4 extra assertion: a blank line now separates the fence from prose. ──
+  test('F4: a blank line is inserted between a closed fence and the following prose', () => {
+    const fx = TORTURE_SET.find((f) => f.name === 'F4-blank-line-after-closed-fence')!
+    const { body } = transform(fx.input)
+    // The fence stays balanced (closed) and the trailing prose survives.
+    const { fences } = scanFences(body)
+    expect(fences.length).toBe(1)
+    expect(fences[0].closed).toBe(true)
+    expect(body).toContain('And it ships today.')
+    // The line immediately following the fence close is blank (the F4 fix).
+    const lines = body.split('\n')
+    const closeIdx = lines.findIndex((l, i) => i > 0 && /^```/.test(l.trim()) && lines[i - 1] !== '```')
+    // Find the LAST fence-close line then assert the next non-fence line has a
+    // blank between it and the fence.
+    const fenceCloseLine = lines.map((l) => l.trim()).lastIndexOf('```')
+    expect(fenceCloseLine).toBeGreaterThan(0)
+    expect(lines[fenceCloseLine + 1] ?? '').toBe('')
+    void closeIdx
+  })
+})
+
+// ---------------------------------------------------------------------------
+// F7 — over-cap indivisible block hard-slices (degraded-but-delivered).
+// Signal (a) does NOT apply per-chunk here by design (a hard slice can bisect
+// a fence). What MUST hold: no content is dropped and every chunk fits the cap.
+// ---------------------------------------------------------------------------
+
+describe('F7-over-cap-hard-slice', () => {
+  const fx = TORTURE_SET.find((f) => f.name === 'F7-over-cap-hard-slice')!
+  const CAP = 100
+
+  test('an oversized indivisible fenced block is sliced to <= cap chunks, losing no content', () => {
+    const { chunks } = transform(fx.input, { cap: CAP })
+    expect(chunks.length).toBeGreaterThan(1)
+    for (const c of chunks) expect(c.length).toBeLessThanOrEqual(CAP)
+    // No content dropped: the slices concatenate back to the original body.
+    // (The transform is a no-op on this fixture apart from chunking — it has no
+    // prose paragraphs to space, so body === input here.)
+    expect(chunks.join('')).toContain('x'.repeat(600))
+  })
+
+  test('the UN-chunked body is itself parse-accept valid (the fence is balanced)', () => {
+    // Sanity: the corruption F7 accepts is ONLY the intra-chunk fence bisection
+    // forced by the cap — the body as a whole is well-formed. This guards
+    // against F7 silently masking a genuine unbalanced-fence bug in the source.
+    const { body } = transform(fx.input, { cap: RICH_MESSAGE_MAX_CHARS })
+    expect(isRichMarkdownValid(body)).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Wiring-level: the fake bot API surfaces parsed entities on the rich path so
+// a test can assert structure at the send boundary (deliverable 3). This uses
+// the SAME independent oracle, keeping the check non-circular.
+// ---------------------------------------------------------------------------
+
+describe('wiring: sendRichMessage entity structure at the send boundary', () => {
+  test('a rich send of a torture body lands parse-valid with the intended entities', async () => {
+    const { createFakeBotApi } = await import('./fake-bot-api.js')
+    const bot = createFakeBotApi()
+    const fx = TORTURE_SET.find((f) => f.name === 'links')!
+    const { body } = transform(fx.input)
+
+    await bot.api.sendRichMessage('chat-1', { markdown: body })
+    const sent = bot.messagesIn('chat-1')
+    expect(sent).toHaveLength(1)
+    expect(sent[0].rich).toBe(true)
+
+    // Re-derive entities from what actually landed on the wire (sent[0].text is
+    // the rich markdown body) using the independent oracle.
+    const landed = sent[0].text
+    expect(isRichMarkdownValid(landed)).toBe(true)
+    for (const want of fx.expect) expectEntityPresent(parseRichEntities(landed), want)
+  })
+})
+
+// Keep a reference so unused-import lint never trips on entitiesOfType even if
+// a future edit drops its only direct use.
+void entitiesOfType

package/telegram-plugin/tests/formatting-torture-set.ts

@@ -0,0 +1,218 @@
+/**
+ * formatting-torture-set — curated fixtures for parse-level formatting
+ * regression testing.
+ *
+ * Each fixture is an INTENT (`input`) plus the STRUCTURE we expect the
+ * formatter's output to parse into (checked by `rich-markdown-oracle.ts`).
+ * The `input` is the raw text as a model/card surface would author it — the
+ * regression test runs it through the SAME outbound transform pipeline the
+ * gateway uses (repairEscapedWhitespace -> normalizeParagraphBreaks ->
+ * addParagraphSpacers -> splitMarkdownChunks) and then asserts:
+ *
+ *   (a) every emitted chunk is parse-accept valid (no rich-path 400), and
+ *   (b) the concatenated output parses into `expect` (entity structure).
+ *
+ * The `expect` block describes WHAT should survive, not a byte-for-byte echo
+ * of formatter output — the oracle is independent of the formatter, so this is
+ * a genuine cross-check, not a circular self-comparison.
+ *
+ * F1/F2/F4/F7 fixtures reproduce the specific formatting fixes from PR #2737
+ * (see `telegram-plugin/format.ts` and `text-voice-scrub.ts`).
+ */
+
+import type { EntityType } from './rich-markdown-oracle.js'
+
+export interface ExpectEntity {
+  readonly type: EntityType
+  /** Exact inner text the entity should carry. */
+  readonly text: string
+  /** For links, the destination. */
+  readonly url?: string
+  /** For fenced blocks, the language info string. */
+  readonly lang?: string
+}
+
+export interface TortureFixture {
+  readonly name: string
+  /** One-line description of the intent this fixture pins. */
+  readonly intent: string
+  /** Raw authored input, before the outbound transform pipeline. */
+  readonly input: string
+  /**
+   * Entities we expect to find in the transformed output. The test asserts
+   * every listed entity is PRESENT (membership), not that these are the only
+   * entities — spacer/structure passes may add nothing observable to the
+   * entity set. Empty ⇒ only signal (a) is asserted for this fixture.
+   */
+  readonly expect: ReadonlyArray<ExpectEntity>
+  /**
+   * When set, the raw input is EXPECTED to be scrubbed by the card-surface
+   * voice pass (F1) before it reaches the rich path — the test applies
+   * `normalizeDashes` first and asserts the em/en-dash glyph is gone.
+   */
+  readonly cardSurfaceScrub?: boolean
+}
+
+export const TORTURE_SET: ReadonlyArray<TortureFixture> = [
+  // ── Multi-item bullet list — one fact per bullet ──────────────────────────
+  {
+    name: 'multi-item-bullet-list',
+    intent: 'A plain multi-item bullet list stays parse-valid and keeps its items intact',
+    input: [
+      'Findings:',
+      '- Master Bath 1 is clean',
+      '- Master Bath 2 shows 33% loss',
+      '- Cabinet is clean',
+    ].join('\n'),
+    expect: [],
+  },
+
+  // ── Middot (·) separator INSIDE a bullet — the collapsed-inline case ──────
+  {
+    name: 'middot-separator-inside-bullet',
+    intent: 'A collapsed one-line bullet list using `·` separators splits without corrupting entities',
+    input: '- Master Bath 1, clean · **Master Bath 2**, 33% loss · Cabinet, clean',
+    expect: [{ type: 'bold', text: 'Master Bath 2' }],
+  },
+
+  // ── Em-dash in prose (voice scrub is a DIFFERENT surface — see F1) ────────
+  {
+    name: 'em-dash-in-prose',
+    intent: 'Prose containing an em-dash is parse-valid on the rich path (raw, un-scrubbed)',
+    input: 'The audit is done — every surface checked, nothing left open.',
+    expect: [],
+  },
+
+  // ── Wide / long code block ────────────────────────────────────────────────
+  {
+    name: 'wide-long-code-block',
+    intent: 'A fenced code block with a long line and reserved chars stays balanced and verbatim',
+    input: [
+      'Run this:',
+      '```bash',
+      'grep -rnE "foo\\|bar\\|baz" src/ | awk -F: \'{print $1}\' | sort -u  # a very very very long command line that keeps going and going',
+      'echo "done"',
+      '```',
+    ].join('\n'),
+    expect: [
+      {
+        type: 'pre',
+        lang: 'bash',
+        text: [
+          'grep -rnE "foo\\|bar\\|baz" src/ | awk -F: \'{print $1}\' | sort -u  # a very very very long command line that keeps going and going',
+          'echo "done"',
+        ].join('\n'),
+      },
+    ],
+  },
+
+  // ── A GFM table ───────────────────────────────────────────────────────────
+  {
+    name: 'gfm-table',
+    intent: 'A GFM table stays row-complete (no bisected/half rows) and parse-valid',
+    input: [
+      'Results:',
+      '',
+      '| Surface | Status | Loss |',
+      '| --- | --- | --- |',
+      '| Bath 1 | clean | 0% |',
+      '| Bath 2 | flagged | 33% |',
+    ].join('\n'),
+    expect: [],
+  },
+
+  // ── A nested list ─────────────────────────────────────────────────────────
+  {
+    name: 'nested-list',
+    intent: 'A nested bullet list stays parse-valid with inline emphasis preserved',
+    input: [
+      '- Top level one',
+      '  - Nested **bold** item',
+      '  - Nested plain item',
+      '- Top level two',
+    ].join('\n'),
+    expect: [{ type: 'bold', text: 'bold' }],
+  },
+
+  // ── A long line that wraps ────────────────────────────────────────────────
+  {
+    name: 'long-wrapping-line',
+    intent: 'A single long prose line is parse-valid and preserves inline entities',
+    input:
+      'This is a single very long line of prose that would wrap on a phone screen and keeps going with more and more words to exceed a comfortable width, and it ends with an inline `code token` plus a **bold phrase** to make sure entities survive the length.',
+    expect: [
+      { type: 'code', text: 'code token' },
+      { type: 'bold', text: 'bold phrase' },
+    ],
+  },
+
+  // ── Links ─────────────────────────────────────────────────────────────────
+  {
+    name: 'links',
+    intent: 'Inline links parse into link entities with the right label + destination',
+    input:
+      'See the [switchroom repo](https://github.com/switchroom/switchroom) and the [docs](https://example.com/docs) for details.',
+    expect: [
+      { type: 'link', text: 'switchroom repo', url: 'https://github.com/switchroom/switchroom' },
+      { type: 'link', text: 'docs', url: 'https://example.com/docs' },
+    ],
+  },
+
+  // ── Inline code containing reserved chars ─────────────────────────────────
+  {
+    name: 'inline-code-reserved-chars',
+    intent: 'Inline code holding *, _, [, ], | renders verbatim without breaking entities',
+    input: 'The pattern `a_b*c[d]|e` is matched literally, and `f*g` too.',
+    expect: [
+      { type: 'code', text: 'a_b*c[d]|e' },
+      { type: 'code', text: 'f*g' },
+    ],
+  },
+
+  // ── F1 — dash-scrub on the card surface ───────────────────────────────────
+  // The card/worker-narration surface runs `normalizeDashes` (voice scrub)
+  // before the rich path; an em-dash must not survive to the wire. Assert the
+  // scrub removes the glyph AND the scrubbed text is parse-valid.
+  {
+    name: 'F1-card-surface-dash-scrub',
+    intent: 'F1: em/en-dash is scrubbed off the card surface and the result stays parse-valid',
+    input: 'Cabinet clean — 33% loss noted, second pass pending – rechecking now.',
+    expect: [],
+    cardSurfaceScrub: true,
+  },
+
+  // ── F2 — a stray pipe must NOT eat paragraph spacing ──────────────────────
+  // A prose line containing a loose ` | ` used to be misread as a table row,
+  // suppressing the paragraph break that follows. The two paragraphs must stay
+  // separated and the whole thing must be parse-valid (no half-table-row).
+  {
+    name: 'F2-stray-pipe-keeps-paragraph-spacing',
+    intent: 'F2: a loose interior pipe in prose does not collapse the following paragraph break',
+    input:
+      'You can choose plan A | plan B depending on scale.\n\nEither way the migration completes in one pass.',
+    expect: [],
+  },
+
+  // ── F4 — blank line after a closed code fence ─────────────────────────────
+  // Prose glued directly onto a fence close (single `\n`) can be swallowed.
+  // The block-boundary pass inserts a blank line; the fence must stay balanced
+  // and the trailing prose must survive as parse-valid text.
+  {
+    name: 'F4-blank-line-after-closed-fence',
+    intent: 'F4: a closed fence followed immediately by prose stays balanced and the prose survives',
+    input: ['Here is the fix:', '```', 'const x = 1', '```', 'And it ships today.'].join('\n'),
+    expect: [{ type: 'pre', text: 'const x = 1' }],
+  },
+
+  // ── F7 — over-cap chunk falls back to hard-slice, not dropped ─────────────
+  // An indivisible fenced block larger than the cap must be hard-sliced into
+  // <= cap pieces rather than emitted whole (which Telegram rejects) or dropped.
+  // The test drives this with a small cap so the giant block cannot fit; it
+  // asserts no content is lost and every emitted chunk fits the cap.
+  {
+    name: 'F7-over-cap-hard-slice',
+    intent: 'F7: an oversized indivisible fenced block is hard-sliced to <= cap, losing no content',
+    input: '```\n' + 'x'.repeat(600) + '\n```',
+    expect: [],
+  },
+]

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

@@ -28,19 +28,55 @@ afterEach(() => {
 })
 
 describe('initHistory', () => {
-  it('creates history.db with chmod 0600', () => {
+  it('creates history.db with chmod 0644', () => {
     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)
+    // 0644: the web container (uid 1000) opens history.db read-only to
+    // stream replies back to Hermes Desktop. Content is redacted on write,
+    // so world-readable is safe (owner-approved behaviour change).
+    expect(st.mode & 0o777).toBe(0o644)
   })
 
   it('is idempotent — second call is a no-op', () => {
     initHistory(stateDir, 30)
     expect(() => initHistory(stateDir, 30)).not.toThrow()
   })
+
+  // Regression for HERMES #2689 review defect #1: the web process (a different
+  // uid than the agent) opens history.db READ-ONLY to stream Telegram replies
+  // back to Hermes Desktop. If the db/WAL sidecars were left 0600, that open
+  // fails and the real-time sync poller silently no-ops. Assert both the perm
+  // bits AND that a readonly open + the poller's exact SELECT succeed.
+  it('history.db is world-readable and the Hermes poller can open it read-only', async () => {
+    initHistory(stateDir, 30)
+    recordInbound({ chat_id: '1', thread_id: null, message_id: 1, user: 'a', user_id: '1', ts: 100, text: 'hi' })
+    recordOutbound({ chat_id: '1', thread_id: null, message_ids: [2], texts: ['hello'], ts: 200 })
+
+    const dbPath = join(stateDir, 'history.db')
+    // Force a WAL sidecar to exist so we exercise the -wal/-shm perm path too.
+    for (const suffix of ['', '-shm', '-wal']) {
+      const f = dbPath + suffix
+      if (existsSync(f)) expect(statSync(f).mode & 0o777).toBe(0o644)
+    }
+
+    // Reproduce the poller's open (src/web/hermes-adapter.ts startHistoryPoll):
+    // readonly connection + MAX(rowid) + assistant-row SELECT.
+    const { Database } = await import('bun:sqlite')
+    const rdb = new Database(dbPath, { readonly: true })
+    try {
+      const max = rdb.prepare('SELECT MAX(rowid) AS r FROM messages').get() as { r: number | null }
+      expect(max.r).toBeGreaterThan(0)
+      const rows = rdb
+        .prepare("SELECT rowid, role, text FROM messages WHERE rowid > ? AND role = 'assistant' ORDER BY rowid ASC")
+        .all(0) as Array<{ role: string; text: string }>
+      expect(rows.some((r) => r.text === 'hello')).toBe(true)
+    } finally {
+      rdb.close()
+    }
+  })
 })
 
 describe('recordInbound + query', () => {

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

@@ -20,39 +20,83 @@ describe("formatIdleFooter", () => {
 
   it("single old turn ended 1h ago → idle 1h ago", () => {
     const r = row({ startedAt: NOW - 70 * 60_000, endedAt: NOW - 60 * 60_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply 1h ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **1h ago**");
   });
 
   it("single turn ended 3m ago → idle 3m ago", () => {
     const r = row({ startedAt: NOW - 5 * 60_000, endedAt: NOW - 3 * 60_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply 3m ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **3m ago**");
   });
 
   it("single turn ended 10s ago → idle <1m ago", () => {
     const r = row({ startedAt: NOW - 30_000, endedAt: NOW - 10_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply <1m ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **<1m ago**");
   });
 
-  it("currently running turn started 2m ago → working since 2m ago", () => {
+  it("currently running turn started 2m ago → working since **2m ago**", () => {
     const r = row({ startedAt: NOW - 2 * 60_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("⚙️ working since 2m ago");
+    expect(formatIdleFooter([r], NOW)).toBe("⚙️ working since **2m ago**");
   });
 
   it("multiple turns, most recent is running → working since recent", () => {
     const old = row({ turnKey: "t1", startedAt: NOW - 10 * 60_000, endedAt: NOW - 8 * 60_000 });
     const running = row({ turnKey: "t2", startedAt: NOW - 90_000 }); // 1m 30s ago
-    expect(formatIdleFooter([old, running], NOW)).toBe("⚙️ working since 1m ago");
+    expect(formatIdleFooter([old, running], NOW)).toBe("⚙️ working since **1m ago**");
   });
 
   it("multiple turns, most recent is ended → idle last reply", () => {
     const old = row({ turnKey: "t1", startedAt: NOW - 30 * 60_000, endedAt: NOW - 28 * 60_000 });
     const recent = row({ turnKey: "t2", startedAt: NOW - 6 * 60_000, endedAt: NOW - 4 * 60_000 });
-    expect(formatIdleFooter([old, recent], NOW)).toBe("🟢 idle · last reply 4m ago");
+    expect(formatIdleFooter([old, recent], NOW)).toBe("🟢 idle · last reply **4m ago**");
   });
 
   it("day-old turn → 1d ago", () => {
     const r = row({ startedAt: NOW - 26 * 3_600_000, endedAt: NOW - 25 * 3_600_000 });
-    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply 1d ago");
+    expect(formatIdleFooter([r], NOW)).toBe("🟢 idle · last reply **1d ago**");
+  });
+
+  it("no-data (quiet) state carries NO ** markup", () => {
+    const out = formatIdleFooter([], NOW);
+    expect(out).toBe("🟡 quiet · no turns yet");
+    expect(out).not.toContain("**");
+  });
+
+  it("working state bolds ONLY the elapsed value, not the whole line", () => {
+    const r = row({ startedAt: NOW - 4 * 60_000 });
+    const out = formatIdleFooter([r], NOW);
+    // The bold span wraps the time and only the time.
+    const bold = out.match(/\*\*(.+?)\*\*/);
+    expect(bold).not.toBeNull();
+    expect(bold![1]).toBe("4m ago");
+    // The label "⚙️ working since " is outside the bold span.
+    expect(out).toBe("⚙️ working since **4m ago**");
+    // Exactly one bold span (two `**` delimiters).
+    expect((out.match(/\*\*/g) ?? []).length).toBe(2);
+  });
+
+  it("idle state bolds ONLY the last-reply value, not the whole line", () => {
+    const r = row({ startedAt: NOW - 6 * 60_000, endedAt: NOW - 3 * 60_000 });
+    const out = formatIdleFooter([r], NOW);
+    const bold = out.match(/\*\*(.+?)\*\*/);
+    expect(bold).not.toBeNull();
+    expect(bold![1]).toBe("3m ago");
+    expect(out).toBe("🟢 idle · last reply **3m ago**");
+    expect((out.match(/\*\*/g) ?? []).length).toBe(2);
+  });
+
+  // Table-driven across elapsed magnitudes: a future change to formatAgo that
+  // drops the bold (or widens it past the time value) is caught here.
+  it.each([
+    { label: "seconds", deltaMs: 10_000, ago: "<1m ago" },
+    { label: "minutes", deltaMs: 7 * 60_000, ago: "7m ago" },
+    { label: "hours", deltaMs: 5 * 3_600_000, ago: "5h ago" },
+    { label: "days", deltaMs: 3 * 86_400_000, ago: "3d ago" },
+  ])("idle footer bolds the $label-magnitude elapsed value", ({ deltaMs, ago }) => {
+    const r = row({ startedAt: NOW - deltaMs - 1000, endedAt: NOW - deltaMs });
+    const out = formatIdleFooter([r], NOW);
+    expect(out).toBe(`🟢 idle · last reply **${ago}**`);
+    const bold = out.match(/\*\*(.+?)\*\*/);
+    expect(bold![1]).toBe(ago);
   });
 
   it("unsorted rows — picks max startedAt", () => {
@@ -61,6 +105,6 @@ describe("formatIdleFooter", () => {
     const r2 = row({ turnKey: "t2", startedAt: NOW - 5 * 60_000, endedAt: NOW - 2 * 60_000 });
     const r3 = row({ turnKey: "t3", startedAt: NOW - 40 * 60_000, endedAt: NOW - 38 * 60_000 });
     // r2 has the largest startedAt, endedAt is 2m ago
-    expect(formatIdleFooter([r1, r2, r3], NOW)).toBe("🟢 idle · last reply 2m ago");
+    expect(formatIdleFooter([r1, r2, r3], NOW)).toBe("🟢 idle · last reply **2m ago**");
   });
 });