switchroom 0.16.28 → 0.16.38

package/telegram-plugin/tests/status-pin.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect } from 'vitest'
+import { GrammyError } from 'grammy'
+import { decidePinAction } from '../status-pin.js'
+import { reconcilePin, type PinBotApi } from '../status-pin-driver.js'
+import type { PinState } from '../status-pin.js'
+
+/** A real GrammyError with the given code + description, mirroring the wire
+ *  shape Telegram returns for the pin-rights failure that crashed marko. */
+function grammyError(error_code: number, description: string): GrammyError {
+  return new GrammyError(
+    `Call to 'pinChatMessage' failed!`,
+    { ok: false, error_code, description },
+    'pinChatMessage',
+    {} as never,
+  )
+}
+
+describe('decidePinAction (pure)', () => {
+  it('pins an existing message when work goes in-flight (nothing pinned yet)', () => {
+    const action = decidePinAction(null, { pinned: true, messageId: 42 })
+    expect(action).toEqual({ kind: 'pin', messageId: 42 })
+  })
+
+  it('unpins when work completes (something pinned)', () => {
+    const action = decidePinAction({ messageId: 42 }, { pinned: false })
+    expect(action).toEqual({ kind: 'unpin', messageId: 42 })
+  })
+
+  it('noops when nothing is pinned and nothing is wanted', () => {
+    const action = decidePinAction(null, { pinned: false })
+    expect(action.kind).toBe('noop')
+  })
+
+  it('noops when the wanted message is already pinned', () => {
+    const action = decidePinAction({ messageId: 42 }, { pinned: true, messageId: 42 })
+    expect(action.kind).toBe('noop')
+  })
+
+  it('unpins the stale claim when the wanted message id changed (feed re-posted)', () => {
+    const action = decidePinAction({ messageId: 42 }, { pinned: true, messageId: 99 })
+    expect(action).toEqual({ kind: 'unpin', messageId: 42 })
+  })
+})
+
+/** A fake Bot API recording calls, with per-method throw toggles. */
+function fakeApi(opts: { pinThrows?: boolean; unpinThrows?: boolean } = {}) {
+  const calls: { verb: string; messageId: number; opts?: unknown }[] = []
+  const api: PinBotApi = {
+    pinChatMessage: async (_chat, message_id, o) => {
+      calls.push({ verb: 'pin', messageId: message_id, opts: o })
+      if (opts.pinThrows) throw new Error('pin failed')
+    },
+    unpinChatMessage: async (_chat, message_id) => {
+      calls.push({ verb: 'unpin', messageId: message_id })
+      if (opts.unpinThrows) throw new Error('unpin failed')
+    },
+  }
+  return { api, calls }
+}
+
+describe('reconcilePin (driver)', () => {
+  it('pin on in-progress: pins the EXISTING message SILENTLY and claims it', async () => {
+    const { api, calls } = fakeApi()
+    const next = await reconcilePin({
+      api,
+      chatId: '123',
+      prevState: null,
+      desired: { pinned: true, messageId: 42 },
+    })
+    expect(next).toEqual({ messageId: 42 })
+    expect(calls).toHaveLength(1)
+    expect(calls[0].verb).toBe('pin')
+    expect(calls[0].messageId).toBe(42)
+    // Silent — must never buzz the device.
+    expect((calls[0].opts as Record<string, unknown>).disable_notification).toBe(true)
+  })
+
+  it('unpin on finalize: unpins and drops the claim', async () => {
+    const { api, calls } = fakeApi()
+    const prev: PinState = { messageId: 42 }
+    const next = await reconcilePin({
+      api,
+      chatId: '123',
+      prevState: prev,
+      desired: { pinned: false },
+    })
+    expect(next).toBeNull()
+    expect(calls).toEqual([{ verb: 'unpin', messageId: 42 }])
+  })
+
+  it('CRITICAL: drops the claim even when unpinChatMessage throws', async () => {
+    const errors: string[] = []
+    const { api, calls } = fakeApi({ unpinThrows: true })
+    const next = await reconcilePin({
+      api,
+      chatId: '123',
+      prevState: { messageId: 42 },
+      desired: { pinned: false },
+      onError: (phase) => errors.push(phase),
+    })
+    // State MUST be cleared even though the API threw — never stay stuck pinned.
+    expect(next).toBeNull()
+    expect(calls).toEqual([{ verb: 'unpin', messageId: 42 }])
+    expect(errors).toEqual(['unpin'])
+  })
+
+  it('does NOT claim a message whose pin failed (retries next reconcile)', async () => {
+    const errors: string[] = []
+    const { api } = fakeApi({ pinThrows: true })
+    const next = await reconcilePin({
+      api,
+      chatId: '123',
+      prevState: null,
+      desired: { pinned: true, messageId: 42 },
+      onError: (phase) => errors.push(phase),
+    })
+    // No claim taken — prevState (null) is returned so the next reconcile retries.
+    expect(next).toBeNull()
+    expect(errors).toEqual(['pin'])
+  })
+
+  it('never sends a new message — only pin/unpin the existing id', async () => {
+    // The fake has no sendMessage; a driver that tried to send would throw.
+    const { api } = fakeApi()
+    await reconcilePin({ api, chatId: '1', prevState: null, desired: { pinned: true, messageId: 7 } })
+    await reconcilePin({ api, chatId: '1', prevState: { messageId: 7 }, desired: { pinned: false } })
+    expect(Object.keys(api)).toEqual(['pinChatMessage', 'unpinChatMessage'])
+  })
+})
+
+// ── Regression: the marko 2026-07-01 gateway crash ─────────────────────────
+// A pinChatMessage 400 "not enough rights to manage pinned messages" (the bot
+// is not an admin in a supergroup) escaped as an unhandledRejection and shut
+// the whole gateway down. Auto status-pin is best-effort/cosmetic — a
+// pin-rights failure must be absorbed, never fatal, and never reach the
+// process-level unhandledRejection handler.
+describe('reconcilePin — pin-rights 400 must never crash (marko 2026-07-01)', () => {
+  it('absorbs the "not enough rights" 400 via onError and never rejects', async () => {
+    const rightsErr = grammyError(
+      400,
+      'Bad Request: not enough rights to manage pinned messages in the chat',
+    )
+    const captured: { phase: string; code?: number }[] = []
+    const api: PinBotApi = {
+      pinChatMessage: async () => {
+        throw rightsErr
+      },
+      unpinChatMessage: async () => {},
+    }
+
+    // reconcilePin resolves (never rejects) even when the pin API throws a
+    // real GrammyError — this is the contract the fire-and-forget
+    // `void reconcileStatusPin(...)` callsites depend on to not leak a
+    // rejection to the process.
+    const next = await reconcilePin({
+      api,
+      chatId: '-1003831053471',
+      prevState: null,
+      desired: { pinned: true, messageId: 4 },
+      onError: (phase, err) =>
+        captured.push({
+          phase,
+          code: err instanceof GrammyError ? err.error_code : undefined,
+        }),
+    })
+
+    // No claim taken (pin failed), error routed through onError, promise
+    // resolved cleanly.
+    expect(next).toBeNull()
+    expect(captured).toEqual([{ phase: 'pin', code: 400 }])
+  })
+
+  it('a fire-and-forget reconcilePin does NOT emit an unhandledRejection', async () => {
+    const rejections: unknown[] = []
+    const onUnhandled = (err: unknown) => rejections.push(err)
+    process.on('unhandledRejection', onUnhandled)
+    try {
+      const api: PinBotApi = {
+        pinChatMessage: async () => {
+          throw grammyError(
+            400,
+            'Bad Request: not enough rights to manage pinned messages in the chat',
+          )
+        },
+        unpinChatMessage: async () => {},
+      }
+      // Fire-and-forget, exactly as the gateway's auto-pin callsites do.
+      void reconcilePin({
+        api,
+        chatId: '-1003831053471',
+        prevState: null,
+        desired: { pinned: true, messageId: 4 },
+        onError: () => {},
+      })
+      // Let microtasks + a macrotask flush so any leaked rejection would fire.
+      await new Promise((r) => setTimeout(r, 20))
+      expect(rejections).toEqual([])
+    } finally {
+      process.off('unhandledRejection', onUnhandled)
+    }
+  })
+})

