switchroom 0.16.29 → 0.16.46

package/telegram-plugin/tests/tool-activity-summary.test.ts

@@ -84,10 +84,10 @@ describe("appendActivityLine + renderActivityFeed — accumulating activity feed
       "**→ Reading gateway.ts**",
     );
     expect(appendActivityLine(lines, "mcp__hindsight__reflect", { query: "x" })).toBe(
-      "_✓ Reading gateway.ts_\n**→ Searching memory**",
+      "~~_✓ Reading gateway.ts_~~  \n**→ Searching memory**",
     );
     expect(appendActivityLine(lines, "Bash", { command: "ls", description: "List workspace" })).toBe(
-      "_✓ Reading gateway.ts_\n_✓ Searching memory_\n**→ List workspace**",
+      "~~_✓ Reading gateway.ts_~~  \n~~_✓ Searching memory_~~  \n**→ List workspace**",
     );
   });
 
@@ -110,14 +110,14 @@ describe("appendActivityLine + renderActivityFeed — accumulating activity feed
     const lines = Array.from({ length: total }, (_, i) => `Action ${i + 1}`);
     const out = renderActivityFeed(lines)!;
     const hidden = total - STATUS_ROLLING_LINES;
-    expect(out.startsWith(`_✓ +${hidden} earlier…_\n`)).toBe(true);
+    expect(out.startsWith(`_✓ +${hidden} earlier…_  \n`)).toBe(true);
     // Only the last STATUS_ROLLING_LINES actions are shown; older ones collapsed.
     const firstVisible = total - STATUS_ROLLING_LINES + 1;
-    expect(out).toContain(`_✓ Action ${firstVisible}_`);
+    expect(out).toContain(`~~_✓ Action ${firstVisible}_~~`);
     expect(out).not.toContain(`Action ${firstVisible - 1}<`);
     // The newest action is the in-progress step (bold →); the rest are done (✓).
     expect(out).toContain(`**→ Action ${total}**`);
-    expect(out).toContain(`_✓ Action ${total - 1}_`);
+    expect(out).toContain(`~~_✓ Action ${total - 1}_~~`);
     expect(out).not.toContain(`**→ Action ${total - 1}**`);
   });
 
@@ -145,26 +145,46 @@ describe("appendActivityLine + renderActivityFeed — accumulating activity feed
     const lines = ["Reading a.ts", "Searching memory", "Running a command"];
     const out = renderActivityFeed(lines, true)!;
     expect(out).toBe(
-      "_✓ Reading a.ts_\n_✓ Searching memory_\n_✓ Running a command_",
+      "~~_✓ Reading a.ts_~~  \n~~_✓ Searching memory_~~  \n~~_✓ Running a command_~~",
     );
     expect(out).not.toContain("→"); // no in-progress arrow anywhere
   });
 
   it("final=true on a single line is also done (✓)", () => {
-    expect(renderActivityFeed(["Reading a.ts"], true)).toBe("_✓ Reading a.ts_");
+    expect(renderActivityFeed(["Reading a.ts"], true)).toBe("~~_✓ Reading a.ts_~~");
   });
 
   it("final defaults false (live render keeps the → in-progress newest line)", () => {
     expect(renderActivityFeed(["Reading a.ts"])).toBe("**→ Reading a.ts**");
   });
 
