switchroom 0.16.24 → 0.16.28

package/telegram-plugin/tests/ipc-server-validate-send-outbound.test.ts

@@ -7,6 +7,7 @@
  */
 import { describe, it, expect } from "vitest";
 import { validateClientMessage } from "../gateway/ipc-server.js";
+import { RICH_MESSAGE_MAX_CHARS } from "../format.js";
 
 const base = { type: "send_outbound", agentName: "clerk", chatId: "12345", text: "Daily heartbeat" };
 
@@ -38,8 +39,11 @@ describe("validateClientMessage — send_outbound", () => {
     expect(validateClientMessage({ ...base, text: undefined })).toBe(false);
     expect(validateClientMessage({ ...base, text: "" })).toBe(false);
     expect(validateClientMessage({ ...base, text: 5 })).toBe(false);
-    expect(validateClientMessage({ ...base, text: "x".repeat(4096) })).toBe(true); // at the cap
-    expect(validateClientMessage({ ...base, text: "x".repeat(4097) })).toBe(false); // over Telegram's limit
+    // send_outbound posts via sendRichMessage (rich path), so the cap is the
+    // rich-message wire limit (RICH_MESSAGE_MAX_CHARS, 32768) post-#2669, not
+    // the legacy 4096 plain-text limit.
+    expect(validateClientMessage({ ...base, text: "x".repeat(RICH_MESSAGE_MAX_CHARS) })).toBe(true); // at the cap
+    expect(validateClientMessage({ ...base, text: "x".repeat(RICH_MESSAGE_MAX_CHARS + 1) })).toBe(false); // over the cap
   });
 
   it("rejects a non-integer threadId", () => {

package/telegram-plugin/tests/length-error-classify.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Tests for the over-length error classification (task E of the Telegram-
+ * formatting bundle) and the hardSliceToCap last-resort slicer.
+ *
+ * The rich path rejects a 32769+ char body with `RICH_MESSAGE_TEXT_TOO_LONG`
+ * (and the legacy plain path with `MESSAGE_TOO_LONG`). That is a LENGTH error,
+ * not a markdown-parse error — it must be classified so the caller re-splits
+ * the body rather than (a) misclassifying it as a parse-reject and resending
+ * the same oversized payload as plain text, or (b) surfacing the raw 400.
+ */
+import { describe, test, expect } from 'vitest'
+import { GrammyError } from 'grammy'
+import { isLengthError, isParseEntitiesError } from '../rich-send.js'
+import { isMessageTooLongError, isHtmlParseRejectError } from '../retry-api-call.js'
+import { hardSliceToCap, splitMarkdownChunks, RICH_MESSAGE_MAX_CHARS } from '../format.js'
+
+// Build a GrammyError with a given 400 description. GrammyError's constructor
+// takes (message, payload, method, parameters) in grammy 1.44.
+function grammy400(description: string): GrammyError {
+  return new GrammyError(
+    `Call to 'sendRichMessage' failed! (400: ${description})`,
+    { ok: false, error_code: 400, description },
+    'sendRichMessage',
+    {},
+  )
+}
+
+describe('length-error classification (rich-send.isLengthError)', () => {
+  test('RICH_MESSAGE_TEXT_TOO_LONG is a length error', () => {
+    const err = grammy400('RICH_MESSAGE_TEXT_TOO_LONG')
+    expect(isLengthError(err)).toBe(true)
+  })
+
+  test('legacy MESSAGE_TOO_LONG / "message is too long" are length errors', () => {
+    expect(isLengthError(grammy400('MESSAGE_TOO_LONG'))).toBe(true)
+    expect(isLengthError(grammy400('Bad Request: message is too long'))).toBe(true)
+  })
+
+  test('a parse-entities error is NOT a length error', () => {
+    expect(isLengthError(grammy400("can't parse entities: bad offset"))).toBe(false)
+  })
+
+  test('a length error is NOT misclassified as a parse-entities error', () => {
+    const err = grammy400('RICH_MESSAGE_TEXT_TOO_LONG')
+    expect(isParseEntitiesError(err)).toBe(false)
+  })
+
+  test('non-GrammyError and non-400 are neither', () => {
+    expect(isLengthError(new Error('boom'))).toBe(false)
+    const err403 = new GrammyError(
+      'forbidden',
+      { ok: false, error_code: 403, description: 'Forbidden: bot was blocked' },
+      'sendRichMessage',
+      {},
+    )
+    expect(isLengthError(err403)).toBe(false)
+  })
+})
+
+describe('length-error classification (retry-api-call.isMessageTooLongError)', () => {
+  test('RICH_MESSAGE_TEXT_TOO_LONG is a length error', () => {
+    expect(isMessageTooLongError(grammy400('RICH_MESSAGE_TEXT_TOO_LONG'))).toBe(true)
+  })
+
+  test('a length error is NOT misclassified as an html-parse-reject', () => {
+    const err = grammy400('RICH_MESSAGE_TEXT_TOO_LONG')
+    expect(isHtmlParseRejectError(err)).toBe(false)
+  })
+
+  test('a parse-reject error still classifies as a parse-reject (not length)', () => {
+    const err = grammy400("can't parse entities: unexpected end")
+    expect(isHtmlParseRejectError(err)).toBe(true)
+    expect(isMessageTooLongError(err)).toBe(false)
+  })
+})
+
+describe('hardSliceToCap', () => {
+  test('returns the input as one piece when it already fits', () => {
+    expect(hardSliceToCap('short', 100)).toEqual(['short'])
+  })
+
+  test('slices an oversized body into pieces each <= cap', () => {
+    const body = 'x'.repeat(250)
+    const pieces = hardSliceToCap(body, 100)
+    expect(pieces).toHaveLength(3)
+    for (const p of pieces) expect(p.length).toBeLessThanOrEqual(100)
+    expect(pieces.join('')).toBe(body)
+  })
+
+  test('defaults the cap to RICH_MESSAGE_MAX_CHARS', () => {
+    const body = 'y'.repeat(RICH_MESSAGE_MAX_CHARS + 5)
+    const pieces = hardSliceToCap(body)
+    expect(pieces).toHaveLength(2)
+    expect(pieces[0].length).toBe(RICH_MESSAGE_MAX_CHARS)
+    expect(pieces[1].length).toBe(5)
+  })
+})
+
+// The gateway length-error recovery (gateway.ts sendChunkResplit, ~8758) re-splits
+// an oversized chunk with `splitMarkdownChunks` and falls back to `hardSliceToCap`
+// when the block is indivisible. These tests pin that seam at the function level:
+// a >RICH_MESSAGE_MAX_CHARS body is ALWAYS chunked into >=2 sends (each <= cap),
+// never silently dropped or resent whole on a RICH_MESSAGE_TEXT_TOO_LONG reject.
+describe('resplit-on-reject: oversized body chunks into >=2 sends', () => {
+  test('a >cap body with prose boundaries re-splits into >=2 chunks each <= cap', () => {
+    // A paragraph-separated body twice the cap: splitMarkdownChunks finds the
+    // `\n\n` boundaries and yields multiple chunks.
+    const para = 'x'.repeat(4000)
+    const body = Array.from({ length: 20 }, () => para).join('\n\n')
+    expect(body.length).toBeGreaterThan(RICH_MESSAGE_MAX_CHARS)
+    const pieces = splitMarkdownChunks(body, RICH_MESSAGE_MAX_CHARS)
+    expect(pieces.length).toBeGreaterThanOrEqual(2)
+    for (const p of pieces) expect(p.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS)
+  })
+
+  test('an indivisible >cap blob falls back through hardSliceToCap to >=2 chunks each <= cap', () => {
+    // A single boundary-free blob larger than the cap: splitMarkdownChunks
+    // cannot break it and emits it whole (length > cap), so the recovery path
+    // hands it to hardSliceToCap — mirroring sendChunkResplit's fallback.
+    const blob = 'z'.repeat(RICH_MESSAGE_MAX_CHARS + 5000)
+    const subPieces = splitMarkdownChunks(blob, RICH_MESSAGE_MAX_CHARS)
+    const pieces =
+      subPieces.length > 1 && subPieces.every((p) => p.length <= RICH_MESSAGE_MAX_CHARS)
+        ? subPieces
+        : hardSliceToCap(blob, RICH_MESSAGE_MAX_CHARS)
+    expect(pieces.length).toBeGreaterThanOrEqual(2)
+    for (const p of pieces) expect(p.length).toBeLessThanOrEqual(RICH_MESSAGE_MAX_CHARS)
+    // Nothing is dropped — the pieces reconstitute the original body.
+    expect(pieces.join('')).toBe(blob)
+  })
+})

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/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)
+  })
+})

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