package/telegram-plugin/tests/stream-reply-handler.test.ts

@@ -117,6 +117,45 @@ describe('handleStreamReply', () => {
     expect(bot.api.sendMessage.mock.calls[0][2]?.parse_mode).toBeUndefined()
   })
 
+  it('applies addParagraphSpacers on the rich path (multi-paragraph gap spaced)', async () => {
+    const state = makeState()
+    // Spacer dep replaces every `\n\n` gap with a visible marker so we can
+    // assert the rich path ran it (mirrors the real gateway wiring).
+    const deps = makeDeps(bot, {
+      addParagraphSpacers: (t) => t.replace(/\n\n/g, '\n\nSPACER\n\n'),
+    })
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Para one.\n\nPara two.', done: true },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    expect(bot.api.sendRichMessage).toHaveBeenCalledTimes(1)
+    expect(richSendMarkdown(bot)).toBe('Para one.\n\nSPACER\n\nPara two.')
+  })
+
+  it('does NOT apply addParagraphSpacers on the literal format=text path', async () => {
+    const state = makeState()
+    const deps = makeDeps(bot, {
+      addParagraphSpacers: (t) => t.replace(/\n\n/g, '\n\nSPACER\n\n'),
+    })
+
+    const pending = handleStreamReply(
+      { chat_id: '1', text: 'Para one.\n\nPara two.', format: 'text', done: true },
+      state,
+      deps,
+    )
+    await microtaskFlush()
+    await pending
+
+    expect(bot.api.sendMessage).toHaveBeenCalledTimes(1)
+    // Literal path is byte-exact — no spacer injected.
+    expect(bot.api.sendMessage.mock.calls[0][1]).toBe('Para one.\n\nPara two.')
+  })
+
   it('throws when text exceeds the rich-message cap (no silent id:pending)', async () => {
     const state = makeState()
     const deps = makeDeps(bot)

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

@@ -19,6 +19,8 @@ import {
   repairEscapedWhitespace,
   escapeMarkdown,
   splitMarkdownChunks,
+  addParagraphSpacers,
+  PARAGRAPH_SPACER,
   RICH_MESSAGE_MAX_CHARS,
 } from '../format.js'
 
@@ -63,6 +65,26 @@ describe('escapeMarkdown', () => {
     // `\*` in the input is backslash + star → both get escaped exactly once.
     expect(escapeMarkdown('\\*')).toBe('\\\\\\*')
   })
+
+  // The de-dup pass (#2695) replaced ~12 local escaper copies with this one
+  // canonical function. Every consolidated caller now depends on this exact
+  // contract: the FULL metacharacter set in a single string, each escaped.
+  test('escapes the full metacharacter set in one combined string', () => {
+    // Backslash placed last so it doesn't re-escape the chars after it.
+    expect(escapeMarkdown('`*_~=[]|\\')).toBe('\\`\\*\\_\\~\\=\\[\\]\\|\\\\')
+  })
+
+  test('already-safe text passes through unchanged', () => {
+    const safe = 'Switched fleet to alice (5h window 29% resets in 2h)'
+    expect(escapeMarkdown(safe)).toBe(safe)
+  })
+
+  // card-format.ts re-exports this same symbol; the consolidated callers
+  // import from one or the other. Lock that they are the identical function.
+  test('card-format re-exports the identical canonical escaper', async () => {
+    const cardFormat = await import('../card-format.js')
+    expect(cardFormat.escapeMarkdown).toBe(escapeMarkdown)
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -138,6 +160,72 @@ describe('splitMarkdownChunks', () => {
     expect(chunks.length).toBe(1)
     expect(chunks[0]).toBe(giant)
   })
+
+  // -------------------------------------------------------------------------
+  // Chunk-boundary spacer hygiene. addParagraphSpacers injects a
+  // `\n\n${PARAGRAPH_SPACER}\n\n` gap between prose paragraphs. When a cut
+  // lands inside that gap, the boundary must not leave a chunk that opens or
+  // ends with a bare U+00A0 spacer line (a stray blank bubble line).
+  // -------------------------------------------------------------------------
+
+  test('no chunk starts or ends with a bare U+00A0 spacer line (reviewer repro)', () => {
+    // The exact reviewer repro: a spacer gap straddling a small cap.
+    const A = 'Alpha sentence one'
+    const B = 'Bravo sentence two'
+    const spaced = addParagraphSpacers(`${A}.\n\n${B}.`)
+    const chunks = splitMarkdownChunks(spaced, 33)
+    expect(chunks.length).toBeGreaterThan(1)
+    const spacerOnly = new RegExp(`^[ \\t]*${PARAGRAPH_SPACER}[ \\t]*$`)
+    for (const c of chunks) {
+      const lines = c.split('\n')
+      expect(spacerOnly.test(lines[0])).toBe(false)
+      expect(spacerOnly.test(lines[lines.length - 1])).toBe(false)
+    }
+  })
+
+  test('visible paragraph content survives the boundary (no text dropped)', () => {
+    const A = 'Alpha sentence one'
+    const B = 'Bravo sentence two'
+    const spaced = addParagraphSpacers(`${A}.\n\n${B}.`)
+    const chunks = splitMarkdownChunks(spaced, 33)
+    const rejoined = chunks.join('\n')
+    expect(rejoined).toContain(`${A}.`)
+    expect(rejoined).toContain(`${B}.`)
+  })
+
+  test('spacer-boundary strip is robust across several gaps and small caps', () => {
+    const paras = Array.from({ length: 6 }, (_, i) => `Paragraph ${i} body text here.`)
+    const spaced = addParagraphSpacers(paras.join('\n\n'))
+    const spacerOnly = new RegExp(`^[ \\t]*${PARAGRAPH_SPACER}[ \\t]*$`)
+    for (const cap of [20, 31, 40, 64]) {
+      const chunks = splitMarkdownChunks(spaced, cap)
+      for (const c of chunks) {
+        const lines = c.split('\n')
+        expect(spacerOnly.test(lines[0])).toBe(false)
+        expect(spacerOnly.test(lines[lines.length - 1])).toBe(false)
+      }
+      // No visible word is dropped: concatenating the chunks' non-blank,
+      // non-spacer tokens reproduces the original word sequence. (Word-level,
+      // not line-level, because a small cap may split mid-word — that's the
+      // chunker's normal space-boundary behaviour, orthogonal to spacers.)
+      const words = (s: string): string[] =>
+        s.split(/\s+/).filter((w) => w.length > 0 && w !== PARAGRAPH_SPACER)
+      // Join chunks with a space — each chunk is a separate Telegram message,
+      // so inter-chunk whitespace is irrelevant; what matters is no word is
+      // lost or fused. (A small cap may end a chunk mid-sentence at a space
+      // boundary, e.g. "...here." | "Paragraph 1...", which is normal.)
+      expect(words(chunks.join(' '))).toEqual(words(paras.join(' ')))
+    }
+  })
+
+  test('a boundary with NO spacer is unaffected (legacy ^\\n+ behaviour preserved)', () => {
+    const text = Array.from({ length: 10 }, (_, i) => `plain line ${i}`).join('\n\n')
+    const chunks = splitMarkdownChunks(text, 40)
+    // No spacer was ever present, so no chunk gains/loses anything beyond the
+    // normal leading-newline strip; content is preserved.
+    const rejoined = chunks.join('\n').replace(/\n+/g, '\n')
+    expect(rejoined).toBe(text.replace(/\n+/g, '\n'))
+  })
 })
 
 // ---------------------------------------------------------------------------

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");
@@ -238,7 +258,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 +267,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 +327,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 +362,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 +401,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 +418,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 +632,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 +790,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 +804,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 +844,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 +867,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/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', () => {