+  // Strikethrough contract (operator request): done (✓) step lines render with
+  // GFM strikethrough wrapping the italic so completed items visually recede,
+  // while the active (→ bold) line is never struck.
+  it("done step lines are struck (~~) AND italic; the active → line is not struck", () => {
+    const out = renderActivityFeed(["Reading a.ts", "Searching memory"])!;
+    // earlier step is done → struck italic
+    expect(out).toContain("~~_✓ Reading a.ts_~~");
+    // newest step is active → bold, NOT struck
+    expect(out).toContain("**→ Searching memory**");
+    expect(out).not.toContain("~~_✓ Searching memory_~~");
+    expect(out).not.toContain("~~**→");
+    // the meta/footer count lines stay UNSTRUCK (kept legible as meta)
+    const overflow = Array.from({ length: STATUS_ROLLING_LINES + 2 }, (_, i) => `Action ${i + 1}`);
+    const finalOut = renderActivityFeed(overflow, true, "", overflow.length)!;
+    expect(finalOut).toContain(`_✓ +${overflow.length - STATUS_ROLLING_LINES} earlier…_`);
+    expect(finalOut).toContain(`_✓ ${overflow.length} steps_`);
+    expect(finalOut).not.toContain(`~~_✓ +`);
+    expect(finalOut).not.toContain(`~~_✓ ${overflow.length} steps_~~`);
+  });
+
   // liveSuffix (PR1 heartbeat): appended INSIDE the newest in-progress line so a
   // long single step visibly advances ("→ Pulling Meta data · 18s") even though
   // the feed is pull-only and no new tool label arrived.
   describe("liveSuffix (heartbeat)", () => {
     it("appends the suffix to the newest in-progress line only", () => {
       expect(renderActivityFeed(["Reading a.ts", "Running a command"], false, " · 18s")).toBe(
-        "_✓ Reading a.ts_\n**→ Running a command · 18s**",
+        "~~_✓ Reading a.ts_~~  \n**→ Running a command · 18s**",
       );
     });
     it("single live line gets the suffix", () => {
@@ -176,7 +196,7 @@ describe("appendActivityLine + renderActivityFeed — accumulating activity feed
       const out = renderActivityFeed(["Reading a.ts", "Running a command"], true, " · 18s")!;
       expect(out).not.toContain("·");
       expect(out).not.toContain("→");
-      expect(out).toBe("_✓ Reading a.ts_\n_✓ Running a command_");
+      expect(out).toBe("~~_✓ Reading a.ts_~~  \n~~_✓ Running a command_~~");
     });
     it("default empty suffix is byte-identical to no suffix", () => {
       expect(renderActivityFeed(["Reading a.ts"], false, "")).toBe(
@@ -191,7 +211,7 @@ describe("appendActivityLabel — precomputed label feed (tool_label path)", ()
     const lines: string[] = [];
     expect(appendActivityLabel(lines, "Searching memory")).toBe("**→ Searching memory**");
     expect(appendActivityLabel(lines, "List workspace")).toBe(
-      "_✓ Searching memory_\n**→ List workspace**",
+      "~~_✓ Searching memory_~~  \n**→ List workspace**",
     );
     // consecutive dup collapses
     appendActivityLabel(lines, "List workspace");
@@ -221,10 +241,15 @@ describe("clipNarrative — narrative-step clip (JSONL-text-narrative primitive)
     const narrativeLines: string[] = [];
     const labelLines: string[] = [];
     const text = "Important find: no main branch yet — branching off origin.";
+    // F1: the feed renders through renderStatusCard → stripMarkdown, which now
+    // normalizes em/en-dashes on this card surface. A narrative and a label go
+    // through the exact same path, so the render is still byte-identical — the
+    // dash is scrubbed to a full stop (new sentence, recapitalized) in BOTH.
+    const scrubbed = "Important find: no main branch yet. Branching off origin.";
     const narrativeRender = appendActivityLabel(narrativeLines, clipNarrative(text));
     const labelRender = appendActivityLabel(labelLines, clipNarrative(text));
     expect(narrativeRender).toBe(labelRender);
-    expect(narrativeRender).toBe(`**→ ${text}**`);
+    expect(narrativeRender).toBe(`**→ ${scrubbed}**`);
   });
 
   it("empty string yields an empty clip (appendActivityLabel then drops it)", () => {
@@ -238,7 +263,7 @@ describe("renderActivityFeed — ✓ N steps total (final render, issue #2461)",
     const lines = ["Reading CLAUDE.md", "Searching memory", "Running a command"];
     const out = renderActivityFeed(lines, true, "", 5)!;
     // All lines are done (✓) and the footer is appended.
-    expect(out).toContain("_✓ Running a command_");
+    expect(out).toContain("~~_✓ Running a command_~~");
     expect(out).toContain("_✓ 5 steps_");
     expect(out.endsWith("_✓ 5 steps_")).toBe(true);
   });
@@ -247,7 +272,7 @@ describe("renderActivityFeed — ✓ N steps total (final render, issue #2461)",
     const lines = ["Reading CLAUDE.md"];
     const out = renderActivityFeed(lines, true, "", 0)!;
     expect(out).not.toContain("steps");
-    expect(out).toBe("_✓ Reading CLAUDE.md_");
+    expect(out).toBe("~~_✓ Reading CLAUDE.md_~~");
   });
 
   it("stepCount undefined → no footer (live/non-final callers omit it)", () => {
@@ -307,11 +332,11 @@ describe("renderActivityFeedWithNested — foreground sub-agent nesting (Model A
     const child = ["Reading schema.ts", "Looking for foreign keys"];
     const out = renderActivityFeedWithNested(parent, child)!;
     // Parent is blocked at the Task tool → none of its lines is the live step.
-    expect(out).toContain("_✓ Searching memory_");
-    expect(out).toContain("_✓ Delegating: review the migration_");
+    expect(out).toContain("~~_✓ Searching memory_~~");
+    expect(out).toContain("~~_✓ Delegating: review the migration_~~");
     expect(out).not.toContain("**→ Delegating");
     // The live → step is the newest nested child line; earlier child = italic.
-    expect(out).toContain("   ↳ _Reading schema.ts_");
+    expect(out).toContain("   ↳ ~~_Reading schema.ts_~~");
     expect(out).toContain("   ↳ **→ Looking for foreign keys**");
   });
 
@@ -342,13 +367,13 @@ describe("renderActivityFeedWithNested — foreground sub-agent nesting (Model A
       ["Reading schema.ts", "Looking for foreign keys"],
       true,
     )!;
-    expect(out).toContain("   ↳ _Looking for foreign keys_"); // newest now italic done
+    expect(out).toContain("   ↳ ~~_Looking for foreign keys_~~"); // newest now struck italic done
     expect(out).not.toContain("→"); // no in-progress arrow in the finalized feed
   });
 
   it("final=true with no children delegates to the finalized flat render", () => {
     expect(renderActivityFeedWithNested(["Reading a.ts"], [], true)).toBe(
-      "_✓ Reading a.ts_",
+      "~~_✓ Reading a.ts_~~",
     );
   });
 
@@ -381,7 +406,7 @@ describe("renderActivityFeedWithNested — foreground sub-agent nesting (Model A
   it("stepCount footer appears on final=true with no children (delegates to flat render)", () => {
     const out = renderActivityFeedWithNested(["Reading a.ts"], [], true, "", 3)!;
     expect(out).toContain("_✓ 3 steps_");
-    expect(out).toBe("_✓ Reading a.ts_\n_✓ 3 steps_");
+    expect(out).toBe("~~_✓ Reading a.ts_~~  \n_✓ 3 steps_");
   });
 
   // Liveness-driven feed open (dark-turn fix): a turn that emits no tool_label
@@ -398,7 +423,7 @@ describe("renderActivityFeedWithNested — foreground sub-agent nesting (Model A
 
     it("finalizes the placeholder to a done record (no frozen → line)", () => {
       expect(renderActivityFeedWithNested(["Working…"], [], true)).toBe(
-        "_✓ Working…_",
+        "~~_✓ Working…_~~",
       );
     });
 
@@ -612,8 +637,8 @@ describe("extreme-edge: single oversized line with markdown specials & && _ *",
     expect(out).not.toBeNull();
     expect(out.length).toBeLessThanOrEqual(4000);
     expect(isValidMarkdown(out)).toBe(true);
-    expect(out.startsWith("_✓ ")).toBe(true);
-    expect(out.endsWith("_")).toBe(true);
+    expect(out.startsWith("~~_✓ ")).toBe(true);
+    expect(out.endsWith("_~~")).toBe(true);
   });
 
   it("renderActivityFeedWithNested: single ~4100-char parent line → ≤ budget and valid markdown", () => {
@@ -770,7 +795,7 @@ describe("renderActivityFeed — header param (main-session card fix)", () => {
     expect(out).toContain("🤖 **Agent**");
     expect(out).toContain("_15s · 7 tools_");
     // Step feed follows the header.
-    expect(out).toContain("_✓ Reading CLAUDE.md_");
+    expect(out).toContain("~~_✓ Reading CLAUDE.md_~~");
     expect(out).toContain("**→ Searching memory**");
   });
 
@@ -784,7 +809,7 @@ describe("renderActivityFeed — header param (main-session card fix)", () => {
     const out = renderActivityFeed(["Reading CLAUDE.md"], true, "", undefined, header)!;
     expect(out).toContain("🤖 **Agent**");
     expect(out).toContain("_done · 3 tools · 1m05s_");
-    expect(out).toContain("_✓ Reading CLAUDE.md_");
+    expect(out).toContain("~~_✓ Reading CLAUDE.md_~~");
     // No in-progress arrow (final=true).
     expect(out).not.toContain("→");
   });
@@ -824,7 +849,7 @@ describe("renderActivityFeed — header param (main-session card fix)", () => {
     expect(out).toContain("🤖 **Agent**");
     expect(out).toContain("_30s · 5 tools_");
     // Parent step is done-styled (child is the live step).
-    expect(out).toContain("_✓ Delegating: review_");
+    expect(out).toContain("~~_✓ Delegating: review_~~");
     // Child step is the in-progress step.
     expect(out).toContain("   ↳ **→ Reading schema.ts**");
   });
@@ -847,3 +872,41 @@ describe("describeToolUse — surface-tool suppression is key-agnostic", () => {
     expect(describeToolUse("mcp__clerk-telegram__react", {})).toBeNull();
   });
 });
+
+describe("status-card body stacks like a reply (#2669 rich-message renderer)", () => {
+  // The single most-seen surface: the operator's progress card. Its step lines
+  // are styled prose (`~~_✓ …_~~`, `**→ …**`), NOT GFM list items, so a lone `\n`
+  // between them is a SOFT break the renderer collapses — bullets ran together
+  // into one line. The card now joins via stackCardLines (hard breaks), so the
+  // bullets stack exactly as the reply path renders them.
+
+  it("multiple step bullets stack on their own lines (no soft-break collapse)", () => {
+    const out = renderActivityFeed(["Reading a.ts", "Searching memory", "Running tests"], true)!;
+    const lines = out.split("  \n");
+    expect(lines).toEqual(["~~_✓ Reading a.ts_~~", "~~_✓ Searching memory_~~", "~~_✓ Running tests_~~"]);
+    // Not a single lone `\n` survives to collapse two bullets.
+    expect(out).not.toMatch(/(?<! {2})\n/);
+  });
+
+  it("the collapsed-inline-bullet case is fixed on a card body specifically", () => {
+    // Three labels that, joined by a lone `\n`, would render as a single run-on
+    // visual line in the rich renderer. After stacking, each renders distinctly.
+    const out = renderActivityFeed(["Editing foo.ts", "Editing bar.ts", "Writing baz.ts"])!;
+    // Every adjacent pair is separated by a hard break.
+    expect(out.match(/ {2}\n/g)?.length).toBe(2);
+    // The newest is the in-progress bold step; earlier are done — all visible.
+    expect(out).toContain("~~_✓ Editing foo.ts_~~");
+    expect(out).toContain("~~_✓ Editing bar.ts_~~");
+    expect(out).toContain("**→ Writing baz.ts**");
+  });
+
+  it("stacking does not corrupt the card's own italic/bold wrapper markup", () => {
+    // The status card wraps each step in `_…_` (done) or `**→ …**` (live). The
+    // stacking pass only changes the SEPARATOR between lines — the per-line
+    // wrapper markup must be byte-identical. (Step TEXT is stripped to plain
+    // prose by escapeStepLine; the inline-markup-survives case is covered by
+    // the stackCardLines unit test, which operates on pre-rendered lines.)
+    const out = renderActivityFeed(["Reading a.ts", "Running tests"], false)!;
+    expect(out).toBe("~~_✓ Reading a.ts_~~  \n**→ Running tests**");
+  });
+});

package/telegram-plugin/tests/tts-normalize.test.ts

@@ -0,0 +1,242 @@
+/**
+ * Tests for tts-normalize.ts — deterministic L1 TTS normalization
+ * (issue #2760, Phase 1). Bun test (this dir uses bun test, not vitest).
+ */
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
+import { normalizeForTts, ttsNormalizeEnabled } from '../tts-normalize.js'
+
+const KILL = 'SWITCHROOM_DISABLE_TTS_NORMALIZE'
+
+let savedKill: string | undefined
+
+beforeEach(() => {
+  savedKill = process.env[KILL]
+  delete process.env[KILL]
+})
+
+afterEach(() => {
+  if (savedKill === undefined) delete process.env[KILL]
+  else process.env[KILL] = savedKill
+})
+
+describe('gating', () => {
+  test('ON by default — normalizes with no env vars set', () => {
+    expect(ttsNormalizeEnabled()).toBe(true)
+    expect(normalizeForTts('**bold** $5.20')).toBe('bold five dollars twenty')
+  })
+
+  test('kill switch → byte-identical pass-through', () => {
+    process.env[KILL] = '1'
+    const input = '**bold** and $5.20 🚀 https://github.com/x'
+    expect(normalizeForTts(input)).toBe(input)
+    expect(ttsNormalizeEnabled()).toBe(false)
+  })
+
+  test('kill switch accepts "true"', () => {
+    process.env[KILL] = 'true'
+    expect(ttsNormalizeEnabled()).toBe(false)
+  })
+
+  test('empty input stays empty', () => {
+    expect(normalizeForTts('')).toBe('')
+  })
+})
+
+describe('markdown', () => {
+  test('bold/italic/strike markers removed', () => {
+    expect(normalizeForTts('**bold** and *italic* and ~~gone~~')).toBe(
+      'bold and italic and gone',
+    )
+  })
+
+  test('headings become plain text', () => {
+    expect(normalizeForTts('## Status report\nAll good')).toBe(
+      'Status report All good',
+    )
+  })
+
+  test('links become link text', () => {
+    expect(normalizeForTts('see [the docs](https://example.com/a/b) now')).toBe(
+      'see the docs now',
+    )
+  })
+
+  test('list markers dropped', () => {
+    expect(normalizeForTts('- first\n- second')).toBe('first second')
+  })
+
+  test('blockquote markers dropped', () => {
+    expect(normalizeForTts('> quoted line')).toBe('quoted line')
+  })
+
+  test('code fences become spoken placeholder', () => {
+    const out = normalizeForTts('before\n```ts\nconst x = 1\n```\nafter')
+    expect(out).toContain('code block omitted')
+    expect(out).not.toContain('const x')
+  })
+
+  test('inline code read as-is without backticks, content untouched', () => {
+    expect(normalizeForTts('run `deploy_5km_run` now')).toBe(
+      'run deploy_5km_run now',
+    )
+  })
+
+  test('unterminated fence swallows to end-of-input (deliberate)', () => {
+    // An opening ``` with no close drops everything after it — reading
+    // half a code block aloud is worse than omitting it. Pinned as the
+    // intended trade-off.
+    const out = normalizeForTts('before\n```ts\nconst secret = 1\nmore code')
+    expect(out).toBe('before code block omitted.')
+  })
+
+  test('tables summarized as table omitted', () => {
+    const out = normalizeForTts('| a | b |\n|---|---|\n| 1 | 2 |\n')
+    expect(out).toContain('table omitted')
+    expect(out).not.toContain('|')
+  })
+})
+
+describe('numbers', () => {
+  test('currency $5.20 → five dollars twenty', () => {
+    expect(normalizeForTts('that costs $5.20 today')).toBe(
+      'that costs five dollars twenty today',
+    )
+  })
+
+  test('whole-dollar and singular', () => {
+    expect(normalizeForTts('$1 fee')).toBe('one dollar fee')
+    expect(normalizeForTts('$300 total')).toBe('three hundred dollars total')
+  })
+
+  test('percent 12% → twelve percent', () => {
+    expect(normalizeForTts('up 12% overnight')).toBe('up twelve percent overnight')
+  })
+
+  test('ordinal 3rd → third', () => {
+    expect(normalizeForTts('the 3rd item and the 21st day')).toBe(
+      'the third item and the twenty-first day',
+    )
+  })
+
+  test('time 14:30 spoken', () => {
+    expect(normalizeForTts('meet at 14:30 sharp')).toBe(
+      'meet at fourteen thirty sharp',
+    )
+  })
+
+  test('ISO date spoken', () => {
+    expect(normalizeForTts('due 2026-07-04 ok')).toBe(
+      'due July fourth two thousand twenty-six ok',
+    )
+  })
+
+  test('phone-like digit run read as digits', () => {
+    expect(normalizeForTts('call 0412 345 678 now')).toBe(
+      'call zero four one two three four five six seven eight now',
+    )
+  })
+
+  test('international +-prefixed number read as digits', () => {
+    expect(normalizeForTts('call +61 412 345 678')).toBe(
+      'call plus six one four one two three four five six seven eight',
+    )
+  })
+
+  test('ordinary space-separated numbers stay untouched', () => {
+    expect(normalizeForTts('scores were 1024 2048 4096 today')).toBe(
+      'scores were 1024 2048 4096 today',
+    )
+  })
+
+  test('short digit groups without phone prefix stay untouched', () => {
+    // The unit pass may expand a trailing unit, but the digit groups
+    // themselves must never be read digit-by-digit.
+    const out = normalizeForTts('12 34 56 78 items')
+    expect(out).toBe('12 34 56 78 items')
+  })
+
+  test('currency with thousands separator: $1,000 → one thousand dollars', () => {
+    expect(normalizeForTts('paid $1,000 up front')).toBe(
+      'paid one thousand dollars up front',
+    )
+    expect(normalizeForTts('$12,345.67 total')).toBe(
+      'twelve thousand three hundred forty-five dollars sixty-seven total',
+    )
+  })
+
+  test('odd cents ($5.203) left unchanged rather than half-read', () => {
+    expect(normalizeForTts('value $5.203 today')).toBe('value $5.203 today')
+  })
+
+  test('HH:MM:SS left unchanged (no dangling seconds)', () => {
+    expect(normalizeForTts('at 12:34:56 sharp')).toBe('at 12:34:56 sharp')
+  })
+
+  test('units expand: 5km, 10GB, 500ms', () => {
+    expect(normalizeForTts('ran 5km')).toBe('ran five kilometres')
+    expect(normalizeForTts('used 10GB')).toBe('used ten gigabytes')
+    expect(normalizeForTts('took 500ms')).toBe('took five hundred milliseconds')
+  })
+
+  test('identifiers with digits are never touched', () => {
+    expect(normalizeForTts('rename class5 and my5thing')).toBe(
+      'rename class5 and my5thing',
+    )
+  })
+})
+
+describe('URLs', () => {
+  test('bare URL → spoken domain', () => {
+    expect(normalizeForTts('see https://github.com/switchroom/switchroom for code')).toBe(
+      'see github dot com link for code',
+    )
+  })
+
+  test('www prefix dropped from spoken domain', () => {
+    expect(normalizeForTts('at https://www.example.org/x')).toBe(
+      'at example dot org link',
+    )
+  })
+
+  test('IP-host URL degrades to a link', () => {
+    expect(normalizeForTts('at http://127.0.0.1:8080/x ok')).toBe('at a link ok')
+  })
+})
+
+describe('emoji', () => {
+  test('common emoji spoken via map', () => {
+    expect(normalizeForTts('great work 👍')).toBe('great work thumbs up')
+  })
+
+  test('other emoji stripped', () => {
+    expect(normalizeForTts('launch 🚀 now 🎉')).toBe('launch now')
+  })
+})
+
+describe('symbols', () => {
+  test('& → and, @ → at, # → hash', () => {
+    expect(normalizeForTts('cats & dogs')).toBe('cats and dogs')
+    expect(normalizeForTts('ping @ken')).toBe('ping at ken')
+    expect(normalizeForTts('see #general')).toBe('see hash general')
+  })
+
+  test('prose slash spoken', () => {
+    expect(normalizeForTts('yes/no answer')).toBe('yes slash no answer')
+  })
+
+  test('~ before a number → about', () => {
+    expect(normalizeForTts('~5 minutes left')).toBe('about 5 minutes left')
+  })
+})
+
+describe('conservatism', () => {
+  test('plain prose passes through unchanged', () => {
+    const input = 'The build finished and everything looks good.'
+    expect(normalizeForTts(input)).toBe(input)
+  })
+
+  test('deterministic: same input, same output', () => {
+    const input = '## Hi\n**bold** $5.20 at 14:30 👍 https://github.com/a'
+    expect(normalizeForTts(input)).toBe(normalizeForTts(input))
+  })
+})

package/telegram-plugin/tests/turns-jsonl-rotate.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { maybeRotate, TURNS_JSONL_MAX_BYTES, type RotateFs } from '../gateway/turns-jsonl-rotate.js'
+
+describe('maybeRotate — turns.jsonl size cap', () => {
+  const mkFs = (size: number | undefined) => {
+    const rename = vi.fn()
+    const fs: RotateFs = { statSize: () => size, rename }
+    return { fs, rename }
+  }
+
+  it('does not rotate below the cap', () => {
+    const { fs, rename } = mkFs(TURNS_JSONL_MAX_BYTES - 1)
+    expect(maybeRotate('/state/agent/turns.jsonl', fs)).toBe(false)
+    expect(rename).not.toHaveBeenCalled()
+  })
+
+  it('rotates at/over the cap → renames to <path>.1', () => {
+    const { fs, rename } = mkFs(TURNS_JSONL_MAX_BYTES)
+    expect(maybeRotate('/state/agent/turns.jsonl', fs)).toBe(true)
+    expect(rename).toHaveBeenCalledWith('/state/agent/turns.jsonl', '/state/agent/turns.jsonl.1')
+  })
+
+  it('absent file (statSize undefined) → no rotation', () => {
+    const { fs, rename } = mkFs(undefined)
+    expect(maybeRotate('/state/agent/turns.jsonl', fs)).toBe(false)
+    expect(rename).not.toHaveBeenCalled()
+  })
+
+  it('rotation is bounded to one generation (overwrites <path>.1)', () => {
+    // A second rotation renames onto the same .1 target — no unbounded
+    // accumulation of generations.
+    const { fs, rename } = mkFs(TURNS_JSONL_MAX_BYTES * 3)
+    maybeRotate('/a/turns.jsonl', fs)
+    maybeRotate('/a/turns.jsonl', fs)
+    expect(rename).toHaveBeenNthCalledWith(1, '/a/turns.jsonl', '/a/turns.jsonl.1')
+    expect(rename).toHaveBeenNthCalledWith(2, '/a/turns.jsonl', '/a/turns.jsonl.1')
+  })
+})

package/telegram-plugin/tests/unhandled-rejection-policy.test.ts

@@ -84,6 +84,18 @@ describe('classifyRejection — benign Telegram 400s', () => {
     const err = grammyError(400, 'Bad Request: MESSAGE IS NOT MODIFIED: blah')
     expect(classifyRejection(err)).toBe('log_only')
   })
+
+  it('returns "log_only" for pin-rights 400 "not enough rights to manage pinned messages" (marko 2026-07-01)', () => {
+    // The bot is not an admin in a supergroup, so the auto status-pin
+    // driver's pinChatMessage returns this 400. It was crashing the whole
+    // gateway via a leaked fire-and-forget rejection. Auto-pin is cosmetic —
+    // a missing pin right must never be fatal.
+    const err = grammyError(
+      400,
+      'Bad Request: not enough rights to manage pinned messages in the chat',
+    )
+    expect(classifyRejection(err)).toBe('log_only')
+  })
 })
 
 describe('classifyRejection — genuine errors still crash', () => {

package/telegram-plugin/tests/vault-grant-inbound-builders.test.ts

@@ -15,6 +15,7 @@
 import { describe, it, expect } from 'vitest'
 import {
   buildVaultGrantApprovedInbound,
+  buildVaultGrantApprovedCardText,
   buildVaultGrantDeniedInbound,
   buildVaultSaveCompletedInbound,
   buildVaultSaveFailedInbound,
@@ -22,6 +23,7 @@ import {
   type VaultGrantInboundContext,
   type VaultSaveInboundContext,
 } from '../gateway/vault-grant-inbound-builders.js'
+import { richMessage } from '../rich-send.js'
 
 const FIXED_NOW = 1_700_000_000_000
 
@@ -40,6 +42,58 @@ const CTX_WRITE: VaultGrantInboundContext = {
   ttl_seconds: 7 * 86400,
 }
 
+describe('buildVaultGrantApprovedCardText — the [object Object] regression guard', () => {
+  const BASE = {
+    agentEscaped: 'gymbro',
+    scope: 'read' as const,
+    key: 'fatsecret/credentials',
+    days: 30,
+    grantId: 'vg_a1b2c3',
+  }
+
+  it('renders the full confirmation as ONE markdown string wrapped once — no [object Object]', () => {
+    // This is the whole point of the helper: the card text is built as a
+    // single string and passed to a single richMessage(...) call. The bug
+    // (fixed here) was `"prefix " + richMessage("suffix")`, which coerces
+    // the {markdown} object and prints "[object Object]".
+    const text = buildVaultGrantApprovedCardText(BASE)
+    const rich = richMessage(text)
+    expect(rich.markdown).toBe(text)
+    expect(rich.markdown).not.toContain('[object Object]')
+    expect(rich.markdown).toContain('vg_a1b2c3') // grant id present
+  })
+
+  it('includes agent, scope, key, days, and the grant id', () => {
+    const text = buildVaultGrantApprovedCardText(BASE)
+    expect(text).toContain('**gymbro**')
+    expect(text).toContain('read access')
+    expect(text).toContain('`fatsecret/credentials`')
+    expect(text).toContain('for 30d')
+    expect(text).toContain('(grant `vg_a1b2c3`)')
+  })
+
+  it('appends the footer when provided, omits it otherwise', () => {
+    const withFooter = buildVaultGrantApprovedCardText({
+      ...BASE,
+      footer: '\n_Approver verified by Telegram identity._',
+    })
+    expect(withFooter).toContain('_Approver verified by Telegram identity._')
+    // still one clean string
+    expect(withFooter).not.toContain('[object Object]')
+
+    const noFooter = buildVaultGrantApprovedCardText(BASE)
+    expect(noFooter.endsWith('(grant `vg_a1b2c3`)')).toBe(true)
+  })
+
+  it('DOCUMENTS the original bug: bare-string + richMessage() coerces to [object Object]', () => {
+    // Demonstrates why the fix matters — if a future edit reintroduces the
+    // "concatenate a string onto the richMessage object" pattern, the result
+    // contains the literal "[object Object]". The helper above avoids it.
+    const buggy = '✅ Granted access. ' + (richMessage('(grant `vg_x`)') as unknown as string)
+    expect(buggy).toContain('[object Object]')
+  })
+})
+
 describe('buildVaultGrantApprovedInbound', () => {
   it('emits the canonical envelope (type, chat_id, user, userId, ts, messageId)', () => {
     const msg = buildVaultGrantApprovedInbound({