@@ -368,6 +368,49 @@ describe('formatPermissionCardBody', () => {
   })
 })
 
+// Bug 1: the hostd rollout verb gained an optional `reason` (which the agent
+// can now actually supply) and a curated MCP_TOOL_DESCRIPTIONS title, so the
+// card stops rendering the generic "rollout (Hostd)" with "why: not provided".
+describe('formatPermissionCardBody — hostd rollout (Bug 1)', () => {
+  test('renders the caller-supplied reason on the why: line', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__hostd__rollout',
+      inputPreview: JSON.stringify({
+        reason: 'promote canary-green v0.16.24 to the fleet',
+        pin: 'v0.16.24',
+      }),
+      description: 'SAFELY roll the fleet to a pinned SEMVER version …',
+      agentName: 'overlord',
+    })
+    expect(body).toContain('why: _promote canary-green v0.16.24 to the fleet_')
+    // #2469: never the schema description.
+    expect(body).not.toContain('SAFELY roll the fleet')
+  })
+
+  test('renders the clean MCP_TOOL_DESCRIPTIONS title, not the raw tool id', () => {
+    const body = formatPermissionCardBody({
+      toolName: 'mcp__hostd__rollout',
+      inputPreview: JSON.stringify({
+        reason: 'rollback to last-good tag',
+        pin: 'v0.16.20',
+      }),
+      description: 'desc',
+      agentName: 'overlord',
+    })
+    const firstLine = body.split('\n')[0]
+    // Curated phrase from MCP_TOOL_DESCRIPTIONS["mcp__hostd__rollout"].
+    expect(firstLine).toBe('🔐 **Overlord** wants to roll the fleet to a pinned version')
+    expect(firstLine).not.toContain('mcp__hostd__rollout')
+    expect(firstLine).not.toMatch(/rollout \(Hostd\)/i)
+  })
+
+  test('naturalAction surfaces the curated title for the rollout verb', () => {
+    expect(naturalAction('mcp__hostd__rollout', undefined)).toBe(
+      'roll the fleet to a pinned version',
+    )
+  })
+})
+
 describe('describeGrant — phrased from the chosen scope', () => {
   test('MCP server wildcard → "use any <Server> tool"', () => {
     expect(describeGrant('mcp__perplexity__search', undefined, opt('mcp__perplexity__*'))).toBe(

package/telegram-plugin/tests/poll-health.test.ts

@@ -68,6 +68,70 @@ describe("createPollHealthCheck", () => {
     hc.stop();
   });
 
+  it("detects stall when getMe passes but getUpdates heartbeat is stale", async () => {
+    // Simulates the 2026-06-30 incident: one getUpdates TimeoutError left the
+    // grammy runner loop frozen. getMe kept succeeding so the original
+    // getMe-only health check never fired. Fleet was deaf for 2 h.
+    // The fix: ping() also checks lastGetUpdatesHeartbeatMs; if stale, throws
+    // so the failure counter increments and stall recovery fires.
+    const onStall = vi.fn().mockResolvedValue(undefined);
+    let tickFn: () => void = () => {};
+    let lastGetUpdatesMs = Date.now() - 999_999; // very stale
+    const staleThresholdMs = 180_000; // 3 min (threshold × interval)
+
+    const hc = createPollHealthCheck({
+      ping: async () => {
+        // getMe succeeds (network fine):
+        // (no throw from network layer)
+        // heartbeat stale check (mirrors gateway.ts logic):
+        const staleMs = Date.now() - lastGetUpdatesMs;
+        if (staleMs > staleThresholdMs) {
+          throw new Error(
+            `getUpdates heartbeat stale: last seen ${Math.round(staleMs / 1000)}s ago — runner loop frozen`,
+          );
+        }
+      },
+      onStall,
+      failureThreshold: 3,
+      setIntervalFn: (fn) => { tickFn = fn; return 1 as unknown as ReturnType<typeof setInterval>; },
+      clearIntervalFn: () => {},
+      log: () => {},
+    });
+    hc.start();
+    tickFn(); await Promise.resolve();
+    tickFn(); await Promise.resolve();
+    tickFn(); await Promise.resolve();
+    await new Promise((r) => setTimeout(r, 10));
+    expect(onStall).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT stall when getUpdates heartbeat is fresh", async () => {
+    const onStall = vi.fn().mockResolvedValue(undefined);
+    let tickFn: () => void = () => {};
+    let lastGetUpdatesMs = Date.now(); // fresh
+    const staleThresholdMs = 180_000;
+
+    const hc = createPollHealthCheck({
+      ping: async () => {
+        const staleMs = Date.now() - lastGetUpdatesMs;
+        if (staleMs > staleThresholdMs) {
+          throw new Error("getUpdates heartbeat stale");
+        }
+      },
+      onStall,
+      failureThreshold: 3,
+      setIntervalFn: (fn) => { tickFn = fn; return 1 as unknown as ReturnType<typeof setInterval>; },
+      clearIntervalFn: () => {},
+      log: () => {},
+    });
+    hc.start();
+    for (let i = 0; i < 5; i++) {
+      tickFn(); await Promise.resolve();
+    }
+    expect(onStall).not.toHaveBeenCalled();
+    hc.stop();
+  });
+
   it("stop() cancels the interval", () => {
     const onStall = vi.fn();
     let cleared = false;