switchroom 0.16.29 → 0.16.46

package/telegram-plugin/tests/paragraph-normalizer.test.ts

@@ -9,7 +9,12 @@
  * (un-promoted break) are preferred over false positives (double-spaced list).
  */
 import { describe, test, expect } from 'vitest'
-import { normalizeParagraphBreaks } from '../format.js'
+import {
+  normalizeParagraphBreaks,
+  splitCollapsedInlineBullets,
+  addParagraphSpacers,
+  PARAGRAPH_SPACER,
+} from '../format.js'
 
 describe('normalizeParagraphBreaks', () => {
   test('promotes a lone prose paragraph break (prev ends with `.`, next is prose)', () => {
@@ -43,11 +48,71 @@ describe('normalizeParagraphBreaks', () => {
     expect(normalizeParagraphBreaks(input)).toBe(input)
   })
 
-  test('does NOT promote when the next line is a list item (tight list stays tight)', () => {
-    const input = 'Here are the steps.\n- first\n- second\n- third'
+  test('promotes every interior break in a vertical stat card (#2750)', () => {
+    // The gymbro food-log card: lines end in digits/letters (no terminator),
+    // but each is a standalone `label: value` stat line, so every interior
+    // break must become a GFM hard break instead of collapsing to one wall.
+    const input = 'Calories: 1800\nProtein: 120g\nCarbs: 200g'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      'Calories: 1800  \nProtein: 120g  \nCarbs: 200g',
+    )
+  })
+
+  test('promotes a key-value line followed by prose (#2750)', () => {
+    const input = 'Status: active\nEverything is running smoothly.'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      'Status: active  \nEverything is running smoothly.',
+    )
+  })
+
+  test('promotes bold-label stat cards — colon inside AND outside the emphasis (#2750)', () => {
+    // The fleet HOUSE style uses markdown-bold labels. Both `**Calories:** 1800`
+    // (colon inside the bold) and `**Calories**: 1800` (colon outside) must have
+    // every interior break promoted.
+    const inside = '**Calories:** 1800\n**Protein:** 120g\n**Carbs:** 200g'
+    expect(normalizeParagraphBreaks(inside)).toBe(
+      '**Calories:** 1800  \n**Protein:** 120g  \n**Carbs:** 200g',
+    )
+    const outside = '**Calories**: 1800\n**Protein**: 120g'
+    expect(normalizeParagraphBreaks(outside)).toBe('**Calories**: 1800  \n**Protein**: 120g')
+  })
+
+  test('regression guard: a mid-sentence colon soft-wrap still does NOT promote (#2750)', () => {
+    // A wrapped sentence that happens to contain a colon must NOT be mistaken
+    // for a stat line: the next line continues the sentence in lowercase.
+    const input = 'He made one point: the plan was sound and\nthe timing was right too'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('regression guard: a long colon-clause with a CAPITAL continuation does NOT promote (#2750)', () => {
+    // The lowercase-continuation guard alone would miss this: the wrapped clause
+    // continues with a capitalised proper noun. The label before the colon is a
+    // long multi-word run (not a short stat label), so the word/length cap keeps
+    // it from being mistaken for a stat line.
+    const input = 'The deal has one catch: the buyer wants it and\nToronto lawyers must sign off'
     expect(normalizeParagraphBreaks(input)).toBe(input)
   })
 
+  test('lowercase-label stat cards are an ACCEPTED false-negative (not promoted) (#2750)', () => {
+    // `calories: 1800\nprotein: 120g` — the lowercase-started next line is
+    // indistinguishable from a mid-sentence soft-wrap continuation, so the
+    // conservative guard leaves it alone. Documented, not fixed: models are
+    // steered toward capitalised / bold labels, and a false-negative (un-promoted
+    // break) is the module's preferred failure mode over a false-positive.
+    const input = 'calories: 1800\nprotein: 120g'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('list glued to prose gains a block-boundary blank line; interior stays tight', () => {
+    // Uniform-block-spacing: a list start glued to prose by a single `\n`
+    // gets a blank line (so the spacer pass can see the transition); the
+    // list's own single-`\n` interior is never touched.
+    const input = 'Here are the steps.\n- first\n- second\n- third'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      'Here are the steps.\n\n- first\n- second\n- third',
+    )
+  })
+
   test('does NOT promote between list items (ordered or unordered)', () => {
     const ul = '- alpha.\n- beta.\n- gamma.'
     const ol = '1. first.\n2. second.\n3. third.'
@@ -270,4 +335,320 @@ describe('normalizeParagraphBreaks', () => {
     const input = '- first item\n    continued text of the first item'
     expect(normalizeParagraphBreaks(input)).toBe(input)
   })
+
+  test('F2: prose with an interior ` | ` gets normal paragraph-break treatment (not table)', () => {
+    // `isMarkerLine` used to treat any line containing ` | ` as a table row and
+    // suppress the paragraph-break promotion. A sentence like "choose A | B" is
+    // prose, not a table — the lone `\n` after a terminated prose line must
+    // still be promoted to a GFM hard break.
+    const input = 'Pick one option, choose A | B here.\nThen continue below.'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      'Pick one option, choose A | B here.  \nThen continue below.',
+    )
+  })
+
+  test('F2: a genuine table (header + delimiter) is still detected as structural', () => {
+    // The tightened check must still recognise a real GFM table: a blank line
+    // is inserted before the header and the rows stay contiguous.
+    const input = 'Here is data.\n| a | b |\n| --- | --- |\n| 1 | 2 |'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      'Here is data.\n\n| a | b |\n| --- | --- |\n| 1 | 2 |',
+    )
+  })
+
+  test('F4: blank line inserted after a closed code fence before glued prose', () => {
+    // Prose glued directly onto a fence close (single `\n`) can be swallowed /
+    // mis-parsed. A blank line after a closed fence is always CommonMark-safe.
+    const input = 'Intro.\n\n```\nconst x = 1\n```\nThen the prose continues.'
+    const out = normalizeParagraphBreaks(input)
+    // The fence interior is untouched...
+    expect(out).toContain('```\nconst x = 1\n```')
+    // ...and a blank line now separates the fence close from the following prose.
+    expect(out).toContain('```\n\nThen the prose continues.')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// splitCollapsedInlineBullets — stack an inline-collapsed bullet list
+// ---------------------------------------------------------------------------
+
+describe('splitCollapsedInlineBullets', () => {
+  test('splits the bath-bulb run-on (4 inline bullets → 4 lines)', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Master Bath 3, clean • Cabinet, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(
+      '• Master Bath 1, clean\n• Master Bath 2, 33% packet loss\n• Master Bath 3, clean\n• Cabinet, clean',
+    )
+  })
+
+  test('a bold segment inside one bullet survives the split', () => {
+    const input = '• A, clean • **Master Bath 2** (192.168.5.252), **33% loss** • C, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(
+      '• A, clean\n• **Master Bath 2** (192.168.5.252), **33% loss**\n• C, clean',
+    )
+  })
+
+  test('a <b> segment inside one bullet survives the split', () => {
+    const input = '• A, clean • <b>Master Bath 2</b>, <b>33% packet loss</b> • C, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(
+      '• A, clean\n• <b>Master Bath 2</b>, <b>33% packet loss</b>\n• C, clean',
+    )
+  })
+
+  test('splits on the middle-dot `·` separator too, and a `·`-led line', () => {
+    const input = '· one · two · three'
+    expect(splitCollapsedInlineBullets(input)).toBe('· one\n· two\n· three')
+  })
+
+  test('accepts a `-` or `*` leading marker (but only splits unicode interior bullets)', () => {
+    expect(splitCollapsedInlineBullets('- lead marker • two • three')).toBe(
+      '- lead marker\n• two\n• three',
+    )
+    expect(splitCollapsedInlineBullets('* lead marker • two')).toBe('* lead marker\n• two')
+  })
+
+  test('prose containing a mid-sentence `•` (line does not start with a bullet) is untouched', () => {
+    const input = 'The plan uses A • B notation throughout the design doc.'
+    expect(splitCollapsedInlineBullets(input)).toBe(input)
+  })
+
+  test('does NOT split on interior `-`/`*` (hyphens, ranges, multiplication)', () => {
+    const input = '• range 1-3 and a * b product stay on one bullet'
+    // No interior unicode bullet → line is returned unchanged.
+    expect(splitCollapsedInlineBullets(input)).toBe(input)
+  })
+
+  test('is idempotent on the bath-bulb input', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Master Bath 3, clean • Cabinet, clean'
+    const once = splitCollapsedInlineBullets(input)
+    const twice = splitCollapsedInlineBullets(once)
+    expect(twice).toBe(once)
+  })
+
+  test('an already-correct multi-line bullet list passes through unchanged', () => {
+    const input = '• Master Bath 1, clean\n• Master Bath 2, 33% loss\n• Cabinet, clean'
+    expect(splitCollapsedInlineBullets(input)).toBe(input)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// addParagraphSpacers — restore a VISIBLE blank line between prose paragraphs.
+//
+// The rich GFM renderer (post-#2669) collapses a `\n\n` paragraph gap TIGHT, so
+// multi-paragraph replies render jammed together — the operator-confirmed
+// regression vs the old HTML path (`parse_mode:"HTML"`, `\n\n` → real blank
+// line). addParagraphSpacers wedges a U+00A0 spacer paragraph into each prose
+// `\n\n` gap so the rich renderer shows a visible empty line. Conservative:
+// only between two prose blocks, never adjacent to list/table/code/quote/heading.
+// ---------------------------------------------------------------------------
+
+describe('addParagraphSpacers', () => {
+  const gap = `\n\n${PARAGRAPH_SPACER}\n\n`
+
+  test('the spacer is a single non-breaking space (U+00A0), not an ASCII space', () => {
+    expect(PARAGRAPH_SPACER).toBe(' ')
+  })
+
+  test('inserts a visible spacer paragraph into a prose `\\n\\n` gap', () => {
+    expect(addParagraphSpacers('Paragraph one.\n\nParagraph two.')).toBe(
+      `Paragraph one.${gap}Paragraph two.`,
+    )
+  })
+
+  test('spaces every gap in a three-paragraph body', () => {
+    expect(addParagraphSpacers('One.\n\nTwo.\n\nThree.')).toBe(
+      `One.${gap}Two.${gap}Three.`,
+    )
+  })
+
+  test('is idempotent — a spaced gap is not doubled on a second pass', () => {
+    const once = addParagraphSpacers('Alpha.\n\nBravo.')
+    expect(addParagraphSpacers(once)).toBe(once)
+  })
+
+  test('leaves a single-`\\n` separation alone (only `\\n\\n` gaps are spaced)', () => {
+    // normalizeParagraphBreaks owns lone-break promotion; this pass only adds a
+    // visible spacer where a genuine blank-line gap already exists.
+    const input = 'Line one.\nLine two.'
+    expect(addParagraphSpacers(input)).toBe(input)
+  })
+
+  test('spaces prose↔list transitions (uniform block spacing), list interior tight', () => {
+    expect(addParagraphSpacers('Here are the steps.\n\n- first\n- second')).toBe(
+      `Here are the steps.${gap}- first\n- second`,
+    )
+    expect(addParagraphSpacers('- first\n- second\n\nClosing prose after the list.')).toBe(
+      `- first\n- second${gap}Closing prose after the list.`,
+    )
+  })
+
+  test('spaces a prose→table boundary; table rows stay contiguous', () => {
+    const table = '| a | b |\n| --- | --- |\n| 1 | 2 |'
+    expect(addParagraphSpacers(`Intro.\n\n${table}`)).toBe(`Intro.${gap}${table}`)
+  })
+
+  test('spaces prose↔fence boundaries; fence interior untouched', () => {
+    const input = 'Look here.\n\n```js\nconst a = 1;\n```\n\nDone.'
+    expect(addParagraphSpacers(input)).toBe(
+      `Look here.${gap}\`\`\`js\nconst a = 1;\n\`\`\`${gap}Done.`,
+    )
+  })
+
+  test('spaces heading→anything and blockquote boundaries', () => {
+    expect(addParagraphSpacers('Intro prose.\n\n## Section\n\nBody prose.')).toBe(
+      `Intro prose.${gap}## Section${gap}Body prose.`,
+    )
+    expect(addParagraphSpacers('Said.\n\n> a quote\n\nAfter.')).toBe(
+      `Said.${gap}> a quote${gap}After.`,
+    )
+  })
+
+  test('does NOT space between items of the same loose list / same-kind blocks', () => {
+    const looseList = '- first\n\n- second\n\n- third'
+    expect(addParagraphSpacers(looseList)).toBe(looseList)
+    const quotes = '> one\n\n> two'
+    expect(addParagraphSpacers(quotes)).toBe(quotes)
+  })
+
+  test('never reaches inside a fenced block (interior blank line untouched)', () => {
+    const input = 'Before.\n\n```\nline 1\n\nline 2\n```\n\nAfter.'
+    const out = addParagraphSpacers(input)
+    // The fence interior — including its own blank line — is byte-for-byte intact.
+    expect(out).toContain('```\nline 1\n\nline 2\n```')
+  })
+
+  test('a body with no paragraph gap is returned unchanged', () => {
+    expect(addParagraphSpacers('just one paragraph, no gap')).toBe('just one paragraph, no gap')
+  })
+
+  test('composes after normalizeParagraphBreaks: prose gap spaced, list left tight', () => {
+    const input = [
+      'Summary of the change.',
+      '',
+      'It does two things.',
+      '',
+      '- adds a normalizer',
+      '- lifts the cap',
+    ].join('\n')
+    const out = addParagraphSpacers(normalizeParagraphBreaks(input))
+    // The two prose paragraphs gain a visible spacer between them.
+    expect(out).toContain(`Summary of the change.${gap}It does two things.`)
+    // The prose→list transition gains a spacer too (uniform block spacing),
+    // but the list INTERIOR stays tight.
+    expect(out).toContain(`It does two things.${gap}- adds a normalizer\n- lifts the cap`)
+  })
+})
+
+describe('normalizeParagraphBreaks — inline bullet split integration', () => {
+  test('splits the bath-bulb run-on as part of the full outbound pass', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Master Bath 3, clean • Cabinet, clean'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      '• Master Bath 1, clean\n• Master Bath 2, 33% packet loss\n• Master Bath 3, clean\n• Cabinet, clean',
+    )
+  })
+
+  test('a `•` inside an inline code span is NOT split (code masked)', () => {
+    const input = '`• a • b • c` is a code span'
+    // The line does not start with a bullet marker (it starts with the masked
+    // code placeholder), and the bullets live inside masked code regardless.
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('a `•` inside a fenced code block is NOT split', () => {
+    const input = '```\n• a • b • c\n```'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('idempotent through the full pass on the bath-bulb input', () => {
+    const input =
+      '• Master Bath 1, clean • Master Bath 2, 33% packet loss • Cabinet, clean'
+    const once = normalizeParagraphBreaks(input)
+    const twice = normalizeParagraphBreaks(once)
+    expect(twice).toBe(once)
+  })
+})
+
+/**
+ * Regression guard for the stray whitespace-only blank line between paragraphs
+ * (the "\n\n \n\n" seen in a real reply). A model (or an upstream transform)
+ * that authors a blank line whose only content is ASCII whitespace leaves a
+ * ragged / oversized gap: CommonMark discards it so it buys no visible space,
+ * but it reads as noise in the raw text. Step 1 of normalizeParagraphBreaks now
+ * collapses any run of blank lines — including whitespace-only interior lines —
+ * to exactly one clean `\n\n`, WITHOUT ever eating the deliberate U+00A0
+ * paragraph spacer that addParagraphSpacers (#2692) adds later for a visible
+ * gap on the rich-message path.
+ */
+describe('normalizeParagraphBreaks — whitespace-only blank-line collapse (Bug 2)', () => {
+  const NBSP = ' '
+
+  test('a lone-space blank line between paragraphs collapses to a clean `\\n\\n` (real string)', () => {
+    const input =
+      "Here's what was fixed and how it validates.\n\n \n\n" +
+      'One loose end: a stray thing.'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      "Here's what was fixed and how it validates.\n\n" +
+        'One loose end: a stray thing.',
+    )
+  })
+
+  test('a single whitespace-only blank line (`A\\n \\nB`) collapses to `\\n\\n`', () => {
+    expect(normalizeParagraphBreaks('Alpha para.\n \nBravo para.')).toBe(
+      'Alpha para.\n\nBravo para.',
+    )
+    expect(normalizeParagraphBreaks('Alpha para.\n\t\nBravo para.')).toBe(
+      'Alpha para.\n\nBravo para.',
+    )
+  })
+
+  test('multiple stray whitespace-only lines in one gap collapse to a single `\\n\\n`', () => {
+    expect(normalizeParagraphBreaks('A.\n\n \n\n \n\nB.')).toBe('A.\n\nB.')
+  })
+
+  test('a legitimate single `\\n\\n` paragraph break is preserved exactly', () => {
+    expect(normalizeParagraphBreaks('Alpha para.\n\nBravo para.')).toBe(
+      'Alpha para.\n\nBravo para.',
+    )
+  })
+
+  test('never EMITS a whitespace-only line between two prose paragraphs', () => {
+    const out = normalizeParagraphBreaks('First.\n\n  \n\nSecond.')
+    for (const line of out.split('\n')) {
+      // Every line is either empty or has real (non-ASCII-whitespace) content.
+      expect(line === '' || /\S/.test(line) || line.includes(NBSP)).toBe(true)
+    }
+    expect(out).toBe('First.\n\nSecond.')
+  })
+
+  test('a blank line inside a fenced code block (masked) is NOT collapsed', () => {
+    const input = '```\ncode line 1\n \ncode line 2\n```'
+    // The whitespace-only line lives inside a masked fence and must survive.
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('trailing hard-break spaces on a CONTENT line are not eaten', () => {
+    // "line.  \n\nNext." — the two trailing spaces are a GFM hard break on a
+    // content line, not a blank line; they must survive.
+    const input = 'Trailing spaces on line.  \n\nNext.'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('the deliberate U+00A0 spacer from addParagraphSpacers is preserved (no #2692 regression)', () => {
+    const normalized = normalizeParagraphBreaks('Alpha para.\n\nBravo para.')
+    const spaced = addParagraphSpacers(normalized)
+    // addParagraphSpacers wedges a U+00A0-only line to force a visible gap.
+    expect(spaced).toContain('\n\n' + PARAGRAPH_SPACER + '\n\n')
+    expect(spaced.split('\n')).toContain(NBSP)
+    // And re-running the normalizer must NOT eat that intentional spacer.
+    expect(normalizeParagraphBreaks(spaced)).toBe(spaced)
+  })
+
+  test('idempotent: collapsing a stray gap twice is stable', () => {
+    const once = normalizeParagraphBreaks('A.\n\n \n\nB.')
+    const twice = normalizeParagraphBreaks(once)
+    expect(twice).toBe(once)
+    expect(once).toBe('A.\n\nB.')
+  })
 })

package/telegram-plugin/tests/permission-card-single-edit.test.ts

@@ -0,0 +1,66 @@
+/**
+ * Structural pin for card-ux fix 3 — the "Allow once" tap updates the SAME
+ * card instead of spawning a separate "▶️ … got it, continuing" message.
+ *
+ * What broke before: tapping Allow edited the card to "✅ Allowed once" AND
+ * posted a separate resume message (to EVERY resolvePermissionCardTargets()
+ * surface). Ken wants no split — the continuation folds into the tapped card.
+ *
+ * The turn-resume trigger (dispatchPermissionVerdict) and the glyph flip
+ * (resumeReactionAfterVerdict) MUST still fire; only the user-visible second
+ * message collapses. mtcute UAT can observe the card edit and a separate
+ * sendMessage, but wiring a full Grammy ctx here is heavy, so this is a
+ * source-structure pin over the exact callback block (mirrors
+ * permission-verdict-resume-guard.test.ts).
+ */
+
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, resolve } from 'node:path'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const GATEWAY_SRC = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+  'utf8',
+)
+
+// Isolate the single "Allow once / Deny" verdict-tap block: from the
+// `labelWithResume` construction to the end of its finalizeCallback call.
+function allowOnceBlock(): string {
+  const start = GATEWAY_SRC.indexOf('const resumeLine = process.env.SWITCHROOM_RESUME_MSG')
+  expect(start).toBeGreaterThan(-1)
+  // Cut a generous slice covering resumeLine + finalizeCallback + synthInbound.
+  return GATEWAY_SRC.slice(start, start + 2000)
+}
+
+describe('permission "Allow once" tap → single in-place card edit (card-ux fix 3)', () => {
+  it('folds the resume line into the card edit via formatPermissionResumeMessage', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain('formatPermissionResumeMessage(')
+    // The card newText carries BOTH the verdict label and the resume line.
+    expect(block).toContain('const labelWithResume = resumeLine')
+    expect(block).toMatch(/newText:\s*baseText\s*\?\s*`\$\{baseText\}\\n\\n\$\{labelWithResume\}`/)
+  })
+
+  it('does NOT post a separate resume message on this path', () => {
+    const block = allowOnceBlock()
+    expect(block).not.toContain('postPermissionResumeMessage(')
+  })
+
+  it('still fires the turn-resume trigger and glyph flip', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain('dispatchPermissionVerdict(')
+    expect(block).toContain('resumeReactionAfterVerdict()')
+  })
+
+  it('honours the SWITCHROOM_RESUME_MSG=0 kill-switch for the folded line', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain("process.env.SWITCHROOM_RESUME_MSG === '0'")
+  })
+
+  it('carries the card-folded-resume sentinel the resume guard keys off', () => {
+    const block = allowOnceBlock()
+    expect(block).toContain('card-folded-resume')
+  })
+})

package/telegram-plugin/tests/permission-card-store.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { createPermissionCardStore } from '../gateway/permission-card-store.js'
+
+function makeTmpDir() {
+  return mkdtempSync(join(tmpdir(), 'perm-card-store-test-'))
+}
+
+describe('createPermissionCardStore', () => {
+  let dir: string
+
+  beforeEach(() => { dir = makeTmpDir() })
+  afterEach(() => { rmSync(dir, { recursive: true, force: true }) })
+
+  it('starts empty', () => {
+    const store = createPermissionCardStore(dir)
+    expect(store.loadAll()).toEqual([])
+  })
+
+  it('add and loadAll returns the entry', () => {
+    const store = createPermissionCardStore(dir)
+    const entry = {
+      requestId: 'aabcd',
+      chatId: '12345',
+      messageId: 999,
+      startedAt: Date.now(),
+      toolName: 'mcp__shell__run',
+      cardText: 'Run shell command',
+    }
+    store.add(entry)
+    expect(store.loadAll()).toEqual([entry])
+  })
+
+  it('add multiple entries for same requestId (different messageIds)', () => {
+    const store = createPermissionCardStore(dir)
+    store.add({ requestId: 'aabcd', chatId: '111', messageId: 1, startedAt: 1000, toolName: 't', cardText: 'c' })
+    store.add({ requestId: 'aabcd', chatId: '222', messageId: 2, startedAt: 1000, toolName: 't', cardText: 'c' })
+    const all = store.loadAll()
+    expect(all.length).toBe(2)
+  })
+
+  it('does not duplicate same requestId+messageId', () => {
+    const store = createPermissionCardStore(dir)
+    const entry = { requestId: 'aabcd', chatId: '111', messageId: 1, startedAt: 1000, toolName: 't', cardText: 'c' }
+    store.add(entry)
+    store.add(entry)
+    expect(store.loadAll().length).toBe(1)
+  })
+
+  it('remove clears all entries for a requestId', () => {
+    const store = createPermissionCardStore(dir)
+    store.add({ requestId: 'aabcd', chatId: '111', messageId: 1, startedAt: 1000, toolName: 't', cardText: 'c' })
+    store.add({ requestId: 'aabcd', chatId: '222', messageId: 2, startedAt: 1000, toolName: 't', cardText: 'c' })
+    store.add({ requestId: 'xyzab', chatId: '333', messageId: 3, startedAt: 1000, toolName: 't', cardText: 'c' })
+    store.remove('aabcd')
+    const all = store.loadAll()
+    expect(all.length).toBe(1)
+    expect(all[0].requestId).toBe('xyzab')
+  })
+
+  it('remove is idempotent when entry not present', () => {
+    const store = createPermissionCardStore(dir)
+    expect(() => store.remove('nonexistent')).not.toThrow()
+  })
+
+  it('clear empties the store', () => {
+    const store = createPermissionCardStore(dir)
+    store.add({ requestId: 'aabcd', chatId: '111', messageId: 1, startedAt: 1000, toolName: 't', cardText: 'c' })
+    store.clear()
+    expect(store.loadAll()).toEqual([])
+  })
+
+  it('survives re-instantiation (data persists across instances)', () => {
+    createPermissionCardStore(dir).add({
+      requestId: 'aabcd', chatId: '111', messageId: 1, startedAt: 1000, toolName: 't', cardText: 'c',
+    })
+    const all = createPermissionCardStore(dir).loadAll()
+    expect(all.length).toBe(1)
+    expect(all[0].requestId).toBe('aabcd')
+  })
+})

package/telegram-plugin/tests/permission-timeout.test.ts

@@ -13,7 +13,9 @@ import {
   timeoutDenyMessage,
   duplicateDenyMessage,
   isRecentTimeoutDuplicate,
+  approvalTtlMs,
   PERMISSION_TTL_MS,
+  PERMISSION_TTL_DEFAULT_MS,
   HOSTD_PERMISSION_TTL_MS,
   ttlForTool,
   buildTimedOutCardEdits,
@@ -22,6 +24,35 @@ import {
   TIMED_OUT_FOOTER,
 } from '../gateway/permission-timeout.js'
 
+describe('approvalTtlMs (config-driven approval-card lifetime)', () => {
+  it('defaults to 60 minutes when unset', () => {
+    expect(approvalTtlMs({})).toBe(60 * 60_000)
+    expect(PERMISSION_TTL_DEFAULT_MS).toBe(60 * 60_000)
+  })
+
+  it('honours a configured value (threaded as SWITCHROOM_TG_APPROVAL_TIMEOUT_MS ms)', () => {
+    expect(approvalTtlMs({ SWITCHROOM_TG_APPROVAL_TIMEOUT_MS: '1800000' })).toBe(1_800_000)
+  })
+
+  it('falls back to the 60-min default on blank / garbage / non-positive', () => {
+    const d = 60 * 60_000
+    expect(approvalTtlMs({ SWITCHROOM_TG_APPROVAL_TIMEOUT_MS: '' })).toBe(d)
+    expect(approvalTtlMs({ SWITCHROOM_TG_APPROVAL_TIMEOUT_MS: 'abc' })).toBe(d)
+    expect(approvalTtlMs({ SWITCHROOM_TG_APPROVAL_TIMEOUT_MS: '0' })).toBe(d)
+    expect(approvalTtlMs({ SWITCHROOM_TG_APPROVAL_TIMEOUT_MS: '-5' })).toBe(d)
+  })
+
+  it('the default permission-card lifetime is at least 60 min', () => {
+    // With no env override at module load, PERMISSION_TTL_MS is the default.
+    expect(PERMISSION_TTL_MS).toBeGreaterThanOrEqual(60 * 60_000)
+  })
+
+  it('hostd verbs never get a shorter window than the default card', () => {
+    expect(HOSTD_PERMISSION_TTL_MS).toBeGreaterThanOrEqual(PERMISSION_TTL_MS)
+    expect(HOSTD_PERMISSION_TTL_MS).toBeGreaterThanOrEqual(30 * 60_000)
+  })
+})
+
 describe('permissionSignature', () => {
   it('is stable for the same tool + input', () => {
     expect(permissionSignature('mcp__meta_ads__set_budget', '{"id":"1","budget":1400}'))
@@ -96,7 +127,7 @@ describe('isRecentTimeoutDuplicate', () => {
 // ─── Bug 2 — per-tool TTL, timed-out card hygiene, stale-tap honesty ────────
 
 describe('ttlForTool (Bug 2 fix #2)', () => {
-  it('gives hostd gated verbs a 30-min window', () => {
+  it('gives hostd gated verbs at least a 30-min window (>= the default card)', () => {
     for (const tool of [
       'mcp__hostd__rollout',
       'mcp__hostd__update_apply',
@@ -105,20 +136,20 @@ describe('ttlForTool (Bug 2 fix #2)', () => {
       'mcp__hostd__config_propose_edit',
     ]) {
       expect(ttlForTool(tool)).toBe(HOSTD_PERMISSION_TTL_MS)
-      expect(ttlForTool(tool)).toBe(30 * 60_000)
+      expect(ttlForTool(tool)).toBeGreaterThanOrEqual(30 * 60_000)
     }
   })
 
-  it('keeps the 10-min default for non-hostd tools', () => {
+  it('applies the config-driven default (60 min) to non-hostd tools', () => {
     expect(ttlForTool('Bash')).toBe(PERMISSION_TTL_MS)
-    expect(ttlForTool('Bash')).toBe(10 * 60_000)
+    expect(ttlForTool('Bash')).toBe(60 * 60_000)
     expect(ttlForTool('mcp__perplexity__search')).toBe(PERMISSION_TTL_MS)
     expect(ttlForTool('mcp__agent-config__schedule_add')).toBe(PERMISSION_TTL_MS)
     expect(ttlForTool(undefined)).toBe(PERMISSION_TTL_MS)
   })
 
-  it('hostd TTL is strictly longer than the default', () => {
-    expect(HOSTD_PERMISSION_TTL_MS).toBeGreaterThan(PERMISSION_TTL_MS)
+  it('hostd TTL is never shorter than the default (the 60-min raise subsumes the old 30-min floor)', () => {
+    expect(HOSTD_PERMISSION_TTL_MS).toBeGreaterThanOrEqual(PERMISSION_TTL_MS)
   })
 })