switchroom 0.16.23 → 0.16.27

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

@@ -0,0 +1,273 @@
+/**
+ * Tests for normalizeParagraphBreaks (task A of the Telegram-formatting bundle).
+ *
+ * The rich GFM render path collapses a LONE `\n` (it's a soft break), so a model
+ * that separates paragraphs with one newline produces a cramped wall of text.
+ * normalizeParagraphBreaks promotes a lone *prose* `\n` into a GFM hard break
+ * (`  \n`) while leaving lists, tables, blockquotes, headings, code, and genuine
+ * `\n\n` gaps untouched. It is deliberately conservative — false negatives
+ * (un-promoted break) are preferred over false positives (double-spaced list).
+ */
+import { describe, test, expect } from 'vitest'
+import { normalizeParagraphBreaks } from '../format.js'
+
+describe('normalizeParagraphBreaks', () => {
+  test('promotes a lone prose paragraph break (prev ends with `.`, next is prose)', () => {
+    const input = 'First thought ends here.\nSecond thought starts here.'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      'First thought ends here.  \nSecond thought starts here.',
+    )
+  })
+
+  test('promotes after ! ? and : terminators too', () => {
+    expect(normalizeParagraphBreaks('Done!\nNext line here.')).toBe('Done!  \nNext line here.')
+    expect(normalizeParagraphBreaks('Really?\nYes, really.')).toBe('Really?  \nYes, really.')
+    expect(normalizeParagraphBreaks('Steps follow:\nDo the thing.')).toBe(
+      'Steps follow:  \nDo the thing.',
+    )
+  })
+
+  test('promotes when the terminator is wrapped by a closing quote or paren', () => {
+    expect(normalizeParagraphBreaks('He said "go."\nThen we went.')).toBe(
+      'He said "go."  \nThen we went.',
+    )
+    expect(normalizeParagraphBreaks('(all done.)\nMoving on now.')).toBe(
+      '(all done.)  \nMoving on now.',
+    )
+  })
+
+  test('does NOT promote a lone mid-sentence soft wrap (prev has no terminator)', () => {
+    // A soft-wrapped sentence: the first line does not end in terminal
+    // punctuation, so we leave the break alone (false negative by design).
+    const input = 'this is a long sentence that wrapped\nonto a second line mid-thought'
+    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'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  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.'
+    expect(normalizeParagraphBreaks(ul)).toBe(ul)
+    expect(normalizeParagraphBreaks(ol)).toBe(ol)
+  })
+
+  test('does NOT promote indented (nested) list items', () => {
+    const input = '- parent.\n    - child one.\n    - child two.'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('does NOT touch a markdown table', () => {
+    const input = '| col a | col b |\n| --- | --- |\n| r1a | r1b |\n| r2a | r2b |'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('does NOT promote into a blockquote or heading (but DOES guarantee a block-start blank line)', () => {
+    // The lone `\n` is never promoted to a hard break (`  \n`) when the next
+    // line is a blockquote / heading marker — but Step 3 DOES guarantee the
+    // blank line a GFM block needs to start, so prose→quote and prose→heading
+    // transitions get a `\n\n` gap (the block renders correctly).
+    expect(normalizeParagraphBreaks('As noted.\n> a quoted line')).toBe(
+      'As noted.\n\n> a quoted line',
+    )
+    expect(normalizeParagraphBreaks('Intro line.\n# Heading')).toBe('Intro line.\n\n# Heading')
+    // No spurious hard break (`  \n`) is ever introduced at the boundary.
+    expect(normalizeParagraphBreaks('As noted.\n> a quoted line')).not.toContain('  \n')
+  })
+
+  test('preserves a fenced code block verbatim (interior newlines untouched)', () => {
+    const input = 'Look here.\n```js\nconst a = 1;\nconst b = 2;\n```\nDone.'
+    const out = normalizeParagraphBreaks(input)
+    // The fence body is preserved exactly — no hard break injected inside it.
+    expect(out).toContain('```js\nconst a = 1;\nconst b = 2;\n```')
+    // A blank line is guaranteed BEFORE the fence open so it starts a fresh
+    // GFM code block instead of being glued to the preceding prose line.
+    expect(out).toContain('Look here.\n\n```js')
+  })
+
+  test('preserves inline code spans verbatim', () => {
+    const input = 'Run `npm test` now.\nThen check the output.'
+    const out = normalizeParagraphBreaks(input)
+    expect(out).toContain('`npm test`')
+    // Prose break after a sentence ending in `.` is still promoted.
+    expect(out).toBe('Run `npm test` now.  \nThen check the output.')
+  })
+
+  test('preserves an existing `\\n\\n` paragraph gap (never collapses it)', () => {
+    const input = 'Paragraph one.\n\nParagraph two.'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('collapses 3+ newlines down to exactly `\\n\\n`', () => {
+    expect(normalizeParagraphBreaks('A.\n\n\nB.')).toBe('A.\n\nB.')
+    expect(normalizeParagraphBreaks('A.\n\n\n\n\nB.')).toBe('A.\n\nB.')
+  })
+
+  test('does not promote a break adjacent to a blank line', () => {
+    // The newline that is part of a `\n\n` gap must stay a plain newline, not
+    // become a `  \n` hard break.
+    const input = 'Done.\n\nMore prose.'
+    const out = normalizeParagraphBreaks(input)
+    expect(out).not.toContain('  \n\n')
+    expect(out).toBe('Done.\n\nMore prose.')
+  })
+
+  test('handles a mixed body: prose promoted, list left alone, fence preserved', () => {
+    const input = [
+      'Summary of the change.',
+      'It does two things now.',
+      '',
+      '- adds a normalizer',
+      '- lifts the char cap',
+      '',
+      '```ts',
+      'const x = 1',
+      '```',
+    ].join('\n')
+    const out = normalizeParagraphBreaks(input)
+    // The two prose lines get a hard break between them.
+    expect(out).toContain('Summary of the change.  \nIt does two things now.')
+    // The list stays tight.
+    expect(out).toContain('- adds a normalizer\n- lifts the char cap')
+    // The fence is intact.
+    expect(out).toContain('```ts\nconst x = 1\n```')
+  })
+
+  test('returns single-line input unchanged (no newline to consider)', () => {
+    expect(normalizeParagraphBreaks('just one line, no breaks')).toBe('just one line, no breaks')
+  })
+
+  test('does not double-promote an already-hard break', () => {
+    // A break already followed by two trailing spaces should not gain more.
+    const input = 'Done.  \nNext.'
+    const out = normalizeParagraphBreaks(input)
+    // prev line trimEnd() ends in `.`, so it promotes — but the result must not
+    // accumulate extra spaces beyond the single `  \n` hard break.
+    expect(out).toBe('Done.  \nNext.')
+  })
+
+  test('CRLF input promotes to a hard break with NO stranded `\\r`', () => {
+    // A CRLF source must not leave a lone carriage return before the injected
+    // `  \n`. The trailing-whitespace strip includes `\r` so the result is a
+    // clean `  \n` hard break, not `  \r\n` or `\r  \n`.
+    const out = normalizeParagraphBreaks('Alpha.\r\nBravo.')
+    expect(out).toBe('Alpha.  \nBravo.')
+    expect(out).not.toContain('\r')
+  })
+
+  test('does NOT promote a break adjacent to an indented code block', () => {
+    // CommonMark indented code block (4+ leading spaces then non-space) is a
+    // block marker — a break adjacent to it must NOT be promoted to a hard break.
+    const input = 'Note:\n    indented code'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  // -------------------------------------------------------------------------
+  // Step 3 — block-boundary blank-line guarantee. A GFM block glued to the
+  // previous line by a single `\n` fails to render (a table prints as literal
+  // pipe text; prose after a list is absorbed as a lazy list continuation).
+  // These cases capture the two live-render bugs plus the regression guards
+  // that the tight-list / code / table-internals constraints depend on.
+  // -------------------------------------------------------------------------
+
+  test('inserts a blank line before a table header glued to a single-`\\n` text line (VERIFY 5)', () => {
+    // The live render showed the table printing as inline literal pipe text
+    // because only a single `\n` separated the preceding text line from the
+    // table's first row. A blank line must be inserted BEFORE the header, and
+    // header + delimiter + body rows must stay contiguous (single `\n`).
+    const input =
+      'VERIFY 5 — GFM table\n| Name | Role |\n|---|---|\n| Ada | Engineer |\n| Bob | Designer |'
+    expect(normalizeParagraphBreaks(input)).toBe(
+      'VERIFY 5 — GFM table\n\n| Name | Role |\n|---|---|\n| Ada | Engineer |\n| Bob | Designer |',
+    )
+  })
+
+  test('inserts a blank line before post-list prose, list stays tight, fence untouched (VERIFY 7)', () => {
+    // The live render showed "A prose line after the list." absorbed into the
+    // last bullet (GFM lazy continuation). A blank line must break it out of
+    // the list, while the bullets stay tight and the fence stays verbatim.
+    const input =
+      'VERIFY 7 — mixed\n' +
+      'This first prose sentence stands alone.\n' +
+      'This second prose sentence should show a gap above it.\n' +
+      '- bullet\n' +
+      '- list\n' +
+      'A prose line after the list.\n' +
+      '```\n' +
+      'echo hello.\n' +
+      'echo world.\n' +
+      '```'
+    const out = normalizeParagraphBreaks(input)
+    // The two leading prose sentences are promoted (each ends in `.`).
+    expect(out).toContain(
+      'This first prose sentence stands alone.  \nThis second prose sentence should show a gap above it.',
+    )
+    // The bullet items stay TIGHT — no blank line between same-list items.
+    expect(out).toContain('- bullet\n- list')
+    // The post-list prose is separated from the list by a blank line.
+    expect(out).toContain('- list\n\nA prose line after the list.')
+    // The fence interior is untouched and the fence is preceded by a blank line.
+    expect(out).toContain('```\necho hello.\necho world.\n```')
+    expect(out).toContain('A prose line after the list.\n\n```')
+  })
+
+  test('regression: a pure tight bullet list stays tight (no blank lines inserted)', () => {
+    const input = '- alpha\n- beta\n- gamma'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('regression: a pure tight numbered list stays tight (no blank lines inserted)', () => {
+    const input = '1. first\n2. second\n3. third'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('regression: existing `\\n\\n` paragraphs are unchanged (no extra gap)', () => {
+    const input = 'Para one.\n\nPara two.\n\nPara three.'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('regression: a fenced code block with `|` pipes / `-` lines is NOT treated as a table', () => {
+    // The pipes and dashes live INSIDE a fence — masking must keep them out of
+    // the table heuristic so no spurious blank line is injected inside or
+    // around the code, and the interior is byte-for-byte preserved.
+    const input = 'Header here.\n```\n| not | a | table |\n|---|---|---|\n--- dash line\n```'
+    const out = normalizeParagraphBreaks(input)
+    // The fence interior is verbatim — pipes and dashes untouched.
+    expect(out).toContain('```\n| not | a | table |\n|---|---|---|\n--- dash line\n```')
+    // The fence open gets its block-start blank line (it's a code block, not a
+    // table) but nothing inside it is reflowed.
+    expect(out).toBe(
+      'Header here.\n\n```\n| not | a | table |\n|---|---|---|\n--- dash line\n```',
+    )
+  })
+
+  test('a heading after prose gets its block-start blank line', () => {
+    expect(normalizeParagraphBreaks('Some intro prose.\n## Section')).toBe(
+      'Some intro prose.\n\n## Section',
+    )
+  })
+
+  test('a blockquote after prose gets its block-start blank line', () => {
+    expect(normalizeParagraphBreaks('Some intro prose.\n> quoted wisdom')).toBe(
+      'Some intro prose.\n\n> quoted wisdom',
+    )
+  })
+
+  test('does NOT split a table header from its delimiter or body rows', () => {
+    // A table already preceded by a blank line must keep all of its own rows
+    // contiguous (single `\n`) — the blank-line rule only fires BEFORE the
+    // header, never between header/delimiter/body.
+    const input = 'Intro.\n\n| a | b |\n| --- | --- |\n| 1 | 2 |\n| 3 | 4 |'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+
+  test('list followed by an indented continuation line stays glued (no breakout)', () => {
+    // A 4-space indented line under a bullet is a lazy paragraph continuation
+    // of that item, not breakout prose — it must NOT gain a blank line.
+    const input = '- first item\n    continued text of the first item'
+    expect(normalizeParagraphBreaks(input)).toBe(input)
+  })
+})

package/telegram-plugin/tests/pending-work-progress.test.ts

@@ -139,7 +139,7 @@ describe('pending-work-progress', () => {
     expect(cap.edits).toHaveLength(1)
     expect(cap.edits[0].messageId).toBe(100)
     expect(cap.edits[0].newText).toBe(
-      "Background sleep running; awaiting completion.\n\n— still working (1m) · message me anytime, I'll keep you posted",
+      "Background sleep running; awaiting completion.\n\n_still working (1m) · message me anytime, I'll keep you posted_",
     )
 
     // Tick at 3 intervals total — second edit, "3m".
@@ -148,7 +148,7 @@ describe('pending-work-progress', () => {
     await flush()
     expect(cap.edits).toHaveLength(2)
     expect(cap.edits[1].newText).toBe(
-      "Background sleep running; awaiting completion.\n\n— still working (3m) · message me anytime, I'll keep you posted",
+      "Background sleep running; awaiting completion.\n\n_still working (3m) · message me anytime, I'll keep you posted_",
     )
   })
 
@@ -168,7 +168,7 @@ describe('pending-work-progress', () => {
     await flush()
     // The new edit should be based on 'worker dispatched' alone.
     expect(cap.edits[0].newText).toBe(
-      "worker dispatched\n\n— still working (1m) · message me anytime, I'll keep you posted",
+      "worker dispatched\n\n_still working (1m) · message me anytime, I'll keep you posted_",
     )
   })
 
@@ -186,7 +186,7 @@ describe('pending-work-progress', () => {
     __tickForTests(cap.now)
     await flush()
     expect(cap.edits[0].newText).toBe(
-      "worker dispatched\n\n— still working (1m) · message me anytime, I'll keep you posted",
+      "worker dispatched\n\n_still working (1m) · message me anytime, I'll keep you posted_",
     )
   })
 
@@ -336,17 +336,17 @@ describe('pending-work-progress', () => {
     expect(cap.edits).toHaveLength(0)
   })
 
-  // ─── #1698 regression — preserve parse_mode on the cross-turn edit ───
-  it("preserves the anchor's parse_mode on every edit (#1698)", async () => {
+  // ─── #1698 successor — preserve the anchor's send shape (literalText) on
+  //     every cross-turn edit (#2669 single-rich-path contract) ───
+  it("preserves the anchor's rich shape on every edit (default literalText=false)", async () => {
     const cap = setup()
     startTurn(KEY)
     noteAsyncDispatch(KEY)
-    // Anchor was sent through the reply tool with format='html', so
-    // the captured text is already rendered Telegram HTML.
+    // Anchor was sent via the rich-markdown path (the default), so the
+    // captured text is raw GFM markdown and the edit re-sends it richly.
     noteOutbound(KEY, {
       messageId: 100,
-      text: '<b>Worker back.</b> Both blockers fixed.',
-      parseMode: 'HTML',
+      text: '**Worker back.** Both blockers fixed.',
     })
     cap.now = 0
     noteTurnEnd(KEY)
@@ -354,42 +354,41 @@ describe('pending-work-progress', () => {
     __tickForTests(cap.now)
     await flush()
     expect(cap.edits).toHaveLength(1)
-    expect(cap.edits[0].parseMode).toBe('HTML')
+    expect(cap.edits[0].literalText).toBe(false)
     expect(cap.edits[0].newText).toBe(
-      "<b>Worker back.</b> Both blockers fixed.\n\n— still working (1m) · message me anytime, I'll keep you posted",
+      "**Worker back.** Both blockers fixed.\n\n_still working (1m) · message me anytime, I'll keep you posted_",
     )
   })
 
-  it('passes undefined parseMode through when the anchor was plain text', async () => {
+  it('threads literalText=true through when the anchor was a literal format:text send', async () => {
     const cap = setup()
     startTurn(KEY)
     noteAsyncDispatch(KEY)
-    // format: 'text' path — anchor was sent without parse_mode.
+    // format: 'text' path — the anchor was a literal plain send.
     noteOutbound(KEY, {
       messageId: 100,
       text: 'plain text reply',
-      parseMode: undefined,
+      literalText: true,
     })
     noteTurnEnd(KEY)
     cap.now = EDIT_INTERVAL_MS
     __tickForTests(cap.now)
     await flush()
-    expect(cap.edits[0].parseMode).toBeUndefined()
+    expect(cap.edits[0].literalText).toBe(true)
   })
 
-  it('defaults parseMode to undefined when caller omits it (test ergonomics)', async () => {
+  it('defaults literalText to false when caller omits it (rich path, test ergonomics)', async () => {
     const cap = setup()
     startTurn(KEY)
     noteAsyncDispatch(KEY)
-    // Callsite that hasn't been updated for the new field — must not
-    // typecheck-fail nor crash. The edit goes out parse_mode-less,
-    // matching the pre-#1698 behaviour for legacy callers.
+    // Callsite that omits the field — must not typecheck-fail nor crash.
+    // The edit goes out on the rich path (literalText=false).
     noteOutbound(KEY, { messageId: 100, text: 'wd' })
     noteTurnEnd(KEY)
     cap.now = EDIT_INTERVAL_MS
     __tickForTests(cap.now)
     await flush()
-    expect(cap.edits[0].parseMode).toBeUndefined()
+    expect(cap.edits[0].literalText).toBe(false)
   })
 
   it('multiple chats — independent state', async () => {

package/telegram-plugin/tests/permission-no-repeat-wiring.test.ts

@@ -41,12 +41,22 @@ describe('no-repeat-on-timeout wiring', () => {
   })
 
   it('the TTL auto-deny attaches a timeout message and records the signature', () => {
-    // Within the pending-permission sweep block.
-    const sweep = slice(GATEWAY, 'for (const [k, v] of pendingPermissions)', 2200)
+    // Within the pending-permission sweep block. Span bumped (2200 → 3200)
+    // when Bug 2 added per-tool TTL + the timed-out keyboard-strip to this
+    // block — the signature-record line now sits further down but the wiring
+    // is intact.
+    const sweep = slice(GATEWAY, 'for (const [k, v] of pendingPermissions)', 3200)
     expect(sweep).toContain('timeoutDenyMessage(')
     expect(sweep).toContain('permissionTimeoutSignatures.set(')
   })
 
+  it('the TTL auto-deny strips the timed-out card keyboard (Bug 2)', () => {
+    const sweep = slice(GATEWAY, 'for (const [k, v] of pendingPermissions)', 3200)
+    // Per-tool TTL + keyboard-strip are both wired into the sweep.
+    expect(sweep).toContain('ttlForTool(')
+    expect(sweep).toContain('stripTimedOutPermissionCards(')
+  })
+
   it('onPermissionRequest short-circuits a recent-timeout duplicate before posting a card', () => {
     const fn = slice(GATEWAY, 'onPermissionRequest(', 4000)
     const dupIdx = fn.indexOf('isRecentTimeoutDuplicate(')

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

@@ -13,6 +13,13 @@ import {
   timeoutDenyMessage,
   duplicateDenyMessage,
   isRecentTimeoutDuplicate,
+  PERMISSION_TTL_MS,
+  HOSTD_PERMISSION_TTL_MS,
+  ttlForTool,
+  buildTimedOutCardEdits,
+  isStaleTap,
+  STALE_TAP_NOTICE,
+  TIMED_OUT_FOOTER,
 } from '../gateway/permission-timeout.js'
 
 describe('permissionSignature', () => {
@@ -85,3 +92,73 @@ describe('isRecentTimeoutDuplicate', () => {
     expect(isRecentTimeoutDuplicate(m, permissionSignature('t', 'Rentals'), NOW, WINDOW)).toBe(true)
   })
 })
+
+// ─── 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', () => {
+    for (const tool of [
+      'mcp__hostd__rollout',
+      'mcp__hostd__update_apply',
+      'mcp__hostd__agent_restart',
+      'mcp__hostd__agent_exec',
+      'mcp__hostd__config_propose_edit',
+    ]) {
+      expect(ttlForTool(tool)).toBe(HOSTD_PERMISSION_TTL_MS)
+      expect(ttlForTool(tool)).toBe(30 * 60_000)
+    }
+  })
+
+  it('keeps the 10-min default for non-hostd tools', () => {
+    expect(ttlForTool('Bash')).toBe(PERMISSION_TTL_MS)
+    expect(ttlForTool('Bash')).toBe(10 * 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)
+  })
+})
+
+describe('buildTimedOutCardEdits (Bug 2 fix #1 — strip stale keyboard)', () => {
+  it('marks every recorded card for keyboard-strip and appends the footer', () => {
+    const cards = [
+      { chatId: '111', messageId: 5 },
+      { chatId: '222', messageId: 9 },
+    ]
+    const edits = buildTimedOutCardEdits('🔐 **Overlord** wants to roll the fleet', cards)
+    expect(edits).toHaveLength(2)
+    for (const [i, edit] of edits.entries()) {
+      // The keyboard MUST be stripped — a live Approve on a dead request_id is
+      // exactly the bug.
+      expect(edit.stripKeyboard).toBe(true)
+      expect(edit.chatId).toBe(cards[i]!.chatId)
+      expect(edit.messageId).toBe(cards[i]!.messageId)
+      expect(edit.text).toContain('roll the fleet')
+      expect(edit.text).toContain('Timed out — re-request to act')
+      expect(edit.text.endsWith(TIMED_OUT_FOOTER)).toBe(true)
+    }
+  })
+
+  it('returns no edits when there were no recorded cards', () => {
+    expect(buildTimedOutCardEdits('body', [])).toEqual([])
+  })
+})
+
+describe('isStaleTap (Bug 2 fix #3 — do not dispatch a verdict for a dead id)', () => {
+  it('is stale when no pending entry exists for the tapped request_id', () => {
+    // hasPending=false ⇒ the reaper already auto-denied + deleted it.
+    expect(isStaleTap(false)).toBe(true)
+  })
+
+  it('is NOT stale (live id) when a pending entry still exists', () => {
+    expect(isStaleTap(true)).toBe(false)
+  })
+
+  it('exposes an honest operator notice for the stale path', () => {
+    expect(STALE_TAP_NOTICE).toMatch(/already resolved/i)
+    expect(STALE_TAP_NOTICE).toMatch(/ask again/i)
+  })
+})